text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Создание нестандартного компонента с нуля. Часть 2
#### Вступление
Вновь приветствую, коллеги.
В своей [предыдущей](http://habrahabr.ru/post/176643/) статье я рассказал об основах создания кастомного компонента на примере простенькой, но симпатичной фортепианной клавиатуры.
В этой статье под катом мы продолжим накручивать ~~свистелки и...~~ дополнительные возможности нашей клавиатуре. На повестке дня:
1. Сохранение состояния компонента при повороте экрана
2. добавление подсветки при оверскролле
3. передача параметров в XML
4. Мультитач зуммирование
#### Сохранение состояния компонента при повороте экрана
Сейчас мы можем обнаружить такое поведение у нашего компонента. Если мы проскроллим на любую позицию, затем повернем экран, скролл будет на нуле. Очевидно, это происходит потому, что при повороте экрана Activity пересоздается, соответственно, пересоздается и View.
Первое, что здесь приходит на ум, это использовать метод `onSaveInstanceState()` нашей активити, вытянуть значение скролла из компонента и сохранить, а позже, при повторном создании, установить скролл в наш компонент. И это будет работать, но это с трудом можно назвать верным подходом. Представим, что у нас не один параметр, который нужно сохранить, а десять, или не один компонент, а десять… с десятью параметрами.
К счастью, внутренние механизмы Android уже предусматривают автоматическое сохранение состояние всех компонентов, имеющих идентификатор. Ведь вам же не надо ничего делать, чтобы сохранился скролл у ListView при повороте, верно? Вот и мы воспользуемся тем, что уже есть во View и будем управлять сохранением состояние компонента изнутри, а не снаружи.
А делается это удивительно просто. Нам надо переопределить методы класса View `onSaveInstanceState()` и `onRestoreInstanceState(Parcelable state)`. Однако, тут есть маленькое отличие от аналогов в активити. Там мы имеем дело с `Bundle`, здесь у нас Parcelable. Нам нужно сделать свой собственный Parcelable класс, который обязательно должен быть наследником `android.view.View.BaseSavedState`.
```
public static class SavedState extends BaseSavedState {
int xOffset;
int instrumentWidth; // Зачем я сохраняю это поле станет понятно чуть ниже :)
SavedState(Parcelable superState) {
super(superState);
}
@Override
public void writeToParcel(Parcel out, int flags) {
super.writeToParcel(out, flags);
out.writeInt(xOffset);
out.writeInt(instrumentWidth);
}
public static final Parcelable.Creator CREATOR = new Parcelable.Creator() {
public SavedState createFromParcel(Parcel in) {
return new SavedState(in);
}
public SavedState[] newArray(int size) {
return new SavedState[size];
}
};
private SavedState(Parcel in) {
super(in);
xOffset = in.readInt();
instrumentWidth = in.readInt();
}
}
```
Вот так он выглядит в нашем случае. Теперь осталось только его использовать:
```
@Override
protected Parcelable onSaveInstanceState() {
SavedState st = new SavedState(super.onSaveInstanceState());
st.xOffset = xOffset;
st.instrumentWidth = xOffset;
return st;
}
protected void onRestoreInstanceState(Parcelable state) {
if (!(state instanceof SavedState)) {
super.onRestoreInstanceState(state);
return;
}
SavedState ss = (SavedState) state;
super.onRestoreInstanceState(ss.getSuperState());
xOffset = ss.xOffset;
xOffset = ss.instrumentWidth;
};
```
Готово. Если вы теперь повернете экран, скролл не потеряется. Но есть еще одна маленькая косметическая деталь, которую я бы добавил. В нашем компоненте при повороте есть большая вероятность, что ширина клавиатуры изменится, так как у нас изменится его высота (меньше в ландшафном режиме), клавиши станут уже или шире. Поэтому нашу статическую величину xOffset, загруженную после пересоздания, нужно подкорректировать. Делается это очень просто. Во-первых, будем сохранять старую ширину нашей клавиатуры при пересоздании. Именно поэтому в коде выше я также сохраняю поле instrumentWidth в нашем SavedState.
В нашем onDraw() там, где мы инициализируем компонент после изменения его размеров, добавим такие модификации:
```
if (measurementChanged) {
measurementChanged = false;
keyboard.initializeInstrument(getMeasuredHeight(), getContext());
float oldInstrumentWidth = instrumentWidth;
instrumentWidth = keyboard.getWidth();
float ratio = (float) instrumentWidth / oldInstrumentWidth; // Рассчитываем отношение новой длины к старой и выравниваем значение
xOffset = (int) (xOffset * ratio);
}
```
Теперь если наш скролл до поворота был, например, на начале второй октавы, он там и останется после поворота.
Итак, мы успешно сохраняем состояние нашего компонента при повороте. Теперь добавим еще визуальной красоты, а именно эффект свечения по бокам при достижении скроллом конца инструмента.
#### Эффект свечения для оверскролла
Как и следовало ожидать, для нас уже сделан готовый компонент, который эти самые края умеет правильно рисовать, нам же нужно его правильно воткнуть и вуаля. Этот компонент называется [EdgeEffect](http://developer.android.com/reference/android/widget/EdgeEffect.html). Но мы его использовать не будем, т. к. он появился только в ICS. Мы же воспользуемся классом [EdgeEffectCompat](https://developer.android.com/reference/android/support/v4/widget/EdgeEffectCompat.html), который доступен compatibility library и является оберткой над EdgeEffect. К сожалению, это означает, что в версиях, где эффект не поддерживается, этот класс будет выполнять роль простой заглушки и ничего не будет происходить.
Итак, нам понадобится два экземпляра — для левого и правого края.
```
private EdgeEffectCompat leftEdgeEffect;
private EdgeEffectCompat rightEdgeEffect;
```
Инициализируются они простым образом в activity.
Теперь, отрисовка. Как и скроллбары, рисуется эффект поверх всего контента, поэтому, разумно вынести его в метод draw(). Тут я честно признаюсь, что то, что идет дальше сделано по аналогии с тем, как это реализовано в классе ViewPager. В общем-то, мы можем с точно таким же результатом нарисовать эффект и в onDraw, но, в общем-то, это на мой взгляд даже красивее, т. к. в onDraw мы рисуем свое, в draw — системные эффекты.
```
public void draw(Canvas canvas) {
super.draw(canvas);
boolean needsInvalidate = false;
final int overScrollMode = ViewCompat.getOverScrollMode(this);
if (overScrollMode == ViewCompat.OVER_SCROLL_ALWAYS
|| (overScrollMode == ViewCompat.OVER_SCROLL_IF_CONTENT_SCROLLS)) {
if (!leftEdgeEffect.isFinished()) {
final int restoreCount = canvas.save();
final int height = getHeight() - getPaddingTop() - getPaddingBottom();
final int width = getWidth();
canvas.rotate(270);
canvas.translate(-height + getPaddingTop(), 0);
leftEdgeEffect.setSize(height, width);
needsInvalidate |= leftEdgeEffect.draw(canvas);
canvas.restoreToCount(restoreCount);
}
if (!rightEdgeEffect.isFinished()) {
final int restoreCount = canvas.save();
final int width = getWidth();
final int height = getHeight() - getPaddingTop() - getPaddingBottom();
canvas.rotate(90);
canvas.translate(-getPaddingTop(), -width);
rightEdgeEffect.setSize(height, width);
needsInvalidate |= rightEdgeEffect.draw(canvas);
canvas.restoreToCount(restoreCount);
}
} else {
leftEdgeEffect.finish();
rightEdgeEffect.finish();
}
if (needsInvalidate) {
ViewCompat.postInvalidateOnAnimation(this);
}
}
```
Итак, что здесь происходит. Сначала мы проверяем, поддерживает ли наш компонент оверскролл, и, если да, рисуем последовательно оба эффекта. Дело в том, что EdgeEffect не поддерживает направления, в котором он рисуется, поэтому, чтобы корректно отобразить эффект слева или справа, нам необходимо правильным образом повернуть нашу канву.
```
if (!leftEdgeEffect.isFinished()) {
final int restoreCount = canvas.save();
final int height = getHeight() - getPaddingTop() - getPaddingBottom();
final int width = getWidth();
canvas.rotate(270);
canvas.translate(-height + getPaddingTop(), 0);
leftEdgeEffect.setSize(height, width);
needsInvalidate |= leftEdgeEffect.draw(canvas);
canvas.restoreToCount(restoreCount);
}
```
Здесь мы последовательно:
1. Сохраняем канву, используя canvas.save()
2. вычисляем ее высоту минус паддинги и выставляем размер эффекта используя метод leftEdgeEffect.setSize(height, width);
3. Поворачиваем канву на 270 градусов и правильно ее позиционируем.
Я хочу представить это более наглядно. Давайте уберем трансформации канвы:
вот так выглядит эффект по-умолчанию. Всегда вниз. Если мы добавим только поворот на 270, мы увидим, что эффект рисуется в верном направлении, но в самом верхнем углу канвы.
И лишь после добавления смещения канвы мы видим, что эффект на месте.
Но это я забежал вперед, т. к. пока у нас эффект хоть и рисуется, но он не активируется при скролле.
Вот здесь нам нужно вернуться к нашему детектору жестов и модифицировать onScroll.
```
public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
resetTouchFeedback();
xOffset += distanceX;
if (xOffset < 0) {
leftEdgeEffect.onPull(distanceX / (float) getMeasuredWidth());
}
if (xOffset > instrumentWidth - getMeasuredWidth()) {
rightEdgeEffect.onPull(distanceX / (float) getMeasuredWidth());
}
if (!awakenScrollBars()) {
invalidate();
}
return true;
}
```
Во-первых, мы перестали ограничивать xOffset границами, как мы делали раньше, плюс, мы вызываем метод onPull у соответствующего эффекта.
Важно тут отметить, что раз мы перестали ограничивать здесь переменную xOffset, нам нужно делать это в других местах, где это может вызвать ошибку, например в методе onDraw и computeHorizontalScrollOffset(). Возможно, есть более красивый способ делать это, но мне он пока не пришел в голову.
Последний штрих, который мы хотим добавить — это поглощение скорости прокрутки при достижении края нашим свечением. Для этого добавим в наш `onDraw` следующий код:
```
if (scroller.isOverScrolled()) {
if (xOffset < 0) {
leftEdgeEffect.onAbsorb(getCurrentVelocity());
} else {
rightEdgeEffect.onAbsorb(getCurrentVelocity());
}
}
// ...
@TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
private int getCurrentVelocity() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
return (int) scroller.getCurrVelocity();
}
return 0;
}
```
К сожалению, метод `Scroller.getCurrVelocity()` доступен нам только начиная с ICS, поэтому я пометил метод как нацеленный на API 14+. Да, это далеко от идеала, но, опять же, это то, что у нас есть.
Теперь, при попытке скроллинга за пределы View, мы получаем красивое свечение в стиле Holo.
#### Добавление параметров компонента в XML
Перед тем, как приступить непосредственно к добавлению параметров, я добавлю маленькую фичу в наш компонент. Пусть, при клике по клавише у нас отобразится кружочек с именем этой ноты.
Делается это тривиально. Я завел массив объектов Note
```
private ArrayList notesToDraw = new ArrayList();
```
и каждый раз, когда кликаю по клавише, я определяю ноту по миди коду клавиши и добавляю ее в массив. Подробно как это происходит можно увидеть в коде на гитхабе.
Теперь в класс Keyboard я добавляю метод drawOverlays(ArrayList)
```
public void drawOverlays(ArrayList notes, Canvas canvas) {
int firstVisibleKey = getFirstVisibleKey();
int lastVisibleKey = getLastVisibleKey();
for (Note note : notes) {
int midiCode = note.getMidiCode();
if (midiCode >= firstVisibleKey && midiCode <= lastVisibleKey) {
drawNoteFromMidi(canvas, note, midiCode, false);
}
}
}
private void drawNoteFromMidi(Canvas canvas, Note note, int midiCode, boolean replica) {
Key key = keysArray[midiCode - Keyboard.START\_MIDI\_CODE];
overlayTextPaint.setColor(circleColor);
canvas.drawCircle(key.getOverlayPivotX(), key.getOverlayPivotY(), overlayCircleRadius, overlayTextPaint);
String name = note.toString();
overlayTextPaint.getTextBounds(name, 0, name.length(), bounds);
int width = bounds.right - bounds.left;
int height = bounds.bottom - bounds.top;
overlayTextPaint.setColor(Color.BLACK);
canvas.drawText(name, key.getOverlayPivotX() - width / 2, key.getOverlayPivotY() + height / 2, overlayTextPaint);
}
```
… и рисую ноту как кружок и текст. Как вы наверное уже догадались, я сделал это для того, чтобы мы могли настраивать параметры этого кружка и текста через XML.
Давайте вынесем настройку цвета, радиуса кружка и размера текста в XML атрибуты нашего View. Для начала, нужно их объявить. Для этого используется тэг .
```
```
добавим это определение в attrs.xml. Теперь, мы должны загрузить их в нашем компоненте. В конструкторе добавляем следующий код
```
TypedArray pianoAttrs = context.obtainStyledAttributes(attrs, R.styleable.PianoView);
int circleColor;
float circleRadius;
float circleTextSize;
try {
circleColor = pianoAttrs.getColor(R.styleable.PianoView_overlay_color, Color.GREEN);
circleRadius = pianoAttrs.getDimension(R.styleable.PianoView_overlay_circle_radius, TypedValue
.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 24, context.getResources().getDisplayMetrics()));
circleTextSize = pianoAttrs.getDimension(R.styleable.PianoView_overlay_circle_text_size, TypedValue
.applyDimension(TypedValue.COMPLEX_UNIT_SP, 12, context.getResources().getDisplayMetrics()));
} finally {
pianoAttrs.recycle();
}
```
с помощью метода getXXX мы получаем значение атрибута типа XXX. Если атрибут отсутсвует, второй аргумент определяет значение по-умолчанию.
Осталось теперь указать их в нашей разметке. Для этого сначала нужно объявить namespace в заголовке: `xmlns:piano="http://schemas.android.com/apk/res-auto"`, после чего получим такой файл с разметкой:
```
```
Таким образом мы можем делать наши компоненты такими же гибкими, как и стандартные компонеты платформы.
#### Поддержка мультитач-зума
Последнее, о чем я хотел рассказать сегодня, это базовая поддержка зумирования при помощи мультитач жеста.
Для создания эффекта зума мы воспользуемся компонентом [ScaleGestureDetector](https://developer.android.com/reference/android/view/ScaleGestureDetector.html). Он абсолютно аналогичен GestureDetector в плане использования в коде, отличается, только передаваемый в него listener:
```
private OnScaleGestureListener scaleGestureListener = new OnScaleGestureListener() {
@Override
public void onScaleEnd(ScaleGestureDetector detector) {
}
@Override
public boolean onScaleBegin(ScaleGestureDetector detector) {
return true;
}
@Override
public boolean onScale(ScaleGestureDetector detector) {
scaleX *= detector.getScaleFactor();
if (scaleX < 1) {
scaleX = 1;
}
if (scaleX > 2) {
scaleX = 2;
}
ViewCompat.postInvalidateOnAnimation(PianoView.this);
return true;
}
};
```
мы завели переменную scaleX, которая будет выражать уровень нашего зума и ограничим ее 1 и 2.
Другой вопрос, как мы будем зуммировать нашу клавиатуру. Для этой статьи я выбрал наипростейший вариант — просто преобразовать канву. Да, это не идеально, и приведет к искажению рисунка. Правильно — на основе значения scaleX увеличивать ширину клавиш, радиус кружков и текста. Это специфично именно для моей задачи и не имеет отношения к зуму в целом. Поэтому мы просто отмасштабируем канву:
```
canvas.save();
// задаем масштаб канвы
canvas.scale(scaleX, 1.0f);
canvas.translate(-localXOffset, 0);
keyboard.updateBounds(localXOffset, canvasWidth + localXOffset);
keyboard.draw(canvas);
if (!notesToDraw.isEmpty()) {
keyboard.drawOverlays(notesToDraw, canvas);
}
canvas.restore();
```
Готово, если сделать раздвигающий жест пальцами, мы увидим, как клавиатура растет в ширину:
#### Заключение
Вот и подошла к концу вторая часть моего цикла статей. Я надеюсь, что это поможет кому-то быстрее разобраться в тонкостях создания кастомных компонентов и улучшить качество своих проектов.
Готовый пример по-прежнему доступен на моем гитхабе: [goo.gl/VDeuw](http://goo.gl/VDeuw).
Также, всячески рекомендую ознакомиться с этой статьей из официальной документации:
[developer.android.com/training/gestures/index.html](http://developer.android.com/training/gestures/index.html)
В третьей статье постараюсь осветить вопросы оптимизации, использования битмапов вместо программного рисования текста, кружков, рассмотреть, какие возникают перерисовки пикселей в нашем компоненте, и как можно от них избавиться. | https://habr.com/ru/post/176919/ | null | ru | null |
# Подробности Firefox 3.6 для разработчиков
На официальном сайте Mozilla Developer Center появилась статья [Firefox 3.6 for developers](https://developer.mozilla.org/en/Firefox_3.6_for_developers), в которой описываются нововведения и изменения в грядущей версии Firefox 3.6. Особый интерес представляют изменения в работе с DOM:* сообщение reorder посылается фреймам, когда их документы загружены;
* метод getBoxObjectFor() был исключен, как нестандартный и привносящий в web нестандартный функционал;
* **добавлено событие hashchange!** Вслед за Internet Explorer 8, Firefox так же получает поддержку нового события из черновиков HTML 5. Подробнее я описывал его в [этой статье](http://habrahabr.ru/blogs/ie/64305/);
* добавлена поддержка адресов геолокации, что предоставит информацию о местоположении в удобном виде:
`a.address.streetNumber
a.address.street
a.address.premises
a.address.city
a.address.county
a.address.region
a.address.county
a.address.countryCode
a.address.postalCode`
где а — это объект, который вернул API геолокации.
Изменения пока не слишком значимые, но вместе с другими изменениями в XUL, вроде возможности скрывать menu bar автоматически, на отдельный минорный релиз вполне тянет. | https://habr.com/ru/post/65724/ | null | ru | null |
# System.IO.Pipelines — a little-known tool for lovers of high performance
Hello reader. Quite a lot of time has passed since the release of .NET Core 2.1. And such cool innovations as Span and Memory are already widely known, you can read, see and hear a lot about them. However, unfortunately, library called System.IO.Pipeslines did not receive the same attention. Almost everything there is on this topic is [the only post](https://devblogs.microsoft.com/dotnet/system-io-pipelines-high-performance-io-in-net/) that have been translated and copied on many resources. There should be more information about that technology to look on it from different angles.
Introduction
------------
So, this library aims to speed up processing of streaming data. It was originally created and used by the development team of Kestrel (a cross-platform web server for ASP.NET Core), but it is currently available for mortals through a [nuget package](https://www.nuget.org/packages/System.IO%20.Pipelines/).
Before we delve into the topic, we can imagine the library mechanism as an improved analogue of MemoryStream. The problem with the original MemoryStream is an excessive number of copies, which is obvious if you remember that a private byte array is used inside MemoryStream as a buffer. For example, in the [Read](https://github.com/dotnet/corefx/blob/master/src/Common/src/CoreLib/System/IO/MemoryStream.cs#L338) and [Write](https://github.com/dotnet/corefx/blob/master/src/Common/src/CoreLib/System/IO/MemoryStream.cs#L634) methods you can clearly see the data copying. Thus, for the object that we want to write to the stream, a copy will be created in the internal buffer, and during reading, a copy of the internal copy will be returned to the consumer. It sounds like not the most rational usage of memory.
System.IO.Pipelines does not aim to replace all streams, it is an additional tool in the arsenal of a developer writing high-performance code. I suggest that you familiarize yourself with the basic methods and classes, see their implementation details and analyze basic examples.
Let's start with the internals and implementation details, at the same time looking at simple code fragments. After that, it will become clear how it works and how it should be used. When working with System.IO.Pipelines it is worth remembering that the basic concept is that all read-write operations should take place without additional allocations. But some methods that are attractive at first glance contradict this rule. Accordingly, the code that you are trying to speed up so hard begins to allocate memory for new and new data, loading the garbage collector.
The library’s internals use the widest possibilities of the latest versions of the language and runtime — Span, Memory, object pools, ValueTask and so on. It’s worth to look there at least for a great example of using these features in production.
At one time, some developers were not satisfied with the implementation of streams in C#, because one class was used for both reading and writing. But as they say, you cannot throw methods out of a class. Even if the stream doesn't support reading/writing/seeking, the CanRead, CanWrite and CanSeek properties are used. It looks like a small crutch. But now things become different.
To work with pipelines, 2 classes are used: [PipeWriter](https://github.com/dotnet/corefx/blob/master/src/System.IO.Pipelines/src/System/IO/Pipelines/Pipe.DefaultPipeWriter.cs) and [PipeReader](https://github.com/dotnet/corefx/blob/master/src/System.IO.Pipelines/src/System/IO/Pipelines/Pipe.DefaultPipeReader.cs). These classes contain approximately 50 lines of code and are pseudo-facades (not the most classic of its incarnations, since they hide a single class, not a lot) for the class [Pipe](https://github.com/dotnet/corefx/blob/%20master/src/System.IO.Pipelines/src/System/IO/Pipelines/Pipe.cs), which contains all the basic logic for working with data. This class contains 5 public members: 2 constructors, 2 get-only properties — Reader and Writer, the Reset() method, which resets internal fields to their initial state so that the class can be reused. The remaining methods for work are internal and called using pseudo-facades.
Let's get started with the Pipe class
-------------------------------------
The class instance occupies 320 bytes, which is quite a lot (almost a third of a kilobyte, 2 of such objects could not fit in the memory of Manchester Mark I). So allocation huge amount of it's instances is a bad idea. Moreover, the object is intended for long-term use. Using pools also makes an argument for this statement. The objects used in the pool will live forever (for the default pool implementation).
Note that the class is marked as sealed and that it is thread safe — many sections of the code are a critical section and are wrapped in locks.
To start using this class you should create an instance of the Pipe class and obtain the PipeReader and PipeWriter objects using the properties mentioned.
**Simple initialization**
```
var pipe = new Pipe();
PipeWriter pipeWriter = pipe.Writer;
PipeReader pipeReader = pipe.Reader;
```
Consider the methods for working with pipes:
Writing with PipeWriter — WriteAsync, GetMemory/GetSpan, Advance, FlushAsync, Complete, CancelPendingFlush, OnReaderCompleted.
Reading with PipeReader — AdvanceTo, ReadAsync, TryRead, Complete, CancelPendingRead, OnWriterCompleted.
As stated in the [mentioned post](https://devblogs.microsoft.com/dotnet/system-io-pipelines-high-performance-io-in-net/), the class uses a singly linked list of buffers. But, obviously, they are not transferred between PipeReader and PipeWriter — all the logic is in one class. This list is used for both reading and writing. Moreover, the returned data is stored in this list (so no copying performed).
Also, there are objects indicating the beginning of data to read (ReadHead and index), the end of data to read (ReadTail and index) and the beginning of space to write (WriteHead and the number of buffered bytes written). Here ReadHead, ReadTail and WriteHead are a specific members (segments) of the internal list of segments, and the index indicates a specific position within the segment. Thus, recording can start from the middle of a segment, capture one whole next segment and end in the middle of the third. These pointers are moved in various methods.
Getting started with PipeWriter methods
---------------------------------------
### #1 [ValueTask WriteAsync(ReadOnlyMemory source, CancellationToken cancellationToken)](https://github.com/dotnet/corefx/blob/master/src/System.IO.Pipelines/src/System/IO/Pipelines/Pipe.cs#L941)
That is mentioned attractive at first glance method. It has a very suitable and fashionable signature — accepts ReadOnlyMemory, asynchronous. And many may be tempted, especially remembering that Span and Memory are so fast and cool. But do not flatter yourself. All that this method does is copying the ReadOnlyMemory passed to it into the internal list. And by “copy” is meant a call to the CopyTo() method, and not copying only the object itself. All the data that we want to record will be copied, thereby loading the memory. This method should be mentioned only to make sure that it is better not to use it. Well, and perhaps for some rare situations, this behavior is appropriate.
The body of the method is a critical section, access to it is synchronized through a monitor.
Then the question may arise, how to write something, if not through the most obvious and only suitable method
### #2 [Memory GetMemory(int sizeHint)](https://github.com/dotnet/corefx/blob/master/src/System.IO.Pipelines/src/System/IO/Pipelines/Pipe.cs#L139)
The method takes one parameter of an integer type. In it, we must indicate how many bytes we want to write to the pipeline (what size of the buffer we want). This method checks if there is enough space for writing in the current memory fragment stored in \_writingHeadMemory. If enough, \_writingHeadMemory is returned as the Memory. Otherwise, for the data written to the buffer, but for which the FlushAsync method was not called, it is called and another BufferSegment is allocated, which is connected to the previous one (here is our internal list). If \_writingHeadMemory is null, it is initialized with a new BufferSegment. And the allocation of the buffer is a critical section and is done under the lock.
I suggest to look at such an example. At first glance, it might seem that the compiler (or runtime) has beguiled the demon.
**Devilry**
```
var pipeNoOptions = new Pipe();
Memory memoryOne = pipeNoOptions.Writer.GetMemory(2);
Console.WriteLine(memoryOne.Length); //2048 or 4096
var pipeWithOptions = new Pipe(new PipeOptions(minimumSegmentSize: 5));
Memory memoryTwo = pipeWithOptions.Writer.GetMemory(2);
Console.WriteLine(memoryTwo.Length); //16
```
But everything in this example is understandable and simple.
While creating a Pipe instance, we can pass the [PipeOptions](https://github.com/dotnet/corefx/blob/master/src/System.IO.Pipelines/src/System/IO/Pipelines/PipeOptions.cs) object to it in the constructor with options for creating.
PipeOptions has a default minimum segment size field. Not so long ago, it was 2048, but [this commit](https://github.com/dotnet/corefx/commit/b49b512a6288edd96d4fbb68bf23a4bd2f831545#diff-617aa01c1102482ea5b65d3935be887e) has updated this value to 4096. At the time of writing this article, the 4096 version was in prerelease nuget-package, the last release version had a value of 2048. This explains the behavior of the first example. If you are critical of using a smaller size for the default buffer, you can specify it in an instance of the PipeOptions type.
But in the second example, where the minimum size is specified, the length does not match it anyway. And this is happening because the creation of a new BufferSegment occurs using pools. One of the options in PipeOptions is the memory pool. After that, the specified pool will be used to create a new segment. If you did not specify memory pool, the default ArrayPool will be used, which, as you know, has several buckets for different sizes of arrays (each next one is 2 times larger than the previous one) and when it is requested for a certain size, it searches for a bucket with arrays of suitable size (i.e., the nearest larger or equal). Accordingly, the new buffer will almost certainly be larger than you requested. The minimum array size in the default ArrayPool (System.Buffers.TlsOverPerCoreLockedStacksArrayPool) is 16. But do not worry, this is a pool of arrays. Accordingly, in the vast majority of cases, the array does not exert pressure on the garbage collector and will be reused later.
### #2.5 [Span GetSpan(int sizeHint)](https://github.com/dotnet/corefx/blob/master/src/System.IO.Pipelines/src/System/IO/Pipelines/Pipe.cs#L156)
It works similarly, giving Span from Memory.
Thus GetMemory() or GetSpan() are the main methods for writing. They give us an object that we can write to. To do this, we do not need to allocate memory for new arrays of values, we can write directly into the pipe. Which one to use will mainly depend on the API you are using and the method asynchrony. However, in view of the above, a question arises. How will the reader know how much we wrote? If we always used a specific implementation of the pool, which gives an array of exactly the same size as requested, then the reader could read the entire buffer at once. However, as we have already said, we are allocated a buffer with a high probability of a larger size. This leads to the following method required for operation.
### #3 [void Advance(int bytes)](https://github.com/dotnet/corefx/blob/master/src/System.IO.Pipelines/src/System/IO/Pipelines/Pipe.cs#L309)
A terribly simple method. It takes the number of bytes written as an argument. They increment the internal counters — \_unflushedBytes and \_writingHeadBytesBuffered, whose names speak for themselves. It also truncates (slices) \_writingHeadMemory exactly to the number of bytes written (using the Slice method). Therefore, after calling this method, you need to request a new memory block in the form of Memory or Span, you cannot write to the previous one. And the whole body of the method is a critical section and runs under a lock.
It seems that after this the reader can receive data. But one more step is needed.
### #4 [ValueTask FlushAsync(CancellationToken cancellationToken)](https://github.com/dotnet/corefx/blob/master/src/System.IO.Pipelines/src/System/IO/Pipelines/Pipe.cs#L330)
The method is called after we write the necessary data to the received Memory (GetMemory) and indicate how much we wrote there (Advance). The method returns ValueTask, however it is not asynchronous (unlike its descendant StreamPipeWriter). ValueTask is a special type (readonly struct) used in the case when most calls will not be asynchronous, that is all the necessary data will be available at the time of its call and the method will end synchronously. Inside itself it contains either data or Task (in case it didn’t work out synchronously). It depends on \_writerAwaitable.IsCompleted property. If we look for what changes the state of this \_writerAwaitable, we will see that this happens if the amount of not consumed data (this is not exactly the same as not examined data will be explained later) exceeds a certain threshold (\_pauseWriterThreshold). The default value is 16 segment sizes. If desired, the value can be changed in PipeOptions. Also, this method starts the continuation of the ReadAsync method, if one was blocked.
Returns a FlushResult containing 2 properties — IsCanceled and IsCompleted. IsCanceled indicates whether Flush has been canceled (CancelPendingFlush() call). IsCompleted indicates whether the PipeReader has completed (by calling the Complete() or CompleteAsync() methods).
The main part of the method is performed under the lock.
Other methods of PipeWriter are not interesting from the implementation point of view and are used much less often, therefore only a brief description will be given.
### #5 void Complete(Exception exception = null) or ValueTask CompleteAsync(Exception exception = null)
Marks pipe closed for writing. An exception will be thrown when attempting to use the write methods after completion. If PipeReader has already been completed, the entire Pipe instance is also completed. Most of the work is done under the lock.
### #6 void CancelPendingFlush()
As the name implies, it cancels the current FlushAsync() operation. There is a lock.
### #7 void OnReaderCompleted(Action callback, object state)
Executes the passed delegate when the reader completes. There is also a lock.
In the [documentation](https://docs.microsoft.com/en-us/dotnet/api/system.io.pipelines.pipewriter.onreadercompleted?view=dotnet-plat-ext-2.1) it is currently written that this method may not be called on some PipeWriter implementations and will be removed in the future. Therefore, you should not tie logic to these methods.
It's time for PipeReader
------------------------
### #1 [ValueTask ReadAsync(CancellationToken token)](https://github.com/dotnet/corefx/blob/master/src/System.IO.Pipelines/src/System/IO/Pipelines/Pipe.cs#L646)
Here, like in FlushAsync(), ValueTask is returned, which hints that the method is mostly synchronous, but not always. Depends on the state of \_readerAwaitable. As with FlushAsync, you need to find when \_readerAwaitable is set to incomplete. This happens when PipeReader has read everything from the internal list (or it contains data that was marked as examined and you need more data to continue). Which, in fact, is obvious. Accordingly, we can conclude that it is desirable to fine-tune Pipe to your work, to set all its options thoughtfully, based on empirically identified statistics. Proper configuration will reduce the chance of an asynchronous execution branch and will allow more efficient processing of data. Almost all code in the entire method is surrounded by a lock.
Returns some mysterious [ReadResult](https://github.com/dotnet/corefx/blob/master/src/System.IO.Pipelines/src/System/IO/Pipelines/ReadResult.cs). In fact, it’s just a buffer + flags showing the status of the operation (IsCanceled — whether ReadAsync was canceled and IsCompleted indicating whether the PipeWriter was closed). IsCompleted is a value indicating whether the PipeWriter Complete() or CompleteAsync() methods were called. If these methods were called with an exception passed, then it will be thrown when trying to read.
And again, the buffer has a mysterious type — [ReadOnlySequence](https://github.com/dotnet/corefx/blob/d3911035f2ba3eb5c44310342cc1d654e42aa316/src/System.Memory/src/System/Buffers/ReadOnlySequence.cs). This, in turn, is the object for the contents of segments [(ReadOnlySequenceSegment)](https://github.com/dotnet/corefx/blob/cbb62e0e6ebdb10d5b2c6badb9245b4d28120131/src/System.Memory/src/System/Buffers/ReadOnlySequenceSegment.cs) of the beginning and the end + start and end indexes inside the corresponding segments. Which actually resembles the structure of the Pipe class itself. By the way, BufferSegment is inherited from ReadOnlySequenceSegment, which hints that BufferSegment is used in this sequence. Thanks to this, you can just get rid of unnecessary memory allocations for data transfer from writer to reader.
ReadOnlySpan can be obtained from the buffer for further processing. To complete the picture, you can check if the buffer contains a single ReadOnlySpan. If it contains, we do not need to iterate over the collection from one element and we can get it using the First property. Otherwise, it is necessary to go over all segments in the buffer and process ReadOnlySpan of each.
Discussion topic — in the ReadOnlySequence class, nullable reference types are actively used and there is goto (not for deep loop nesting and not in the generated code) — in particular, [here](https://github.com/dotnet/corefx/blob/d3911035f2ba3eb5c44310342cc1d654e42aa316/src/System.Memory/src/System/Buffers/ReadOnlySequence.cs#L349).
After processing, you need to signal the Pipe instance that we read the data.
### #2 [bool TryRead(out ReadResult result)](https://github.com/dotnet/corefx/blob/master/src/System.IO.Pipelines/src/System/IO/Pipelines/Pipe.cs#L674)
Synchronous version. Allows you to get the result if it exists. Otherwise, unlike ReadAsync it does not block and returns false. Also the code of this method is in the lock.
### #3 [void AdvanceTo(SequencePosition consumed, SequencePosition examined)](https://github.com/dotnet/corefx/blob/master/src/System.IO.Pipelines/src/System/IO/Pipelines/Pipe.cs#L428)
In this method, you can specify how many bytes we examine and consume. Data that has been examined but not consumed will be returned the next time it is read. This feature may seem strange at first glance, but when processing a stream of bytes it is rarely necessary to process each byte individually. Usually data is exchanged using messages. A situation may arise that the reader, when reading, received one whole message and part of the second. The whole must be processed, and part of the second should be left for future so that it comes along with the remaining part. The AdvanceTo method takes a SequencePosition, which is actually a segment + index. When processing everything that ReadAsync has read, you can specify buffer.End. Otherwise, you have to explicitly create a position, indicating the segment and index at which processing was stopped. Lock is under the hood.
Also, if the amount of not consumed information is less than the specified threshold (\_resumeWriterThreshold), it starts the continuation of PipeWriter if it was blocked. By default, this threshold is 8 segment volumes (half the blocking threshold).
### #4 void Complete(Exception exception = null)
Completes the PipeReader. If the PipeWriter is completed at this point, then the entire Pipe instance completes. Lock inside.
### #5 void CancelPendingRead()
Allows you to cancel the reading that is currently in pending state. Lock.
### #6 void OnWriterCompleted(Action callback, object state)
Allows you to specify the delegate to execute upon completion of the PipeWriter.
Like the similar method of PipeWriter, in the [documentation](https://docs.microsoft.com/en-us/dotnet/api/system.io.pipelines.pipereader.onwritercompleted?view=dotnet-plat-ext-2.1) there is the same tag that will be removed. Lock is under the hood.
Example
-------
The listing below shows an example of working with pipes.
Since the introduction of .NET Core Span and Memory, many classes for working with data have been supplemented by overloads using these types. So the general interaction scheme will be approximately the same. In my example, I used pipelines to work with pipes (I like similar words) — OS objects for interprocess communication. The pipes API has just been expanded accordingly to read data in Span and Memory. The asynchronous version uses Memory, since the asynchronous method will be converted to a template method using an auto-generated finite state machine, in which all local variables and method parameters are stored, and since Span is ref readonly struct, it cannot be placed in the heap, respectively, using Span in an asynchronous method is impossible. But there is also a synchronous version of the method that allows you to use Span. In my example, I tried both and it turned out that the synchronous version in this situation shows itself better. When using it, less garbage collection occurs, and data processing is faster. But this was only because there was a lot of data in the pipe (the data was always available). In the situation in which it is rather likely that there will be no data at the time of applying for the next batch, you should use the asynchronous version so as not to strain the processor idle.
The example has comments that explain some points. I draw your attention to the fact that despite the fact that the fragments of the program responsible for reading from the pipe and processing are separated, when writing to a file, the data is read exactly from the place where it is written when reading from the pipe.
**Years of evolution for the sake of a powerful feature - asynchronous main**
```
class Program
{
static async Task Main(string args)
{
var pipe = new Pipe();
var dataWriter = new PipeDataWriter(pipe.Writer, "testpipe");
var dataProcessor = new DataProcessor(new ConsoleBytesProcessor(), pipe.Reader);
var cts = new CancellationTokenSource();
await Task.WhenAll(dataWriter.ReadFromPipeAsync(cts.Token), dataProcessor.StartProcessingDataAsync(cts.Token));
}
}
```
**PipeDataWriter**
```
public class PipeDataWriter
{
private readonly NamedPipeClientStream _namedPipe;
private readonly PipeWriter _pipeWriter;
private const string Servername = ".";
public PipeDataWriter(PipeWriter pipeWriter, string pipeName)
{
_pipeWriter = pipeWriter ?? throw new ArgumentNullException(nameof(pipeWriter));
_namedPipe = new NamedPipeClientStream(Servername, pipeName, PipeDirection.In);
}
public async Task ReadFromPipeAsync(CancellationToken token)
{
await _namedPipe.ConnectAsync(token);
while (true)
{
token.ThrowIfCancellationRequested();
//// when working with the asynchronous method, use Memory
//Memory buffer = \_pipeWriter.GetMemory();
//// asynchronous reading from a named pipe in Memory
//// there can be any operation to obtain data - from reading from a file to random generation.
//int readBytes = await \_namedPipe.ReadAsync(buffer, token);
// synchronous reading from the named pipe to the requested from PipeWriter Span
// there can be any operation to obtain data - from reading from a file to random generation.
int readBytes = \_namedPipe.Read(\_pipeWriter.GetSpan());
// if there was nothing in the channel, release the thread for half a second and try again
// in other cases we can break the loop, it's just example
if (readBytes == 0)
{
await Task.Delay(500, token);
continue;
}
// specify the amount of bytes read from the pipe
\_pipeWriter.Advance(readBytes);
// flush data to make them available PipeReader
FlushResult result = await \_pipeWriter.FlushAsync(token);
// if PipeReader has been completed, it no longer needs to write data
// PS this behavior was chosen by me as an example, it depends on business logic
if (result.IsCompleted)
{
break;
}
}
// complete \_pipeWriter to complete the entire instance of pipe
\_pipeWriter.Complete();
}
}
```
**DataProcessor**
```
public class DataProcessor
{
private readonly IBytesProcessor _bytesProcessor;
private readonly PipeReader _pipeReader;
public DataProcessor(IBytesProcessor bytesProcessor, PipeReader pipeReader)
{
_bytesProcessor = bytesProcessor ?? throw new ArgumentNullException(nameof(bytesProcessor));
_pipeReader = pipeReader ?? throw new ArgumentNullException(nameof(pipeReader));
}
public async Task StartProcessingDataAsync(CancellationToken token)
{
while (true)
{
token.ThrowIfCancellationRequested();
// reading data from a pipe instance
ReadResult result = await _pipeReader.ReadAsync(token);
ReadOnlySequence buffer = result.Buffer;
// We perform calculations with the data obtained.
await \_bytesProcessor.ProcessBytesAsync(buffer, token);
// indicate to which position the data was processed. In this case, everything is written to the file.
// in situations where not all data has been processed, you need to create a position manually using the buffer and index
// in this situation, IBytesProcessor.ProcessBytesAsync can be supplemented by returning this position
\_pipeReader.AdvanceTo(buffer.End);
// if PipeWriter has been completed, reading is no longer necessary
// this behavior was chosen by me as an example, it depends on business logic
if (result.IsCompleted)
{
break;
}
}
// complete \_pipeReader to complete the entire instance of pipe
\_pipeReader.Complete();
}
}
```
**BytesProcessor**
```
public interface IBytesProcessor
{
Task ProcessBytesAsync(ReadOnlySequence bytesSequence, CancellationToken token);
}
public class ConsoleBytesProcessor : IBytesProcessor
{
//Let's imagine that in this class there is a normal constructor and IDisposable
readonly FileStream \_fileStream = new FileStream("buffer", FileMode.Create);
public Task ProcessBytesAsync(ReadOnlySequence bytesSequence, CancellationToken token)
{
if (bytesSequence.IsSingleSegment)
{
ProcessSingle(bytesSequence.First.Span);
}
else
{
foreach (var segment in bytesSequence)
{
ProcessSingle(segment.Span);
}
}
return Task.CompletedTask;
}
private void ProcessSingle(ReadOnlySpan span)
{
\_fileStream.Write(span);
}
}
``` | https://habr.com/ru/post/466137/ | null | en | null |
# HomeKit для Z-Wave, Raspberry GPIO и устройств с HTTP API с помощью контроллера RaZberry
Тема интернета вещей сейчас как никогда наиболее популярна. Каждый день выходят новые интересные устройства способные общаться друг с другом через интернет. Пока различные производители договариваются о общем протоколе общения, Apple решила взять дела в свои руки и выпустила Framework HomeKit стандартизирующий способы управления устройствами различных производителей. В перспективе с помощью мобильного приложения HomeKit можно будет управлять различными лампочками, термостатами, розеточными модулями по wifi или bluetooth. Но это все в ближайшем будущем, хотя нет, постойте…
Вы уже сейчас можете работать более чем с 1000 HomeKit устройствами или создавать свои HomeKit совместимые устройства!!!
1. О HomeKit шлюзе RaZberry
2. Установка ПО автоматизации Z-Way
3. Создание датчика температуры из данных OpenWeather и Реле из GPIO Raspberry
4. Приложение HomeKit для iOS из примеров Apple
### О HomeKit шлюзе RaZberry
На данный момент на мировом рынке присутствует более 1000 Z-Wave устройств и все они совместимы друг с другом. Устройства могут работать, как друг с другом напрямую так и через центральный контроллер, который выполняет роль шлюза Z-Wave <=> TCP/IP. Обычно такие шлюзы служат для управления Z-Wave устройствами из Web интерфейса или мобильного приложения. Одним из самых популярных шлюзов является Z-Wave контроллер RaZberry <http://razberry.z-wave.me/>.
RaZberry — это программно-аппаратный комплекс поддерживающий протоколы Z-Wave, HTTP, TCP и возможность запуска системных команд, например Bash. ПО автоматизации RaZberry называется Z-Way и благодаря поддержке HTTP API можно создать, датчик температуры, взяв данные с OpenWeather, который можно использовать в различных правилах автоматизации. Z-Way распространяется бесплатно и доступен для многих платформ, более того проект является OpenSource, за исключением части работы с Z-Wave, т.к. подписан NDA с Sigma Designs, владелицей протокола Z-Wave. В состав Z-Way входит модуль для работы с HomeKit, который и позволяет транслировать Z-Wave и HTTP устройства из RaZberry в HomeKit приложение на iOS.
### Установка ПО автоматизации Z-Way
Скачайте Z-Way <http://razberry.z-wave.me/z-way-server/> на ваш компьютер, есть различные сборки под Linux x86, Raspberry и Windows. Для Raspberry можно воспользоваться инсталлятором, который ко всему прочему установит еще и сервис удаленного доступа, позволяющий попасть в панель управления умным домом через сервис find.z-wave.me, используя RaZberry ID и пароль:
```
wget -q -O - razberry.z-wave.me/install/v2.0.1-rc24 | sudo bash
```
Для различных версий Linux скаченный архив нужно просто распаковать и запустить z-way-server:
```
LD_LIBRARY_PATH=./libs ./z-way-server &
```
### Создание датчика температуры из данных OpenWeather и Реле из GPIO Raspberry
После запуска нужно перейти в Web интерфейс настройки автоматизации [IP\_ADDRESS](http://IP_ADDRESS):8083.
Выберите интерфейс Z-Way Home Automation UI.
Теперь нужно создать устройства, которыми будем управлять. Если используется плата RaZberry или USB Z-Wave Stick, то у вас уже есть устройства, иначе давайте создадим датчик температуры и подключим реле к GPIO выходам Raspberry.
Для создания датчика температуры перейдите на вкладку **Preferences-->Modules-->Environment** и выберите модуль **OpenWeather**.
Проводим не сложную настройку.
И получаем датчик температуры.
Далее добавляем реле. Управлять GPIO будем командой echo, поэтому системе автоматизации нужно разрешить использовать внешнюю программу. В **z-way-server/automation/.syscommands** вносим разрешенную команду **echo**:
```
echo "echo" >> .syscommands
```
Возвращаемся в интерфейс автоматизации и переходим на вкладку **Preferences-->Modules-->Devices**, здесь нужно выбрать модуль **CodeDevice**.
Указываем тип: **SwitchBinary**
Команда включить:
```
system('echo "1" > /sys/class/gpio/gpio24/value');
```
Команда выключить:
```
system('echo "0" > /sys/class/gpio/gpio24/value');
```
При старте системы автоматизации нужно настроить GPIO порт на выход, для этого переходим на вкладку **Preferences-->Modules-->Scripting** и выбираем модуль **CustomUserCode**, в текстовое поле пишем код:
```
system('echo "24" > /sys/class/gpio/export');
system('echo "out" > /sys/class/gpio/gpio24/direction');
```
Теперь у нас есть 2 работающих устройства.
Далее нужно активировать модуль HomeKit. Для сопряжения устройства с приложением HomeKit требуется ввести код, в Z-Way этот код можно посмотреть в логе, запускаем просмотр лога в консоле:
```
tail -f /var/log/z-way-server.log
```
И теперь запускаем модуль **HomeKitGate** на вкладке **Preferences-->Modules-->Peripherals**.
Из настроек, только имя которое будет отображаться при поиске на iOS устройстве.
После запуска модуля смотрим в лог и видим код сопряжения **HomeKit PIN:249-01-266**.
### Приложение HomeKit для iOS из примеров Apple
В AppStore есть одно работающее приложение HomeKit — MyTouchHome (на момент написания статьи), стоит 1.99$.
Для iOS разработчиков компания Apple охотно делится примерами, поэтому мы сами можем скачать исходники и скомпилировать себе приложение на iOS устройство. Исходники примера HomeKit берем здесь:
<https://developer.apple.com/library/ios/samplecode/HomeKitCatalog/HomeKitCatalog.zip>
Для сборки приложения требуется аккаунт разработчика, без него приложение сообщало об ошибке, что не может подключиться.
После запуска приложения находим наш контроллер, добавляем его в наш дом, и видим список наших устройств, которыми можем управлять.
Состояния устройств полностью синхронизированы, управлять можно и из Web панели и из приложения HomeKit.
Надеюсь в скором времени появится много функциональных приложений с поддержкой HomeKit, ну а мы уже готовы! | https://habr.com/ru/post/378175/ | null | ru | null |
# Обновление строк на лету в мобильных приложениях: часть 2
Привет, Хабр!
[В недавней статье](https://habrahabr.ru/company/badoo/blog/346458/) наш коллега Дмитрий Марущенко [yojick](https://habrahabr.ru/users/yojick/) рассказал о том, как доставлять динамические обновления переводов с сервера на мобильные устройства. В продолжение темы сегодня поговорим о том, как мы используем эти обновлённые переводы в наших приложениях.
Исторически сложилось, что все основные мобильные платформы «из коробки» обладают превосходной поддержкой локализации сообщений. В iOS, Android и Windows Phone приложение можно локализовать без всяких трудностей. Все средства для этого уже встроены в IDE: просто укажите нужный язык в списке поддерживаемых локализаций, введите текст на этом языке — и всё остальное за вас сделает IDE. Работает как часы. Но у этого подхода всё же есть недостатки.
Нашли в тексте ошибку? Хотите что-то перефразировать? Вам нравится экспериментировать с разными обращениями к разным целевым группам? Во всех случаях ответ один: придётся пересобирать приложение, снова выкладывать его в магазин, проходить проверку, получать одобрение, публиковать новую версию со всеми изменениями и ждать, чтобы пользователи обновили приложение на своих устройствах. Даже если все процедуры пройдут без заминок, это займёт дни или недели. А если пользователи не захотят обновляться? Или того хуже — не смогут этого сделать по техническим причинам вроде неподдерживаемой ОС? Тогда нежелательный текст в вашем приложении проживет гораздо дольше, чем хотелось бы.
Это довольно неудобно. К счастью, нам удалось решить эту проблему на разных платформах (с учётом особенностей каждой из них). И мы рады поделиться своим решением.
Всё просто. Мы воспользуемся имеющимися платформенными средствами локализации, но добавим к ним динамические обновления по требованию. Для этого внедрим систему версионирования локализации. Когда разработчик, технический писатель или кто-либо ещё изменит базу данных локализации, мы увеличим номер версии локализации. При сборке мобильного приложения мы получим самую свежую версию локализации и положим её в бандл вместе с номером версии.
Если клиент получает от сервера сигнал о появлении новой версии локализации, он запрашивает обновление, предоставляя серверу текущую версию локализации. Имея две разные версии, сервер создаёт дифф и передаёт его мобильному клиенту. Получив дифф, клиент применяет его к текущей версии, сохраняет последнюю версию и с этого момента использует в приложении только обновлённый пакет.
Процесс можно повторять раз за разом. Клиент всегда будет получать от сервера самую свежую версию локализации. Подход, о котором пойдёт речь далее, мы используем на клиентской стороне во всех мобильных приложениях Badoo. Учитывая все реализованные серверные средства и предполагая, что клиентский код уже имеет доступ к обновлённым локализациям, нам нужно лишь предоставлять компонентам пользовательского интерфейса правильные сообщения. За работу!
iOS
---
Естественный способ локализации сообщения в iOS заключается в использовании одного из методов семейства `NSLocalizedString`. Мы создали набор аналогичных методов `BPFLocalizedString` (префикс BPF означает Badoo Platform Foundation) и используем их по всему приложению. «Под капотом» `BPFLocalizedString` использует сервис локализации, который содержит все данные и реализует основной функционал. Мы сохраняем все поступающие от сервера обновления в отдельном бандле. Когда клиентский код запрашивает локализованную строку, мы ищем в этом бандле нужное сообщение и при необходимости возвращаемся к дефолтному бандлу локализации.
```
public func localizedStringForKey(_ key: String) - > String {
let str = self.localizationsBundle.localizedString(forKey: key)
return str == key ? Bundle.main.localizedString(forKey: key,
value: nil, table: nil) : str
}
```
Этот подход сильно упрощает клиентский код. При этом можно использовать всю тяжёлую локализационную iOS-машинерию, включая поддержку языков с правосторонним начертанием и множественные (plural) локализации. Для этого нам нужно лишь поддерживать внутри дополнительного пакета валидные данные.
Верхнеуровневый API для `BPFLocalizedString` выглядит так:
```
NSString * __nonnull BPFLocalizedString(NSString * __nonnull key, NSString * __nullable comment);
public func BPFLocalizedString(_ key: String) - > String {
return
BPFGlobals.shared().localizedStringsService.localizedStringForKey(
key)
}
```
Его легко использовать как из Objective-C-, так и из Swift-кода.
Есть одна тонкость. Обновления локализации могут приходить в любой момент жизненного цикла клиентского приложения. И при этом мы ещё можем показывать пользователям какие-то «старые» локализованные сообщения. Чтобы сохранять согласованность данных, лучше не смешивать «старые» локализации с «новыми». Эту задачу мы решаем, применяя обновления только при следующем запуске приложения. Такое решение всё упрощает и позволяет клиентскому коду не «думать» о неожиданных случаях.
Какие здесь ограничения? Нужно быть уверенными, что мы везде заменили `NSLocalizedString` на соответствующие `BPFLocalizedString`. К счастью, эту задачу можно легко решить с помощью автоматических скриптов. Другим ограничением является невозможность применения `BPFLocalizedString` напрямую к статично упакованным элементам пользовательского интерфейса (XIB и Storyboard). Это вполне естественное ограничение, поскольку мы заменяем статичную локализацию на динамическую.
Android
-------
В Android локализации упакованы в APK-файл, и в ходе выполнения менять его невозможно. В этой ОС стандартным решением по локализации сообщения является использование Resources. Доступ к `Resources` является частью интерфейса `Context`. `Resources` предоставляет конфигурацию текущего устройства (локейшн, размер экрана, ориентацию и так далее). Одним из решений является замена всех `Resources.getString()` на нашу собственную кастомную реализацию, как в iOS. Но мы выбрали более элегантный способ.
Что, если можно было бы внедрять свою реализацию `Resources` вместо системной? К счастью, это возможно! Возьмём класс `Activity`, напишем его наследника и везде применим:
```
public abstract class BaseActivity extends Activity {
private Resources mResources;
public Resources getResources() {
if (mResources == null) {
Resources r = super.getResources();
mResources = new ResourceWrapper(this, r);
}
return mResources;
}
}
```
И сделаем обёртку вокруг стандартного `Resources` для извлечения обновлённых значений лексем:
```
public class ResourceWrapper extends Resources {
private final Resources mResources;
private final LexemeProvider mLexemeProvider;
public ResourceWrapper(Context context, Resources r) {
super(r.getAssets(), r.getDisplayMetrics(), r.getConfiguration());
mResources = resources;
mLexemeProvider = new LexemeProvider(...);
}
@Override
public String getString(@StringRes int id) throws
NotFoundException{
String hotString = mLexemeProvider.getString(id);
if (hotString == null) {
return mResources.getString(id);
} else {
return hotString;
}
// Override each method and return corresponding value from
mResources
@Override
public boolean getBoolean(int id) throws NotFoundException {
return mResources.getBoolean(id);
}
}
```
Очевидно, что нужно перехватывать все методы, относящиеся к тексту (getString, getText, getQuantityString, getQuantityText), и возвращать значения, полученные от нашего собственного поставщика локализаций.
Обычно система использует не непосредственно класс Resources, который есть в исходниках Android, а некоего его наследника, поэтому надо пробрасывать *все* вызовы к `ResourceWrapper` в эту конкретную реализацию (`mResources`в нашем случае).
Пока что мы имели дело с явными получателями лексем. А что насчёт представлений, «надуваемых» из XML-макетов? Когда вы объявляете атрибут android:text, после своего «надувания» `TextView` вызывает context.getTheme().obtainStyledAttributes(…).getText(…), чтобы получить соответствующие значения, и в этом случае наша замена для `Resources` уже не работает.
Нужно и сюда тоже внедрить наш `LocalizationProvider`.
```
public class DynamicLexemeInflater {
private static void applyDynamicLexems(View view, String name,
Context context, AttributeSet attrs) {
if (view instanceof TextView) {
TextView textView = (TextView) view;
TypedArray typedArray = context.obtainStyledAttributes(attrs,
new int[] {
android.R.attr.text, android.R.attr.hint
});
int textResourceId = typedArray.getResourceId(0, -1);
if (textResourceId != -1) {
String dispatchedString = context.getString(textResourceId);
textView.setText(dispatchedString);
}
int hintResourceId = typedArray.getResourceId(1, -1);
if (hintResourceId != -1) {
String dispatchedString = context.getString(hintResourceId);
textView.setHint(dispatchedString);
}
typedArray.recycle();
}
}
```
Здесь мы настроили свою фабрику `InflaterFactory` для добавления «постобработки» «надуваемых» представлений, в которых задаются текстовые значения.
Windows Phone
-------------
Как и в iOS с Android, в Windows Phone ресурсы локализации помещены в пакет приложения. Его тоже нельзя изменить в ходе выполнения программы. Наш подход к горячему обновлению локализаций основан на API Windows Phone Silverlight 8.1.
В WP-приложениях мы обычно обращаемся к локализованным сообщениям через генерируемый инструментарием класс `AppResources` (или можно дать ему любое другое имя), который содержит статические геттеры для всех строк, используемых в приложении. Вот что находится внутри этих геттеров:
```
public static string ApplicationTitle {
get {
return ResourceManager.GetString("ApplicationTitle",
resourceCulture);
}
}
```
Обратите внимание, что здесь используется свойство `ResourceManager`, определённое как
```
public static global::System.Resources.ResourceManager
ResourceManager {
get {
if (object.ReferenceEquals(resourceMan, null)) {
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("PhoneApp.Resources.AppResources",
typeof (AppResources).Assembly);
resourceMan = temp;
}
return resourceMan;
}
}
```
`System.Resources.ResourceManager` — это центральный компонент API системы локализации, на него ложится весь нелёгкий труд по загрузке актуальных строковых значений. К счастью, в перегруженном методе (overloaded method) у него есть точка расширения:
`public virtual string GetString(string name, CultureInfo culture)`. Именно это нам и нужно для внедрения своей машинерии и для дополнения предоставляемых системой средств. Нужно лишь унаследоваться от этого класса и перегрузить метод `GetString`:
```
public class UpdateableResourceManager: ResourceManager {
public override string GetString(string name, CultureInfo culture)
{
var lexemesHandler = _localizationService.GetLexemesHandler(culture);
return lexemesHandler?.GetLexeme(name)?.Value?.Text ?? base.GetString(name, culture);
}
}
```
Теперь нужно использовать наш `UpdateableResourceManager` вместо того, что по умолчанию используется в классе `AppResources`. Но поскольку этот класс генерируется автоматически, нужно также получить контроль над генерированием, чтобы добавлять в получающийся файл свои данные. Обычно это делается при каждом открывании файла `AppResources` в Visual Studio, но можно сделать это и вручную (или автоматически в скрипте) с помощью инструмента RESGen, как в этом примере с PowerShell:
```
$resgenPath = “C:\Program Files (x86)\Microsoft SDKs\Windows\v10.0A\bin\NETFX 4.6 Tools\ResGen.exe” & $resgenPath AppResources.resx to_delete.txt “/str:cs,Badoo.Is.Ponies.Namespace,AppResources,AppResources.Designer.cs” / publicclass
Remove — Item “to_delete.txt”
```
Также нужно заменить строку `System.Resources.ResourceManager` в нашем `Badoo.Next.Big.Thing.UpdateableResourceManager`. Остальное обрабатывается в отдельном LocalizationService, отвечающем за всю работу с сетью, сохранение и поиск данных.
Заключение
----------
Это краткий обзор нашего подхода к реализации процесса динамического обновления локализаций для собственных мобильных приложений на всех основных платформах. У всех трёх случаев много общего. Мы создали мощный и гибкий в использовании инструмент, позволяющий в любое время применять обновления локализаций. При этом мы постарались как можно более органично интегрировать его с нашей базой кода. Это позволило нам внедрить локализационную инфраструктуру в мобильные приложения с минимальными усилиями со стороны клиентских разработчиков. Мы используем средства локализации в повседневном рабочем процессе. Это проверенный временем, надёжный и полезный инструмент.
Пётр Колпащиков, iOS-разработчик
Виктор Патрушев, Android-разработчик
Стас Шуша, Windows Phone-разработчик | https://habr.com/ru/post/348350/ | null | ru | null |
# Как подружить helm со своим шаблонизатором?
Helm использует [go templates](https://pkg.go.dev/text/template) для рендеринга манифестов. Есть функции, которые были разработаны специально для helm. Но в большинстве своем используется библиотека [Sprig](http://masterminds.github.io/sprig/).
Но что, если нам мало функций и мы хотим воспользоваться каким-нибудь своим кастомным шаблонизатором?
В этой статье я покажу пример, как подключить шаблонизатор `gomplate`. Но это не помешает вам использовать какой-нибудь другой. Принципы одинаковые.
`gomplate` содержит огромное количество функций по работе со строками, сетью, криптографией и т.д.
Одна из киллер-фичей – получать данные из разных источников: файлы, https, git, ssh, AWS EC2 metadata, AWS Secret Manager, [BoltDB](https://pkg.go.dev/go.etcd.io/bbolt), [Hashicorp Consul](https://www.consul.io/) и [Hashicorp Vault](https://www.vaultproject.io/).
### Подготовка
Для начала надо установить `helm` и `gomplate` , если они еще не установлены.
```
$ brew install helm
$ brew install gomplate
```
Первая сложность: [gomplate](https://github.com/hairyhenderson/gomplate) и helm используют одинаковые кавычки-разделители `{{` и `}}` для шаблонов.
Можно было бы начать их экранировать. Но это ни к чему хорошему не приведет. Будет много некрасивого кода и кавычек. Поэтому проще назначить другие кавычки для `gomplate`.
```
export GOMPLATE_LEFT_DELIM="[["
export GOMPLATE_RIGHT_DELIM="]]"
```
**Тестируем:**
```
echo 'Hello, [[ .Env.USER ]]' | gomplate
Hello, zhilyaev
```
### Создаем helm chart
```
# [[ defineDatasource "foo" "https://httpbin.org/get" ]]
# [[ if not (datasourceReachable "foo")]] unreachable [[end]]
# [[ $d := ds "foo" ]]
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ include "this.fullname" . }}
labels: {{ include "this.labels" . | nindent 4 }}
data:
random: "[[ random.AlphaNum 32 ]]"
host: "[[ $d.headers.Host ]]"
```
Переходим к основной части. Helm имеет флажок `--post-renderer` его мы и будем жадно абузить.
Диаграмма работы**Запускаем:**
helm template this chart --post-renderer gomplate
```
# Source: this/templates/configmap.yaml
#
#
#
apiVersion: v1
kind: ConfigMap
metadata:
name: this
labels:
helm.sh/chart: this-0.1.0
app.kubernetes.io/name: this
app.kubernetes.io/instance: this
app.kubernetes.io/version: "1.16.0"
app.kubernetes.io/managed-by: Helm
data:
random: "2tJyK9xSsg1gvEmunEokQf4lyGkvojiQ"
host: "httpbin.org"
```
**Деплоим:**
```
helm upgrade --install this chart --post-renderer gomplate
```
**Profit**
### Послесловие
Внедрение `--post-renderer` вносит дополнительную сложность. Cледуя принципам KISS, попробуйте [helmwave](https://github.com/helmwave/helmwave). В нем мы решаем повседневные проблемы при работе с helm, не вмешиваясь в функционал чартов. | https://habr.com/ru/post/582578/ | null | ru | null |
# Математика на пальцах: линейно-квадратичный регулятор
Пара часов из жизни математика-программиста или читаем википедию
================================================================
Для начала в качестве эпиграфа [цитирую](https://habrahabr.ru/post/277275/#comment_8774641) [rocknrollnerd](https://habrahabr.ru/users/rocknrollnerd/):
> — Здравствуйте, меня зовут %username%, и втайне раскрываю суммы из сигма-нотации на листочке, чтобы понять, что там происходит.
>
> — Привет, %username%!
>
>
Итак, как я и говорил в своей прошлой статье, у меня есть студенты, которые **панически** боятся математики, но в качестве хобби ковыряются паяльником и сейчас хотят собрать тележку-сигвей. Собрать-то собрали, а вот держать равновесие она не хочет. Они думали использовать [ПИД-регулятор](https://ru.wikipedia.org/wiki/%D0%9F%D0%98%D0%94-%D1%80%D0%B5%D0%B3%D1%83%D0%BB%D1%8F%D1%82%D0%BE%D1%80), да вот только не сумели подобрать коэффициенты, чтобы оно хорошо работало. Пришли ко мне за советом. А я ни бум-бум вообще в теории управления, никогда и близко не подходил. Но зато когда-то на хабре я видел [статью](https://habrahabr.ru/post/220989/), которая говорила про то, что линейно-квадратичный регулятор помог автору, а пид не помог.
Если ПИД я ещё себе худо-бедно на пальцах представляю ([вот моя статья](https://geektimes.ru/post/255598/), которую с какого-то перепугу перенесли на гиктаймс), то про другие способы управления я даже и не слышал толком. Итак, моя задача — это представить себе (и объяснить студентам, а заодно и вам), что такое линейно-квадратичный регулятор. Пока что работы с железом не будет, я просто покажу, как я работаю с литературой, ведь именно это и составляет львиную долю моей работы.
Раз уж пошёл эксгибиционизм про мою работу, то вот вам моё рабочее место (кликабельно):
[](https://hsto.org/files/087/df6/2a0/087df62a041a40499f4f6447da33ab1c.jpg)[](https://hsto.org/files/68e/c8f/5d1/68ec8f5d11b1401ebde13c7e767dff39.jpg)
Используемые источники
======================
Итак, первое, что я делаю, иду в [википедию](https://en.wikipedia.org/wiki/Linear-quadratic_regulator). Русская википедия жестока и беспощадна, поэтому читаем только английский текст. Он тоже отвратителен, но всё же не настолько. Итак, читаем. Из всех вводных кирпичей текста только одна фраза меня заинтересовала:
> The theory of optimal control is concerned with operating a dynamic system at minimum cost. The case where the system dynamics are described by a set of linear differential equations and the cost is described by a quadratic function is called the LQ problem.
В переводе на русский они говорят, что моделируют некую динамическую систему дифференциальными уравнениями (о ужас), и выбирают непосредственно управление, минимизируя какую-то квадратичную функцию (о! я чувствую приближение наименьших квадратов). Так, хорошо. Пытаемся читать дальше:
> Finite-horizon, continuous-time LQR,
>
> [серия ужасных формул]
Пропускаем, ну его в болото такое читать, кроме того, явно будет противно руками считать непрерывные функции.
> Infinite-horizon, continuous-time LQR,
>
> [серия ещё более ужасных формул]
Час от часу не легче, ещё и несобственные интегралы пошли, пропускаем, вдруг дальше что интересного найдём.
> Finite-horizon, discrete-time LQR
О, это я люблю. У нас дискретная система, смотрим её состояние через некие промежутки (некие промежутки в первом прочтении всегда равны одной секунде) времени. Производные из уравнения ушли, т.к. они теперь могут быть приближены как (x\_{k+1}-x\_{l})/1 секунду. Теперь неплохо было бы понять, что такое x\_k.
Одномерный пример
=================
Фейнман писал, как именно он читал все уравнения, что ему приходилось:
> Actually, there was a certain amount of genuine quality to my guesses. I had a scheme, which I still use today when somebody is explaining
>
> something that I'm trying to understand: I keep making up examples. For instance, the mathematicians would come in with a terrific theorem, and they're all excited. As they're telling me the conditions of the theorem, I construct something which fits all the conditions. You know, you have a set (one ball) — disjoint (two balls). Then the balls turn colors, grow hairs, or whatever, in my head as they put more conditions on. Finally they state the theorem, which is some dumb thing about the ball which isn't true for my hairy green ball thing, so I say, «False!»
Ну а мы что, круче Фейнмана? Лично я нет. Поэтому давайте так. Имеется автомобиль, едущий с некой начальной скоростью. Задача его разогнать до некой финальной скорости, при этом единственное, на что мы можем влиять, это на педаль газа, сиречь на ускорение автомобиля.
Давайте представим, автомобиль идеален и движется по такому закону:
x\_k — это скорость автомобиля в секунду k, u\_k — это положение педали газа, которое мы захотим, можно её интерпретировать как ускорение в секунду k. Итого, мы стартуем с некой скорости x\_0, и затем проводим вот такое численное интегрирование (во какие слова пошли). Отметьте, что я не складываю м/с и м/с^2, u\_k умножается на одну секунду интервала между измерениями. По умолчанию у меня все коэффициенты либо ноль, либо один.
Итак, чтобы понять, что происходит, я пишу [вот такой код](https://github.com/ssloy/tutorials/tree/2ac7a4d03f2dfb4ee4d26431d89f8e0dff81eaf5/tutorials/lqr) (я пишу **очень** много одноразового кода, который выкидываю сразу после написания). Привожу листинг здесь на всякий случай, как обычно, я использую [OpenNL](http://alice.loria.fr/index.php/software/4-library/23-opennl.html) для решения больших разреженных линейных систем уравнений.
**Скрытый текст**
```
#include
#include "OpenNL\_psm.h"
int main() {
const int N = 60;
const double xN = 2.3;
const double x0 = .5;
const double hard\_penalty = 100.;
nlNewContext();
nlSolverParameteri(NL\_NB\_VARIABLES, N\*2);
nlSolverParameteri(NL\_LEAST\_SQUARES, NL\_TRUE);
nlBegin(NL\_SYSTEM);
nlBegin(NL\_MATRIX);
nlBegin(NL\_ROW); // x0 = x0
nlCoefficient(0, 1);
nlRightHandSide(x0);
nlScaleRow(hard\_penalty);
nlEnd(NL\_ROW);
nlBegin(NL\_ROW); // xN = xN
nlCoefficient((N-1)\*2, 1);
nlRightHandSide(xN);
nlScaleRow(hard\_penalty);
nlEnd(NL\_ROW);
nlBegin(NL\_ROW); // uN = 0, for convenience, normally uN is not defined
nlCoefficient((N-1)\*2+1, 1);
nlScaleRow(hard\_penalty);
nlEnd(NL\_ROW);
for (int i=0; i
```
Итак, давайте разбираться, что я делаю. Для начала я говорю N=60, на всё отвожу 60 секунд. Затем говорю, что финальная скорость должна быть 2.3 метра в секунду, а начальная полметра в секунду, это выставлено от балды. Переменных у меня будет 60\*2 — 60 значений скорости и 60 значений ускорения (строго говоря, ускорения должно быть 59, но мне проще сказать, что их 60, а последнее должно быть равно строго нулю).
Итого, у меня 2\*N переменных (N=60), чётные переменные (я начинаю считать с нуля, как и всякий нормальный программист) — это скорость, а нечётные — это ускорение. Задаю начальную и конечную скорость вот этими строчками:
По факту, я сказал, что хочу, чтобы начальная скорость была равна x0 (.5m/s), а конечная — xN (2.3m/s).
```
nlBegin(NL_ROW); // x0 = x0
nlCoefficient(0, 1);
nlRightHandSide(x0);
nlScaleRow(hard_penalty);
nlEnd(NL_ROW);
nlBegin(NL_ROW); // xN = xN
nlCoefficient((N-1)*2, 1);
nlRightHandSide(xN);
nlScaleRow(hard_penalty);
nlEnd(NL_ROW);
```
Мы знаем, что x{i+1} = xi + ui, поэтому давайте добавим N-1 такое уравнение в нашу систему:
```
for (int i=0; i
```
Итак, мы добавили всё жёсткие ограничения в систему, а что именно, собственно, мы можем хотеть оптимизировать? Давайте просто для начала скажем, что мы хотим, чтобы x\_i как можно скорее достиг финальной скорости xN:
```
for (int i=0; i
```
Ну вот наша система готова, жёсткие правила перехода между состояниями заданы, квадратичная функция качества системы тоже, давайте потрясём коробочку и посмотрим, что наименьшие квадраты нам дадут в качестве решения x\_i, u\_i (красная линия — это скорость, зелёная — ускорение):
Ооокей, мы действительно ускорились с полуметра в секунду до двух метров запятая трёх в секунду, но уж больно большое ускорение наша система выдала (что логично, т.к. мы потребовали сойтись как можно скорее).
А давайте изменим ([вот коммит](https://github.com/ssloy/tutorials/tree/35d1a19d05ae92985edab129feac8dc62bb47d20/tutorials/lqr)) целевую функцию, вместо наискорейшей сходимости попросим как можно меньшее ускорение:
```
for (int i=0; i
```
Мда, теперь машина ускоряется на два метра в секунду за целую минуту. Ок, давайте и быструю сходимость к финальной скорости, и маленькое ускорение попробуем ([вот коммит](https://github.com/ssloy/tutorials/tree/a704594dc6694352e121276ecc594a2b37ab75d6))?
```
for (int i=0; i
```
Ага, супер, теперь становится красиво:
Итак, быстрая сходимость и ограничение величины управления — это конкурирующие цели, понятно. Обратите внимание, на данный момент я остановился на первой строчке параграфа википедии, дальше идут страшные формулы, я их не понимаю. Зачастую чтение статей сводится к поиску ключевых слов и полному выводу всех результатов, используя тот матаппарат, которым лично я владею.
Итак, что мы имеем на данный момент? То, что имея начальное состояние системы + имея конечное состояние системы + количество секунд, мы можем найти идеальное управление u\_i. Это хорошо, только к сигвею слабо применимо. Чёрт, как же они делают-то? Так, читаем следующий текст в википедии:
> with a performance index defined as
>
>
>
> 
>
>
>
> the optimal control sequence minimizing the performance index is given by
>
>
>
> 
>
>
>
> where [ААА, ЧТО ТАМ ДАЛЬШЕ ТАКОЕ?!]
>
>
Так. Я не понимаю что после знака равно в формуле «J = ...», но это явно квадратичная функция, что мы попробовали. Типа, скорейшей сходимости к цели плюс наименьшими затратами, это мы позже посмотрим ближе, сейчас мне достаточно моего понимания.
u\_k = -F x\_k. Оп-па. Они говорят, что для нашего одномерного примера в любой момент времени оптимальное ускорение — это некая константа -F, помноженная на текущую скорость? Ну-ка, ну-ка. А ведь и правда, зелёный и красный графики подозрительно друг на друга похожи!
Давайте-ка попробуем написать настоящие уравнения для нашего 1D примера.
Итак, у нас есть функция качества управления:
Мы хотим её минимизировать, при этом соблюдая ограничения на связь между соседними значениями скорости нашей машины:
Стоп-стоп-стоп, а какого хрена в википедии стоит x\_k^T Q x\_k? Ведь это же простой x\_k^2 в нашем случае, а у нас (x\_k-x\_N)^2?! Ёлки, да ведь они предполагают, что финальное состояние, в которое мы хотим попасть, **это нулевой вектор!!!** КАКОГО [CENSORED] ОБ ЭТОМ НА ВСЕЙ СТРАНИЦЕ ВИКИПЕДИИ НИ СЛОВА?!
Окей, дышим глубоко, успокаиваемся. Теперь я все x\_i в формулировке J выражу через u\_i, чтобы не иметь ограничений. Теперь у меня переменными будет являться только вектор управления. Итак, мы хотим минимизировать функцию J, которая записывается вот так:
Зашибись. А теперь давайте раскрывать скобки (см. эпиграф):
Многоточие здесь означает всякую муть, которая от u\_0 не зависит. Так как мы ищем минимум, то чтобы его найти, нужно приравнять нулю все частные производные, но для начала меня интересует частная производная по u\_0:
Итого мы получаем, что оптимальное управление будет оптимально только тогда, когда u\_0 имеет вот такое выражение:
Обратите внимание, что в это выражение входят и другие неизвестные u\_i, но есть одно «но». Прикол в том, что я не хочу, чтобы машина ускорялась всю минуту на всего два метра в секунду. Минуту я ей дал просто как заведомо достаточное время. А могу и час дать. Член, зависящий от u\_i, если грубо, то это вся работа по ускорению, от N она не зависит. Поэтому если N достаточно большой, то оптимальный u\_0 **линейно** зависит только от того, насколько x0 далёк от конечного положения!
**То есть, управление должно выглядеть следующим образом: мы моделируем систему, находим магический коэффициент, линейно связывающий u\_i и x\_i, записываем его, а затем в нашем роботе просто делаем линейный пропорциональный регулятор, используя найденный магический коэффициент!**
Если быть предельно честным, то до вот этого момента я кода, конечно, не писал, всё вышеозначенное я проделал в уме и чуть-чуть на бумажке. Но это не отменяет факта, что одноразового кода я пишу действительно много.
2D пример
=========
В качестве интуиции это прекрасно, а [вот первый код](https://github.com/ssloy/tutorials/tree/720a410dc3233d0468f8399887aa2153ff999cc1/tutorials/lqr), который я действительно написал:
**Скрытый текст**
```
#include
#include
#include "OpenNL\_psm.h"
int main() {
const int N = 60;
const double x0 = 3.1;
const double v0 = .5;
const double hard\_penalty = 100.;
const double rho = 16.;
nlNewContext();
nlSolverParameteri(NL\_NB\_VARIABLES, N\*3);
nlSolverParameteri(NL\_LEAST\_SQUARES, NL\_TRUE);
nlBegin(NL\_SYSTEM);
nlBegin(NL\_MATRIX);
nlBegin(NL\_ROW);
nlCoefficient(0, 1); // x0 = 3.1
nlRightHandSide(x0);
nlScaleRow(hard\_penalty);
nlEnd(NL\_ROW);
nlBegin(NL\_ROW);
nlCoefficient(1, 1); // v0 = .5
nlRightHandSide(v0);
nlScaleRow(hard\_penalty);
nlEnd(NL\_ROW);
nlBegin(NL\_ROW);
nlCoefficient((N-1)\*3, 1); // xN = 0
nlScaleRow(hard\_penalty);
nlEnd(NL\_ROW);
nlBegin(NL\_ROW);
nlCoefficient((N-1)\*3+1, 1); // vN = 0
nlScaleRow(hard\_penalty);
nlEnd(NL\_ROW);
nlBegin(NL\_ROW); // uN = 0, for convenience, normally uN is not defined
nlCoefficient((N-1)\*3+2, 1);
nlScaleRow(hard\_penalty);
nlEnd(NL\_ROW);
for (int i=0; i solution;
for (int i=0; i<3\*N; i++) {
solution.push\_back(nlGetVariable(i));
}
nlDeleteContext(nlGetCurrent());
for (int i=0; i
```
Здесь всё то же самое, только переменных системы теперь две: не только скорость, но и координата машины.
Итак, дана начальная позиция + начальная скорость (x0, v0), мне нужно достичь конечной позиции (0,0), остановиться в начале координат.
Переход из одного момента в следующий осуществляется как x\_{k+1} = x\_k + v\_k, а v\_{k+1} = v\_k + u\_k.
Я достаточно прокомментировал предыдущий код, этот не должен вызвать трудностей. Вот результат работы:
Красная линия — координата, зелёная — скорость, а синяя — это непосредственно положение «педали газа». Исходя из предыдущего, предполагается, что синяя кривая — это взвешенная сумма красной и зелёной. Хм, так ли это? Давайте попробуем посчитать!
То есть, теоретически, нам нужно найти два числа a и b, такие, что u\_i = a\*x\_i + b\*v\_i. А это есть не что иное, как линейная регрессия, что мы делали в прошлой статье! Вот [код](https://github.com/ssloy/tutorials/tree/715887cc2835ac8a779e35e1e72c750bca8c7309/tutorials/lqr).
В нём я сначала считаю кривые, что на картинке выше, а затем ищу такие a и b, что синяя кривая = a\*красная + b\*зелёная.
Вот разница между настоящими u\_i и теми, что я получил, складывая зелёную и красную прямую:
Отклонение порядка одной сотой метра за секунду за секунду! Круто!!! Тот коммит, что я привёл, даёт a=-0.0513868, b=-0.347324. Отклонение действительно небольшое, но ведь это нормально, начальные данные-то я не менял.
А теперь давайте [кардинально изменим](https://github.com/ssloy/tutorials/tree/108ddde79895fe6b14ffb25401690c7ab8006d81/tutorials/lqr) начальное положение и скорость машины, оставив магические числа a и b из предыдущих вычислений.
Вот разница между настоящим оптимальным решением и тем, что мы получаем наитупейшей процедурой, давайте-ка я её ещё раз приведу полностью:
```
double xi = x0;
double vi = v0;
for (int i=0; i
```
И никаких дифференциальных уравнений Риккати, которые нам предлагала википедия. Возможно, что и про них мне придётся почитать, но это будет потом, когда припечёт. А пока что простые квадратичные функции меня устраивают более чем полностью.
Сухой остаток
=============
Итого: чтобы это использовать, будут две основных трудности:
а) найти хорошие матрицы перехода A и B, это нужно будет записывать кинематические уравнения, так как, конечно, там всё будет зависеть от масс объектов и прочего
б) найти хорошие коэффициенты компромисса между целями наискорейшего схождения к цели, но при этом ещё и не делая сверхусилий.
Если а и б сделать, то метод выглядит многообещающим. Единственное, что он требует полного знания состояния системы, что не всегда получается. Например, положение сигвея мы не знаем, можем только догадываться о нём, исходя из данных датчиков типа гироскопа и акселерометра. Ну да это про это я расскажу своим студентам в следующий раз.
Итак, я хотел добиться трёх целей:
а) понять, что такое lqr
б) объяснить то, что понял, студентам и вам
в) показать вам и моим студентам, что я (как и большинство людей) ни хрена не понимаю в математических текстах, что печально, но совсем не катастрофично. Ищем ключевые слова, за которые зацепиться, выкидываем излишние, ненужные нам методы и абстракции, и пытаемся это впихнуть в рамки наших текущих знаний.
Надеюсь, мне удалось. Ещё раз, я совсем не специалист в теории управления, я её в глаза не видел, если у вас есть что дополнить и поправить, не стесняйтесь.
Enjoy! | https://habr.com/ru/post/277671/ | null | ru | null |
# Интегрируем iOS-приложение с Evernote: первые шаги
Одно из преимуществ Evernote — его вездесущность. Наши приложения работают практически на всех значимых мобильных платформах, на двух наиболее популярных компьютерных ОС и во всех остальных случаях (через веб-интерфейс). Но мы не собираемся останавливаться на этом.
Сейчас все больше и больше мобильных приложений поддерживают возможность чтения и отправки информации в Evernote. Нам это очень нравится, и мы бы хотели, чтобы так продолжалось и дальше — чем больше у вас будет способов получить доступ к своим заметкам, тем лучше (во всяком случае, нам так кажется). Будучи разработчиком, вы получаете выход на 30 с лишним миллионов наших пользователей и можете мгновенно увеличить ценность своего приложения в глазах этих людей, открыв им возможность связи с их внешней “цифровой памятью”.
Мы решили периодически публиковать руководства для разработчиков, которые только начинают осваивать платформу Evernote (или разработку в целом) и хотят интегрировать свои приложения с нашим сервисом.
В этом посте мы опишем конкретные шаги для интеграции Evernote в тестовое приложение iOS. Мы начнем новый проект в Xcode, загрузим и установим Evernote Software Development Kit (SDK) и создадим простое приложение, которое будет взаимодействовать с Evernote через Cloud API.
Прежде чем начать, перечислим, что вам понадобится для самостоятельной работы в дальнейшем:
1. аккаунт на сервере sandbox.evernote.com — это сервер-“песочница” Evernote для разработчиков. Он используется для отладки ваших приложений, работащих через Evernote Cloud API. Тестовый аккаунт можно создать [здесь](http://sandbox.evernote.com/Registration.action).
2. ключ Evernote API ([Запросить ключ](http://dev.evernote.com/documentation/cloud/)). Ключ API состоит из двух частей: *consumer key* и *consumer secret*. (*Примечание: Если вы разрабатываете свое собственное приложение, то имейте в виду, что после окончания разработки приложения нужно будет попросить нас включить ваш ключ на основном сервере Evernote. Это можно сделать через форму на [dev.evernote.com/support](http://dev.evernote.com/support)*).
3. последняя на момент написания версия Xcode — 4.3.2, установленная на Intel Mac.
Все в наличии? Отлично, тогда приступим.
Наше приложение будет делать ровно две вещи: показывать имя текущего пользователя и общее число заметок в его аккаунте.
\* Стоит уточнить, что эту идею для приложения мы выбрали совершенно случайно и на момент начала работы не знали, есть ли API для более простого доступа к этой информации\*
#### Закладываем фундамент
Прежде чем мы начнем писать код и впечатлять первых пользователей, нужно подготовить почву — создать проект XCode и установить Evernote SDK для iOS.
##### Создание проекта XCode
1. Запустите XCode и создайте проект, используя меню: File > New > Project.
2. Когда вас попросят указать шаблон проекта, выберите “Application” под “iOS” в меню слева и нажмите на “Single View Application”. Затем нажмите “Next”.
3. На следующем экране вам нужно будет уточнить несколько характеристик нового приложения:
* В Product Name укажите “EvernoteCounter”.
* Company Identifier может быть произвольный. Это значение используется для идентификации вашего приложения в мире, но поскольку мы не собираемся пускать его дальше своего компьютера, это не имеет значения. В примере мы указали “com.somecompany”.
* Укажите в Class Prefix “EC” (сокращение от “EvernoteCounter”). Эта аббревиатура будет предшествовать всем именам классов, когда мы начнем писать код.
* Укажите в Device Family “iPhone”.
* Убедитесь, что сняты все три флажка.
* Когда вы закончите, поля должны быть заполнены так:
4. В конце вас попросят указать место сохранения проекта. Выберите его на свое усмотрение.
Вот и все, ваш проект XCode готов. Отложим его в сторонку на несколько минут. Чтобы наше приложение могло взаимодействовать с Evernote Cloud API, нам понадобится SDK. Давайте добудем его и добавим к проекту.
##### Загрузка и установка Evernote SDK для iOS
1. Все SDK Evernote доступны на Github. Среди них есть и [iOS SDK](https://github.com/evernote/evernote-sdk-ios).
2. Нажмите на ссылку “Downloads” посередине справа.
3. На появившейся странице нажмите “Download as zip”. Вы загрузите текущую версию SDK.
4. Разархивируйте файл, и вы увидите каталог вроде этого:
В загруженном каталоге SDK выберите папку `evernote-sdk-ios` и перетащите ее в ваш проект XCode:
XCode задаст вам пару вопросов по поводу того, что вы сейчас сделали. Все можно оставить по умолчанию — нажимайте “Finish”.
Evernote SDK для iOS требуется компонент `Security.framework`, так что нужно включить его в процесс разработки приложения:
1. Нажмите на проект верхнем левом углу окна XCode.
2. Нажмите на “Build Phases” в центре верхней части окна.
3. Раскройте список “Link Binary With Libraries”, затем нажмите на знак плюса внизу слева.
4. В поисковой строке появившегося списка начните вводить “Security”.
5. Когда в списке появится `Security.framework`, нажмите на него, чтобы выделить, а затем нажмите “Add”:
Теперь, когда все подготовительные работы завершены, настало время перейти к самому интересному.
#### Создание приложения
Как уже говорилось, наше приложение должно уметь делать только одну вещь — авторизовать пользователя в его аккаунте Evernote и показать общее число заметок в этом аккаунте.
Прежде чем мы углубимся в корневую функциональность нашего приложения, нужно сконфигурировать его для аутентификации через Evernote Cloud API с помощью OAuth. iOS SDK позволяет реализовать эту связку без проблем за пару минут.
##### Конфигурирование OAuth
Во-первых, нам нужно модифицировать `ECAppDelegate.m`. По умолчанию Xcode автоматически создает для нас метод didFinishLaunchingWithOptions. До внесения изменений этот метод выглядит так:
[](https://gist.github.com/2705809)
*Нажмите на изображение, чтобы просмотреть этот код на [Github](http://github.com/evernote)*
Для того чтобы OAuth заработал, нам нужно создать экземпляр `EvernoteSession` с корректным хостом и полномочиями аутентификации. Модифицированный `ECAppDelegate.m` будет выглядеть так:
[](https://gist.github.com/2705822)
*Нажмите на изображение, чтобы просмотреть этот код на [Github](http://github.com/evernote)*
`EVERNOTE_HOST` — удаленный хост, с которым мы будем взаимодействовать. Пока приложение находится на стадии разработки, нам нужно будет связываться с sandbox.evernote.com, нашим сервером-“песочницей”. Перед выпуском приложения в свет не забудьте заменить `EVERNOTE_HOST` на `www.evernote.com` и запросить активацию ключа на основном сервере, как мы писали ранее.
`CONSUMER_KEY` и `CONSUMER_SECRET` — две части ключа API, которые мы ранее получили. Так что вам нужно будет поменять имеющиеся значения параметрами своего реального ключа.
Далее мы инициализируем новый экземпляр `EvernoteSession`, затем указываем его свойства: хост, `consumerKey` и `consumerSecret`. И наконец наша новая переменная сессии назначается singleton-объектом, который будет использоваться каждый раз, когда приложение будет взаимодействовать с Evernote Cloud API.
И еще нам нужно не забыть включить EvernoteSession.h в файл заголовка. Добавьте соответствующее объявление сразу после того, как наш `ECViewController.h` будет включен в `ECAppDelegate.m`:
[](https://gist.github.com/2705836)
*Нажмите на изображение, чтобы просмотреть этот код на [Github](http://github.com/evernote)*
Поскольку процедура OAuth подразумевает авторизацию наше приложения через веб-страницу, нужно убедиться, что наше приложение может обрабатывать открытые ссылки. К счастью это уже встроено в iOS SDK, и все, что нам нужно сделать — добавить этот метод в конец нашего файла `ECAppDelegate.m` (прямо перед `end`):
[](https://gist.github.com/2706011)
*Нажмите на изображение, чтобы просмотреть этот код на [Github](http://github.com/evernote)*
##### Создание пользовательского интерфейса
Теперь можно сделать простой интерфейс для нашего приложения. Нажмите на `ECViewController.xib` в левой части. Откроется редактор интерефейса с настройками, расчитанными на экран iPhone. Здесь мы сможем перетаскивать, создавать и настраивать элементы интерфейса: кнопки, текстовые поля и т. д. Для этого приложения нам понадобится пара текстовых полей (одно для имени пользователя в Evernote, другое для числа заметок), подпись для каждого поля и кнопка, по нажатию которой будет запускаться процедура. (Обратите внимание, что текстовые поля должны иметь тип `UILabel`, что позволит задавать их значения динамически; подробнее об этом мы расскажем чуть позже).
Перетащите все нужные элементы интерфейса из библиотеки объектов в поле редактора. Когда вы закончите, это должно выглядеть примерно так:
Нам понадобится объявить свойства `IBOutlet` и метод `IBAction` для обработки нажатий на нашу кнопку. Давайте добавим все это в наш файл `ECViewController.h`:
[](https://gist.github.com/2629655)
*Нажмите на изображение, чтобы просмотреть этот код на [Github](http://github.com/evernote)*
Теперь свяжем наши текстовые области значений, которые будут показывать имя пользователя и число заметок с их соответствующими свойствами в `ECViewController` (`usernameField` и `noteCountField`).
1. Нажмите на `ECViewController.xib` в обозревателе проекта слева, чтобы открыть наш макет интерфейса.
2. Затем нажмите правой кнопкой мыши на “File’s Owner” под “Placeholders”, чтобы раскрыть панель связей.
3. Нажмите на пустую область справа от `usernameField` и перетащите ее на соответствующую область значений так, как показано здесь:
4. Выполните то же самое с `noteCountField`.
Теперь надо связать нашу кнопку с методом `retrieveUserNameAndNoteCount`, который мы объявили ранее. Для этого, удерживая Control, перетащите кнопку на “File’s Owner”. После того, как вы отпутстите кнопку мыши, выберите в появившемся окне “Sent Events” пункт `retrieveUserNameAndNoteCount`.
Теперь у нас есть текстовые поля и кнопка, готовые для выполнения своих задач, и надо провести внутреннюю работу в `ECViewController.m`. Вот как этот файл выглядит по умолчанию после того, как его сгенерировал XCode:
[](https://gist.github.com/2630580)
*Нажмите на изображение, чтобы просмотреть этот код на [Github](http://github.com/evernote)*
Чтобы выполнить наши задачи (показать имя пользователя и число заметок в аккаунте), нужно создать два метода.
Первый, разумеется, метод, вызываемый при нажатии на кнопку: `retrieveUserNameAndNoteCount`.
Это метод будет:
1. обеспечивать аутентификацию с Evernote Cloud API (и показывать сообщение об ошибке, если что-то пойдет не так);
2. получать информацию о текущем пользователе в качестве объекта `EDAMUser`. (кстати, “EDAM” расшифровывается как “Evernote Data Access and Management”);
3. указывать имя пользователя в качестве значения в `usernameField`;
4. вызывать другой метод для получения числа заметок для данного пользователя.
Вот наш метод в законченном виде:
[](https://gist.github.com/2706089)
*Нажмите на изображение, чтобы просмотреть этот код на [Github](http://github.com/evernote)*
Только не пугайтесь — сейчас мы все это подробно разберем.
Во-первых, мы получаем локальный экземпляр `EvernoteSession` (поскольку он является единственным экземпляром (singleton), то будет тем же, что мы создавали в `ECAppDelegate.m`). Затем вызываем `authenticateWithCompletionHandler`. Этот метод пытается проверить аутентифицировать нашу сессию с Evernote Cloud API (подробнее об этом в разделе про OAuth ниже). В случае ошибки во время аутентификации или же если аутентификация по каким-то причинам не удалась, информация об этом записывается с помощью NSLog и показывается в диалоговом окне (экземпляр `UIAlertView`), и о неудачной аутентификации сообщается пользователю.
Если же аутентификация прошла успешно, мы можем перейти к основной логике нашего приложения. Важно помнить, что, как только приложение получит аутентификационный токен, он будет действовать в течение года, затем пользователю вновь придется авторизоваться. Одако, если пользователь решит переустановить ваше приложение, то ему нужно будет авторизоваться повторно.
Во-первых, нужно определить аккаунт, с которым мы работаем. Для этого создаем локальный экземпляр `EvernoteUserStore` (`userStore`) и вызываем его метод `getUserWithSuccess`. Это асинхроннный запрос, который в ответ запрашивает функции, реализованные в виде блоков (по сути, это анонимные функции). Первый блок принимает единый параметр `EDAMUser` и сообщает, что запрос прошел успешно. Второй блок (`failure`) принимает один экземпляр `NSError`, где описывается, что именно пошло не так. При обнаружении ошибки приложение просто регистрирует его и больше ничего не делает.
Если запрос к API прошел успешно, мы запрашиваем у нашего экземпляра `EDAMUser` свойство `username` и указываем его в качестве значения для `usernameField`.
И наконец, мы вызываем наш другой метод `countAllNotesAndSetTextField`:
[](https://gist.github.com/2712630)
*Нажмите на изображение, чтобы просмотреть этот код на [Github](http://github.com/evernote)*
Этот метод, о чем красноречиво говорит его название, подсчитывает число заметок в аккаунте и отображает его на экране. Давайте посмотрим, как он работает.
Во-первых, мы объявляем переменную счетчика `noteCount`. В этой переменной будет вестись подсчет заметок аккаунта (подробнее об этом далее).
Затем мы создаем локальный экземпляр `EvernoteNoteStore` под названием `noteStore`. Используя этот объект, мы будем запрашивать у Evernote Cloud API доступ к заметкам, блокнотам и т. д., применяя такие методы как `listNotebooksWithSuccess` (который мы вызываем в следующей строке). Поскольку Cloud API не содержит готового способа получения числа всех заметок в аккаунте, нам нужно проделать следующую последовательность действий:
1. получить список всех блокнотов в аккаунте пользователя, используя `listNotebooksWithSuccess`;
2. пройтись по этому списку и для каждого блокнота получить число заметок.
Ответ `listNotebooksWithSuccess`, как и `getUserWithSuccess`, представляет собой пару блоков. Первый обрабатывает успешный ответ сервера и принимает единственный параметр `NSArray`, который содержит коллекцию объектов `EDAMNotebook` — по одному для каждого блокнота в аккаунте пользователя.
Каждый из имеющихся у нас объектов `EDAMNotebook` содержит уникальный идентификатор блокнота GUID. Используя этот GUID, мы создаем экземпляр `EDAMNoteFilter`, которые позволит нам найти заметки, имеющиеся в соответствующем блокноте. И наконец, имея `EDAMNoteFilter` в качестве параметра, мы можем вызвать `findNoteCountsWithFilter`, чтобы получить число заметок в данном блокноте (как экземпляр объекта `EDAMNoteCollectionsCounts`).
Теперь, когда у нас есть число, мы прибавляем его к переменной `noteCount` и обновляем `noteCountField` на экране. И вот результат:
##### OAuth
Если сессия не прошла аутентификацию (то есть не получен токен), то при нажатии на кнопку приложение передаст контроль мобильному Safari, где откроется сайт Evernote. Там пользователь должен войти в свой аккаунт Evernote и авторизовать наше приложение для доступа к своему аккаунту.
После того, как пользователь авторизовался, браузер возвращает контроль приложению, и процесс продолжается, как если бы пользователь только что нажал кнопку. Если все прошло удачно, имя пользователя и число его заметок будут показаны на экране, как показано выше.
#### В заключение
И еще момент, которые стоит отметить: приложение EvernoteCounter создано для того, чтобы показать простоту интеграции и использования нашего iOS SDK. Если бы это было реальное приложение для массового использования, нужно было бы уделить гораздо больше внимания условиям, в которых потенциально могут возникать ошибки и работе над “защитными” программистскими практиками. Однако они были опущены здесь для того, чтобы не усложнять для понимания код тестового приложения.
[Весь проект EvernoteCounter для Xcode](https://github.com/evernote/simple-api-client-example-ios) доступен на Github. Если вы хотите помочь и улучшить код, не стесняйтесь предлагать свои правки (Обратите внимание, что мы не говорим о новой *функциональности* этого приложения, а лишь о том, чтобы сделать приложение еще более подходящим в качестве учебного пособия.) | https://habr.com/ru/post/145717/ | null | ru | null |
# Spring Boot 2: чего не пишут в release notes
Когда у масштабного проекта происходит масштабное обновление, всё никогда не бывает просто: неизбежно возникают неочевидные нюансы (проще говоря, грабли). И тогда, как бы хороша ни была документация, с чем-то поможет только опыт — свой или чужой.
На конференции Joker 2018 я рассказал, с какими проблемами столкнулся сам при переходе к Spring Boot 2 и как они решаются. А теперь специально для Хабра — текстовая версия этого доклада. Для удобства в посте есть и видеозапись, и оглавление: можно не читать всё целиком, а перейти непосредственно к волнующей вас проблеме.
Оглавление
----------
* **[Видеозапись](#video)**
* **[Вступление](#intro)**
* **Грабли compile time**
[Примеры проблем](#compile)
[Как быть](#compile_solution)
* **Content-Type. Определение типа HTTP-ответа**
[Проблема](#contenttype)
[Как быть](#contenttype_solution)
* **Scheduling. Запуск по расписанию**
[Проблема](#scheduling)
[Как быть](#scheduling_solution)
* **Spring Cloud & Co. Совместимость библиотек**
[Проблема](#proxy)
[Бонус: сложий случай](#bonus)
[Как быть](#proxy_solution)
* **Relax Binding. Нечёткая привязка параметров**
[Проблема](#relax)
[Как быть](#relax_solution)
* **Unit Testing. Выполнение тестов в Mockito 2**
[Проблема](#unit)
[Как быть](#unit_solution)
* **Gradle Plugin. Сборка Spring Boot проектов**
[Проблема](#gradle)
[Как быть](#gradle_solution)
* **[Прочее](#other)**
* **[Заключение. Резюме и выводы](#summary)**
День добрый! Хочу рассказать вам о некоторых особенностях (назовём их граблями), с которыми вы можете столкнуться при обновлении фреймворка Spring Boot на вторую версию и при последующей его эксплуатации.
Меня зовут Владимир Плизгá ([GitHub](https://github.com/Toparvion)), я работаю в компании «ЦФТ», одном из крупнейших и старейших разработчиков ПО в России. Последние несколько лет занимаюсь там бэкенд-разработкой, отвечая за техническое развитие интернет-банка предоплаченных карт. Как раз на этом проекте я стал инициатором и исполнителем перехода от монолитной архитектуры к микросервисной (который ещё длится). Ну и коль скоро большинство тех знаний, которыми я решил с вами поделиться, накоплено на примере именно этого проекта, расскажу о нём чуть-чуть поподробнее.
Коротко о подопытном продукте
-----------------------------
Это интернет-банк, который в одиночку обслуживает порядка двух с лишним десятков компаний-партнёров по всей России: предоставляет конечным клиентам возможность управлять их денежными средствами с помощью дистанционного банковского обслуживания (мобильные приложения, сайты). Один из партнеров — компания Билайн и её платёжная карта. Интернет-банк для нее получился неплохим, судя по рейтингу [Markswebb Mobile Banking Rank](http://markswebb.ru/e-finance/mobile-banking-rank-2017/), где наш продукт занял неплохие позиции для новичков.
«Кишочки» всё ещё в переходном процессе, поэтому у нас есть один монолит, так называемое ядро, вокруг которого возведены 23 микросервиса. Внутри у микросервисов Spring Cloud Netflix, Spring Integration и кое-что ещё. А на Spring Boot 2 всё это дело летает примерно с июля месяца. И вот как раз на этом месте остановимся поподробнее. Переводя этот проект на вторую версию, я столкнулся с некоторыми особенностями, о которых и хочу вам рассказать.
План доклада
------------
Областей, где появились особенности Spring Boot 2, довольно много, постараемся пробежаться по всем. Чтобы сделать это быстро, нам понадобится опытный сыщик или следователь — кто-то, кто всё это раскопает как будто бы за нас. Поскольку Холмс с Ватсоном уже [выступили с докладом](https://youtu.be/RBhf8TPy5i4) на Joker, нам будет помогать другой специалист — лейтенант Коломбо. Вперёд!
Spring Boot / 2
---------------
Для начала пару слов о Spring Boot в целом и второй версии в частности. Во-первых, вышла эта версия, мягко говоря, не вчера: 1 марта 2018 она уже была в General Availability. Одна из главных целей, которую преследовали разработчики, — это полноценная поддержка Java 8 на уровне исходников. То есть скомпилировать на меньшей версии не удастся, хотя runtime совместим. В качестве основы взят Spring Framework пятой версии, который вышел чуть-чуть раньше Spring Boot 2. И это не единственная зависимость. Ещё у него есть такое понятие, как [BOM](https://github.com/spring-projects/spring-boot/blob/master/spring-boot-project/spring-boot-dependencies/pom.xml) (Bill Of Materials) — это огромный XML, в котором перечислены все (транзитивные для нас) зависимости от всевозможных сторонних библиотек, дополнительных фреймворков, инструментов и прочего.
Соответственно, не все те спецэффекты, которые привносит второй Spring Boot, произрастают из него самого или из экосистемы Spring. На всё это хозяйство написано два отличных документа: [Release Notes](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-2.0-Release-Notes) и [Migration Guide](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-2.0-Migration-Guide). Документы классные, Spring в этом смысле вообще молодцы. Но, по понятным причинам, там возможно охватить далеко не всё: есть какие-то частности, отклонения и прочее, что либо нельзя, либо не стоит туда включать. О таких особенностях и поговорим.
Compile time. Примеры изменений в API
-------------------------------------
Начнём с более-менее простых и очевидных граблей: это те, что возникают в compile time. То есть то, что не даст вам даже скомпилировать проект, если вы просто поменяете у Spring Boot в скрипте сборки цифру 1 на цифру 2.
Основной источник изменений, который стал основанием для таких правок в Spring Boot, — это, конечно, переход Spring на Java 8. Кроме того, веб-стек Spring 5 и Spring Boot 2 разделился, условно говоря, на два. Теперь он сервлетный, традиционный для нас, и реактивный. Кроме того, потребовалось учесть ряд недочётов из прошлых версий. Ещё сторонние библиотеки поднакинули (извне Spring). Если посмотреть в Release Notes, то никаких подводных камней с ходу не видно и, честно говоря, когда я впервые читал Release Notes, мне показалось, там вообще всё нормально. И выглядело для меня это примерно вот так:
Но, как вы наверняка догадываетесь, всё не так хорошо.
**На чем сломается компиляция (пример 1):**
* **Почему**: класса `WebMvcConfigurerAdapter` больше нет;
* **Зачем**: для поддержки фишек Java 8 (default-методы в интерфейсах);
* **Что делать**: использовать интерфейс `WebMvcConfigurer`.
Проект может не скомпилироваться как минимум из-за того, что некоторых классов просто больше нет. Почему? Да потому что в Java 8 они не нужны. Если это были адаптеры с примитивной имплементацией методов, то пояснять особо нечего, default-методы всё это отлично решают. Вот на примере этого класса понятно, что достаточно использовать сам интерфейс, и никакие адаптеры уже не понадобятся.
**На чем сломается компиляция (пример 2):**
* **Почему**: метод `PropertySourceLoader#load` стал возвращать список источников вместо одного;
* **Зачем**: для поддержки мульти-документных ресурсов, например, YAML;
* **Что делать**: оборачивать ответ в `singletonList()` (при переопределении).
Пример из совсем другой области. Некоторые методы изменили даже сигнатуры. Если вам доводилось использовать метод load PropertySourceLoader, то он теперь возвращает коллекцию. Соответственно, это позволило поддержать мульти-документные ресурсы. Например, в YAML через три чёрточки можно указать кучу документов в одном файле. Если теперь вам понадобилось с ним работать из Java, имейте в виду, что это нужно делать через коллекцию.
**На чем сломается компиляция (пример 3):**
* **Почему**: некоторые классы из пакета `org.springframework.boot.autoconfigure.web` разъехались по пакетам `org.springframework.boot.autoconfigure.web` — `.servlet` и `.reactive`;
* **Зачем**: чтобы поддержать реактивный стек наравне с традиционным;
* **Что делать**: обновить импорты.
Ещё больше изменений было привнесено тем самым разделением стеков. Например, то, что раньше лежало в одном пакете web, теперь разъехалась по двум пакетам с кучей классов. Это `.servlet` и `.reactive`. Зачем сделано? Потому что реактивный стек не должен был стать огромным костылём поверх сервлетного. Нужно было сделать это так, чтобы они могли поддерживать свой собственный жизненный цикл, развиваться в своих направлениях и не мешать друг другу. Что с этим делать? Достаточно поменять импорты: большинство из этих классов остались совместимыми на уровне API. Большинство, но не все.
**На чем сломается компиляция (пример 4):**
* **Почему**: поменялась сигнатура методов класса `ErrorAttributes`: вместо `RequestAttributes` стали использоваться `WebRequest(servlet)` и `ServerRequest(reactive)`;
* **Зачем**: чтобы поддержать реактивный стек наравне с традиционным;
* **Что делать**: заменить имена классов в сигнатурах.
Например, в классе ErrorAttributes отныне вместо RequestAttributes в методах стали использоваться два других класса: это WebRequest и ServerRequest. Причина всё та же самая. А что с этим делать? Если вы именно переходите с первого на второй Spring Boot, то надо поменять RequestAttributes на WebRequest. Ну а если вы уже на втором, то использовать ServerRequest. Очевидно, не правда ли?..
### Как быть?
Таких примеров довольно много, мы не будем разбирать по полочкам их все. Что с этим делать? Прежде всего, стоит поглядывать в Spring Boot 2.0 Migration Guide для того, чтобы вовремя заметить касающееся вас изменение. Например, в нём упоминаются переименования совершенно неочевидных классов. Ещё, если уж всё-таки что-то разъехалось и поломалось, стоит учитывать, что понятие «web» разделилось на 2: «servlet» и «reactive». При ориентации во всяких классах и пакетах это может помогать. Кроме того, надо иметь в виду, что переименовались не только сами классы и пакеты, но и целые зависимости и артефакты. Как это, например, произошло со Spring Cloud.
---
Content-Type. Определение типа HTTP-ответа
------------------------------------------
Хватит об этих простых вещах из compile time, там всё понятно и просто. Поговорим о том, что может твориться во время исполнения и, соответственно, может выстрелить, даже если Spring Boot 2 у вас уже давно работает. Поговорим об определении content-type.
Ни для кого не секрет, что на Spring можно писать веб-приложения, причём как страничные, так и REST API, и они могут отдавать контент с самыми разными типами, будь то XML, JSON или что-то ещё. И одна из прелестей, за которые Spring так любят, — это то, что можно вообще не заморачиваться с определением отдаваемого типа у себя в коде. Можно надеяться на магию. Эта магия работает, условно говоря, тремя разными способами: либо полагается на заголовок Accept, пришедший от клиента, либо на расширение запрошенного файла, либо на специальный параметр в URL, которым, естественно, тоже можно рулить.
Рассмотрим простенький примерчик ([полный исходный код](https://github.com/Toparvion/joker-2018-samples/tree/master/content-type)). Здесь и далее я буду использовать нотацию от Gradle, но даже если вы поклонник Maven, вам не составит труда понять, что здесь написано: мы собираем малюсенькое приложение на первом Spring Boot и используем всего один starter web.
Пример (v1.x):
```
dependencies {
ext {
springBootVersion = '1.5.14.RELEASE'
}
compile("org.springframework.boot:spring-boot-starter-web:$springBootVersion")
}
```
В качестве исполняемого кода у нас один-единственный класс, в котором сразу объявлен метод контроллера.
```
@GetMapping(value = "/download/{fileName: .+}",
produces = {TEXT_HTML_VALUE, APPLICATION_JSON_VALUE, TEXT_PLAIN_VALUE})
public ResponseEntity download(@PathVariable String fileName) {
//формируем только тело ответа, без Content-Type
}
```
Он принимает на вход некое имя файла, которое якобы сформирует и отдаст. Он действительно формирует его контент в одном из трёх указанных типов (определяя это по имени файла), но никак не задает content-type — у нас же Spring, он сам всё сделает.
В общем-то, можно даже попробовать так сделать. Действительно, если мы будем запрашивать один и тот же документ с разными расширениями, он будет отдаваться с правильным content-type в зависимости от того, что мы возвращаем: хочешь — json, хочешь — txt, хочешь — html. Работает как в сказке.
### Обновляем до v2.x
```
dependencies {
ext {
springBootVersion = '2.0.4.RELEASE'
}
compile("org.springframework.boot:spring-boot-starter-web:$springBootVersion")
}
```
Приходит время обновляться на второй Spring Boot. Мы просто меняем цифру 1 на 2.
[Spring MVC Path Matching Default Behavior Change](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-2.0-Migration-Guide#spring-mvc-path-matching-default-behavior-change)
Но мы же инженеры, мы ещё заглянем в Migration Guide, а вдруг там что-нибудь про это сказано. Но там упоминается какой-то «suffix path matching». Речь о том, как правильно маппить методы в Java с URL. Но это не наш случай, хотя немножко похоже.
Поэтому забиваем, проверяем и бах! — внезапно не работает. Почему-то везде начинает отдаваться просто text/html, а если покопать, то не именно text/html, а просто первый из типов, указанных вами в атрибуте produces на аннотации @GetMapping. Почему так? Выглядит, мягко говоря, непонятно.
И здесь уже никакие Release Notes не помогут, придётся почитать исходники.
### ContentNegotiationManagerFactoryBean
```
public ContentNegotiationManagerFactoryBean build() {
List strategies = new ArrayList<>();
if (this.strategies != null) {
strategies.addAll(this.strategies);
}
else {
if (this.favorPathExtension) {
PathExtensionContentNegotiationStrategy strategy;
// …
```
Там можно будет найти классик с очень понятным лаконичным коротким именем, в котором упоминается некий флажок под названием «учитывай расширение в пути» (favorPathExtension). Значение этого флажка «истина» соответствует применению некой стратегии с другим понятным коротким лаконичным именем, из которого понятно, что она как раз отвечает за определение content-type по расширению файла. Как видите, если флажок будет равен «ложь», то стратегия не применится.
Да, наверное, многие замечали, что в Spring, видимо, есть какой-то гайдлайн, чтобы имя обязательно было ну хотя бы из двадцати символов.
Если покопаться ещё чуть глубже, то можно нарыть вот такой фрагмент. В самом Spring-фреймворке, причём не в пятой версии, как можно бы было ожидать, а испокон веков этот флажок по умолчанию равен «истина». В то время как в Spring Boot и именно во второй версии он был перекрыт ещё другим, который теперь доступен для управления из настроек. То есть теперь мы можем рулить им из энвайронмента, и это только во второй версии. Чуете? Там он уже принял значение «ложь». То есть хотели, вроде как, сделать как лучше, вынесли этот флажок в настройки (и это здорово), но значение по умолчанию переключили на другое (это уже не очень).
Разработчики фреймворка тоже люди, им тоже свойственно ошибаться. Что с этим делать? Понятно, надо переключить параметр у себя в проекте, и всё будет хорошо.
Единственное, что стоит сделать на всякий случай, для очистки совести, — это заглянуть в документацию на Spring Boot просто на предмет какого-нибудь упоминания этого флажка. И там он действительно [упоминается](https://docs.spring.io/spring-boot/docs/2.0.5.RELEASE/reference/htmlsingle/#boot-features-spring-mvc-pathmatch), но только в каком-то странном контексте:
> If you **understand the caveats** and would still like your application to use suffix pattern matching, the following configuration is required:
>
> spring.mvc.contentnegotiation.favor-path-extension=true
>
> …
>
>
Написано, дескать, если вы понимаете все заковырки и всё ещё хотите использовать suffix path matching, то ставьте этот флажок. Чувствуете расхождение? Вроде как мы говорим-то об определении content-type в контексте этого флажка, а здесь речь о матчинге Java-методов и URL. Выглядит как-то непонятно.
Приходится закапываться дальше. На GitHub есть вот такой [pull request](https://github.com/spring-projects/spring-boot/issues/11105):
В рамках данного пулл-реквеста были сделаны эти изменения — переключение значения по умолчанию — и там один из авторов фреймворка говорит, что у этой проблемы есть два аспекта: один — это как раз-таки path matching, а второй — это определение content-type. То есть, другими словами, флажок относится и к тому, и к другому, и они неразрывно связаны.
Можно бы было, конечно, найти это сразу на GitHub, если б знать только, где искать.
[Suffix match](https://docs.spring.io/spring/docs/5.0.9.RELEASE/spring-framework-reference/web.html#mvc-ann-requestmapping-suffix-pattern-match)
Более того, в документации на сам Spring Framework ещё говорится, что использование расширений файлов было необходимо раньше, однако теперь более не считается необходимостью. Более того, оно показало себя проблематичным в ряде случаев.
### Резюмируем
Изменение значения флажка по умолчанию — это вовсе не баг, а фича. Она неразрывно связана с определением path matching и призвана делать **три вещи**:
* снизить риски по безопасности (какие именно, я уточню);
* выровнять поведение WebFlux и WebMvc, они отличались в этом аспекте;
* выровнять заявление в документации с кодом фреймворка.
### Как быть?
Во-первых, по возможности нужно не полагаться на определение content-type по расширению. Тот пример, который я показал, — это контрпример, так делать не надо! Равно как и не надо полагаться на то, что запросы вида «GET что-нибудь.json», например, смапятся просто на «GET что-нибудь». Так было в Spring Framework 4 и в Spring Boot 1. Больше так не работает. Если нужно смапиться на файл с расширением, это нужно делать в явном виде. Вместо этого лучше полагаться на заголовок Accept либо на URL-параметр, именем которого вы можете рулить. Ну если это никак не сделать, допустим, у вас какие-то старые мобильные клиенты, которые перестали обновляться в прошлом веке, то придётся вернуть этот флажок, выставить его в «true», и всё будет работать как раньше.
Кроме того, для общего понимания можно почитать главу «Suffix match» в документации на Spring Framework, она самими разработчиками считается своеобразным сборником best practices в этой области, и ознакомиться с тем, что такое [атака Reflected File Download](https://pivotal.io/security/cve-2015-5211), как раз реализуемая с помощью манипуляций с расширением файлов.
Scheduling. Выполнение задач по расписанию или периодически
-----------------------------------------------------------
Давайте немного сменим область рассмотрения и поговорим о выполнении задач по расписанию или периодически.
### Пример задачи. Выводить сообщение в лог каждые 3 секунды
О чём идёт речь, я думаю, понятно. У нас есть какие-то бизнес-потребности, делать что-либо с каким-то повтором, поэтому мы сразу перейдём к примеру. Допустим, у нас стоит мегасложная задача: выводить в лог какую-нибудь гадость каждые 3 секунды.
Сделать это можно, очевидно, самыми разными способами, под них по-любому уже что-нибудь есть в Spring. И найти это — способов уйма.
### Вариант 1: поиск примера в своём проекте
```
/**
*A very helpful service
*/
@Service
public class ReallyBusinessService {
// … a bunch of methods …
@Scheduled(fixedDelay = 3000L)
public void runRepeatedlyWithFixedDelay() {
assert Runtime.getRuntime().availableProcessors() >= 4;
}
// … another bunch of methods …
}
```
Мы можем посмотреть в нашем же проекте и наверняка найдём что-нибудь вот такое. На публичном методе будет висеть одна аннотация, и из неё будет понятно, что как только её вешаешь, всё работает прям как в сказке.
### Вариант 2: поиск нужной аннотации
Можно саму аннотацию поискать прямо по названию, и наверняка тоже будет понятно из документации, что её вешаешь — и всё работает.
### Вариант 3: Googling
Если себе веры нет, то можно загуглить, и по [найденному](https://dzone.com/articles/running-on-time-with-springs-scheduled-tasks) тоже будет понятно, что с одной аннотации всё заведётся.
```
@Component
public class EventCreator {
private static final Logger LOG = LoggerFactory.getLogger(EventCreator.class);
private final EventRepository eventRepository;
public EventCreator(final EventRepository eventRepository) {
this.eventRepository = eventRepository;
}
@Scheduled(fixedRate = 1000)
public void create() {
final LocalDateTime start = LocalDateTime.now();
eventRepository.save(
new Event(new EventKey("An event type", start, UUID.randomUUID()), Math.random() * 1000));
LOG.debug("Event created!");
}
}
```
Кто видит в этом подвох? Мы же инженеры всё-таки, давайте проверим, как это работает в реальности.
### Show me the code!
Рассмотрим конкретную задачу (сама задача и код есть [в моем репозитории](https://github.com/Toparvion/joker-2018-samples/tree/master/enable-scheduling)).
Кто не хочет читать, можете посмотреть вот этот фрагмент видео с демонстрацией (до 22-й минуты):
В качестве зависимости будем использовать первый Spring Boot с двумя стартерами. Один — для веба, мы же вроде как веб-сервер разрабатываем, а второй — spring starter actuator, чтобы у нас были production-ready фичи, чтобы мы были хотя бы немножко похожи на что-то настоящее.
```
dependencies {
ext {
springBootVersion = '1.5.14.RELEASE'
// springBootVersion = '2.0.4.RELEASE'
}
compile("org.springframework.boot:spring-boot-starter-web:$springBootVersion")
compile("org.springframework.boot:spring-boot-starter-actuator:$springBootVersion")
// +100500 зависимостей в случае настоящего приложения
}
```
А исполняемый код у нас будет ещё проще.
```
package tech.toparvion.sample.joker18.schedule;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.Scheduled;
@SpringBootApplication
public class EnableSchedulingDemoApplication {
private static final Logger log = LoggerFactory.getLogger(EnableSchedulingDemoApplication.class);
public static void main(String[] args) {
SpringApplication.run(EnableSchedulingDemoApplication.class, args);
}
@Scheduled(fixedRate = 3000L)
public void doOnSchedule() {
log.info(“Еще 3 секунды доклада потрачено без дела…”);
}
}
```
Вообще практически ничего примечательного, кроме одного-единственного метода, на который мы навешали аннотацию. Мы её где-то скопипастили и ожидаем, что она будет работать.
Давайте проверим, мы же инженеры. Запускаем. Мы предполагаем, что каждые три секунды в лог будет выводиться такое сообщение. Всё должно работать из коробки, мы убеждаемся, что у нас всё запущено именно на первом Spring Boot, и ожидаем вывода нужной строчки. Проходит три секунды — строчка выводится, проходит шесть — строчка выводится. Оптимисты победили, всё работает.
Только приходит время обновляться на второй Spring Boot. Не будем заморачиваться, просто переключимся с одного на другой:
```
dependencies {
ext {
// springBootVersion = '1.5.14.RELEASE'
springBootVersion = '2.0.4.RELEASE'
}
```
По идее, Migration Guide нас ни о чём не предупреждал, и мы ожидаем, что всё будет работать без отклонений. С точки зрения исполняемого кода, никакие из других граблей, о которых я упоминал раньше (несовместимость на уровне API или что-то ещё) здесь у нас нет, поскольку приложение максимально простое.
Запускаем. Первым делом убеждаемся, что мы работаем на втором Spring Boot, в остальном никаких, вроде бы, отклонений нет.
Однако проходит 3 секунды, 6, 9, а Германа всё нет — никакого вывода, ничего не работает.
Как это часто бывает, ожидание расходится с реальностью. Нам часто пишут в документации, что на самом деле в Spring Boot всё работает из коробки, что мы вообще можем с минимальными заморочками просто запуститься как есть, и никакой конфигурации не потребуется. Но как только дело доходит до реальности, часто выясняется, что надо бы всё-таки почитать документацию. В частности, если хорошенько покопаться, там можно найти вот такие строчки:
> 7.3.1. [Enable Scheduling Annotations](https://docs.spring.io/spring/docs/current/spring-framework-reference/integration.html#scheduling-enable-annotation-support)
>
> To enable support for @Scheduled and [Async](https://habr.com/ru/users/async/) annotations, you can add @EnableScheduling and @EnableAsync to one of your @Configuration classes.
Для того, чтобы заработала аннотация Scheduled, надо повесить ещё одну аннотацию на класс с ещё одной аннотацией. Ну, как обычно в Spring. Но почему оно раньше-то работало? Мы же вроде ничего такого не делали. Очевидно, эта аннотация где-то висела раньше в первом Spring Boot, а сейчас во втором её почему-то нет.
Начинаем рыться в исходниках первого Spring Boot. Находим, что есть какой-то класс, на котором она якобы висит. Смотрим ближе, он называется «MetricExportAutoConfiguration» и, судя по всему, отвечает за поставку этих метрик производительности вовне, в какие-нибудь централизованные агрегаторы, и на нём действительно есть эта аннотация.
Причём она работает так, что включает своё поведение на всё приложение сразу, её не надо вешать на отдельные классы. Именно этот класс был поставщиком этого поведения, а потом почему-то не стал. Почему?
Всё тот же GitHub наталкивает нас на такую археологическую раскопку: в рамках перехода на вторую версию Spring Boot этот класс был выкошен вместе с аннотацией. Почему? Да потому что движок поставки метрик тоже изменился: они больше не стали использовать свой самописный, а перешли на Micrometer — действительно осмысленное решение. Вот только вместе с ним удалилось кое-что лишнее. Может быть, это даже правильно.
Кто не хочет читать, смотрите коротенькое демо на 30 секунд:
Из этого следует, что если мы сейчас возьмём и в нашем исходном классе вручную повесим недостающую аннотацию, то, по идее, поведение должно стать корректным.
```
package tech.toparvion.sample.joker18.schedule;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
@SpringBootApplication
@EnableScheduling
public class EnableSchedulingDemoApplication {
private static final Logger log = LoggerFactory.getLogger(EnableSchedulingDemoApplication.class);
public static void main(String[] args) {
SpringApplication.run(EnableSchedulingDemoApplication.class, args);
}
@Scheduled(fixedRate = 3000L)
public void doOnSchedule() {
log.info(“Еще 3 секунды доклада потрачено без дела…”);
}
}
```
Как думаете, заработает? Давайте проверять. Запускаем.
Видно, что через 3 секунды, через 6 и через 9 сообщение, ожидаемое нами, в лог всё-таки выводится.
### Как быть?
Что с этим делать в этом конкретном и в более общем случае? Как бы нравоучительно это ни звучало, во-первых, стоит читать не только копируемые фрагменты документации, но и чуть шире, как раз чтобы охватывать вот такие аспекты.
Во-вторых, помнить, что в Spring Boot хоть многие фичи есть из коробки (scheduling, async, caching, …), они не всегда включены, их нужно явно включать.
В-третьих, не мешает перестраховаться: добавлять аннотации [Enable](https://habr.com/ru/users/enable/)\* (а их целое семейство) в свой код, не надеясь на фреймворк. Но тогда возникает вопрос: а что будет, если случайно я и мои коллеги добавим несколько аннотаций, как они себя поведут? Сам фреймворк утверждает, что дублирование аннотаций никогда не приводит к ошибкам. А на самом деле: почти никогда. Дело в том, что некоторые из этих аннотаций имеют атрибуты.
Например, @EnableAsync и [Enable](https://habr.com/ru/users/enable/)Caching имеют атрибуты, которые, в частности, управляют тем, в каком режиме будут проксироваться бины для того, чтобы реализовать соответствующую функциональность. Следовательно, вы можете случайно задать эти аннотации в двух местах с разным значением атрибутов. Что в этом случае будет? Частично на этот вопрос отвечает javadoc на один из классов, как раз причастных к этой функциональности. Он говорит, что этот регистратор работает путём поиска ближайшей аннотации. Он знает о том, что есть несколько возможных [Enable](https://habr.com/ru/users/enable/)\*, но по большому счёту ему всё равно, какой именно он выберет. К чему это может привести? А вот об этом мы как раз и поговорим в следующем кейсе.
Spring Cloud & Co. Совместимость библиотек
------------------------------------------
Возьмём за основу маленький микросервис на Spring Boot 2 в качестве базы, навернём на него Spring Cloud — нам понадобится только его фича Service Discovery (обнаружение сервисов по имени). Ещё в качестве мониторинга прикрутим JavaMelody. И ещё нам понадобится какая-нибудь традиционная база. Не важно, какая, лишь бы поддерживала JDBC, поэтому возьмём простейшую H2.
Не в качестве рекламы, а просто для общего понимания скажу, что JavaMelody — это встроенный мониторинг, к которому можно обратиться прямо из приложения и посмотреть всякие графики, метрики и прочее. Удобно в dev-окружении, в test, а в бою она умеет экспортировать метрики для потребления каким-нибудь централизованным инструментом, типа Prometheus.
Наш замес будет выглядеть на Gradle вот таким образом:
```
dependencies {
ext {
springBootVersion = '2.0.4.RELEASE'
springCloudVersion = '2.0.1.RELEASE'
}
compile("org.springframework.boot:spring-boot-starter-web:$springBootVersion")
runtime("org.springframework.boot:spring-boot-starter-jdbc:$springBootVersion")
runtime group: "org.springframework.cloud",
name: "spring-clooud-starter-netflix-eureka-client",
version: springCloudVersion
runtime("net.bull.javamelody:javamelody-spring-boot-starter:1.72.0")
//…
}
```
[(полный исходный код)](https://github.com/Toparvion/joker-2018-samples/tree/master/hikari-javamelody)
Мы берём две зависимости от Spring Boot — это web и jdbc, от Spring Cloud берём его клиента к eureka (это, если кто не знает, как раз фишка Service Discovery), и сам JavaMelody. Исполняемого кода у нас вообще практически не будет.
```
@SpringBootApplication
public class HikariJavamelodyDemoApplication {
public static void main(String[] args) {
SpringApplication.run(HikariJavamelodyDemoApplication.class, args);
}
}
```
Запускаем.
Такое приложение развалится прямо при старте. Выглядеть это будет не очень приятно, а в самом конце лога ошибок будет сказано, что якобы не удалось скастить какой-то там com.sun.proxy к Hikari, HikariDataSource. На всякий случай поясню, что Hikari — это пул коннектов к базе данных, такой же как Tomcat, C3P0 или прочее.
Почему так произошло? Тут нам как раз понадобится помощь следователя.
Материалы дела
--------------
### Spring Cloud оборачивает dataSource в прокси
Следователь накопал, что Spring Cloud здесь причастен тем, что он оборачивает dataSource (единственный в этом приложении), в прокси. Делает он это для того, чтобы поддержать фичу AutoRefresh или RefreshScope — это когда конфигурацию микросервиса можно подтягивать из другого централизованного микросервисного конфига и на лету её применять. Как раз за счёт прокси он это обновление и проворачивает. Для этого он использует только CGLIB.
Как вы, наверное, знаете в Spring Boot и в принципе в Spring поддерживаются два механизма проксирования: на основе встроенного в JDK механизма (тогда проксируется не сам бин, а его интерфейс) и с помощью библиотеки CGLIB (тогда проектируется сам бин). Обёртывание производится раньше всех BeanPostProcessor’ов за счёт подмены BeanDefinition и задания так называемого фабричного бина, который выпускает целевой бин сразу обернутым в прокси.
### JavaMelody оборачивает dataSource в прокси
Второй участник — это JavaMelody. Он тоже оборачивает DataSource в прокси, но делает это для снятия метрик, чтобы перехватывать вызовы и записывать их в своё хранилище. JavaMelody использует только JDK-проксирование, потому что больше никак не умеет, просто не предусмотрели. Но работает он более традиционным способом — при помощи BeanPostProcessor.
Если посмотреть на всё это через призму дебаггера, то будет видно, что непосредственно перед падением DataSource выглядел как обертка в JDK-прокси, внутри которой обёртка CGLIB-прокси. Получилась вот такая матрешка:
Само по себе это неплохо. Если только не учитывать тот факт, что не все обёртки друг с другом хорошо работают.
### Spring Boot вызывает dataSource.unwrap()
Масло в огонь подливает Spring Boot, он делает на этом DataSource#unwrap(), чтобы провалидировать этот бин перед выставлением по JMX. В этом случае JDK-прокси свободно пропускает через себя этот вызов (поскольку ей нечего с ним делать), а CGLIB-прокси, которую добавил Spring Cloud, снова запрашивает бин у Spring Context. Естественно, получает полноценную матрёшку, у которой на внешнем уровне JDK-обёртка, применяет к ней CGLIB API и на этом ломается.
Если показать то же самое в картинках, то выглядит это примерно так:
<https://jira.spring.io/browse/SPR-17381>
Внешний вызов проходит через внешнюю же оболочку, но вместо того, чтобы делегироваться к целевому бину, ещё раз запрашивает у контекста этот же самый бин. Под это дело заведён баг, он пока ещё не разрешён, но, надеюсь, когда-нибудь это будет поправлено.
Но это не вся картина. При чём тут на самом деле Hikari?
Если понаблюдать, то при замене пула Hikari на какой-нибудь другой пул проблема исчезает, потому что Spring Cloud просто его не оборачивает. Ещё одно наблюдение: Hikari стал пулом по умолчанию именно в Spring Boot 2. Чувствуете? Что-то тут уже попахивает какими-то новшествами. Но казалось бы, где Spring Cloud? Из названия предполагается, что он витает где-то в облаках, а где пул коннектов к базе данных? Тоже не близко. По идее, они не должны друг о друге знать.
### А на самом деле…
```
org.springframework.cloud.autoconfigure.RefreshAutoConfiguration
.RefreshScopeBeanDefinitionEnhancer:
/**
* Class names for beans to post process into refresh scope. Useful when you
* don’t control the bean definition (e.g. it came from auto-configuration).
*/
private Set refreshables = new HashSet<>(
Arrays.asList("com.zaxxer.hikari.HikariDataSource"));
```
А на самом деле в Spring Cloud есть такой волшебный autoconfiguration, в котором есть ещё более волшебный Enhancer BeanDefinition’ов, в котором пусть не в явном виде, но прямо захардкожена зависимость от Hikari. То есть разработчики Spring Cloud сразу предусмотрели возможность работы именно с этим пулом. И именно поэтому оборачивают его в прокси.
Какие выводы из этого можно сделать? Автообновление бинов в Spring Cloud достаётся не бесплатно, все бины сразу из коробки выходят в CGLIB-обёртках. Это нужно учитывать, например, для того, чтобы знать, что не все прокси-обёртки одинаково хорошо работают друг с другом. Этот пример как раз нам это доказывает (jira.spring.io/browse/SPR-17381). Оборачивать в прокси могут не только BeanPostProcessor, если вы вдруг так думали. Выдавать обёртки можно через подмену BeanDefinition и переопределение фабричного бина ещё до того, как применились все BeanPostProcessor’ы. И ещё Stack Overflow часто учит нас тому, что если вы сталкиваетесь с какой-то такой ересью, то просто порулите флажками, proxyTargetClass переключите с true на false или наоборот, и всё пройдёт. Но не всё проходит, и в некоторых случаях этого флажка просто нет. Мы увидели сразу два таких примера.
По сути дела это просто частный случай такой вот индивидуальной совместимости компонентов, которую приходится учитывать путём вытеснения какого-то одного из них, чтобы вся сбойная комбинация разрушилась.
Вытеснять можно тремя способами:
* Переключиться на другой пул коннектов (например, Tomcat JDBC Pool)
spring.datasource.type=org.apache.tomcat.jdbc.pool.DataSource
Не забыв добавить зависимость
runtime 'org.apache.tomcat:tomcat-jdbc:8.5.29'
Hikari берёт, вроде как, производительностью, но не факт, что вы уже упёрлись в неё, можно вернуться на старый пул Tomcat, который использовался в первом Spring Boot.
* Можно потеснить JavaMelody, либо отключив JDBC-мониторинг, либо вытеснив её полностью.
javamelody.excluded-datasources=scopedTarget.dataSource
* Отключить автообновление на лету в Spring Cloud.
spring.cloud.refresh.enabled=false
Мы, если помните, втащили эту фичу ради того, чтобы работать с Service Discovery, обновлять бины нам не нужно было вовсе.
Таким образом можно избежать этой проблемы. Она кажется одним вырожденным случаем и можно бы было о нём и не упоминать, но на самом деле проявлений у такой проблемы гораздо больше.
### Бонус (схожий случай\*)
\*но без Spring Cloud (и можно без JavaMelody)
```
@Component
@ManagedResource
@EnableAsync
public class MyJmxResource {
@ManagedOperation
@Async
public void launchLongLastingJob() {
// какой-то долгоиграющий код
}
}
```
Полный исходный код: [github.com/toparvion/joker-2018-samples/tree/master/jmx-resource](https://github.com/toparvion/joker-2018-samples/tree/master/jmx-resource).
Возьмём схожий случай. То же самое приложение, только мы выкинем из него Spring Cloud. Можно и JavaMelody выкинуть, оставив лишь один Spring-бин, создаваемый этим мониторингом. А чтобы придать этому проекту больше полезности, мы предположим, что в нём есть класс, который выставляет по JMX один публичный метод. И этот метод якобы выполняет какую-то долгую работу, поэтому мы его пометили как Async, чтобы не заставлять JMX-консоль долго ждать. Чтобы он был виден по JMX, мы вешаем на него аннотацию @ManagedOperation, а чтобы всё это заработало, добавляем ещё два рубильника (как мы любим в Spring — надо накидать больше аннотаций, и тогда всё будет OK).
Так вот если такое приложение запустить, то оно действительно успешно стартанет, не будет никаких ошибок в логах, но, увы, бин myJMXResource не будет доступен по JMX, его даже не будет видно. И если посмотреть через дебаггер, то снова будет видна всё та же самая матрёшка — бин обернут в две прокси, CGLIB и JDK.
Снова JDK и CGLIB-прокси. И сразу становится понятно, что где-то здесь замешан BeanPostProcessor.
И действительно, есть два причастных BeanPostProcessor’а:
AsyncAnnotationBeanPostProcessor
* Должность: директор по работе с аннотацией [Async](https://habr.com/ru/users/async/)
* Прописка: org.springframework.scheduling
* Место рождения: аннотация @EnableAsync (через [Import](https://habr.com/ru/users/import/))
2. DefaultAdvisorAutoProxyCreator
* Должность: помощник по работе с AOP-прокси, отвечает за перехват вызовов для навешивания аспектов
* Прописка: org.springframework.aop.framework.autoproxy
* Место рождения: @Configuration-класс PointcutAdvisorConfig (библиотечный или самописный)
DefaultAdvisorAutoProxyCreator происходит из @Configuration-класса. В моём случае, когда я это дело проходил впервые, это был JavaMelody, но на самом деле он мог быть добавлен и любым другим прикладным configuration-классом. И кстати, если он называется PointcutAdvisorConfig, то с ним будет ещё одно интересное наблюдение.
Стоит его переименовать, как внезапно проблема уходит. Он назывался PointcutAdvisorConfig, стал просто AdvisorConfig, причём это не обычный бин, а configuration-класс, который поставляет бины, то есть, вроде как, ничего не должно сломаться, но поведение реально меняется с ошибочного на корректное или наоборот.
Казалось бы, переименование тут ни при чём, но важно помнить, что где переименование, там и порядок чего-либо.
И в данном случае это порядок BeanPostProcessor’ов. Если посмотреть на их список в двух режимах, когда всё хорошо и когда всё плохо, то будет видно, что эти два BeanPostProcessor следуют в обратном по отношению друг к другу порядке. Если зарыться в кишочки, первый из них клюёт на искусственно добавленный интерфейс Advised (вставленный предыдущим BeanPostProcessor’ом), видит этот интерфейс, думает, что он прикладной, а раз есть прикладной интерфейс, значит, лучше применить JDK-проксирование, оно как раз позволяет это сделать более естественным образом. Он делает и этим всё ломает.
Но на самом деле это не вся картина. Если посмотреть всю цепочку влияния, то она выглядит примерно так:
На обнаружение бина для выставления по JMX повлиял как раз порядок прокси. Тот в свою очередь определился порядком применения BeanPostProcessor. Он неразрывно связан с порядком регистрации BeanPostProcessor’ов, который происходит от порядка имен бинов в контексте, который, в свою очередь, как ни странно, определяется порядком загрузки или сортировки ресурсов с файловой системы или из JAR, в зависимости от того, откуда вы запускаетесь.
### Как быть?
Во-первых, по возможности стоит использовать более высокоуровневые абстракции, предоставляемые фреймворком Spring AOP, в частности, аспекты. Почему «по возможности»? Потому что зачастую вы можете даже не знать, что откуда-то у вас существуют бины вот этих Advice и Advisor, они могут быть привнесены сторонними библиотеками, как это было в случае с мониторингом.
Во-вторых, не забывать о best practices. Элементарно, если бы мы взяли и спрятали этот прикладной бин JMX-ресурс под интерфейсом, то проблемы могло бы и не быть. Если всё-таки сломалось, можно посмотреть на состав прокси через отладчик, увидеть, из каких слоёв он состоит. Если вдруг этого не сделано раньше, можно попробовать autowire’ить (заинжектить) этот бин в любой другой. Это позволит вскрыть проблему раньше. Скорее всего, вы увидите по исключению, что там есть какое-то наслоение. В качестве обхода можно попытаться порулить порядком бинов через аннотации [Order](https://habr.com/ru/users/order/), чтобы не заниматься случайным переименованием. И там, где это применимо, можно попробовать порулить режимом проксирования, т.е. всё тем же флажком proxyTargetClass, если он применим.
Резюме: что делать в общих случаях, связанных с прокси. Во-первых, «Keep calm and YAGNI». Не стоит думать, что такая жесть ждёт вас за каждым углом и надо прямо сейчас обязательно от неё защищаться. Пробуйте «в лоб», в крайнем случае всегда можно где-то откатиться, где-то попробовать обойти иначе, но не стоит думать, что надо решать эту проблему до того, как она появилась. Если вы привносите новые библиотеки, стоит поинтересоваться, как они работают именно в отношении прокси: создают ли они прокси-объекты, в каком порядке, можно ли повлиять на режимы проксирования — как видите, это не всегда так. И ещё не стоит включать всё подряд на всякий случай. Да, Spring приучает нас к тому, что там ничего не надо делать, всё работает из коробки. И вот доклады того же Кирилла Толкачёва [tolkkv](https://habr.com/ru/users/tolkkv/), где он показывает, что простенькое приложение состоит из 436-ти бинов, это ярко доказывают. И на этом примере было видно, что не все фичи одинаково полезны.
Relax Binding. Работа со свойствами (параметрами) приложения
------------------------------------------------------------
О прокси поговорили, переключаемся на другую тему.
<https://docs.spring.io/spring-boot/docs/2.0.5.RELEASE/reference/htmlsingle/#boot-features-external-config-relaxed-binding>
Есть такой замечательный механизм, как Relax Binding в Spring Boot. Это возможность чтения свойств для приложения откуда-то извне без чёткого их совпадения с именем внутри приложения. Например, если у вас есть в каком-то бине поле firstName и вы хотите, чтобы оно смапилось извне с префиксом acme.my-project.person, то Spring Boot может это обеспечить достаточно лояльным способом. Как бы ни были заданы эти свойства снаружи: через camel case, через дефисы, как принято в переменных окружениях, или как-то ещё — всё это корректно смапится просто на firstName. Как раз это и называется Relax Binding.
Так вот во второй версии Spring Boot’а эти правила немного ужесточились, а ещё утверждается, что с ними стало проще работать из кода приложения — унифицирован способ задания имен свойств в коде приложения. Я, честно говоря, этого не почувствовал, но так написано в документации:
* [github.com/spring-projects/spring-boot/wiki/Spring-Boot-2.0-Migration-Guide#relaxed-binding](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-2.0-Migration-Guide#relaxed-binding) (примерно 1 страница)
* [docs.spring.io/spring-boot/docs/2.0.5.RELEASE/reference/htmlsingle/#boot-features-external-config-relaxed-binding](https://docs.spring.io/spring-boot/docs/2.0.5.RELEASE/reference/htmlsingle/#boot-features-external-config-relaxed-binding) (примерно 3 страницы)
* [github.com/spring-projects/spring-boot/wiki/Relaxed-Binding-2.0](https://github.com/spring-projects/spring-boot/wiki/Relaxed-Binding-2.0) (примерно 4 страницы)
Чтиво очень увлекательное, советую ознакомиться, много интересного. Но грабли-то остались. Понятно, что всех кейсов там не учтёшь.
Например:
```
dependencies {
ext {
springBootVersion = '1.5.4.RELEASE'
}
compile("org.springframework.boot:spring-boot-starter:$springBootVersion")
}
```
([полный исходный код](https://github.com/toparvion/joker-2018-samples/tree/master/relax-binding))
У нас есть малюсенькое приложение с одним-единственным стартером, даже не web, на первом Spring Boot, и у него в исполняемом коде теперь уже чуть-чуть побольше всего.
```
@SpringBootApplication
public class RelaxBindingApplication implements ApplicationRunner {
private static final Logger log =
LoggerFactory.getLogger(RelaxBindingDemoApplication.class);
@Autowired
private SecurityProperties securityProperties;
public static void main(String[] args) {
SpringApplication.run(RelaxBindingDemoApplication.class, args);
}
@Override
public void main run(ApplicationArguments args) {
log.info("KEYSTORE TYPE IS: {}", securityProperties.getKeyStoreType());
}
}
```
В частности, мы инжектим некий POJO-объект (носитель свойств) и выводим в лог одно из этих свойств, в данном случае KEYSTORE TYPE. Этот POJO представляет из себя два поля с двумя геттерами и сеттерами, значения для которых берутся из applications.properties или application.yaml, не важно.
Если говорить конкретно о поле keystoreType, то оно выглядит как private String keystoreType, а значение задаётся ему в applications.properties: security.keystoreType=jks.
```
@Component
@ConfigurationProperties(prefix = "security")
public class SecurityProperties {
private String keystorePath;
private String keystoreType;
public String getKeystorePath() {
return keystorePath;
}
public void setKeystorePath(String keystorePath) {
this.keystorePath = keystorePath;
}
public String getKeyStoreType() {
return keystoreType;
}
public void setKeystoreType(String keystoreType) {
this.keystoreType = keystoreType;
}
}
```
Запустим это на первом Spring Boot и всё будет работать отлично.
Всё выводится, всё работает, поют птицы, играет арфа. Стоит нам обновиться на вторую версию, как приложение внезапно даже не запустится.
Не то что свойство не определится, даже не запустится. И сообщение будет, на первый взгляд, несколько неадекватным, якобы не найден какой-то сеттер для свойства, которого у нас вообще нет в проекте, какой-то key-store-type. То есть стоило нам в первый раз попробовать, всё работало прям огонь, а второй раз делаем фактически то же самое, и уже проходит не очень.
Тут нас может спасти только режим паранойи. Включаем его и проверяем, нет ли у нас такого свойства.
Такого свойства у нас нет. Мы проверяем проект не из 2 миллионов строк, поэтому легко убедиться, что свойство отсутствует. Сопоставляем прямо вот побуквенно и с учётом регистра код в Java и в properties — всё одинаковое, нигде ничего не разъехалось. Но мы же знаем, что, наверное, там не сразу рефлексия применяется, должен ещё быть сеттер, и он тоже должен быть корректным. Проверяем его — сеттер тоже удовлетворяет конвенции для Java bean и полностью соответствует остальным буквам в регистре. На всякий случай, раз уж включили паранойю, проверим геттеры. А вот с геттером есть одна особенность, у него «keystore» написано так, будто это два слова: «Key» и «Store». Внезапненько…
Казалось бы, при чём тут геттер, если не смогли засеттить? Разбираемся.
Оказывается, что первоисточником списка бинов, при вот этом Relax Binding стали внезапно геттеры (в том числе getStoreType()). Не только они, но они в первую очередь. Соответственно, под каждый геттер должен быть найден и свой сеттер. Но под такое свойство, как keyStoreType, никакого сеттера нет. Собственно, об это как раз и ломается Relax Binding, пытаясь найти возможность связывания, и выводит об этом сообщение таким неочевидным образом, как мы видели выше.
Может показаться, что это какой-то вырожденный кейс, там кто-то один раз накосячил, и из этого раздули проблему. Но она может воспроизводиться достаточно легко, если принять поправку на реальность. В действительности класс конфигурации может выглядеть примерно вот так:
А проблема может воспроизводиться не только на том, что кто-то ошибся в одном методе, но и на том, что в результате, например, кривого мёржа или ещё чего-нибудь, в классе оказалось два метода с почти одинаковым именем. Проявление проблемы в этом случае будет таким же.
### Как быть?
В первую очередь режим паранойи придётся оставить включенным: сверять регистры букв в именах свойств всё-таки надо. Во-вторых, если вы предполагаете, что у вас в dev-окружении свойства будут браться, например, из YAML и properties, а на боевом — из переменных окружения в операционной системе, то проверьте это заранее, может и не смапиться. В-третьих, было бы здорово ознакомиться [c тем самым гайдом](https://github.com/spring-projects/spring-boot/wiki/Relaxed-Binding-2.0), который написали именно по второй версии Relax Binding, достаточно один раз прочитать. Ну и, наконец, надеяться, что в третьей версии Spring Boot всё будет хорошо.
Unit Testing. Выполнение тестов в Mockito 2
-------------------------------------------
Поговорим немного о тестировании, только не о каком-то там высокоуровневом интеграционном и функциональном, а об обычном модульном тестировании при помощи Mockito.
Mockito оказался при делах потому, что если вы подтяните себе в зависимости Spring Boot Starter, ну или вообще тестовую оснастку Spring, то автоматически получите зависимость ещё и от Mockito.
```
$gradle -q dependencyInsight --configuration testCompile --dependency mockito
org.mockito:mockito-core:2.15.0
variant "runtime"
/--- org.springframework.boot:spring-boot-starter-test:2.0.2.RELEASE
/---testCompile
```
Но какую версию этой зависимости? Вот тут есть один неочевидный момент. В первой версии Spring Boot использовал Mockito также первой версии, однако с версией 1.5.2 Spring Boot стал допускать ручное включение Mockito 2, то есть стал с ним совместим. Однако по умолчанию это по-прежнему не изменилось. И только со второй версии он стал использовать Mockito 2.
Сам Mockito обновился достаточно давно, ещё в конце 2016-го года вышли Mockito 2.0 и Mockito.2.1— две серьёзные версии с кучей изменений: поддержали Java 8 с её выведением типов, обошли пересечение с библиотекой Hamcrest и учли много набитых давным-давно шишек. И эти версии, как предполагает изменение мажорной цифры, обратно не совместимы с первой.
Всё это приводит к тому, что вы не только сталкиваетесь с кучей проблем в основном коде, но и получаете провальные (хоть и компилируемые) тесты.
Например, у вас был вот такой простенький тест, в котором вы замокали JButton из Swing, выставили ему имя null, а потом проверяете, действительно ли вы выставили какую-то любую строчку. С одной стороны, string’у можно присвоить null, с другой стороны, null не проходит instanceof на string. В общем, в Mockito 1 это всё проходило без проблем, но Mockito 2 уже научился вникать в это дело более основательно и говорит, что anyString на null больше не проходит, он в явном виде выдаст ошибку о том, что такой тест более не является корректным. И заставляет проверять в явном виде: если вы ожидаете там увидеть null, будьте добры так и пропишите. По [утверждению разработчиков](https://static.javadoc.io/org.mockito/mockito-core/2.24.0/org/mockito/ArgumentMatchers.html#anyString--), они почувствовали, что такое изменение сделает тестовую оснастку чуть более безопасной, чем она была в Mockito 1.
Возьмем похожий, на первый взгляд, пример.
```
public class MyService {
public void setTarget(Object target) {
//…
}
}
---
@Test
public void testAnyStringMatcher() {
MyService myServiceMock = mock(MyService.class);
myServiceMock.setTarget(new JButton());
verify(myServiceMock).setTarget(anyString());
}
```
Допустим, у нас есть прикладной класс с единственным методом, принимающим любой объект. И теперь мы его замокировали и в качестве этого любого объекта задали ему всё тот же JButton. А потом внезапно проверяем его на anyString. Казалось бы, это полная ересь: мы передали кнопку, а проверяем на строчку — вообще не связанные вещи. Но это здесь, в вырожденном одном классе такое кажется безумным. Когда вы проверяете какое-либо поведение приложения под разными углами в 10-ти аспектах с сотней тестов, написать такое на самом деле легко и просто. И Mockito 1 никак не скажет, что вы проверяете полную фигню:
Mockito 2 уже об этом предупредит, хотя, на первый взгляд, anyString ведёт себя точно так же:
Поговорим немножко о другой области. Ещё один пример, только теперь касающийся исключений. Допустим, у нас есть всё тот же прикладной класс, теперь с ещё более простым методом, который вообще ничего не принимает и ничего не делает, и мы хотим сэмулировать в нём падение по SocketTimeoutException, то есть как будто бы там какой-то сетевой сбой внутри. При этом сам метод изначально никаких проверяемых исключений не декларировал, а SocketTimeoutException проверяемый, если помните. Так вот такой тест без проблем проходил в Mockito 1.
А вот Mockito 2 уже научился в это дело вникать и говорить, что проверяемое исключение для данного случая не валидно:
Фишка в том, что Mockito 1 тоже умел так делать, но только в том случае, если исключение было создано именно как экземпляр класса. То есть если вы создали new SocketTimeoutException прямо через new, через constructor, то Mockito 1 бы тоже заругался.
Что с этим делать? Придётся оборачивать такие исключения, например, в RuntimeException, а потом уже вышвыривать их из класса, так как теперь Mockito стал более чётким в проверках.
Таких кейсов достаточно много. Я привёл парочку примеров, а остальное обозначу лишь в общих чертах. В первую очередь это несовместимость в compile-time. Кое-какие классы переехали в другие пакеты, чтобы не пересекаться с Hamcrest. Касательно Spring Boot, в Mockito 1 больше не поддерживаются классы @MockBean и @SpyBean. И ещё отдельного внимания заслуживает полноценный тестовый фреймворк, который запилили в Spring Integration, мне довелось приложить к нему руку в части review.
(Почитать: <https://docs.spring.io/spring-integration/docs/5.0.0.RELEASE/reference/htmlsingle/#testing>)
### Как быть?
Как бы нравоучительно ни звучало, но те практики, которые рекомендовались для использования с Mockito 1, зачастую позволяют обходить проблем с Mockito 2 ([dzone.com/refcardz/mockito](https://dzone.com/refcardz/mockito)).
Во-вторых, если вам ещё предстоит такой переход, вы можете сделать его заранее, начав с версии Spring Boot 1.5.2 использовать Mockito 2.
В-третьих, конечно, можно учитывать те гайды, которые приведены для Mockito 2, и на них уже собрано уже довольно много интересного опыта: [раз](https://asolntsev.github.io/en/2016/10/11/mockito-2.1), [два](https://github.com/mockito/mockito/wiki/What's-new-in-Mockito-2).
Gradle Plugin. Сборка Spring Boot проектов
------------------------------------------
Последнее, о чем хотелось бы поговорить, — это Spring Boot-плагин для Gradle.
В самом Migration Guide сказано, что Spring Boot плагин для Gradle был изрядненько переписан. Что есть, то есть. Из основного: ему теперь нужен Gradle 4 версии (соответственно, хотя бы пустой settings.gradle в корне проекта). Он больше по умолчанию не подключает dependency management plugin, чтобы было поменьше магии. И ещё задача bootRepackage, самая магическая, распалась на две: на bootWar и bootJar. Вот как раз на bootJar мы чуть поподробнее и остановимся.
Задача bootJar:
* Активируется автоматически, если применены плагины org.springframework.boot и java;
* Отключает задачу jar;
* Умеет находить mainClassName (главное имя класса для запуска) разными способами (и валит сборку, если все-таки не нашла).
Казалось бы, такие понятные очевидные выводы, но что из них следует — отнюдь не очевидно, пока не попробуешь, ибо это Gradle, да ещё и со Spring Boot.
О чём конкретно идёт речь? Мы возьмём какое-нибудь простенькое приложение на Spring Boot 2, сборочку, естественно, на Gradle 4 и с использованием вот этого Spring Boot-плагина. И чтобы добавить ему реалистичности, мы сделаем его не обычным, а составным: у нас будет и прикладной код, и библиотека, как это часто делается (общий код выделяется в библиотеку, все остальные от него зависят).
Если на картинках, то вот так. Цифра в имени app1 предполагает, что может быть app2, app3 и т. д. Этот app1 зависит от библиотеки lib.
### «Show me the code!»
Корневой проект
```
subprojects {
repositories {
mavenCentral()
}
apply plugin: 'java'
apply plugin: 'org.springframework.boot'
}
```
В корневом проекте у нас всё очень просто — применяется два плагина: java и сам Spring Boot ко всем подпроектам.
Кстати, я не упомянул, что это не единственный способ это сделать, можно разными способами. Можно либо в корневом проекте указать, что мы будем применять плагин к каждому подпроекту, либо в каждом подпроекте указать, с чем он будет работать. Ради лаконичности нашего примера выберем первый способ.
app1: скрипт сборки
```
dependencies {
ext {
springBootVersion = '2.0.4.RELEASE'
}
compile("org.springframework.boot:spring-boot-starter:$springBootVersion")
compile project(':lib')
}
```
В прикладном коде у нас указана только зависимость от lib и то, что это Spring Boot-приложение.
app1: исполняемый код
```
@SpringBootApplication
public class GradlePluginDemoApplication implements ApplicationRunner {
//…
@Override
public void run(ApplicationArguments args) {
String appVersion = Util.getAppVersion(getClass());
log.info("Current application version: {}", appVersion);
}
}
```
В исполняемом коде мы только обратимся к классу Util, лежащему у нас в либе.
lib: исполняемый код
```
public abstract class Util {
public static String getAppVersion(Class appClass) {
return appClass.getPackage().getImplementationVersion();
}
}
```
Этот класс Util своим методом getAppVersion просто обратится к пакету, возьмёт у него манифест, запросит ImplementationVersion и вернёт её. А скрипт сборки у этого подпроекта вообще пустой.
Если запускать такое приложение из IDE, всё будет нормально, она разрешит все зависимости, и всё будет работать идеально. Но стоит выполнить gradle build извне IDE вручную, как сборка сломается. И причиной станет внезапно невозможность разрешения зависимости от Util. То есть, казалось бы, библиотека лежит совсем рядышком, но найти её компилятор не может, потому что якобы не видит такого пакета.
### Результаты расследования
Причины:
* bootJar глушит собою jar;
* Gradle поставляет зависимости подпроектам на основе выхлопа от jar.
Следствия:* Компилятор не может разрешить зависимость от библиотеки;
* Все атрибуты манифеста, выставленные на задаче jar (тот же ImplementationVersion), игнорируются.
Как можно это исправить? Один из вариантов: сделать в самом корневом скрипте вот такое исключение.
То есть как бы оторвать применение Spring Boot-плагина от остальных проектов, сказав, что для lib его применять не нужно. Однако есть и другой способ.
Вариант 2: применять SB Gradle Plugin только к Spring Boot-подпроектам
```
bootJar {
enabled = false
}
```
Если мы не хотим, чтобы корневой проект знал о каких-то отдельной вычурной библиотеке, можно в ней самой, точнее, в её скрипте сборки, прописать, что конкретно для этого подпроекта bootJar должен быть выключен. Соответственно, обычная стандартная задача jar останется включенной, и всё будет работать как и прежде.
Прочее
------
Мы поговорили, наверное, лишь о небольшой доле всех граблей, которые могут встретиться при обновлении Spring Boot. Некоторые из оставшихся я упомяну лишь вкратце.
В Spring Boot за скобками нашего рассмотрения остались многочисленные переименования параметров: они связаны и с переходом на web-стек, на разбивку его на сервлетный и реактивный, и с другими правками. Чтобы с этим как-то работать, со второй версией поставляется такая классная штука, как Spring Boot properties migrator, очень рекомендую задействовать её для того, чтобы понять, какие у вас параметры используются с устаревшими именами. Она прям в лог вам выпишет, что вот этот параметр устарел, его нужно заменить на такой-то, а вот этот отныне бесполезен и так далее.
Ещё много изменений произошло в Actuator. В частности, теперь придётся совсем иначе рулить безопасностью (доступностью) его методов, отныне это больше похоже на Spring Security. Больше нет никаких специальных флажков для этого.
В Spring Cloud произошло много переименований. Это важно потому, что его версия тоже транзитивно будет подтянута вами. Это переименование артефактов, касающихся Netflix и Feign.
В Spring Integration, который тоже достиг пятой версии, как и Spring Framework, произошёл ряд изменений. Одно из самых крупных — это то, что некогда экспериментальный Java DSL въехал в ядро самого проекта и, соответственно, его больше не нужно подключать как отдельную зависимость. Ещё те адаптеры, которые служат для связи с внешним миром, входные и выходные, теперь заполучили свои собственные статические методы, которые могут использоваться в конвейерах на методе handle без специального метода handleWithAdapter.
Заключение. Резюме и выводы
---------------------------
Резюмируя, я обозначу четыре области, от которых стоит ждать подвохов:
При обновлении это, в первую очередь, конечно, Web, поскольку разделение стеков не могло пройти незамеченным.
Второе (Properties Binding), связывание внешних параметров, тоже изрядно доставляет удовольствие за счёт того, что изменился механизм Relax Binding.
Третье — всё, что связано с механизмами проксирования: это всякое кэширование, AOP и прочее, тоже может стать источником изменений за счёт того, что в Spring Boot 2 по умолчанию изменился режим проксирования.
И, наконец, четвёртое, тесты — как раз потому, что произошло обновление с Mockito 1 на Mockito 2. Но это всё какие-то общие слова, а как с этим быть?
* Пробовать «с нахрапа» (YAGNI)
* Сверяться с [образцами;](https://github.com/Toparvion/joker-2018-samples)
* Проверять обновления в [Migration Guide](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-2.0-Migration-Guide);
* Смотреть другие грабледайджесты: [раз](https://www.baeldung.com/new-spring-boot-2), [два](https://medium.com/@nucatus/spring-boot-2-x-migration-analysis-95f42bde402a)
Во-первых, не надо думать, что такие грабли будут ждать вас на каждом шагу, стоит пробовать запускаться как есть, помнить о принципе YAGNI. До тех пор, пока у вас что-то не сломалось, не надо пытаться это чинить. Такой подход, как минимум, позволит вам оценить масштаб проблем.
Во-вторых, если с чем-то всё-таки столкнулись, можете свериться с некоторыми образцами, которые я насобирал, пока готовился к этому докладу. Там нет никакой лишней логики, они исключительно занимаются воспроизведением конкретных ситуаций, которые документированы, описаны, как что делать и откуда что брать. Плюс к тому не мешало бы периодически заглядывать в сам Migration Guide. Благодаря тому, что этот документ постоянно пополняется и развивается самими разработчиками, велика вероятность того, что как только вы в него загляните, вдруг выяснится, что ваш кейс разрешён и там об этом уже написано.
Есть и другие такие грабледайджесты, которые собирали опыт и обобщали всевозможные грабли при обновлении и дальнейшей эксплуатации Spring Boot. Надеюсь, что все эти советы и знания помогут вам обновиться без проблем и в дальнейшем успешно использовать Spring Boot, поставить его себе на службу, чтобы он служил вам верой и правдой… вплоть до третьей версии.
> Если вам понравился доклад, обратите внимание: **5-6 апреля в Москве** пройдёт **JPoint**, и там я выступлю с [новым докладом](https://jpoint.ru/talks/6kyixr30fgfmedztyom628/?utm_source=habr&utm_medium=439796) о Spring Boot: в этот раз о переводе Spring Boot-микросервисов с Java 8 на Java 11. Подробности о конференции — [на сайте](https://jpoint.ru/?utm_source=habr&utm_medium=439796). | https://habr.com/ru/post/439796/ | null | ru | null |
# Ищем и анализируем ошибки в коде GitExtensions
Как изестно Ядро Git представляет собой набор утилит командной строки с параметрами. Для комфортной работы как правило используются утилиты, дающие нам привычный графический интерфейс. Вот и мне довелось в свое время поработать с такой утилитой для Git, как GitExtensions. Не скажу, что это самый удобный инструмент, которым мне доводилось пользоваться (к примеру, тот же TortoiseGit мне нравится больше), но он явно и не безосновательно занимает свою нишу в списке любимых и проверенных утилит для работы с Git.
Недавно я вспомнил про него, и решил проверить статическим анализатором на наличие ошибок и опечаток его исходный код. О том, какие ошибки были найдены после проверки я расскажу в этой статье.
GitExtensions
-------------
GitExtensions — кроссплатформенный визуальный клиент для работы с системой управления версиями Git с [открытым исходным кодом](https://github.com/gitextensions/gitextensions/).
Проект GitExtensions небольшой. В сумме это 10 основных проектов, 20 плагинов и 2 дополнительных проектов, компилируемых в вспомогательные библиотеки. В общей сложности 56 091 строк кода в 441 файле.
Давайте посмотрим, сможет ли что-то интересное найти в этом проекте статический анализатор [PVS-Studio](http://www.viva64.com/ru/pvs-studio/).
Результаты проверки
-------------------
По итогам проверки было получено 121 предупреждение. Если рассматривать более подробно, то 16 предупреждений было получено на первом (высоком) уровне. 11 из них явно указывали на проблемные места или ошибки. На втором уровне (среднем) было получено 80 предупреждений. По моему субъективному мнению, 69 предупреждений были верными и указывали на места с ошибками или опечатками. Третий (низкий) уровень предупреждений мы рассматривать не будем, так как он в основном указывает на места, где возникновение ошибок маловероятно. И так, приступим к рассмотрению найденных ошибок.
### Выражение всегда истинно
Начинает наш хит-парад довольно странный участок кода.
```
string rev1 = "";
string rev2 = "";
var revisions = RevisionGrid.GetSelectedRevisions();
if (revisions.Count > 0)
{
rev1 = ....;
rev2 = ....;
....
}
else
if (string.IsNullOrEmpty(rev1) || string.IsNullOrEmpty(rev2)) // <=
{
MessageBox.Show(....);
return;
}
```
V3022 Expression 'string.IsNullOrEmpty(rev1) || string.IsNullOrEmpty(rev2)' is always true. GitUI FormFormatPatch.cs 155
Анализатор выдал предупреждение, что выражение с проверкой переменных *rev1* и *rev2* всегда будет истинным. Сначала я подумал, что это обычная опечатка, оплошность в логике алгоритма, которая никак не повлияет на корректность работы программы. Но рассмотрев код более детально заметил, по всей видимости лишний оператор *else*. Он находится перед второй проверкой, которая будет выполнена только в случае неравенства первой.
### Одно из сравнений избыточно
Вторым номером в нашем хит-параде идет обычная опечатка. Она никак не влияет на логику работы программы, но данный пример хорошо показывает насколько полезен статический анализ.
```
public void EditNotes(string revision)
{
string editor = GetEffectivePathSetting("core.editor").ToLower();
if (editor.Contains("gitextensions") ||
editor.Contains("notepad") || // <=
editor.Contains("notepad++")) // <=
{
RunGitCmd("notes edit " + revision);
}
....
}
```
V3053 An excessive expression. Examine the substrings 'notepad' and 'notepad++'. GitCommands GitModule.cs 691
В выражении ищется более длинная (*notepad++*) и более короткая (*notepad*) подстроки. При этом проверка с более длинной строкой никогда не сработает, так как проверка с поиском более короткой строки будет ее предотвращать. Как я уже упомянул, это не ошибка, а всего лишь опечатка, но в другой ситуации невинная избыточная проверка могла бы превратиться в потенциально коварный баг.
### Переменная используется перед проверкой на *null*
Третье место занимает довольно распространённая ошибка, но сказать о том, что она в данном случае 100% вызовет некорректную работу программы я сказать не могу, так как не вникал слишком глубоко в логику работы данного кода. Лишь тот факт, что переменная проверяется на *null* может говорить о предполагаемом нулевом значении.
```
void DataReceived(string data)
{
if (data.StartsWith(CommitBegin)) // <=
{
....
}
if (!string.IsNullOrEmpty(data))
{
....
}
}
```
V3095 The 'data' object was used before it was verified against null. Check lines: 319, 376. GitCommands RevisionGraph.cs 319
Переменная *data* используется перед проверкой на *null*, что потенциально может привести к возникновению исключения *NullReferenceException*. Если же переменная *data* никогда не является нулевой (null), то расположенная ниже проверка бесполезна и её следует удалить, чтобы она не вводила в заблуждение.
### Возможно возникновение исключения *NullReferenceException* в переопределенном методе *Equals*.
Данная ошибка во многом напоминает предыдущую. Если сравнивать два объекта используя переопределенный метод *Equals*, всегда есть вероятность, что в качестве второго объекта сравнения придет *null*.
```
public override bool Equals(object obj)
{
return GetHashCode() == obj.GetHashCode(); // <=
}
```
V3115 Passing 'null' to 'Equals(object obj)' method should not result in 'NullReferenceException'. Git.hub User.cs 16
При дальнейшем вызове переопределенного метода *Equals* возможно возникновение исключения *NullReferenceException*, если параметр *obj* будет равен *null*. Для предотвращения данной ситуации необходимо использовать проверку на *null*. Например, так:
```
public override bool Equals(object obj)
{
return GetHashCode() == obj?.GetHashCode(); // <=
}
```
### Идентичные выражения в условии if
Под пятым номером гордо расположились 2 опечатки. Они не влияют на результат выполнения программы, но их мы можем отнести к разряду избыточных проверок.
```
private void ConfigureRemotes()
{
....
if (!remoteHead.IsRemote ||
localHead.IsRemote ||
!string.IsNullOrEmpty(localHead.GetTrackingRemote(localConfig)) ||
!string.IsNullOrEmpty(localHead.GetTrackingRemote(localConfig)) ||
remoteHead.IsTag ||
localHead.IsTag ||
!remoteHead.Name.ToLower().Contains(localHead.Name.ToLower()) ||
!remoteHead.Name.ToLower().Contains(_remote.ToLower()))
continue;
....
}
```
V3001 There are identical sub-expressions to the left and to the right of the '||' operator. GitUI FormRemotes.cs 192
Если посмотреть внимательно, то можно заметить 2 одинаковых условия в проверке. Вероятнее всего это следствие копипасты. Так же есть вероятность ошибки, если учесть, что во втором выражении подразумевалось использование переменной *remoteHead* вместо *localHead*, но без глубокого анализа алгоритма работы программы сказать тяжело.
Так же была найдена еще одна подобная ошибка.
```
if (!curItem.IsSourceEqual(item.NeutralValue) && // <=
(!String.IsNullOrEmpty(curItem.TranslatedValue) &&
!curItem.IsSourceEqual(item.NeutralValue))) // <=
{
curItem.TranslatedValue = "";
}
```
V3001 There are identical sub-expressions to the left and to the right of the '&&' operator. TranslationApp TranslationHelpers.cs 112
### Несоответствие количества параметров при форматировании строки
Шестое место достается довольно распространённой ошибке, которая возникает в следствие невнимательности программистов при рефакторинге текста форматируемых строк.
```
Debug.WriteLine("Loading plugin...", pluginFile.Name); // <=
```
V3025 Incorrect format. A different number of format items is expected while calling 'WriteLine' function. Arguments not used: pluginFile.Name. GitUI LoadPlugins.cs 35
В данной ситуации же могу предположить, что программист думал, что значение переменной *pluginFile.Name* будет добавлено в конец форматируемой строки при выводе в дебаг, но это не так. Корректный код будет выглядеть так:
```
Debug.WriteLine("Loading '{0}' plugin...", pluginFile.Name); // <=
```
### Часть выражения всегда истинна
И в завершение еще одна опечатка, которой можно было бы избежать.
```
private void toolStripButton(...)
{
var button = (ToolStripButton)sender;
if (!button.Enabled)
{
StashMessage.ReadOnly = true;
}
else if (button.Enabled && button.Checked) // <=
{
StashMessage.ReadOnly = false;
}
}
```
V3063 A part of conditional expression is always true if it is evaluated: button.Enabled. GitUI FormStash.cs 301
Поскольку мы проверяем, что *button.Enabled* равен *false*, то в *else* данной проверки мы можем смело утверждать, что *button.Enabled* будет равен *true* и таким образом исключить данную проверку повторно.
Заключение
----------
В данном проекте были найдены и другие ошибки, опечатки, недочёты. Но мне они не показались интересными, чтобы описывать их в статье. Разработчики GitExtensions легко смогут найти все недочёты, воспользовавшись инструментом PVS-Studio. Вы так же можете поискать ошибки в своих проектах воспользовавшись предложенным выше статическим анализатором.
Хочу напомнить, что основная польза от статического анализа заключается в регулярном его использовании. Скачать и разово проверить код, это несерьезно. Например, предупреждения компилятора программисты смотрят регулярно, а не включают их раз в 3 года перед одним из релизов. При регулярном использовании статический анализатор сэкономит массу времени на поиск опечаток и ошибок.
[](http://www.viva64.com/en/b/0440/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Ivan Kishchenko. [GitExtensions bugs found and analyzed](http://www.viva64.com/en/b/0440/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/312526/ | null | ru | null |
# Ваш пакет Composer сломан: обновите идентификатор лицензии
Если вы, как и я:
* являетесь мэйнтейнером какой-либо библиотеки или фреймворка;
* ваша библиотека или фреймворк выпущены под какой-либо свободной лицензией
* ваша библиотека или фреймворк доступны к установке через Composer и размещены на сервисе Packagist;
то у вас, возможно, есть проблемы, о которых вы и не подозреваете.
Что случилось?
--------------
Некоторое время назад изменилась схема файла composer.json
Отныне в свойстве `license` строго рекомендуется указывать лишь те идентификаторы лицензий, которые есть в Реестре открытых лицензий SPDX, либо писать `proprietary`, если вы не планируете следовать какой-либо свободной лицензии.
Все пакеты, в `composer.json` которых идентификатор лицензии указан иначе, чем в списке SPDX, перестали автоматически обновляться на Packagist
И в чем проблема?
-----------------
Ранее большинство пакетов указывали вместо рекомендованного идентификатора лицензии просто её название.
Как было, например, у меня:
```
"license": "LGPL v.3",
```
Как теперь требуется:
```
"license": "LGPL-3.0-or-later",
```
Проблема в том, что пакеты просто молча перестают обновляться. Говорят, что авторам пакетов приходит сообщение на почту от Packagist. Я лично его не видел, возможно сам виноват — просмотрел или случайно запихнул в спам...
Что же делать?
--------------
Для начала зайдите на packagist.org на страницу своего пакета. Авторизуйтесь, как автор пакета, нажмите кнопку Update. Если в вашем пакете указана неверная (с точки зрения packagist) лицензия, вы увидите сообщение с примерно таким текстом:
```
Invalid package information:
License "LGPL v.3" is not a valid SPDX license identifier, see https://spdx.org/licenses/ if you use an open license.
If the software is closed-source, you may use "proprietary" as license.
```
Далее вам не остаётся ничего делать, кроме как обновить свойство `license` в файле composer.json своего пакета, не забыть сделать это во всех ветках, создать новые теги версий и обновить пакет на Packagist.
Позаботьтесь о пользователях ваших пакетов — сделайте это сегодня!
Что почитать?
-------------
* [Ссылка на схему composer.json](https://getcomposer.org/doc/04-schema.md#license)
* [Список лицензий SPDX](https://spdx.org/licenses/) | https://habr.com/ru/post/348520/ | null | ru | null |
# Оптимизация при помощи линейного поиска на Python
Линейный поиск — это алгоритм оптимизации, который может использоваться для целевых функций с одной или несколькими переменными. Он предоставляет возможность использовать алгоритм одномерной оптимизации, например поиск методом деления пополам (бисекции) для многомерной целевой функции, работая с линейным поиском для определения оптимального размера шага в каждом измерении от известной точки до оптимума. Мы уже делились переводами Джейсона Браунли, например статьёй о [смешанных ансамблях](https://habr.com/ru/company/skillfactory/blog/531416/), а в этом учебном руководстве, которое мы перевели к старту курса о [машинном и глубоком обучении](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=130621), рассказывается об основах: вы узнаете, как на Python с помощью линейного поиска выполнить оптимизацию.
---
Прочитав это руководство, вы узнаете:
* что линейный поиск — это алгоритм оптимизации для одномерных и многомерных задач оптимизации;
* что библиотека SciPy предоставляет API выполнения линейного поиска, который требует знания о том, как вычисляется первая производная вашей целевой функции;
* как выполнить линейный поиск для целевой функции и работать с результатом.
Давайте начнём.
Обзор
-----
Этот учебный материал разделён на три части:
1. Что такое линейный поиск?
2. Линейный поиск на Python.
3. Как выполняется линейный поиск? Он состоит из:
a) определения целевой функции;
б) выполнения линейного поиска;
в) работы со сбоями алгоритма.
Что такое линейный поиск?
-------------------------
[Линейный поиск](https://en.wikipedia.org/wiki/Line_search) — это алгоритм оптимизации для одномерной или многомерной оптимизации. Он требует начальной позиции в пространстве поиска, а также указания направления поиска. Затем он из начальной выбирает следующую позицию в пространстве поиска, которая приведёт к значению лучше или же к наилучшему значению целевой функции.
Направление имеет знак (плюс или минус) вдоль линии и максимальную протяжённость поиска, поэтому его лучше рассматривать как область поиска кандидатов, оно должно быть достаточно большим, чтобы охватить оптимумы или точку лучше начальной.
Линейный поиск автоматически выберет коэффициент масштаба, который называется альфа, для размера шага (направления) исходя из текущей, минимизирующей целевую функцию позиции. Чтобы найти оптимальную точку в выбранном направлении и выбрать соответствующую альфа, используется другой алгоритм одномерной оптимизации
> Один из подходов заключается в применении линейного поиска, выбирающего коэффициент шага, который минимизирует одномерную функцию [...]. Мы можем применить метод одномерной оптимизации по нашему выбору.
>
> — [Алгоритмы оптимизации](https://amzn.to/31J3I8l), 2019. — С. 54.
>
>
Альфа — коэффициент масштаба для направления, поэтому при поиске учитываются только значения в диапазоне от 0,0 до 1,0. Один шаг линейного поиска решает задачу минимизации, которая минимизирует целевую функцию для текущей позиции в сумме с масштабируемым направлением, то есть:
* Минимизирует objective(position + alpha \* direction).
Таким образом, линейный поиск работает в одном измерении за один раз и возвращает расстояние перемещения в выбранном направлении.
> Каждая итерация метода линейного поиска вычисляет направление поиска pk, а затем решает, как далеко двигаться в этом направлении.
>
> — [Численная оптимизация](https://amzn.to/3lCRqX9), 2006. — С. 30.
>
>
Чтобы перенести пространство поиска к решению, линейный поиск может быть вызван повторно и может завершиться неудачей, если выбранное направление не содержит точки с меньшим значением целевой функции, например когда алгоритм направлен искать по склону вверх.
Решение приблизительно или неточно и в зависимости от формы пространства поиска может не оказаться общим решением. Условия, при которых этот алгоритм подходит, называются [условиями Вольфе](https://ru.wikipedia.org/wiki/%D0%A3%D1%81%D0%BB%D0%BE%D0%B2%D0%B8%D1%8F_%D0%92%D0%BE%D0%BB%D1%8C%D1%84%D0%B5). Теперь, когда мы знакомы с линейным поиском, давайте посмотрим, как выполнять его на Python.
Линейный поиск на Python
------------------------
Выполнить линейный поиск на Python можно вручную, с помощью функции [line\_search()](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.line_search.html). Она поддерживает одномерную оптимизацию, а также многомерные задачи оптимизации. Эта функция принимает имя целевой функции и имя градиента для целевой функции, а также текущее положение в пространстве поиска и направление движения.
Таким образом, вы должны знать первую производную вашей целевой функции. Вы также должны иметь некоторое представление о том, с чего начать поиск и насколько широко выполнять его. Напомним, что поиск может выполняться несколько раз с разными направлениями (знаком и протяжённостью).
```
...
result = line_search(objective, gradient, point, direction)
```
Функция возвращает кортеж из шести элементов, включая коэффициент масштаба для направления, называемый альфа, и количество выполненных вычислений функций, а также другие значения. Первый элемент в результирующем кортеже содержит альфа. Если поиск не сойдётся, альфа будет иметь значение *None*.
```
...
# retrieve the alpha value found as part of the line search
alpha = result[0]
```
*Альфа*, начальная точка и *направление* могут использоваться при построении конечной точки линейного поиска.
```
...
# construct the end point of a line search
end = point + alpha * direction
```
Для задач оптимизации с более чем одной входной переменной, например многомерной оптимизации, функция [line\_search()](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.line_search.html) вернёт одно альфа-значение для всех измерений. Это значит, функция предполагает, что оптимум равноудалён от начальной точки во всех измерениях, такое ограничение существенно. Теперь, после ознакомления с тем, как в Python выполнять линейный поиск, давайте рассмотрим работающий пример.
### Как выполняется линейный поиск?
Мы можем продемонстрировать, как использовать линейный поиск с простой одномерной целевой функцией и её производной. Этот раздел, в свою очередь, разделён на несколько частей, включая определение тестовой функции, выполнение линейного поиска и обработку неудачных случаев, когда оптимум не находится.
#### Определение целевой функции
Во-первых, мы можем определить целевую функцию. Здесь поработаем с одномерной целевой функцией, а именно со сдвинутой на небольшую величину от нуля функцией x^2. Это выпуклая функция, она была выбрана потому, что её легко понять, а также легко вычислить первую производную.
* objective(x) = (-5 + x)^2.
Обратите внимание, что линейный поиск не ограничивается одномерными или выпуклыми функциями. Реализация этой функции приведена ниже.
```
# objective function
def objective(x):
return (-5.0 + x)**2.0
```
Первая производная этой функции может быть вычислена аналитически следующим образом:
* gradient(x) = 2 \* (-5 + x).
Градиент для каждого входного значения просто указывает наклон к оптимумам в каждой точке. Реализация функции градиента приведена ниже:
```
# gradient for the objective function
def gradient(x):
return 2.0 * (-5.0 + x)
```
Можно определить диапазон входных данных для x от -10 до 20 и вычислить целевое значение для каждого входного значения:
```
...
# define range
r_min, r_max = -10.0, 20.0
# prepare inputs
inputs = arange(r_min, r_max, 0.1)
# compute targets
targets = [objective(x) for x in inputs]
```
Затем, чтобы получить представление о форме функции, мы можем построить график входных значений в сравнении с целевыми значениями:
```
...
# plot inputs vs objective
pyplot.plot(inputs, targets, '-', label='objective')
pyplot.legend()
pyplot.show()
```
Связав всё это воедино, получим такой код:
```
# plot a convex objective function
from numpy import arange
from matplotlib import pyplot
# objective function
def objective(x):
return (-5.0 + x)**2.0
# gradient for the objective function
def gradient(x):
return 2.0 * (-5.0 + x)
# define range
r_min, r_max = -10.0, 20.0
# prepare inputs
inputs = arange(r_min, r_max, 0.1)
# compute targets
targets = [objective(x) for x in inputs]
# plot inputs vs objective
pyplot.plot(inputs, targets, '-', label='objective')
pyplot.legend()
pyplot.show()
```
Программа вычисляет входные значения (x) в диапазоне от -10 до 20 и создаёт график, показывающий знакомую U-образную форму параболы. Оптимум функции, по-видимому, находится в точке x=5,0, целевое значение — 0,0.
Линейный график выпуклой целевой функции#### Выполнение линейного поиска
Затем можно выполнить линейный поиск по этой функции. Во-первых, мы должны определить отправную точку поиска и его направление. Здесь воспользуемся начальной точкой x=-5, расстояние от которой до оптимума — около 10 единиц. Сделаем большой шаг вправо, в данном случае в 100 единиц (что значительно превышает оптимум), например, в положительном направлении. Напомним, что направление похоже на размер шага и поиск масштабирует размер шага, чтобы найти оптимум:
```
...
# define the starting point
point = -5.0
# define the direction to move
direction = 100.0
# print the initial conditions
print('start=%.1f, direction=%.1f' % (point, direction))
# perform the line search
result = line_search(objective, gradient, point, direction)
```
Затем поиск ищет оптимумы и возвращает альфа или расстояние, чтобы изменить направление. Из результата мы можем получить значение альфа, а также количество выполненных вычислений функций:
```
...
# summarize the result
alpha = result[0]
print('Alpha: %.3f' % alpha)
print('Function evaluations: %d' % result[1])
```
Мы можем использовать альфа вместе с нашей начальной точкой и размером шага для вычисления местоположения оптимумов и вычисления целевой функции в этой точке (которая, как мы ожидаем, будет равна 0,0):
```
...
# define objective function minima
end = point + alpha * direction
# evaluate objective function minima
print('f(end) = %.3f' % objective(end))
```
Затем, для развлечения, мы можем снова построить график функции и показать начальную точку в виде зелёного квадрата, а конечную точку — в виде красного квадрата.
```
...
# define range
r_min, r_max = -10.0, 20.0
# prepare inputs
inputs = arange(r_min, r_max, 0.1)
# compute targets
targets = [objective(x) for x in inputs]
# plot inputs vs objective
pyplot.plot(inputs, targets, '--', label='objective')
# plot start and end of the search
pyplot.plot([point], [objective(point)], 's', color='g')
pyplot.plot([end], [objective(end)], 's', color='r')
pyplot.legend()
pyplot.show()
```
Ниже приведён полный пример выполнения линейного поиска для выпуклой целевой функции:
```
# perform a line search on a convex objective function
from numpy import arange
from scipy.optimize import line_search
from matplotlib import pyplot
# objective function
def objective(x):
return (-5.0 + x)**2.0
# gradient for the objective function
def gradient(x):
return 2.0 * (-5.0 + x)
# define the starting point
point = -5.0
# define the direction to move
direction = 100.0
# print the initial conditions
print('start=%.1f, direction=%.1f' % (point, direction))
# perform the line search
result = line_search(objective, gradient, point, direction)
# summarize the result
alpha = result[0]
print('Alpha: %.3f' % alpha)
print('Function evaluations: %d' % result[1])
# define objective function minima
end = point + alpha * direction
# evaluate objective function minima
print('f(end) = f(%.3f) = %.3f' % (end, objective(end)))
# define range
r_min, r_max = -10.0, 20.0
# prepare inputs
inputs = arange(r_min, r_max, 0.1)
# compute targets
targets = [objective(x) for x in inputs]
# plot inputs vs objective
pyplot.plot(inputs, targets, '--', label='objective')
# plot start and end of the search
pyplot.plot([point], [objective(point)], 's', color='g')
pyplot.plot([end], [objective(end)], 's', color='r')
pyplot.legend()
pyplot.show()
```
Программа-пример сначала сообщает начальную точку и направление. Поиск выполняется, и обнаруживается изменяющая направление для нахождения оптимума значение альфа, в данном случае — найденное после трёх вычислений функции 0.1. Точка оптимума находится на отметке 5,0, значение y, как и ожидалось, равно 0,0:
```
start=-5.0, direction=100.0
Alpha: 0.100
Function evaluations: 3
f(end) = f(5.000) = 0.000
```
Наконец, создаётся график функции, показывающий зелёную начальную точку и красную цель.
Линейный график целевой функции с оптимумами и начальной точкой поиска#### Работа со сбоями алгоритма
Линейный поиск не гарантирует нахождения оптимумов функции. Он может не найти оптимумы, если задано значение направления, недостаточно большое, чтобы охватить их. Например, найти оптимумы будет невозможно, когда направление имеет значение 3. Продемонстрировать это можно на полном примере ниже:
```
# perform a line search on a convex objective function with a direction that is too small
from numpy import arange
from scipy.optimize import line_search
from matplotlib import pyplot
# objective function
def objective(x):
return (-5.0 + x)**2.0
# gradient for the objective function
def gradient(x):
return 2.0 * (-5.0 + x)
# define the starting point
point = -5.0
# define the direction to move
direction = 3.0
# print the initial conditions
print('start=%.1f, direction=%.1f' % (point, direction))
# perform the line search
result = line_search(objective, gradient, point, direction)
# summarize the result
alpha = result[0]
print('Alpha: %.3f' % alpha)
# define objective function minima
end = point + alpha * direction
# evaluate objective function minima
print('f(end) = f(%.3f) = %.3f' % (end, objective(end)))
```
При выполнении примера поиск достигает предела альфа 1,0, что даёт конечную точку от -2 до 49. При f(5) = 0,0 от оптимумов очень далеко:
```
start=-5.0, direction=3.0
Alpha: 1.000
f(end) = f(-2.000) = 49.000
```
Кроме того, мы можем выбрать неправильное направление, ведущее только к вычислениям хуже стартовой точки. Здесь оно будет отрицательным в сторону от оптимума, например, вверх по склону от начальной точки:
```
...
# define the starting point
point = -5.0
# define the direction to move
direction = -3.0
```
Ожидается, что поиск не сойдётся, поскольку он не может найти какие-либо точки лучше начальной. Полный пример поиска, который не сходится, приведён ниже:
```
# perform a line search on a convex objective function that does not converge
from numpy import arange
from scipy.optimize import line_search
from matplotlib import pyplot
# objective function
def objective(x):
return (-5.0 + x)**2.0
# gradient for the objective function
def gradient(x):
return 2.0 * (-5.0 + x)
# define the starting point
point = -5.0
# define the direction to move
direction = -3.0
# print the initial conditions
print('start=%.1f, direction=%.1f' % (point, direction))
# perform the line search
result = line_search(objective, gradient, point, direction)
# summarize the result
print('Alpha: %s' % result[0])
```
Выполнение программы приводит к предупреждению LineSearchWarning, указывающему на то, что поиск, как и ожидалось, не может сойтись. Альфа — возвращённое в результате поиска значение — равно None:
```
start=-5.0, direction=-3.0
LineSearchWarning: The line search algorithm did not converge
warn('The line search algorithm did not converge', LineSearchWarning)
Alpha: None
```
### Дальнейшее чтение
Если вы хотите глубже погрузиться в тему, смотрите этот раздел.
#### Книги
* [Алгоритмы оптимизации](https://amzn.to/31J3I8l), 2019.
* [Численная оптимизация](https://amzn.to/3lCRqX9), 2006.
#### API
* [Оптимизация и поиск корней (scipy.optimize)](https://docs.scipy.org/doc/scipy/reference/optimize.html).
* [Оптимизация (scipy.optimize)](https://docs.scipy.org/doc/scipy/reference/tutorial/optimize.html).
* [scipy.optimize.line\_search API](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.line_search.html).
#### Статьи
* [Линейный поиск. Википедия](https://en.wikipedia.org/wiki/Line_search).
* [Условия Вольфе. Википедия](https://ru.wikipedia.org/wiki/%D0%A3%D1%81%D0%BB%D0%BE%D0%B2%D0%B8%D1%8F_%D0%92%D0%BE%D0%BB%D1%8C%D1%84%D0%B5).
### Резюме
Из этого руководства вы узнали, как выполнить оптимизацию линейного поиска на Python. В частности, вы узнали:
* что линейный поиск — это алгоритм оптимизации для одномерных и многомерных задач оптимизации;
* что библиотека SciPy предоставляет API выполнения линейного поиска, требующий знания о том, как вычисляется первая производная вашей целевой функции;
* как выполнить линейный поиск для целевой функции и работать с его результатом.
Применяемые в машинном обучении методы оптимизации, конечно же, не ограничиваются одним лишь линейным поиском, они многочисленны, разнообразны и у каждого есть свои недостатки и преимущества. Если вы хотите погрузиться в машинное обучение, изучить оптимизацию глубже, но не хотите ограничивать себя областью ML, вы можете обратить внимание на наш курс ["Machine Learning и Deep Learning"](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=130621), партнёр которого, компания NVIDIA, не нуждается в представлении.
[Узнайте](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=130621), как прокачаться и в других специальностях или освоить их с нуля:
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=130621)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=130621)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=130621)
Другие профессии и курсы**ПРОФЕССИИ**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=130621)
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=130621)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=130621)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=130621)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=130621)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=130621)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=130621)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=130621)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=130621)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=130621)
**КУРСЫ**
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=130621)
* [Курс "Machine Learning и Deep Learning"](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=130621)
* [Курс "Математика для Data Science"](https://skillfactory.ru/math-stat-for-ds#syllabus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MAT&utm_term=regular&utm_content=130621)
* [Курс "Математика и Machine Learning для Data Science"](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=130621)
* [Курс "Python для веб-разработки"](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=130621)
* [Курс "Алгоритмы и структуры данных"](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=130621)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=130621)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=130621) | https://habr.com/ru/post/561042/ | null | ru | null |
# Ускоряем PHP (с ReactPHP)
В этом посте я хотел бы поделиться не совсем обычным, для мира PHP, способе построения приложения, если угодно — архитектурой. Данный подход позволяет средствами PHP увеличить количество обрабатываемых запросов в разы. Так же я поделюсь своими наработками в этом направлении. Конечно данный подход не бесплатен, в плане требований к коду, но давайте всё по порядку.
Да, в конце мы получим прирост производительности в 30 раз по сравнению с обычным PHP и в 6 раз по сравнению с PHP + OPcache. Но с начала, хотел бы поговорить о существующих, популярных решениях по улучшению быстродействия PHP приложений.
##### OPcache
Большинство современных иснталяций используют APC/OPcache и это считается стандартом и максимум для PHP. У этого подхода наименьшее количество недостатков, т.к. это нативное (родное) решение предлагаемое нам командой PHP. Всё бы хорошо, но скорости маловато.
##### HHVM
HHVM действительно хорош, для популярных Linux дистров уже есть репозитории и остаётся только поставить и настроить, что в целом дело не хитрое. Но это разработка от команды facebook и на данный момент, HHVM сильно ограничивает в выборе расширений, а если у вас вдруг свои патчи для PHP расширений то и вовсе ставит «крест» на безболезненном переходе с PHP на HHVM. Про PHP 5.5 так же можно забыть. Стоит отметить отличную работу facebook команды по увеличению совместимости HHVM с основными инструментами и фреймворками, но это цифра всё таки в районе 97%.
Из приходящих мне в голову вариантов остаются еще сырой HippyVM и фреймворк PhalconPHP. О Phalcon написано много обзоров и думаю повторять их нет смысла. HippyVM в стадии разработки, кстати это альтернатива HHVM от самой же facebook команды, написан на python, что на мой взгляд делает этот проект еще более туманным.
Другие варианты предлагайте в комментариях.
Классическая инсталляция PHP включает в себя установку одного из Nginx, Apache или Lighttpd веб сервера, которые обрабатывают входящие HTTP запросы и перенаправляют динамические к PHP. Существует несколько вариантов подключения PHP к веб серверу:
* mod\_php (apache)
* f(ast)cgi
* php-fpm
Все решения по ускорению PHP в целом направлены на ускорение медленного интерпретатора PHP в момент перенаправления запроса от веб сервера к скрипту, что, как видно по тестам быстродействия даёт свой результат. Но в данном решении есть недостаток, как ни крути, но на каждый запрос PHP приложению приходится объявлять классы, создавать экземпляры, подключаться к базам, читать кэш — инициализировать своё окружение. И как бы мы не ускоряли интерпретатор PHP, но на всю инициализацию тратится много ресурсов и такой подход явно далёк от желаемого, особенно для высоконагруженных решений. Почему так происходит? PHP был изначально сконструирован как язык шаблонов и набора инструментов, и не задумывался как самостоятельный веб сервер. К тому же в PHP нет параллельного выполнения или даже асинхронного как у node.js, а все написанные расширения блокирующие.
Но PHP не стоит на месте. У нас появилась своя экосистема с тысячами инструментов которые легко можно установить благодаря Composer. PHP позаимствовал много патернов у таких языков как Java, JS и других, привет команде Symfony. Появились инструменты позволяющие работать PHP асинхронно. На эту тему уже есть [статья на хабре](http://habrahabr.ru/post/218751/), по этому не буду повторятся в описании этого подхода. Скажу только, что асинхронный подход позволяет нам создавать не только чат на websocket, но и запускать полноценный HTTP сервер, а это значит что нам не придётся инициализировать PHP на каждый запрос. Таким образом, как не сложно догадаться, такой подход сведёт на нет затрачиваемое время на старт различных фреймворков и в конечном счёте улучшиться время отклика.
Данное решение, как понятно из заголовка, построено на ReactPHP. Сам React это скорее инструмент для создания, а не готовое решение. Хотя в нём уже есть инструменты для обработки входящих Http соединений, а так же есть различные инструменты, например для работы с websockets или async redis, но нет реализованных привычных для современных фреймворков MVC патерна, роутинга и т.д. Для этих целей мы подключим ReactPHP к уже существующему Symfony2 приложению.
ReactPHP основывается на eventloop и для реализации этой архитектуры предлагает на выбор установить одну из ext-libevent, ext-libev, ext-event. В случае отказа, React работает через [stream\_select](http://www.php.net/manual/en/function.stream-select.php) и возможности асинхронности сводятся к минимуму, т.к. по сути всё будет выполняться по очереди без возможности на прерывания процесса. Конечно, можно это опустить, т.к. по сути асинхронность, это и есть череда задач в пределах одного процесса. Но если функция будет использовать не блокирующие вызовы, например к async-redis, то eventloop базирующийся на stream\_select будет вынужден ждать выполнения этой функции, т.к. нет возможности прервать php функцию на время выполнения не блокирующего вызова. Конечно это можно обойти разбиением функционала, но суть проблемы надеюсь понятна.
Я сторонник нативных решений, и инсталляция pecl расширений туда не очень входит. К тому же установка pecl потребуется на всём парке серверов да и на хостингах будут проблемы. А ведь у PHP есть возможность реализации корутин средствами PHP 5.5. Благодаря замечательной [статье от nikic](http://nikic.github.io/2012/12/22/Cooperative-multitasking-using-coroutines-in-PHP.html) ([перевод на хабре](http://habrahabr.ru/post/164173/)), я решил впилить свою реализацию eventloop на основе описанного nikic планировщика задач. Да звучит не просто, и с непривычки действительно требует основательного изменения представления построения приложений на PHP. Но на мой взгляд за такими решениями будущее PHP.
Кстати Symfony был выбран не случайно. Реализация стека обработки входящих запросов Symfony, нам позволяет с лёгкостью работать не убивая PHP после каждого запроса. А пока я допиливал этот пост, [предложения с подобной реализацией](https://github.com/symfony/symfony/issues/10810) уже поступают на канале Symfony. И сами разработчики не скрывают, что подобное решение у них теплится в умах с начала запуска 2 версии.
Но давайте перейдём от слов к делу. Для начала нам потребуется ваш любимый Linux дистрибутив с установленными и настроенными nginx, php-cli 5.5.x, composer и вашим приложением на Symfony. Если у вас нет под рукой Symfony приложения, то можно взять голую инсталляцию с Symfony сайта, на которой и будет приведён пример. Если вам и composer не знаком, то вкратце можно ознакомится в [моей статье к Satis](http://habrahabr.ru/post/197666/).
Создаём новую папку, если проект уже есть то заходим в него:
```
mkdir fastapp && cd fastapp
```
Устанавливаем composer:
```
curl -sS https://getcomposer.org/installer | php
```
Ставим Symfony2.4.4:
```
php composer.phar create-project symfony/framework-standard-edition symfdir/ 2.4.4 && mv symfdir/* ./ && rm -fr symfdir
```
**Получаем**
```
ls -l
drwxrwxr-x 6 user user 4.0K Apr 30 11:25 app/
drwxrwxr-x 2 user user 4.0K Apr 30 11:25 bin/
drwxrwxr-x 3 user user 4.0K Mar 14 09:37 src/
drwxrwxr-x 13 user user 4.0K Apr 30 11:25 vendor/
drwxrwxr-x 3 user user 4.0K Apr 30 11:25 web/
-rw-rw-r-- 1 user user 2.0K Mar 14 09:37 composer.json
-rw-rw-r-- 1 user user 56K Apr 30 11:25 composer.lock
-rwxr-xr-x 1 user user 990K Apr 30 11:23 composer.phar*
-rw-rw-r-- 1 user user 1.1K Mar 14 09:37 LICENSE
-rw-rw-r-- 1 user user 5.7K Mar 14 09:37 README.md
-rw-rw-r-- 1 user user 1.3K Mar 14 09:37 UPGRADE-2.2.md
-rw-rw-r-- 1 user user 2.0K Mar 14 09:37 UPGRADE-2.3.md
-rw-rw-r-- 1 user user 356 Mar 14 09:37 UPGRADE-2.4.md
-rw-rw-r-- 1 user user 8.3K Mar 14 09:37 UPGRADE.md
```
Добавляем такие строчки в ваш composer.json:
```
{
"repositories": [
{ "type": "vcs", "url": "http://github.com/Imunhatep/rephp" },
{ "type": "vcs", "url": "http://github.com/Imunhatep/php-pm" }
],
"minimum-stability": "dev",
"prefer-stable": true,
"require": {
"imunhatep/php-pm": "@dev"
}
}
```
**Чтоб выглядело примерно так**
```
{
"name": "symfony/framework-standard-edition",
"license": "MIT",
"type": "project",
"description": "The \"Symfony Standard Edition\" distribution",
"autoload": {
"psr-0": { "": "src/" }
},
"repositories": [
{ "type": "vcs", "url": "http://github.com/Imunhatep/rephp" },
{ "type": "vcs", "url": "http://github.com/Imunhatep/php-pm" }
],
"minimum-stability": "dev",
"prefer-stable": true,
"require": {
"php": ">=5.5.3",
"symfony/symfony": "~2.4",
"doctrine/orm": "~2.2,>=2.2.3",
"doctrine/doctrine-bundle": "~1.2",
"twig/extensions": "~1.0",
"symfony/assetic-bundle": "~2.3",
"symfony/swiftmailer-bundle": "~2.3",
"symfony/monolog-bundle": "~2.4",
"sensio/distribution-bundle": "~2.3",
"sensio/framework-extra-bundle": "~3.0",
"sensio/generator-bundle": "~2.3",
"incenteev/composer-parameter-handler": "~2.0",
"imunhatep/php-pm": "@dev"
},
"scripts": {
"post-install-cmd": [
"Incenteev\\ParameterHandler\\ScriptHandler::buildParameters",
"Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::buildBootstrap",
"Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::clearCache",
"Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::installAssets",
"Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::installRequirementsFile"
],
"post-update-cmd": [
"Incenteev\\ParameterHandler\\ScriptHandler::buildParameters",
"Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::buildBootstrap",
"Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::clearCache",
"Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::installAssets",
"Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::installRequirementsFile"
]
},
"config": {
"bin-dir": "bin"
},
"extra": {
"symfony-app-dir": "app",
"symfony-web-dir": "web",
"incenteev-parameters": {
"file": "app/config/parameters.yml"
},
"branch-alias": {
"dev-master": "2.4-dev"
}
}
}
```
Запускаем обновление пакетов:
```
php composer.phar update
```
**Получаем**
```
Loading composer repositories with package information
Updating dependencies (including require-dev)
- Installing stack/builder (v1.0.1)
Loading from cache
- Installing react/promise (v2.0.0)
Loading from cache
- Installing guzzle/parser (v3.9.0)
Loading from cache
- Installing evenement/evenement (v2.0.0)
Loading from cache
- Installing react/react (v0.4.1)
Loading from cache
- Installing imunhatep/rephp (dev-master 13adf26)
Cloning 13adf2697681a5954978ac56fe2c8fdf6a21dc4a
- Installing imunhatep/php-pm (dev-master 02f44ec)
Cloning 02f44ecb41ca5b4c81d4bb6087da7a0ed4964656
react/react suggests installing ext-libevent (Allows for use of a more performant event-loop implementation.)
react/react suggests installing ext-libev (Allows for use of a more performant event-loop implementation.)
react/react suggests installing ext-event (Allows for use of a more performant event-loop implementation.)
Writing lock file
Generating autoload files
Updating the "app/config/parameters.yml" file
Clearing the cache for the dev environment with debug true
Installing assets using the hard copy option
Installing assets for Symfony\Bundle\FrameworkBundle into web/bundles/framework
Installing assets for Acme\DemoBundle into web/bundles/acmedemo
Installing assets for Sensio\Bundle\DistributionBundle into web/bundles/sensiodistribution
```
Подготавливаем Symfony cache:
```
php app/console cache:warmup --env=dev
```
И запускаем веб сервер, пока средствами только PHP и в одном экземпляре, тестовый так сказать. Порт можно подобрать по вкусу:
```
php bin/ppm start --workers 1 --port 8080
```
Проверяем, что всё работает открыв в любимом браузере localhost:8080. Должна открыться страничка приветствия от Symfony, правда картинки не покажутся и css не подгрузится. Таким образом мы получили PHP веб сервер, обрабатывающий и входящие HTTP запросы и не умирающий. Но у нас только 1 процесс, нет обработки статики и нет балансера. Как многие догадались, для этого нам и понадобится nginx.
Настраиваем nginx для проксирования динамических запросов на наш PHP сервер, попутно выполняя роль балансера, а статику отдавать без участия PHP:
```
upstream backend {
server 127.0.0.1:5501;
server 127.0.0.1:5502;
server 127.0.0.1:5503;
server 127.0.0.1:5504;
server 127.0.0.1:5505;
server 127.0.0.1:5506;
server 127.0.0.1:5507;
server 127.0.0.1:5508;
}
server {
root /path/to/symfony/web/;
server_name fastapp.com;
location / {
# try to serve file directly, fallback to rewrite
try_files $uri @rewriteapp;
}
location @rewriteapp {
if (!-f $request_filename) {
proxy_pass http://backend;
break;
}
}
}
```
При этом server\_name (fastapp.com) нужно прописать в /etc/hosts:
```
127.0.0.1 fastapp.com
```
Теперь чтоб нам не мучиться с ручным запуском n-количества процессов нашего PHP приложения (представленная nginx конф. настроена на n=8), заходим в папку нашего проекта и выполняем:
```
cp vendor/imunhatep/rephp/ppm.json ./
```
Подправляем ./ppm.json файлик:
```
{
"bootstrap": "\\PHPPM\\Bootstraps\\Symfony",
"bridge": "HttpKernel",
"appenv": "dev",
"workers": 8,
"port": 5501
}
```
Иногда после изменений требуется обновить кэш, возможно это только в моём случае, т.к. при написании статьи производил изменения в коде:
```
app/console cache:warmup --env=dev
```
Заново запускаем наш PHP Process Manager:
```
php bin/ppm start
```
Получаем в ответ:
```
8 slaves (5501, 5502, 5503, 5504, 5505, 5506, 5507, 5508) up and ready.
```
Сначала проверяем в браузере линк localhost:5501, если всё открылось то пробуем открыть fastapp.com. Должно всё открываться, с картинками и css.
Теперь можно жечь при помощи тулзы siege или ab, на выбор:
```
siege -qb -t 30S -c 128 http://fastapp.com/
```
Приведу несколько результатов тестирования своего (не helloworld) Symfony приложения, на девелоперской машине с AMD 8core, 8RAM и Fedora20.
##### Php 5.5.10, через nginx + php-fpm:
```
siege -qb -t 30S -c 128 http://login.dev/signup
Lifting the server siege... done.
Transactions: 983 hits
Availability: 100.00 %
Elapsed time: 29.03 secs
Data transferred: 4.57 MB
Response time: 0.91 secs
Transaction rate: 34.26 trans/sec
Throughput: 0.16 MB/sec
Concurrency: 124.23
Successful transactions: 983
Failed transactions: 0
Longest transaction: 1.81
Shortest transaction: 0.42
```
##### Php 5.5.10 с включенным OPcache, через nginx + php-fpm:
```
siege -qb -t 30S -c 128 http://login.dev/signup
Lifting the server siege... done.
Transactions: 5298 hits
Availability: 100.00 %
Elapsed time: 29.54 secs
Data transferred: 24.15 MB
Response time: 0.70 secs
Transaction rate: 179.35 trans/sec
Throughput: 0.82 MB/sec
Concurrency: 126.43
Successful transactions: 5298
Failed transactions: 0
Longest transaction: 1.68
Shortest transaction: 0.07
```
##### Php 5.5.10 с включенным OPcache, через nginx + ReactPHP + Coroutine eventloop:
```
siege -qb -t 30S -c 128 http://fastlogin.dev/signup
Lifting the server siege... done.
Transactions: 30553 hits
Availability: 100.00 %
Elapsed time: 29.85 secs
Data transferred: 157.63 MB
Response time: 0.12 secs
Transaction rate: 1023.55 trans/sec
Throughput: 5.28 MB/sec
Concurrency: 127.43
Successful transactions: 30553
Failed transactions: 0
Longest transaction: 0.76
Shortest transaction: 0.00
```
Увеличиваем количество параллельных запросов до 256.
##### Php 5.5.10 с включенным OPcache, через nginx + php-fpm
```
siege -qb -t 30S -c 256 http://login.dev/signup
siege aborted due to excessive socket failure;
Transactions: 134 hits
Availability: 10.48 %
Elapsed time: 1.58 secs
Data transferred: 0.78 MB
Response time: 1.21 secs
Transaction rate: 84.81 trans/sec
Throughput: 0.49 MB/sec
Concurrency: 102.93
Successful transactions: 134
Failed transactions: 1145
Longest transaction: 1.56
Shortest transaction: 0.00
```
К сожалению php-fpm свалился и отказался работать с лимитом в 32 процесса против 256 параллельных запросов.
##### Пробуем Php5.5.10 + ReactPHP + Coroutine eventloop
```
siege -qb -t 30S -c 256 http://fastlogin.dev/signup
Lifting the server siege... done.
Transactions: 29154 hits
Availability: 100.00 %
Elapsed time: 29.16 secs
Data transferred: 150.40 MB
Response time: 0.25 secs
Transaction rate: 999.79 trans/sec
Throughput: 5.16 MB/sec
Concurrency: 252.70
Successful transactions: 29154
Failed transactions: 0
Longest transaction: 3.66
Shortest transaction: 0.00
```
#### Заключение.
Идея запускать Symfony приложения через ReactPHP не моя, позаимствовал у [Marc из его статьи](http://marcjschmidt.de/blog/2014/02/08/php-high-performance.html), за что ему большое спасибо. Кстати он делал свои замеры и даже сравнивал с HHVM. Ниже приведён график из его статьи:
Мой вклад заключается в создании eventloop на основе работы nikic и допиливании менеджера процессов до, в целом, работоспособности, а также нюансов запуска ReactPHP с новым eventloop. Возможно с pecl event lib, будет это всё работать быстрее, не проверял. К сожалению мои текущие проекты не соответствуют требуемому качеству кода, вот наработка и пылится на полках «лаборатории», т.к. такой подход требует кода без ошибок. То есть PHP, по сути, не имеет права падать, а всеядность и динамика PHP ни как этому не способствует. Это можно исправить, дописав PHP PM, чтоб перезапускал упавшие процессы, а так же можно дописать отслеживание изменений в коде и также перезапускать процессы. Но пока не востребовано. Так же на этой базе можно запускать и websocket сервер. Что было в планах, но так там и осталось.
Оставлял такой сервер на все выходные под нагрузкой, утечек памяти не было. Есть одна проблема которую пока нет ни времени ни необходимости искать: по каким то причинам, после нагрузки, остаются не закрытыми 1-2 соединения. На малых нагрузках выявить причину не удаётся, а для больших нужно потратить время чтоб придумать как выявить причину. Пока что, добавил таймер, которые каждые 10 секунд проверяет текущие соединения на валидность (ресурс, не ресурс) и убивает мёртвые.
Еще стоит отметить, что приложение, в идеале, должно учитывать новые возможности асинхронности и прерывания (yield), а не выполнятся монолитно. Так же хорошо бы использовать не блокирующий функционал. | https://habr.com/ru/post/220393/ | null | ru | null |
# Разрабатываем игру на SVG + React. Часть 1
**TL;DR:** в этих сериях вы узнаете, как заставить React и Redux управлять SVG элементами для создания игры. Полученные в этой серии знания позволят вам создавать анимацию не только для игр. Вы можете найти окончательный вариант исходного кода, разработанного в этой части, на [GitHub](https://github.com/auth0-blog/aliens-go-home-part-1).
Название игры: "Пришельцы, проваливайте домой!"
Игра, разработкой которой вы займетесь в этой серии, называется "Пришельцы, проваливайте домой!". Идея игры проста: у вас будет пушка, с помощью которой вы будете сбивать "летающие диски", которые пытаются вторгнуться на Землю. Для уничтожения этих НЛО вам нужно произвести выстрел из пушки, наведя курсор и кликнув мышью.
Если вам интересно, можете найти и запустить итоговую версию игры [здесь](http://bang-bang.digituz.com.br/) (*ссылка умерла — прим.переводчика*). Но не увлекайтесь игрой, у вас есть работа!
Предварительные условия
-----------------------
Для успешного ознакомления со статьей вам необходимо иметь определенный уровень знаний о вэб-разработке (главным образом о JavaScript) и компьютер с предустановленными [Node.js и NPM](https://nodejs.org/en/download/). Вам не пригодятся глубокие знания JavaScript, React, Redux и SVG для успешного прохождения этой серии туториалов. Впрочем, если вы в теме, вам будет проще понять некоторые части и их соответствие друг другу.
Тем не менее, в серии содержатся ссылки на соответствующие статьи, посты и документы, которые помогут лучше объяснить темы, заслуживающие повышенного внимания.
Прежде чем начать
-----------------
Хотя в предыдущем разделе не было упоминаний о [Git](https://git-scm.com/), стоит отметить, что это хороший инструмент для решения некоторых проблем. Все профессиональные разработчики используют Git (либо иную систему управления версиями, например, Mercurial или SVN) в процессе своей деятельности, даже в ходе "домашних" проектов.
Зачем создавать проект без резервного копирования? Вам даже не нужно за это платить. Вы можете воспользоваться такими сервисами, как [GitHub](https://github.com/) (лучший!) или [BitBucket](https://bitbucket.org/) (неплох, если быть честным) и сохранить ваш код в надежных облачных инфраструктурах.
Использование подобных инструментов даст вам уверенность в сохранности вашего кода и облегчит непосредственно процесс разработки. Например, когда вы создадите новую версию приложения с "багами", вы легко сможете вернуться к предыдущей версии кода, совершив всего несколько простых действий используя Git.
Другим значительным преимуществом является возможность следить за каждым разделом в этой серии и коммитить код, разработанный поэтапно. Это легко позволит вам [видеть изменения в коде после выполнения каждой секции](https://git-scm.com/docs/git-diff). Сделайте вашу жизнь легче уже сейчас, пока вы проходите этот туториал.
В общем, сделайте себе одолжение и установите Git. Также создайте учетную запись на [GitHub](https://github.com/) (если у вас ее еще нет) и репозиторий для сохранения вашего проекта. Затем, после завершения каждой секции, коммитьте изменения в репозиторий. Ох, и не забывайте [пушить ваши изменения](https://help.github.com/articles/pushing-to-a-remote/).
Быстрый старт проекта с помощью Create-React-App
------------------------------------------------
Самый первый ваш шаг для создания игры с React, Redux и SVG — использование `create-react-app` для быстрого старта вашего проекта. Как вы, вероятно, уже знаете (ничего страшного, если это не так), [create-react-app](https://github.com/facebookincubator/create-react-app) — это инструмент с открытым исходным кодом, поддерживаемый Facebook, который помогает разработчикам мгновенно начать работу с React. Имея установленные Node.js and NPM (версия последнего должна быть 5.2 и выше), вы можете использовать create-react-app, даже не устанавливая его:
```
# npx скачает (если нужно)
# create-react-app и запустит
npx create-react-app aliens-go-home
# перейдите в директорию с проектом
cd aliens-go-home
```
Эта "тулза" создаст стуктуру, похожую на ту, что приведена ниже:
```
|- node_modules
|- public
|- favicon.ico
|- index.html
|- manifest.json
|- src
|- App.css
|- App.js
|- App.test.js
|- index.css
|- index.js
|- logo.svg
|- registerServiceWorker.js
|- .gitignore
|- package.json
|- package-lock.json
|- README.md
```
Инструмент create-react-app популярен, хорошо описан в документации и имеет хорошую поддержку в коммьюнити. Если вам интересно углубиться в детали, вы можете [проверить репозиторий create-react-app на гитхабе](https://github.com/facebook/create-react-app) и ознакомиться с [руководствами пользователя](https://github.com/facebook/create-react-app#user-guide).
Прямо сейчас можно избавиться от перечисленных ниже файлов, потому что в дальнейшем они нам не пригодятся:
* `App.css`: хотя компонент `App` важен, стили будут определены в других компонентах;
* `App.test.js`: тесты могут быть темой для другой статьи. Сейчас вам не придется их использовать.
* `logo.svg`: в этой игре логотип React'a не используется.
Удаление этих файлов может привести к ошибке в случае, если вы попытаетесь запустить проект. Это легко исправить, удалив два "импорта" из файла `./src/App.js`:
```
// удалите обе линии из ./src/App.js
import logo from './logo.svg';
import './App.css';
```
А также путем рефакторинга метода `render()`:
```
// ... описание импортов и создание компонента через класс (опущено в коде)
render() {
return (
We will create an awesome game with React, Redux, and SVG!
==========================================================
);
}
// ... (закрывающая скобка и экспорт - аналогично, опущено)
```
> Не забудьте сделать коммит!
Установка Redux и PropTypes
---------------------------
После разворачивания проекта и удаления из него ненужных файлов следует настроить [Redux](https://redux.js.org/) [как единственный верный источник данных в вашем приложении](https://redux.js.org/docs/introduction/ThreePrinciples.html#single-source-of-truth). Также следует установить [PropTypes](https://github.com/facebook/prop-types), [это поможет избежать некоторых распространенных ошибок](https://reactjs.org/docs/typechecking-with-proptypes.html). Оба инструмента могут быть установлены с помощью одной команды:
```
npm i redux react-redux prop-types
```
Как видите, вышеописанная команда включает третий NPM пакет: `react-redux`. Не рекомендуется использовать Redux напрямую с React. [Пакет react-redux выполняет некоторые громоздкие](https://redux.js.org/docs/basics/UsageWithReact.html) для ручной обработки оптимизации производительности.
Настройка Redux и использование PropTypes
-----------------------------------------
С помощью описанных пакетов вы можете настроить ваше приложение для использования Redux. Это несложно, вам лишь нужно создать *контейнер* (умный компонент), *презентационный* компонент (глупый компонент) и редьюсер. Разница между умным и глупым компонентами в том, что первый просто соединяет (`connect`) глупые компоненты с Redux. Третий создаваемый вами элемент, редьюсер, является основным компонентом в Redux store. Этот компонент отвечает за выполнение "экшенов" (действий), вызываемых различными событиями в вашем приложении, и за применение функций для изменения "стора" (источника данных) на основе этих действий.
> Если вы не имеете представления обо всем этом, можете прочитать [данную статью](https://medium.com/@dan_abramov/smart-and-dumb-components-7ca2f9a7c7d0), где более подробно описаны компоненты (тупые) и контейнеры (умные) компоненты, а также открыть [практическое руководство Redux для ознакомления с *экшенами*, *редьюсером* и *стором*](https://auth0.com/blog/redux-practical-tutorial/). Несмотря на то, что изучение этих понятий настоятельно рекомендуется, вы можете продолжить изучение, не утруждая себя дополнительным чтением.
Удобнее начинать процесс с создания редьюсера, так как этот элемент не зависит от других (на самом деле, все наоборот). Для сохранения структурированности можно создать новый каталог под названием `reducers`, внутри него разместить `src` и добавить туда файл с именем `index.js`. Этот файл может содержать следующий исходный код:
```
const initialState = {
message: `React и Redux легко интегрируются, не так ли?`,
};
function reducer(state = initialState) {
return state;
}
export default reducer;
```
Таким образом ваш редьюсер просто инициализирует состояние приложения `сообщением` (*message*), что React и Redux легко интегрируются. Вскоре в этом файле вы начнете определять действия и обрабатывать их.
Затем вы можете провести рефакторинг компонента `App` чтобы вывести это сообщение пользователям. Самое время воспользоваться `PropTypes`. Для этого нужно открыть файл `./src/App.js` и заменить его содержимое следующим текстом:
```
import React, {Component} from 'react';
import PropTypes from 'prop-types';
class App extends Component {
render() {
return (
{this.props.message}
====================
);
}
}
App.propTypes = {
message: PropTypes.string.isRequired,
};
export default App;
```
Как видите, с использованием `PropTypes` очень просто определить типы, которые ожидает ваш компонент. Вам нужно лишь установить `PropTypes` свойства компонента `App` с необходимыми параметрами. В сети есть шпаргалки (например, [вот эта](https://lzone.de/cheat-sheet/React%20PropTypes), [эта](https://reactcheatsheet.com/) и [эта](https://devhints.io/react)), в которых описаны способы создания базовых и расширенных `PropTypes` определений. Ознакомьтесь с ними, если нужно.
После определения исходного состояния вашего `store` (*стора*) и того, что ваш компонент `App` должен отображать, вам необходимо связать эти элементы вместе. Именно для этого необходимы *контейнеры*. Для создания *контейнера* в нашей структуре вам нужно создать каталог с именем `сontainers` внутри каталога `src`. После этого в новом каталоге создайте компонент с названием `Game` внутри файла `Game.js`. Этот контейнер будет использовать функцию `connect` из `react-redux` для передачи `state.message` к параметрам сообщения компонента `App`:
```
import { connect } from 'react-redux';
import App from '../App';
const mapStateToProps = state => ({
message: state.message,
});
const Game = connect(
mapStateToProps,
)(App);
export default Game;
```
Переходим к финальной стадии. Последним шагом к тому, чтобы связать все вместе будет рефакторинг файла `./src/index.js` для инициализации Redux хранилища (*store*) и передачи его в контейнер `Game` (который затем получит сообщение и пошлет (*прокинет*) их в `App`). Следующий код показывает, как будет выглядеть файл `./src/index.js` после рефакторинга:
```
import React from 'react';
import ReactDOM from 'react-dom';
import { Provider } from 'react-redux';
import { createStore } from 'redux';
import './index.css';
import Game from './containers/Game';
import reducer from './reducers';
import registerServiceWorker from './registerServiceWorker';
/* eslint-disable no-underscore-dangle */
const store = createStore(
reducer, /* preloadedState, */
window.__REDUX_DEVTOOLS_EXTENSION__ && window.__REDUX_DEVTOOLS_EXTENSION__(),
);
/* eslint-enable */
ReactDOM.render(
,
document.getElementById('root'),
);
registerServiceWorker();
```
Вы это сделали! Чтобы оценить, как все работает, в терминале перейдите в корень проекта и выполните `npm start`. Таким образом вы запустите приложение в режиме разработки (*в dev-режиме*), и оно откроется в установленном по умолчанию браузере.
Создание компонентов SVG с React
--------------------------------
В этой серии вы оцените простоту создания SVG компонентов с использованием React. На самом деле практически нет разницы между созданием компонентов React с HTML или с SVG. Основным отличием является то, что в SVG вводятся новые элементы и эти элементы рисуются на холсте SVG.
Прежде чем приступить к созданию собственных компонентов с SVG и React, будет полезно вкратце ознакомиться с SVG.
Краткий обзор SVG
-----------------
SVG — один из самых крутых и гибких веб-стандартов. SVG, что расшифровывается как Scalable Vector Graphics (масштабируемая векторная графика), представляет собой язык разметки, позволяющий разработчикам описывать двухмерную векторную графику. Язык SVG довольно похож на HTML. И тот, и другой являются языками разметки на основе XML и отлично работают совместно с другими вэб-стандартами, такими как CSS и DOM. Из этого следует, что правила CSS одинаково применимы как к SVG, так и к HTML, включая анимацию.
На протяжении этой серии с помощью React вами будут созданы более десятка компонентов SVG. Придется даже составлять (группировать) SVG элементы для формирования игровых объектов (пушка, стреляющая пушечными ядрами).
Более подробное изучение SVG невозможно в рамках нашей статьи, оно сделает ее слишком длинной. Если у вас есть желание лучше изучить язык разметки SVG, вы можете [ознакомиться с учебником, представленным Mozilla](https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial), а также с изложенным [в этой статье](https://www.sarasoueidan.com/blog/svg-coordinate-systems/) материалом о системе координат SVG.
Однако, прежде чем приступить к созданию собственных компонентов, важно усвоить несколько характеристик SVG. Во-первых, использование SVG в сочетании с DOM позволяет разработчикам "делать вещи". Использовать SVG с React очень просто.
Во-вторых, система координат SVG похожа на декартову плоскость, перевернутую вверх ногами. Соответственно, по умолчанию отрицательные значения по вертикали будут отображены выше оси Х. При этом горизонтальные значения расположены так же, как и в декартовой плоскости, то есть отрицательные значения находятся слева от оси Y. Такое поведение можно легко изменить, [применив преобразование к холсту SVG](https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/transform). Однако будет лучше придерживаться параметров по умолчанию, дабы избежать путаницы среди разработчиков. Вы быстро привыкнете.
И наконец, следует помнить, что в SVG представлено множество новых элементов (таких, как `circle`, `rect` и `path`). Для использования этих элементов недостаточно просто определить их внутри HTML элемента. Сперва вам нужно определить `svg` элемент (ваш холст), где вы нарисуете все ваши SVG компоненты.
SVG, path элементы и кубические кривые Безье
--------------------------------------------
Рисование элементов SVG может быть выполнено тремя способами. Во-первых, можно использовать базовые элементы, такие как `rect`, `circle` и `line`. Однако эти элементы не обладают особой гибкостью. Они позволяют вам рисовать простые фигуры в соответствии с их названием (прямоугольник, круг и линию).
Второй способ заключается в комбинировании базовых элементов для получения более сложных форм. Например, можно использовать прямоугольник (`rect`) с одинаковыми сторонами (получится квадрат) и две линии для того, чтобы нарисовать дом. Впрочем, такой подход все равно довольно сильно ограничивает.
Третий и наиболее гибкий способ — применять [path элементы](https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths). Такой вариант позволяет разработчикам создавать довольно сложные формы. Рисование фигуры происходит посредством указания определенных команд браузеру. Например, чтобы нарисовать "L", вы можете создать `path` элемент, который содержит три команды:
* `M 20 20`: команда браузеру переместить его "перо" в координаты X и Y, определенные после `M` (т. е. `20, 20`);
* `V 80`: команда браузеру нарисовать линию от предыдущей точки до позиции `80` по оси Y;
* `H 50`: команда браузеру нарисовать линию от предыдущей точки до позиции `50` по оси X;
```
```
`Path` элементы принимают множество других команд. Одна из важнейших — команда кубических кривых Безье. Она позволяет вам добавить любые "сглаженные" кривые с применением двух опорных точек и двух контрольных точек.
> "Кубическая кривая Безье для каждой точки принимает две контрольные точки. Таким образом, для создания кубической кривой Безье требуется указать три набора координат. Последний набор координат описывает точку, в которой заканчивается кривая. Два остальных набора — контрольные точки. [...]. По существу, контрольные точки описывают наклон вашей линии в данной точке. Функция Безье создает плавную кривую, направленную от наклона, установленного вами в начале линии к наклону, установленному в конце." — [Mozilla Developer Network](https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths#Bezier_Curves)
Например, чтобы нарисовать "U", выполните следующее:
```
```
В таком случае команды, переданные `path` элементу, указывают браузеру:
1. Начать чертеж с точки `20,20`;
2. Координаты первой контрольной точки: `20, 110`;
3. Координаты второй контрольной точки: `110, 110`;
4. Координаты конечной точки кривой: `110 20`;
Не отчаивайтесь, если вы до сих пор не поняли принцип работы кубических кривых Безье. У вас будет возможность попрактиковаться в этой серии. Кроме того, вы можете найти множество руководств об этой функции в Интернете, где всегда можно практиковаться в таких инструментах, как [JSFiddle](https://jsfiddle.net/) и [Codepen](https://codepen.io/).
Создание компонента Canvas
--------------------------
*(речь идет не о тэге , а о react-компоненте Canvas (по-русски Холст) — прим.переводчика)*
После того как вы создали структуру своего проекта и узнали основы SVG, можно приступать к созданию игры. Первый элемент, который необходимо создать — это холст SVG, который используется для рисования элементов игры.
Этот компонент характеризуется как презентационный (глупый). Таким образом, вы можете создать каталог `components`, внутри каталога `./src` для хранения нового компонента и его "братьев и сестер" (*соседних/дочерних элементов — прим.переводчика*). Поскольку это будет ваш холст, сложно придумать для него более естественного названия, чем `Canvas`. Создайте новый файл с именем `Canvas.jsx` внутри каталога `./src/components/` и добавьте следующий код:
```
import React from 'react';
const Canvas = () => {
const style = {
border: '1px solid black',
};
return (
);
};
export default Canvas;
```
Перепишите компонент `App`, так чтобы он использовал компонент `Canvas`:
```
import React, {Component} from 'react';
import Canvas from './components/Canvas';
class App extends Component {
render() {
return (
);
}
}
export default App;
```
Если вы запустите проект (`npm start`) и проверите ваше приложение, вы увидите, что браузер рисует только четверть этого круга. Это происходит из-за того, что по умолчанию точка начала координат расположена в левом верхнем углу экрана. Кроме того, вы увидите, что `svg` элемент не занимает весь экран.
Для более интересного и удобного управления сделайте свой холст () пригодным для рисования на весь экран. Можете переместить его начало в центр оси Х и сделать ближе к низу (позже вы добавите к оригиналу свою пушку). Для выполнения обоих условий вам нужно изменить два файла: `./src/components/Canvas.jsx` и `./src/index.css`.
Можете начать с замены содержимого `Canvas`, применим следующий код:
```
import React from 'react';
const Canvas = () => {
const viewBox = [window.innerWidth / -2, 100 - window.innerHeight, window.innerWidth, window.innerHeight];
return (
);
};
export default Canvas;
```
В этой версии компонента вами был задан [атрибут viewBox](https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/viewBox) для тэга `svg`. Этот атрибут позволяет определить, что ваш холст и его содержимое должны соответствовать определенному контейнеру (в данном случае — внутренней области окна/браузера). Как вы видите, атрибут viewBox состоит из четырех чисел:
* `min-x`: это значение определяет самую левую точку, которую могут видеть пользователи. Таким образом, чтобы получить отображение оси (и круга) в центре экрана, ширина экрана делится на 2 со знаком "-" (`window.innerWidth / -2`) для получения значения атрибута (`min-x`). Обратите внимание, что необходимо делить именно на (`-2`), чтобы ваш холст показывал одинаковое количество точек в обе стороны от начала координат.
* `min-y`: определяется самая верхняя точка холста. Здесь нужно вычесть значение `window.innerHeight` из `100`, чтобы задать определенную область (`100` точек) от начала Y.
* `width` и `height`: определяют количество точек по осям X и Y, которое пользователь будет видеть на своем экране.
Помимо определения атрибута `viewBox` в новой версии также задается атрибут под названием [preserveAspectRatio](https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/preserveAspectRatio). Вы использовали `xMaxYMax none` на нем для принудительного равномерного масштабирования вашего холста и его элементов.
(*у меня установка `preserveAspectRatio` вызывала предупреждение от react — прим.переводчика*)
После рефакторинга вашего холста вам необходимо добавить следующее правило в файл `./src/index.css`:
```
/* ... body definition ... */
html, body {
overflow: hidden;
height: 100%;
}
```
Это делается для того, чтобы элементы (тэги) `html` и `body` скрыли (и отключили) прокрутку. Кроме того, элементы будут отображены на весь экран.
Если вы проверите приложение прямо сейчас, обнаружите, что круг расположен внизу экрана в центре по горизонтали.
Создание компонента Sky (Небо)
------------------------------
После того, как на вашем холсте будет установлено разрешение на весь экран и начало координат будет размещено в его центре, можно приступить к созданию реальных игровых элементов. Начать можно с оформления фонового элемента для вашей игры — неба. Для этого создайте новый файл под названием `Sky.jsx` в каталоге `./src/components/` применив следующий код:
```
import React from 'react';
const Sky = () => {
const skyStyle = {
fill: '#30abef',
};
const skyWidth = 5000;
const gameHeight = 1200;
return (
);
};
export default Sky;
```
Вам может быть интересно, почему для игры задается настолько большая площадь (ширина `5000` и высота `1200`). В действительности, ширина в этой игре не имеет значения. Вам лишь нужно задать ее числом, достаточным для того, чтобы покрыть любой размер экрана.
В свою очередь, важна высота. Поскольку вы установили 1200 точек на холсте независимо от разрешения и ориентации экрана пользователя, это даст вашей игре согласованность и все пользователи будут видеть одинаковую область. Таким образом, вы сможете определить, где появятся летающие диски и как долго они будут проходить через заданные точки.
Чтобы на холсте отображалось небо (компонент `Sky`), откройте файл `Canvas.jsx` в своем редакторе и исправьте его так:
```
import React from 'react';
import Sky from './Sky';
const Canvas = () => {
const viewBox = [window.innerWidth / -2, 100 - window.innerHeight, window.innerWidth, window.innerHeight];
return (
);
};
export default Canvas;
```
Если сейчас вы проверите приложение (`npm start`), то вы увидите, что круг по-прежнему находится по центру внизу, а ваш фон стал синим.
**Примечание**: если вы добавите элемент `Sky` после элемента `circle`, вы больше не увидите ваш круг. Это объясняется тем, что SVG **не** поддерживает `z-index`. SVG определяет, который из элементов находится "выше", в соответствии с порядком их перечисления. То есть вам необходимо описать элемент `circle` после `Sky`, чтобы веб-браузеры отображали его поверх синего фона.
Создание компонента Ground (Земля)
----------------------------------
После создания компонента `Sky` следует перейти к созданию компонента `Ground`. Для этого создайте новый файл `Ground.jsx` в каталоге `./src/components/` и добавьте следующий код:
```
import React from 'react';
const Ground = () => {
const groundStyle = {
fill: '#59a941',
};
const division = {
stroke: '#458232',
strokeWidth: '3px',
};
const groundWidth = 5000;
return (
);
};
export default Ground;
```
В этом элементе нет ничего фантастического. Это всего лишь композиция элемента `rect` (прямоугольник) и `line` (линии). Однако, как вы заметили, этот элемент также содержит константу со значением `5000`, определяющую его ширину. Поэтому было бы неплохо создать файл для сохранения глобальных констант, подобных этой.
Раз уж мы пришли к такому выводу, создайте новый каталог с именем `utils` внутри каталога `./src/` и внутри этого нового каталога создайте файл с именем `constants.js`. На данный момент у нас всего одна константа для хранения в этом файле:
```
// очень широко, чтобы наверняка занять весь экран
export const skyAndGroundWidth = 5000;
```
После этого вы можете отрефакторить оба компонента и `Sky` и `Ground`, чтобы в них использовалась эта константа.
Не забудьте добавить компонент `Ground` к вашему холсту (помните, что вам нужно разместить его между небом и элементом окружности (т.е. между `Sky` и `circle`)). Если у вас имеются какие-либо сомнения касательно последних шагов, пожалуйста, взгляните на этот [коммит](https://github.com/auth0-blog/aliens-go-home-part-1/commit/f453eb5147821f0289ecd81b8ae8deb0b7941f0e).
Создание компонента Cannon (Пушка)
----------------------------------
В вашей игре уже созданы элементы, которые определяют небо и землю. В качестве следующего шага хочется добавить нечто более интересное. Возможно, стоит добавить компоненты, которые нарисуют вам пушку. Эти элементы будут немного сложнее описанных ранее элементов. Они содержат намного больше строк исходного кода, но это обусловлено тем, что для их рисования необходимо использовать кубические кривые Безье.
Как вы помните, кубические кривые Безье определяются четырьмя точками: начальной, конечной и двумя контрольными. Эти точки, заданные в свойстве `d` элемента `path`, выглядят следующим образом: `M 20 20 C 20 110, 110 110, 110 20`.
Чтобы в ходе создания кривых в вашем коде не было повторения подобных шаблонов, рекомендуется создать новый файл с именем `formula.js` в каталоге `./src/utils/` и добавить функцию, которая будет возвращать эту строку на основе некоторых параметров:
```
export const pathFromBezierCurve = (cubicBezierCurve) => {
const {
initialAxis, initialControlPoint, endingControlPoint, endingAxis,
} = cubicBezierCurve;
return `
M${initialAxis.x} ${initialAxis.y}
c ${initialControlPoint.x} ${initialControlPoint.y}
${endingControlPoint.x} ${endingControlPoint.y}
${endingAxis.x} ${endingAxis.y}
`;
};
```
Это достаточно простой код, он просто извлекает (деструктурирует) четыре атрибута (`initialAxis`, `initialControlPoint`, `endControlPoint`, `endAxis`) из аргумента функции под названием `cubicBezierCurve` и передает их в шаблонный литерал, который построит необходимую кубическую кривую Безье.
Используя этот файл, вы можете начать создавать вашу пушку. Для поддержания структуры можно условно разделить пушку на две части: `CannonBase` (база) и `CannonPipe` (дуло).
Для описания `CannonBase` создайте новый файл `CannonBase.jsx` внутри `./src/components` и добавьте в него следующий код:
```
import React from 'react';
import { pathFromBezierCurve } from '../utils/formulas';
const CannonBase = (props) => {
const cannonBaseStyle = {
fill: '#a16012',
stroke: '#75450e',
strokeWidth: '2px',
};
const baseWith = 80;
const halfBase = 40;
const height = 60;
const negativeHeight = height * -1;
const cubicBezierCurve = {
initialAxis: {
x: -halfBase,
y: height,
},
initialControlPoint: {
x: 20,
y: negativeHeight,
},
endingControlPoint: {
x: 60,
y: negativeHeight,
},
endingAxis: {
x: baseWith,
y: 0,
},
};
return (
);
};
export default CannonBase;
```
За исключением кубической кривой Безье в этом элементе нет ничего нового. В итоге браузер отобразит этот элемент как кривую с темно-коричневой (`#75450e`) границей и "зальет" ее площадь светло-коричневым цветом (`#a16012`).
Код для создания `CannonPipe` будет похож на код `CannonBase`. Отличия заключаются в других цветах и в том, что он передает другие точки в формулу `pathFromBezierCurve`, чтобы нарисовать трубу. Кроме того, этот элемент использует атрибут `transform` для имитации вращения пушки.
Для создания этого элемента добавьте следующий код в новый файл `CannonPipe.jsx` внутри каталога `./src/components/`:
```
import React from 'react';
import PropTypes from 'prop-types';
import { pathFromBezierCurve } from '../utils/formulas';
const CannonPipe = (props) => {
const cannonPipeStyle = {
fill: '#999',
stroke: '#666',
strokeWidth: '2px',
};
const transform = `rotate(${props.rotation}, 0, 0)`;
const muzzleWidth = 40;
const halfMuzzle = 20;
const height = 100;
const yBasis = 70;
const cubicBezierCurve = {
initialAxis: {
x: -halfMuzzle,
y: -yBasis,
},
initialControlPoint: {
x: -40,
y: height * 1.7,
},
endingControlPoint: {
x: 80,
y: height * 1.7,
},
endingAxis: {
x: muzzleWidth,
y: 0,
},
};
return (
);
};
CannonPipe.propTypes = {
rotation: PropTypes.number.isRequired,
};
export default CannonPipe;
```
После этого сотрите элемент окружности с вашего холста и добавьте к нему `CannonBase` и `CannonPipe`. После рефакторинга холста вы получите следующий код:
```
import React from 'react';
import Sky from './Sky';
import Ground from './Ground';
import CannonBase from './CannonBase';
import CannonPipe from './CannonPipe';
const Canvas = () => {
const viewBox = [window.innerWidth / -2, 100 - window.innerHeight, window.innerWidth, window.innerHeight];
return (
);
};
export default Canvas;
```
Запуск и проверка приложения отобразит вам следующую векторную графику:
Обучаем пушку прицеливаться
---------------------------
Наш процесс набирает обороты! Вы уже создали фоновые элементы (`Sky` и `Ground`) и свою пушку (`CannonBase` + `CannonPipe`). На данном этапе проблема заключается в отсутствии анимации. Следовательно, чтобы сделать что-то интересное, можно сосредоточиться на создании прицела. Для этого вы можете добавить слушатель событий `onmousemove` к вашему холсту и настроить его обновление при каждом возникновении события, т.е. каждый раз, когда пользователь двигает мышью, однако это скажется на производительности вашей игры.
Во избежание этой ситуации, вы можете установить [интервал](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setInterval), по которому будете проверять последнюю позицию мыши для обновления угла наклона вашего элемента `CannonPipe`. В этом случае вы используете слушатель `onmousemove` с той лишь разницей, что эти события не будут вызывать частых ре-рендеров (перерисовок) всего холста. Будет обновляться только нужное свойство в вашей игре (угол наклона пушки), а заданный интервал будет использовать это свойство для запуска повторной обработки (путем обновления хранилища Redux).
В этом случае вам впервые потребуется использование Redux *action* (*экшн, действие*) для обновления состояния вашего приложения (а если быть точнее — угла наклона вашей пушки). Исходя из этого, вы создаете каталог с именем `Actions` внутри каталога `./src/`. В этом новом каталоге вам нужно будет создать файл под названием `index.js`, содержащий следующий код:
```
export const MOVE_OBJECTS = 'MOVE_OBJECTS';
export const moveObjects = mousePosition => ({
type: MOVE_OBJECTS,
mousePosition,
});
```
Примечание: назовите этот экшн *MOVE\_OBJECTS*, поскольку он будет использоваться не только для обновления пушки. В следующих частях этой серии говорится о применении этого экшна для анимации пушечных шаров и летающих объектов.
После определения этого *действия* необходимо поправить редъюсер (файл `index.js` внутри `./src/reducers/`):
```
import { MOVE_OBJECTS } from '../actions';
import moveObjects from './moveObjects';
const initialState = {
angle: 45,
};
function reducer(state = initialState, action) {
switch (action.type) {
case MOVE_OBJECTS:
return moveObjects(state, action);
default:
return state;
}
}
export default reducer;
```
В новой версии этого файла проверяется экшн, и, если он имеет тип `MOVE_OBJECTS`, вызывается функция `moveObjects`. Вам все же следует задать эту функцию, но обратите внимание, что данная версия также определяет начальное состояние (*initial state*) вашего приложения, содержащее свойство под названием `angle` со значением `45`. Именно под таким углом будет нацелена ваша пушка после запуска приложения.
Как вы уже заметили, функция `moveObjects` также является редъюсером. Для того, чтобы сохранить проект в должной мере поддерживаемым и структурированным, рекомендуется сохранить эту функцию в новом файле, поскольку в вашей игре будет присутствовать достаточное количество редъюсеров. Поэтому создайте файл `moveObjects.js` внутри `./src/reducers/` и добавьте к нему следующий код:
```
import { calculateAngle } from '../utils/formulas';
function moveObjects(state, action) {
if (!action.mousePosition) return state;
const { x, y } = action.mousePosition;
const angle = calculateAngle(0, 0, x, y);
return {
...state,
angle,
};
}
export default moveObjects;
```
Этот код достаточно прост, он лишь извлекает свойства `x` и `y` из `mousePosition` и передает их функции `calculateAngle` для получения нового угла наклона. Затем, наконец, он генерирует новое состояние (новый объект) с новым значением угла.
Вероятно, вы заметили, что не определили функцию `calculateAngle` в файле `formula.js`, верно? Изучение математического выражения для расчета угла наклона, основанного на двух точках, выходит за рамки данной серии, но если вам интересно, пройдите по ссылке на [StackExchange](https://math.stackexchange.com/questions/714378/find-the-angle-that-creating-with-y-axis-in-degrees), чтобы понять, как это происходит. Наконец, вам нужно добавить следующие функции в файл `formula.js` (`./src/utils/formulas`):
```
export const radiansToDegrees = radians => ((radians * 180) / Math.PI);
// https://math.stackexchange.com/questions/714378/find-the-angle-that-creating-with-y-axis-in-degrees
export const calculateAngle = (x1, y1, x2, y2) => {
if (x2 >= 0 && y2 >= 0) {
return 90;
} else if (x2 < 0 && y2 >= 0) {
return -90;
}
const dividend = x2 - x1;
const divisor = y2 - y1;
const quotient = dividend / divisor;
return radiansToDegrees(Math.atan(quotient)) * -1;
};
```
**Примечание**: функция `atan`, выполняемая объектом `Math`, возвращает результат в радианах. Вам нужно преобразовать это значение в градусы. Для этого и применяется функция `radiansToDegrees`.
После того, как были определены новый экшн и новый редъюсер, вам необходимо ими воспользоваться. Поскольку управление состоянием вашей игры основано на Redux, нужно сопоставить action (*экшн*) `moveObjects` с props (*свойствами*) вашего компонента `App`. Это осуществляется путем рефакторинга контейнера `Game`. Открывайте файл `Game.js` (`./src/containers`) и заменяйте его содержимое следующим:
```
import { connect } from 'react-redux';
import App from '../App';
import { moveObjects } from '../actions/index';
const mapStateToProps = state => ({
angle: state.angle,
});
const mapDispatchToProps = dispatch => ({
moveObjects: (mousePosition) => {
dispatch(moveObjects(mousePosition));
},
});
const Game = connect(
mapStateToProps,
mapDispatchToProps,
)(App);
export default Game;
```
С этим маппингом (`mapStateToProps` и `mapDispatchToProps`) вы можете использовать необходимые данные в компоненте `App` в качестве `props`. Вам нужно открыть файл `App.js` (расположенный по адресу `./src/`) и заменить его следующим:
```
import React, {Component} from 'react';
import PropTypes from 'prop-types';
import { getCanvasPosition } from './utils/formulas';
import Canvas from './components/Canvas';
class App extends Component {
componentDidMount() {
const self = this;
setInterval(() => {
self.props.moveObjects(self.canvasMousePosition);
}, 10);
}
trackMouse(event) {
this.canvasMousePosition = getCanvasPosition(event);
}
render() {
return (
(this.trackMouse(event))}
/>
);
}
}
App.propTypes = {
angle: PropTypes.number.isRequired,
moveObjects: PropTypes.func.isRequired,
};
export default App;
```
Обратите внимание, что новая версия значительно отличается. Ниже представлен обобщенный список изменений:
* `componentDidMount`: вы задали этот [метод жизненного цикла](https://reactjs.org/docs/react-component.html#componentdidmount) (*lifecycle method*) для запуска интервала (*setInterval*), который вызывает экшн `moveObjects`;
* `trackMouse`: задан для обновления свойства `canvasMousePosition` компонента `App`. Это свойство задействовано в экшне `moveObjects`. Заметьте, что это свойство не имеет отношения к позиции мыши над HTML-документом. Позиция мыши вычисляется [относительно холста](https://stackoverflow.com/questions/10298658/mouse-position-inside-autoscaled-svg). Так же была определена функция `canvasMousePosition`.
* `render`: необходим для передачи свойств угла (*angle*) и метода `trackMouse` к вашему компоненту `Canvas`. Этот компонент использует `angle` для обновления вращения вашей пушки и `trackMouse` для присоединения к элементу SVG в качестве слушателя событий.
* `App.propTypes`: теперь здесь определяются два свойства: `angle` и `moveObjects`. Первое задает угол наклона, под которым целится ваша пушка. Второe, moveObjects — это функция, которая обновляет положение пушки во время срабатывания интервала.
Обновите ваш `App` компонент и добавьте следующую функцию в файл `formula.js`:
```
export const getCanvasPosition = (event) => {
// mouse position on auto-scaling canvas
// https://stackoverflow.com/a/10298843/1232793
const svg = document.getElementById('aliens-go-home-canvas');
const point = svg.createSVGPoint();
point.x = event.clientX;
point.y = event.clientY;
const { x, y } = point.matrixTransform(svg.getScreenCTM().inverse());
return {x, y};
};
```
Если вам интересно, для чего это понадобилось, загляните на [StackOverflow](https://stackoverflow.com/a/10298843/1232793).
Чтобы завершить разработку прицела для пушки, вам необходимо обновить последнюю часть кода — `Canvas` компонент. Откройте файл `Canvas.jsx` (расположенный в `./src/components`) и замените его содержимое следующим:
```
import React from 'react';
import PropTypes from 'prop-types';
import Sky from './Sky';
import Ground from './Ground';
import CannonBase from './CannonBase';
import CannonPipe from './CannonPipe';
const Canvas = (props) => {
const viewBox = [window.innerWidth / -2, 100 - window.innerHeight, window.innerWidth, window.innerHeight];
return (
);
};
Canvas.propTypes = {
angle: PropTypes.number.isRequired,
trackMouse: PropTypes.func.isRequired,
};
export default Canvas;
```
Отличия от прежней версии:
* `CannonPipe.rotation`: теперь это свойство запрограммировано более гибко. Оно привязано к состоянию Redux store путем маппинга (*тех самых функций (mapStateToProps и mapDispatchToProps) внутри функции connect, внутри контейнера Game — прим.переводчика*).
* `svg.onMouseMove`: этот слушатель событий добавлен на холст, чтобы определять положение мыши.
* `Canvas.propTypes`: для полного счастья этому компоненту необходим `angle` и `trackMouse`.
Свершилось! Можете взглянуть через прицел на своего врага. Зайдите в терминале в корень проекта и введите `npm start` (если он еще не запущен). Затем откройте <http://localhost:3000/> в веб-браузере и подвигайте мышью. Тем самым вы приведете в движение свою пушку.
И как вам, весело?!
Заключение и последующие шаги
-----------------------------
В первой части этой серии вы познакомились с некоторыми важными темами, знание которых поможет вам в создании полной версии игры. Вы также использовали приложение `create-react-app` для быстрого старта вашего проекта и создали некоторые игровые элементы, такие как пушка, небо и земля. В конце концов, вы снабдили свою пушку прицелом. Обладая данными элементами, вы можете создать остальные элементы и сделать их анимированными.
В следующей статье этой серии вы будете создавать эти элементы, сделаете так, чтобы летающие диски возникали случайным образом в заранее определенных положениях. После этого вы научите свою пушку стрелять ядрами.
Это будет круто!
Оставайтесь на связи!
### От переводчика
Думаю, что иногда полезно отвлечься от "серьезных" проектов. А что думаете вы?
[Перевод второй части](https://habrahabr.ru/post/350278/) | https://habr.com/ru/post/350274/ | null | ru | null |
# Выбираем правильную структуру данных в Swift
*И снова здравствуйте. Прежде чем уйти на выходные хотим поделиться с вами переводом материала, который был подготовлен специально для базового курса [«iOS-разработчик»](https://otus.pw/8XKY/).*
---
Решить, какую структуру данных использовать для представления заданного набора значений, часто бывает намного сложнее, чем кажется. Поскольку каждый тип структур данных оптимизирован для определенного числа вариантов использования, выбор правильного соответствия для каждого набора данных часто может оказать большое влияние на эффективность нашего кода.
Стандартная библиотека Swift поставляется с тремя основными структурами данных — `Array`, `Dictionary` и `Set`, каждая из которых имеет свой набор оптимизаций, плюсов и минусов. Давайте рассмотрим некоторые из их характеристик, а также случаи, когда нам может понадобиться выйти за рамки стандартной библиотеки, чтобы найти правильную структуру данных для наших целей.
### Линейность массивов
`Array` (массив) является, пожалуй, одной из наиболее часто используемых структур данных в Swift, и для этого есть веские причины. Он хранит свои элементы последовательно, они легко перебираются предсказуемым способом, и в нем могут храниться любые значения: от структур до экземпляров классов и других коллекций.
Например, здесь мы используем массив для хранения коллекции фигур, помещенных на `Canvas` в приложении для рисования. Затем, когда нужно будет визуализировать canvas в изображение, мы просто пройдем по массиву, чтобы нарисовать каждый элемент с помощью `DrawingContext` — следующим образом:
```
struct Canvas {
var shapes: [Shape]
func render() -> Image {
let context = DrawingContext()
shapes.forEach(context.draw)
return context.makeImage()
}
}
```
Когда дело доходит до последовательной отрисовки всех наших фигур, как мы делали выше, массив подходит идеально. Массивы не только хранят свои элементы очень эффективным образом, они также имеют гарантированный порядок перебора, что обеспечивает предсказуемый порядок отрисовки без необходимости выполнять какую-либо дополнительную работу.
Однако, как и все другие структуры данных, массивы имеют свои недостатки. В нашем случае мы столкнемся с одним из его недостатков, когда захотим удалить фигуры с canvas. Поскольку элементы массива хранятся по индексу, нам всегда нужно сначала найти с каким индексом связана данная фигура, прежде чем мы сможем удалить ее:
```
extension Canvas {
mutating func remove(_ shape: Shape) {
guard let index = shapes.firstIndex(of: shape) else {
return
}
shapes.remove(at: index)
}
}
```
Поначалу приведенный выше код может показаться не таким уж проблематичным, но он может стать узким местом в плане производительности для любого canvas, содержащего большое количество фигур, поскольку `firstIndex` является линейной (O(N)) с точки зрения [временной сложности](https://www.swiftbysundell.com/basics/time-complexity).
Хотя мы можем обойти это ограничение там, где мы используем наш тип Canvas. Например, всегда обращаясь к фигурам по индексу, а не по значению или ID — это сделало бы наш код более сложным и более хрупким, поскольку мы всегда должны бы были быть уверенными, что наши индексы не устареют, когда canvas, с которым мы работаем, изменится.
### Скорость множеств
Вместо этого давайте посмотрим, сможем ли мы оптимизировать сам `Canvas`, изменив его базовую структуру данных. Рассматривая вышеупомянутую проблему, одной из наших первоначальных идей может быть использование `Set` (множества) вместо `Array`. Как мы уже рассматривали в статье [The power of sets in Swift](https://www.swiftbysundell.com/articles/the-power-of-sets-in-swift) (Сила множеств в Swift), одно из значительных преимуществ множеств над массивами заключается в том, что как вставка, так и удаление всегда могут выполняться за постоянное (O(1)) время, так как элементы хранятся по значению хеша, а не по индексу.
Обновив `Canvas` таким образом, чтобы в нем использовались множества, мы получим следующее:
```
struct Canvas {
var shapes: Set
func render() -> Image {
let context = DrawingContext()
shapes.forEach(context.draw)
return context.makeImage()
}
mutating func remove(\_ shape: Shape) {
shapes.remove(shape)
}
}
```
Опять же, приведенный выше код может выглядеть правильно, и он даже компилируется без проблем. Однако, хотя мы решили проблему удаления, мы также потеряли наш стабильный порядок отрисовки — поскольку, в отличие от массивов, множества не дают нам гарантированный порядок перебора — что является камнем преткновения в этой ситуации, так как похоже, что мы будем отрисовывать пользовательские фигуры в случайном порядке.
### Индексирование индексов
Давайте продолжим экспериментировать. Теперь посмотрим, сможем ли мы оптимизировать `Canvas`, введя `Dictionary` (словарь), который позволяет нам искать индекс любой фигуры на основе его ID. Мы начнем с того, что изменим уровень доступа для нашего массива `shapes` на `private`, чтобы иметь возможность контролировать вставку элементов, используя новый метод `add`. И каждый раз, когда добавляется новая фигура, мы также добавляем ее индекс в наш словарь:
```
struct Canvas {
private var shapes = [Shape]()
private var indexes = [Shape.ID : Int]()
func render() -> Image {
let context = DrawingContext()
shapes.forEach(context.draw)
return context.makeImage()
}
mutating func add(_ shape: Shape) {
let index = shapes.count
indexes[shape.id] = index
shapes.append(shape)
}
}
```
Поскольку теперь мы всегда знаем, по какому индексу хранится данная фигура, мы можем быстро выполнять удаление за постоянное время, как при использовании множества:
```
extension Canvas {
mutating func remove(_ shape: Shape) {
guard let index = indexes[shape.id] else {
return
}
shapes.remove(at: index)
indexes[shape.id] = nil
}
}
```
Однако в нашей новой реализации `Canvas` есть довольно серьезный баг. Каждый раз, когда мы удаляем фигуру, мы фактически аннулируем все индексы, которые выше, чем тот, который мы только что удалили — так как каждый из этих элементов будет двигаться на один шаг к началу массива. Мы могли бы решить эту проблему, корректируя эти индексы после каждого удаления, но это снова вернуло бы нас на территорию O(N), чего мы пытались избежать с самого начала.
Наша последняя реализация имеет свои достоинства. В целом, использование комбинации двух структур данных может быть отличной идеей в подобных ситуациях, поскольку мы часто можем использовать сильные стороны одной структуры данных, чтобы компенсировать недостатки другой, и наоборот.
Итак, давайте попробуем еще раз с другой комбинацией, но на этот раз начнем с рассмотрения наших *реальных требований*:
* Нам нужно чтобы и вставки, и удаления имели постоянную временную сложность, и должна быть возможность удалить фигуру, не зная ее базовый индекс.
* Нам нужен гарантированный порядок перебора, чтобы иметь возможность поддерживать стабильный порядок отрисовки.
Глядя на вышеприведенные требования, получается, что хотя нам нужен стабильный порядок перебора, нам на самом деле не нужны индексы. Это сделало бы связный список идеально подходящим для нашего варианта использования.
Связные списки состоят из узлов, где каждый узел содержит ссылку (или связь) на следующий узел в списке, что означает, что его можно перебирать предсказуемым образом — без необходимости каких-либо обновлений индекса при удалении элемента. Однако стандартная библиотека Swift (пока) не содержит тип связного списка, поэтому, если мы хотим его использовать, то его сначала нужно создать.
### Создание связного списка
Давайте начнем с объявления структуры `List` (список), которая будет отслеживать первый и последний узлы в нашем списке. Мы сделаем оба эти свойства доступными только для чтения вне нашего типа, чтобы обеспечить согласованность данных:
```
struct List {
private(set) var firstNode: Node?
private(set) var lastNode: Node?
}
```
Далее, давайте создадим наш тип `Node` (узел), который мы сделаем классом, поскольку мы хотим иметь возможность ссылаться на узлы [по ссылке, а не по значению](https://www.swiftbysundell.com/basics/value-and-reference-types). Наш список будет двусвязным, что означает, что каждый узел будет содержать ссылку как на своего следующего соседа, так и на предыдущего. Каждый узел также будет хранить значение — вот так:
```
extension List {
class Node {
var value: Value
fileprivate(set) weak var previous: Node?
fileprivate(set) var next: Node?
init(value: Value) {
self.value = value
}
}
}
```
> Причина, по которой свойство previous мы делаем weak, состоит в том, чтобы избежать retain-циклов, которые появились бы, если бы мы сохраняли сильные ссылки в обоих направлениях. Чтобы узнать больше о том, как избежать retain-циклов, ознакомьтесь со статьей [“Memory Management”](https://www.swiftbysundell.com/basics/memory-management) (Управление памятью).
Это фактически весь код, который нам понадобится для того, чтобы в нашем связном списке могли храниться значения. Но это только первая часть головоломки, как и в любой другой коллекции, мы также хотим иметь возможность перебирать ее и изменять ее содержимое. Давайте начнем с итераций, которые, благодаря очень протокольно-ориентированному дизайну Swift, можно легко реализовать, обеспечив соответствие протоколу `Sequence` и реализовав метод `makeIterator`:
```
extension List: Sequence {
func makeIterator() -> AnyIterator {
var node = firstNode
return AnyIterator {
// Перебирает все узлы, последовательно переходя к следующему, и извлекает его значение:
let value = node?.value
node = node?.next
return value
}
}
}
```
> Поскольку вышеприведенная итерация очень проста, мы используем `AnyIterator` стандартной библиотеки, чтобы избежать необходимости реализовывать пользовательский тип итератора. Для более сложных сценариев его можно реализовать, добавив соответствие с `IteratorProtocol`.
Далее, давайте добавим API для изменения нашего связного списка, начиная с вставок. Мы расширим `List` с помощью метода `append`, который добавляет новый узел для вставляемого значения, а затем возвращает этот узел — вот так:
```
extension List {
@discardableResult
mutating func append(_ value: Value) -> Node {
let node = Node(value: value)
node.previous = lastNode
lastNode?.next = node
lastNode = node
if firstNode == nil {
firstNode = node
}
return node
}
}
```
> Выше мы используем атрибут `@discardableResult`, который говорит компилятору не генерировать никаких предупреждений в случае, если результат вызова нашего метода не использовался, поскольку нас не всегда интересует узел, который был создан.
Поскольку связные списки основаны не на индексах, а на поддержании цепочки значений посредством ссылок, реализация удалений — это всего лишь вопрос обновления следующих и предыдущих соседей удаленных узлов, чтобы они вместо этого указывали друг на друга:
```
extension List {
mutating func remove(_ node: Node) {
node.previous?.next = node.next
node.next?.previous = node.previous
// Используя «тройное равенство», мы можем сравнивать два экземпляра класса по тождеству, а не по значению:
if firstNode === node {
firstNode = node.next
}
if lastNode === node {
lastNode = node.previous
}
}
}
```
С учетом вышеизложенного начальная версия нашего List завершена, и мы готовы проверить его в деле. Давайте обновим Canvas, чтобы использовать наш новый список, а также словарь, который позволяет нам быстро искать, какой узел соответствует данному ID фигуры:
```
struct Canvas {
private var shapes = List()
private var nodes = [Shape.ID : List.Node]()
func render() -> Image {
let context = DrawingContext()
shapes.forEach(context.draw)
return context.makeImage()
}
mutating func add(\_ shape: Shape) {
nodes[shape.id] = shapes.append(shape)
}
mutating func remove(\_ shape: Shape) {
guard let node = nodes.removeValue(forKey: shape.id) else {
return
}
shapes.remove(node)
}
}
```
Теперь у нас есть как быстрые вставки и удаления, так и предсказуемый порядок перебора, без необходимости добавлять дополнительную сложность в процесс вызова — это довольно круто! И, поскольку наш новый List — полностью универсальный тип, теперь мы можем использовать его всякий раз, когда нам снова нужно будет хранить значения без индекса линейным образом.
### Заключение
Несмотря на то, что структуры данных настолько фундаментальны, что их можно найти во всех видах языков программирования, решение о том, какую из них использовать в каждой конкретной ситуации, все же может потребовать значительного количества размышлений, тестирования и экспериментов, особенно если мы хотим, чтобы наш код оставался эффективным по мере роста набора данных.
Также весьма вероятно, что подходящая структура данных для каждый конкретной ситуации может со временем меняться по мере изменения наших требований, и иногда использование комбинации нескольких структур данных, а не только одной, может быть способом достижения требуемых характеристик производительности.
Мы продолжим исследовать мир структур данных в следующих статьях, особое внимание уделяя тем, которые еще не реализованы в стандартной библиотеке. Как и во многих других вещах, иногда требуется расширить наше мышление за пределы Swift, чтобы выбрать правильную структуру данных для каждой ситуации.
Вы можете найти меня [в Твиттере](https://twitter.com/johnsundell) или напишите мне, если у вас есть какие-либо вопросы, комментарии или отзывы.
Спасибо за внимание! | https://habr.com/ru/post/468239/ | null | ru | null |
# Разработка акустического датасета для обучения нейронной сети
Однажды в интервью один всем известный российский музыкант сказал: “Мы работаем над тем, чтобы лежать и плевать в потолок”. Не могу не согласиться с этим утверждением, ведь то, что именно лень является движущей силой в развитии технологий, спору никакого быть не может. И действительно, только за последнее столетие мы перешли от паровых машин к цифровой индустриализации, и теперь искусственный интеллект, о котором писали фантасты и футурологи прошлого столетия, с каждым днём становится всё большей реальностью нашего мира. Компьютерные игры, мобильные устройства, умные часы и многое другое в своей основе используют алгоритмы, связанные с механизмами машинного обучения.
В настоящее время, благодаря росту вычислительных способностей графических процессоров и появившемуся большому объёму данных, популярность получили нейронные сети, с использованием которых решают задачи классификации и регрессии, обучая их на подготовленных данных. О том как обучать нейронные сети и какие фреймворки для этого использовать — уже написано немало статей. Но существует более ранняя задача, которую так же необходимо решить и это задача формирования массива данных — датасета, для дальнейшего обучения нейронной сети. Об этом и пойдет речь в данной статье.
Не так давно возникла необходимость построения акустического классификатора автомобильных шумов способного выделять из общего аудиопотока данных: разбитое стекло, открытие дверей и работу двигателя автомобиля в различных режимах. Разработка классификатора не представляла сложности, но где взять датасет, чтобы он удовлетворял всем требованиям?
На помощь пришёл Google (не в обиду Яндексу — о его плюсах я скажу чуть позже), с использованием которого получилось выделить несколько основных кластеров, содержащих необходимые данные. Заранее хочу отметить, что источники, указанные в данной статье включают в себя большой объём акустической информации, с различными классами, позволяющим сформировать датасет под разные задачи. Теперь перейдём к обзору этих источников.
[**Freesound.org**](https://freesound.org)
Вероятнее всего *Freesound.org* предоставляет самый большой объём акустических данных, являясь совместным хранилищем лицензионных музыкальных образцов, который на данный момент насчитывает более чем 230.000 экземпляров звуковых эффектов. Каждый звуковой образец может распространяться под разной лицензией, поэтому предварительно лучше ознакомиться с [лицензионным соглашением](https://freesound.org/help/faq/#licenses). Для примера, лицензия [zero(cc0)](https://creativecommons.org/publicdomain/zero/1.0/) имеет статус “Без авторских прав”, и позволяет осуществлять копирование, изменение и распространение, включая коммерческое использование, и позволяет использовать данные абсолютно легально.
Для удобства нахождения элементов акустической информации в множестве freesound.org, разработчики предусмотрели [API](https://freesound.org/help/developers/) предназначенный для анализа, поиска и скачивания данных из репозиториев. Для работы с ним необходимо получить доступ, для этого вам необходимо перейти на [форму](https://freesound.org/apiv2/apply/) и заполнить все необходимые поля, после чего пройдёт генерация индивидуального ключа.
Разработчики freesound.org предоставляю [API](https://freesound.org/docs/api/client_libs.html#freesound-apiv2-clients) под различные языки программирования, тем самым позволяя решать разными инструментами одну и ту же задачу. Список поддерживаемых языков и ссылки доступа к ним на GitHub указаны ниже.
Для достижения цели использовался python, так как этот прекрасный язык программирования с динамической типизацией получил свою популярность благодаря своей простоте в использовании, полностью перечёркивая миф о сложности разработки программного обеспечения. [Модуль для работы с freesound.org](https://github.com/MTG/freesound-python) для python можно клонировать из хранилища github.com.
Ниже расположен программный код, состоящий из двух частей и демонстрирующий всю простоту использования данного API. Первая часть программного кода выполняет задачу анализа данных, результатом которого является плотность распределения данных по каждому запрашиваемому классу, а вторая часть осуществляет выгрузку данных из репозиториев freesound.org для подобранных классов. Плотность распределения при поиске акустической информации, с ключевыми словами *glass, engine, door* представлена ниже на круговой диаграмме в качестве примера.
Пример кода для анализа данных freesound.org
```
import plotly
import plotly.graph_objs as go
import freesound
import os
import termcolor
#Построение гистограммы в соответствии с данными
def histogram(data, filename = "tmp_histogram.html"):
data = [
go.Histogram(
histfunc="count",
x=data,
name="count",textfont=dict(size=15)
),
]
plotly.offline.plot({
"data": data,
"layout": go.Layout(title="Histogram")
}, auto_open=True, filename=filename)
pass
# Анализ запрашиваемых данных из пространства freesound.org
def freesound_analysis(search_tokens, output, lim_page_count = 1, key = None):
lim_page_count = int(lim_page_count)
try:
client = freesound.FreesoundClient()
client.set_token(key,"token")
print(termcolor.colored("Authorisation successful ", "green"))
except:
print(termcolor.colored("Authorisation failed ", "red"))
classes = list()
for token in search_tokens:
try:
results = client.text_search(query=token,fields="id,name,previews")
output_catalog = os.path.normpath(output)
if not os.path.exists(output_catalog):
os.makedirs(output_catalog)
page_count = int(0)
while True:
for sound in results:
try:
classes.append(token)
info = "Data has been getter: " + str(sound.name)
print(termcolor.colored(info, "green"))
except:
info = "Data has not been getter: " + str(sound.name)
print(termcolor.colored(info, "red"))
page_count += 1
if (not results.next) or (lim_page_count == page_count):
page_count = 0
break
results = results.next_page()
except:
print(termcolor.colored(" Search is failed ", "red"))
histogram(classes)
pass
```
Пример кода для скачивания данных freesound.org
```
#Скачивание запрашиваемых данных
def freesound_download(search_tokens, output, lim_page_count = 1, key = None):
lim_page_count = int(lim_page_count)
#Попытка подключения клиента. Необходимо указать полученный ключ
try:
client = freesound.FreesoundClient()
client.set_token(key,"token")
print(termcolor.colored("Authorisation successful ", "green"))
except:
print(termcolor.colored("Authorisation failed ", "red"))
for token in search_tokens:
try:
results = client.text_search(query=token,fields="id,name,previews")
output_catalog = os.path.normpath(output + "\\" + str(token))
if not os.path.exists(output_catalog):
os.makedirs(output_catalog)
page_count = int(0)
while True:
for sound in results:
try:
sound.retrieve_preview(output_catalog)
info = "Saved file: " + str(output_catalog) + str(sound.name)
print(termcolor.colored(info, "green"))
except:
info = str("Sound can`t be saved to " + str(output_catalog) + str(sound.name) )
print(termcolor.colored(info, "red"))
page_count += 1
if not results.next or lim_page_count == page_count:
page_count = 0
break
results = results.next_page()
except:
print(termcolor.colored(" Search is failed ", "red"))
```
Особенностью freesound является то, что анализ звуковых данных можно проводить без скачивания аудиофайла, позволяя получать MFCC, spectral energy, spectral centroid и другие коэффициенты. Подробнее о lowlevel информации можно прочесть в [документации freesound.ord](https://freesound.org/docs/api/analysis_docs.html#analysis-descriptor-documentation).
С использованием API freesound.org, время затраченное на выборку и выгрузку данных сводится к минимуму, позволяя экономить рабочие часы на изучение других источников информации, так как для высокой точности акустического классификатора необходим объёмный датасет с большой вариативностью, представляющей данные с различными гармониками на один и тот же класс событий.
**YouTube-8M и AudioSet**
Думаю что youtube особо не требуется в представлении, но всё же википедия говорит нам что youtube — это видехостинговый сайт, предоставляющий пользователям услуги показа видео, забывая сказать о том, что youtube — это огромная база данных, и этот источник просто необходимо использовать в машинном обучении, а Google Inc предоставляет нам проект под названием [YouTube-8M Dataset](https://research.google.com/youtube8m/).
YouTube-8M Dataset — это набор данных включающий в себя более миллиона видеофайлов с YouTube в высоком качестве, если давать более точную информацию, то на май 2018 года насчитывалось 6.1M видео с 3862-мя классами. Данный датасет распространяется под лицензией [Creative Commons Attribution 4.0 International (CC BY 4.0)](https://creativecommons.org/licenses/by/4.0/). Такая лицензия позволяет вам копировать и распространять материал на любом носителе и формате.
Вы наверное задаётесь вопросом: причём тут видеоданные, когда для задачи необходима акустическая информация, и будете очень даже правы. Дело в том, что Google предоставляет не только видеоконтент, но и отдельно выделил подпроект с аудиоданными под названием [AudioSet](https://research.google.com/audioset/index.html).
[AudioSet](https://research.google.com/audioset/index.html) — предоставляет набор данных полученный из роликов YouTube, где множество данных представлено в иерархию классов, с использованием [файла онтологии](https://research.google.com/audioset//ontology/index.html), его графическое представление расположено ниже.
Данный файл позволяет получить представление о вложенности классов, а также получить доступ к youtube роликам. Для выгрузки данных из интернет пространства можно использовать python модуль — youtube-dl, который позволяет скачивать аудио или видеоконтент в зависимости от необходимой задачи.
AudioSet представляет кластер разделённый на три множества: тестовый, тренировочный(сбалансированный) и тренировочный( несбалансированный ) [датасет](https://research.google.com/audioset/download.html).
Давайте рассмотрим данный кластер и проанализируем каждое такое из множеств отдельно, чтобы иметь представление о содержащихся классов.
**Тренировочный (сбалансированный)**
Согласно документации данный датасет состоит из *22,176 сегментов* полученных из различных видеороликов отобранных по ключевым словам, предоставляя каждого класса не менее 59 экземпляров. Если посмотреть на плотность распределения корневых классов в иерархии множества, то мы увидим что самую большую группу аудио файлов представляет класс Music.
Организованные классы декомпозируются в подмножества классов, позволяя получать при использовании более детальную информацию. Данное сбалансированное тренировочное множество имеет плотность распределения на которой видно, что сбалансированность присутствует, но также отдельные классы сильно выделяются из общего вида.
Распределение классов, количество элементов которых превышает среднее значение
Средняя длительность каждого из аудиофайлов равняется 10-ти секундам, более детальную информация представляет дисковая диаграмма, на которой видно, что длительность части файлов отличается от основного множества. Данная диаграмма так же представлена.
Диаграмма длительности полутора процентов, отличных от среднего значения, из сбалансированного множества audioset
**Тренировочный (несбалансированный)**
Преимуществом данного датасета является его размер. Только представьте, что согласно документации это множество включает в себя 2,042,985 сегментов и в сравнении со сбалансированных датасетом представляет большую вариативность, но и энтропия данного множества гораздо выше.
В данном множестве средняя длительность каждого из аудиофайлов также равняется 10-ти секундам, дисковая диаграмма для данного датасета представлена ниже.
Диаграмма длительности, отличных от среднего значения, из несбалансированного множества audioset
**Тестовое множество**
Данное множество очень похоже на сбалансированное множество с преимуществом того, что элементы этих множеств не пересекаются. Их распределение представлено ниже.
Распределение классов, количество элементов которых превышает среднее значение
Средняя длительность одного сегмента из данного датасета также равна 10-ти секундам
а оставшееся часть имеет длительность представленную на дисковой диаграмме
Пример программного кода для анализа и скачивания акустических данных в соответствии с выбранным датасетом:
```
import plotly
import plotly.graph_objs as go
from collections import Counter
import numpy as np
import os
import termcolor
import csv
import json
import youtube_dl
import subprocess
#Построение гистограммы в соответствии с данными
def histogram(data,hist_mean= True, filename = "tmp_histogram.html"):
if hist_mean == True:
cdata = Counter(data)
mean_number_classes = np.asarray([cdata[x] for x in cdata]).mean()
ldata = list()
for name in cdata:
if cdata[name] > mean_number_classes:
ldata += list(Counter({name:cdata[name]}).elements())
trace_mean_data = go.Histogram(histfunc="count", x=ldata, name="count" )
trace_data = go.Histogram(histfunc="count", x=data, name="count", text="" )
trace = [ trace_data, trace_mean_data]
plotly.offline.plot({
"data": trace,
"layout": go.Layout(title="stack")
}, auto_open=True, filename=filename)
pass
#Построение круговой диаграммы в соответствии с данными
def pie_chart(labels, values = None, filename = "tmp_pie_chart.html", textinfo = 'label+value'):
if labels == None:
raise Exception("Can not create pie chart, because labels is None")
if values == None:
data = Counter(labels)
labels = list()
values = list()
for name in data:
labels.append(name)
values.append(data[name])
trace = go.Pie(labels=labels, values=values,textfont=dict(size=20),hoverinfo='label+percent', textinfo=textinfo,
marker=dict(line=dict(color='#000000', width=2))
)
plotly.offline.plot([trace], filename='basic_pie_chart')
pass
#Анализ данных в соответствии с файлом онтологии и выбранного датасета
def audioset_analysis(audioset_file, inputOntology):
if not os.path.exists(inputOntology) or not os.path.exists(audioset_file):
raise Exception("Can not found file")
with open(audioset_file, 'r') as fe:
csv_data = csv.reader(fe)
sx = list()
with open(inputOntology) as f:
data = json.load(f)
duration_hist = list()
for row in csv_data:
if row[0][0] == '#':
continue
classes = row[3:]
try:
color = "green"
tmp_duration = str(float(row[2]) - float(row[1]))
info = str("id: ") + str(row[0]) + str(" duration: ") + tmp_duration
duration_hist.append(tmp_duration)
for cl in classes:
for dt in data:
cl = str(cl).strip().replace('"',"")
if cl == dt['id'] and len(dt['child_ids']) == 0:
sx.append(dt['name'])
info += str(" ")+str(dt['name']) + str(",")
except:
color = "red"
info = "File has been pass: " + str(row[0])
continue
print(termcolor.colored(info, color))
histogram(sx, filename="audioset_class")
pie_chart(duration_hist, textinfo="percent + label", filename="audioset_duration")
```
```
#Скачивание файла из youtube
def youtube_download(filepath, ytid):
ydl_opts = {
'format': 'bestaudio/best',
'outtmpl': os.path.normpath(filepath),
'postprocessors': [{
'key': 'FFmpegExtractAudio',
'preferredcodec': 'wav',
'preferredquality': '192',
}],
}
with youtube_dl.YoutubeDL(ydl_opts) as ydl:
ydl.download(['https://www.youtube.com/watch?v={}'.format(ytid)])
pass
#Обрезание файла с использованием ffmpeg
def cutOfPartFile(filename,outputFile, start, end, frequency = 44100):
duration = float(end) - float(start)
command = 'ffmpeg -i '
command += str(filename)+" "
command += " -ar " + str(frequency)
command += " -ss " + str(start)
command += " -t " + str(duration) + " "
command += str(outputFile)
subprocess.call(command,shell=True)
pass
#Преобразование выгруженных файлов из yotube к виду в соответствии с файлом датасета
def audioset_converter(incatalog,outcatalog, token = "*.wav", frequency = 44100):
find_template = os.path.join(incatalog,token)
files = glob(find_template);
for file in files:
_,name = os.path.split(file)
name = os.path.splitext(name)[0]
duration = str(name).split("_")[1:3]
filename = name.split("_")[0] +"."+ token.split(".")[1];
outfile = os.path.join(outcatalog,filename)
cutOfPartFile(file,outfile,start=duration[0],end=duration[1])
#Скачивание соответствующего датасета из audioset
def audioset_download(audioset_file, outputDataset, frequency = 44100):
t,h = os.path.split(audioset_file)
h = h.split(".")
outputDataset_full = os.path.join(outputDataset,str(h[0])+"_full")
outputDataset = os.path.join(outputDataset,str(h[0]))
if not os.path.exists(outputDataset):
os.makedirs(outputDataset)
if not os.path.exists(outputDataset_full):
os.makedirs(outputDataset_full)
with open(audioset_file, 'r') as fe:
csv_data = csv.reader(fe)
duration_hist = list()
for row in csv_data:
if row[0][0] == '#':
continue
try:
color = "green"
tmp_duration = str(float(row[2]) - float(row[1]))
info = str("id: ") + str(row[0]) + str(" duration: ") + tmp_duration
duration_hist.append(tmp_duration)
save_full_file = str(outputDataset_full) + str("//")+ str(row[0]).lstrip()+str("_") +str(row[1]).lstrip() + str("_").lstrip() + str(row[2]).lstrip() + str('.%(ext)s')
youtube_download(save_full_file,row[0])
except:
color = "red"
info = "File has been pass: " + str(row[0])
continue
print(termcolor.colored(info, color))
audioset_converter(outputDataset_full,outputDataset, frequency = frequency)
```
Для получения более детальной информации по анализу данных audioset, или выгрузки этих данных из пространства yotube в соответствии с [файлом онтологии](https://github.com/audioset/ontology/blob/master/ontology.json) и выбранным [множеством audioset](https://research.google.com/audioset/download.html), программный код располагается в свободном доступе [репозитория GitHub](https://github.com/yurasolovjov/audio_dataset_tools).
**[urbansound](https://urbansounddataset.weebly.com/)**
Urbansound — это один из самых больших датасетов, с размеченными звуковыми событиями, классы которого принадлежат к городской окружающей среде. Данное множество получило название таксономическое(категориальное), т.е. каждый класс разделяется на принадлежащие ему подклассы. Такое множество можно представить в виде дерева.
Чтобы выгрузить данные urbansound для последующего использования достаточно просто перейти к ним на страницу и нажать [скачать](https://urbansounddataset.weebly.com/download-urbansound.html).
Так как в задаче нет необходимости использовать все подклассы, а нужен только единственный класс связанный с автомобилем, то предварительно необходимо осуществить фильтрацию необходимых классов, с использованием meta файла, расположенного в корне каталога получаемого при разархивировании скачанного файла.
После выгрузки всех необходимых данных из перечисленных источников, получилось сформировать датасет содержащий более 15000 файлов. Такой объём данных позволяет перейти к задаче обучения акустического классификатора, но остаётся не решённый вопрос касаемый “чистоты” данных, т.е. тренировочное множество включает в себя данные не относящихся к необходимым классам решаемой задачи. К примеру при прослушивании файлов из класса “разбитие стекла”, можно найти разговоры людей о том что, “как же не хорошо бить стёкла”. Следовательно перед нами возникает задача фильтрации данных и в роли инструмента решения такого рода задачи отлично подходит инструмент, ядро которого разработано белорусскими ребятами и получившее странное название “Яндекс.Толока”.
**[Яндекс.Толока](https://toloka.yandex.ru)**
Яндекс.Толока — это краудфандинговый проект, созданный в 2014 году для разметки или сбора большого объёма данных для дальнейшего использования в машинном обучении. Фактически данный инструмент позволяет собирать, размечать и фильтровать данные с использованием человеческого ресурса. Да, данный проект не только позволяет решать задачи, но и позволяет другим людям заработать. Финансовое обременение в данном случае ложится на ваши плечи, но за счёт того, что со стороны исполнителей выступает более 10000 толокеров результаты работы будут получены уже в ближайшее время. Хорошее описание работы данного инструмента можно прочесть в [блоге компании Яндекс](https://habr.com/company/yandex/blog/305956/).
Вообще использование толоки не представляет особой сложности, так как для публикации задания всего лишь необходима регистрация на [сайте](https://toloka.yandex.ru), минимальная сумма в 10 долларов США, и правильно оформленное задание. Как корректно формировать задание можно посмотреть [документацию Яндекс.Толока](https://tech.yandex.ru/toloka/doc/concepts/about-docpage/) или есть не плохая [статья на Хабре](https://habr.com/company/ods/blog/358574/). От себя к данной статье хочу добавить, что даже если шаблон подходящий под требование вашей задачи отсутствует, то его разработка займет не более нескольких часов работы, с перерывом на кофе и сигарету, а результаты исполнителей можно получить к концу рабочего дня.
**Заключение**
В машинном обучении при решении задачи классификации или регрессии, одной из первичных задач является разработка достоверного набора данных — датасета. В данной статье были рассмотрены источники информации с большим объёмом акустических данных позволяющих сформировать и сбалансировать необходимый набор данных под конкретную задачу. Представленный программный код позволяет упростить операцию выгрузки данных до минимума, позволяя сократить время на получение данных, его остаток потратить на разработку классификатора.
Что касается моей задачи, то после сбора данных, из всех представленных в данной статье источников и последующей фильтрации данных, удалось сформировать необходимый датасет для обучения акустического классификатора, в основе которого находится нейронная сеть. Надеюсь что данная статья позволит вам и вашей команде сэкономить время и потратить его на развитие новых технологий.
**P.S.** Программный модуль разработанный на языке python, для анализа и выгрузки акустических данных по каждому из представленных источников вы можете найти в [хранилище github](https://github.com/yurasolovjov/audio_dataset_tools) | https://habr.com/ru/post/427397/ | null | ru | null |
# Использование NSOperation и NSOperationQueue в Swift
Почти каждый из нас испытывал дискомфорт, когда при нажатии на кнопку или при вводе текста в **iOS** или **Mac** приложениях, как внезапно пользовательский интерфейс переставал отвечать, приложение будто замирало и переставало реагировать на ваши действия.
На **Mac**, пользователи видит песочные часы или вращающийся радужный курсор, пока снова не возобновится взаимодействие с пользовательским интерфейсом. Многие пользователи ошибочно предполагают, что приложения сразу же заработает при прикосновению к экрану. Такие приложение дают ощущение низкой производительности и кажутся медленными, и, как правило, получает плохие отзывы в **AppStore**.
Но обеспечить постоянную отзывчивость пользовательского интерфейса не так уж просто. Как только приложение выполняет множество задач, оно начинает подтормаживать. Не так уж много времени выделяется для выполнения большого количества задач в главном потоке и для обеспечения отзывчивости интерфейса.
Что же должен делать «несчастный» разработчик? Решение есть, оно состоит в том, чтобы отделить основной поток через параллелизм. Параллелизм, это свойство приложения выполнять задачи в несколько потоков одновременно – и при этом пользовательский интерфейс остается отзывчивым, поскольку Вы выполняете свою работу в разных потоках.
Одним из методов для одновременного выполнения операций в **iOS** являются использование классов **NSOperation** и **NSOperationQueue**. В этой статье вы узнаете, как их использовать! Вы будете работать с приложением, которое совсем не использует многопоточность, таким образом, оно будет очень медленным, и будет «тормозить». Когда вы измените приложение, чтобы можно было добавлять параллельные операций и — надеюсь – это обеспечит более отзывчивый интерфейс для пользователя!
**Приступим**
Цель этой статьи состоит в том, чтобы показать таблицу с изображениями, к которым применили фильтр. Изображение будет загружено из интернета, к которому будет применен фильтр, а затем отображено в таблице.
Вот схематическое представление модели приложения:
**Первая попытка**
****От автора:**** Так как статья была написана ранее **09.09.2015** для написания примеров был использован **Swift** версий **1.2**. Я внес в примеры некоторые изменения с связи с выходом новой версий языка **Swift**. Исходный код на Swift 2.0 находиться по ссылкам: [«стартовый» проект](https://github.com/yarmolchuk/ClassicPhotos-Starter) и [«финальная» версия проекта](https://github.com/yarmolchuk/ClassicPhotos-Final).
[Загрузите «стартовый» проект на Swift 1.2](http://cdn5.raywenderlich.com/wp-content/uploads/2014/10/ClassicPhotos-Starter63.zip) и [Swift 2.0](https://github.com/yarmolchuk/ClassicPhotos-Starter), над которым вы будете работать по ходу прочтения этого мануала.
**Примечание:** *Все изображения взяты из [stock.xchng](http://sxc.hu/).Так как существуют случаи, когда изображение не удается загрузить, то для осуществления этой неудавшейся попытки некоторые изображения в источнике данных преднамеренно неверно названы.*
Скомпилируйте и запустите приложение, и (в конечном счете) Вы увидите, что приложение отображает список фотографий. Попробуйте прокрутить список. Раздражает, не так ли?
Все действие происходит в файле **ListViewController.swift**, и большинство действий которые находится внутри метода делегата таблицы **tableView(\_:cellForRowAtIndexPath:)**.
Взгляните на этот метод и обратите внимание на два происходящих действия, которые довольно объемные:
1. Загрузка изображений из сети. Даже если это — простая работа, приложение должно ожидать завершения загрузки, прежде чем оно сможет продолжать выполнять другую операцию.
2. Применение фильтра к изображению с помощью Core Image. Этот метод применяет фильтр сепии к изображению. Если хотите узнать больше о **Core Image filters**, прочитайте **Beginning Core Image in Swift**.
Кроме того, Вы также загружаете список фотографий из сети, при первом запросе:
```
lazy var photos = NSDictionary(contentsOfURL:dataSourceURL)
```
Вся эта работа происходит в основном потоке приложения. Поскольку основной поток также отвечает за взаимодействие с пользователем, то загрузка и применение фильтра к изображениям снижает способность к быстрому реагированию на действия пользователя. Вы можете убедиться в этом с помощью вкладки индикаторов в среде разработки **Xcode**. Вы можете добраться к этой закладке, нажав на **Debug navigator** (Command-6) и затем выбрав CPU, во время выполнения приложения.
Вы увидите все эти пики в первом потоке, который является основным потоком приложения. Для получения более подробной информации, запустите приложение с использование **Инструментов**, но это уже совсем другая история.
Пора подумать о том, как можно улучшить ваш пользовательский опыт! И сделать приложение более отзывчивым.
**Задачи, Потоки и Процессы**
Прежде чем Вы погрузитесь в статью, есть несколько технических понятий, которые нужно рассмотреть. Я дам определение нескольким терминам:
* **Задача/Task:** простая единица, которая должна быть выполнена.
* **Поток/Thread:** механизм, созданный операционной системой, где выполняются несколько команд одновременно в одном приложении.
* **Процесс/Process:** выполняющийся фрагмент программного кода, который может состоять из несколько потоков.
**Примечание:** *В **iOS** и **OS X**, функциональность многопоточность обеспечивается средствами *POSIX Threads API* и является частью операционной системы. Это работа довольно низкого уровня, и вы поймете насколько легко можно наделать ошибок; возможно, худшее в использование потоков – это ошибки, которые невероятно сложно найти!*
***Foundation framework** содержит класс под названием **NSThread**, с которым намного проще работать, но управление несколькими потоками с помощью **NSThread** все еще вызывает трудности. **NSOperation** и **NSOperationQueue** высокоуровневые классы, которые значительно упрощают процесс работы с несколькими потоками.*
В этой схеме Вы видите отношение между процессом, потоками и задачами:
Как Вы видите, процесс может содержать несколько потоков, и каждый поток может выполнять несколько задач поочередно.
В этой схеме, второй поток выполняет чтения файла, в то время как первый поток выполняет код, связанный с пользовательским интерфейсом. Это очень похоже на то, как вы должны структурировать свой код в **iOS** – основной поток должен выполнять любую работу, связанную с пользовательским интерфейсом, а вторичные потоки должны выполнять медленные или длительные операции, такие как чтение файлов, доступ к сети, и т.д.
**NSOperation против Grand Central Dispatch (GCD)**
Возможно, Вы слышали о **Grand Central Dispatch (GCD)**. В общих чертах **GCD** состоит из языковых особенностей, **runtime библиотек** и расширений системы, что в свою очередь обеспечивает системные всесторонние улучшения для поддержания параллелизма на многоядерных мобильных устройствах в **iOS** и **OS X**. Если Вы хотите больше узнать о **GCD**, Вы можете прочитать [Multithreading and Grand Central Dispatch on iOS for Beginners Tutorial](http://www.raywenderlich.com/?p=4295).
**NSOperation** и **NSOperationQueue** построенные поверх **GCD**. Стоит заметить что, **Apple** рекомендует использовать абстракцию высшего уровня, и затем опуститься к нижним уровням, когда измерения показывают, что они необходимы.
Вот краткое сравнение, которое, поможет Вам решить, когда и где использовать **GCD** или **NSOperation**:
* **GCD** это легковесный способ представление единиц работы, которые будут выполняться одновременно. Ненужно вносить в список эти единицы работы; система сама позаботится об этом за Вас. Добавление зависимости среди блоков может быть не легким заданием. Отмена или приостановка блока создает дополнительную работу для Вас как разработчику!
* **NSOperation** добавляет небольшие дополнительные издержки по сравнению с **GCD**, но Вы можете добавить зависимость для различных операций, повторно использовать, отменить или приостановить их.
В этом туториале мы будем использовать класс **NSOperation**, потому что Вы имеете дело с табличным представлением и по причине производительности, и энергопотребления, Вам необходимо отменить операцию для определенного изображения, если пользователь прокрутил изображение за пределы экрана. Даже если операции будут находиться в фоновом потоке, если десятки таких операций будут ожидать своей очереди для выполнения, то производительность будет по-прежнему не на том уровне что нам необходимо.
**Изменение схемы модели приложения**
Пора изменить предварительную без многопоточности модель приложения! Если Вы более внимательно присмотритесь на предварительную модель, Вы увидите, что есть три проблематичных области, которые можно улучшить. Разделяя эти три области и вынести их в отдельный поток, основной поток будет освобожден, и будет способный быстро реагировать на взаимодействие пользователя с **UI**.
Чтобы избавиться от узких мест в приложении, Вам будет нужен поток, который будет отвечать на взаимодействие пользователя с UI, ещё поток, который будет предназначенный для загрузки изображений и ещё один поток для выполнения применения фильтра к изображению. В новой модели приложение запускается в основном потоке и загружает пустое табличное представление. Одновременно, приложение запускает второй поток для загрузки данных.
Как только данные загрузиться, необходимо обновить таблицу. Это должно быть сделано в основном потоке, так как он включает в себя пользовательский интерфейс. На данном этапе табличное представление знает, сколько у него есть ячеек, и какие URL изображений должны быть отображены на экран, но у него еще нет никаких фактических изображений! Если Вы сразу начнете загружать все изображения в один момент, то это будет совсем неэффективно, поскольку Вам не нужны все изображения сразу!
**Что можно сделать для улучшения?**
Усовершенствованная модель начнет загружать изображения, которые соответствуют отображаемым на экране ячейкам. Таким образом, Ваш код сначала узнает, какие ячейки видимы, и только тогда начнется процесс загрузки. Также, процесс применения фильтра для изображения не может быть начат, прежде чем изображение не будет полностью загружено. Поэтому, код который отвечает за применение фильтра не должен запускать, пока нет изображение для обработки.
Для лучшей отзывчивости приложения, мы должны отображать изображение, как только оно загрузиться. Тогда мы начнет работу с изображениям, и затем обновит интерфейс, чтобы вывести на экран обработанные изображение. На схеме ниже схематически показано поток управления для этого процесса:
Чтобы достигнуть этих целей, Вы должны будете отследить, загружается ли изображение в настоящее время, или уже загружено, или был ли применен фильтр к изображению. Вам нужно будет также отследить состояние каждой операции, и является ли это загрузкой или обработкой изображения так, чтобы Вы могли отменить, приостановить или возобновить её.
Хорошо! Теперь можно приступить к самому интересному, реализаций нашей схемы!
Откройте проект и добавьте новый **Swift File** к проекту с именем **PhotoOperations.swift**. Затем добавьте в него следующий код:
```
import UIKit
// This enum contains all the possible states a photo record can be in
enum PhotoRecordState {
case New, Downloaded, Filtered, Failed
}
class PhotoRecord {
let name:String
let url:NSURL
var state = PhotoRecordState.New
var image = UIImage(named: "Placeholder")
init(name:String, url:NSURL) {
self.name = name
self.url = url
}
}
```
**Примечание:** *Убедитесь, что вы сделали импорт **UIKit** в начало файла. По умолчанию **Xcode** делает импорт только **Foundation** в **Swift’е**.*
Этот класс будет представлять каждую фотографию, отображаемую в приложении, вместе с её текущим состоянием, который установлен по умолчанию как **.New** для недавно создаваемых записей. Изображением по умолчанию установлена картинка под названием **«Placeholder»**.
Чтобы отследить состояние каждой операции, Вам будет нужен отдельный класс. Добавьте следующую реализацию в конец **PhotoOperations.swift:**
```
class PendingOperations {
lazy var downloadsInProgress = [NSIndexPath:NSOperation]()
lazy var downloadQueue:NSOperationQueue = {
var queue = NSOperationQueue()
queue.name = "Download queue"
queue.maxConcurrentOperationCount = 1
return queue
}()
lazy var filtrationsInProgress = [NSIndexPath:NSOperation]()
lazy var filtrationQueue:NSOperationQueue = {
var queue = NSOperationQueue()
queue.name = "Image Filtration queue"
queue.maxConcurrentOperationCount = 1
return queue
}()
}
```
Этот класс содержит два словаря, чтобы отслеживать активную и незавершенную загрузку изображений и операции применения фильтра для каждой ячейки в таблице и две очереди операций для каждого типа операций.
Все значения создаются медленно, то есть они не могут быть инициализированными, пока они не получат доступ. Это улучшит производительность вашего приложения.
Создание класса **NSOperationQueue** очень простое. Именование Ваших очередей помогает их потом легко найти в **Инструментах** или в отладчике. **MaxConcurrentOperationCount** установлен в значение **1**, но только для этой статьи, чтобы Вы увидели, что операции завершаются одна за другой. Вы можете пропустить эту часть, чтобы позволить очереди решать, сколько операций она может обработать сразу – это еще больше повысит производительность.
Как же очередь решает, сколько операций она может запустить одновременно? Это хороший вопрос! Это зависит от аппаратного обеспечения. По умолчанию, **NSOperationQueue** делает некоторые вычисления за «кулисами», чтобы решить, что лучше для конкретной платформы, на которой выполняется код, и запустить максимально возможное число потоков.
Рассмотрим следующий пример. Предположим, система неактивна, и есть много доступных ресурсов, таким образом, очередь может запустить приблизительно восемь одновременных потоков. В следующий раз, когда вы запустите приложение, система может быть занята другими операциями, которые используют ресурсы, и очередь запустит только два одновременных потока. Поскольку Вы установили максимальное параллельное количество операций, то в этом приложении будет выполняться только одна операция.
**Примечание:** *Вы можете задаться вопросом, почему Вы должны отслеживать все активные и незаконченные операции. У очереди есть метод operations, который возвращает массив операций, так почему бы не использоваться этим? В этом проекте его нет смысла использовать Вы должны отслеживать, с какими операциями связанные ячейки таблицы, которые включают в себя процесс итерации по массиву каждый раз, когда Вам это нужно. Хранение их в словаре с индексом в качестве основного средства поиска, является быстрым и эффективным способом.*
Пора позаботиться об операциях применения фильтра к изображению и загрузки самого изображения. Добавьте следующий код в конец **PhotoOperations.swift**:
```
class ImageDownloader: NSOperation {
//1
let photoRecord: PhotoRecord
//2
init(photoRecord: PhotoRecord) {
self.photoRecord = photoRecord
}
//3
override func main() {
//4
if self.cancelled {
return
}
//5
let imageData = NSData(contentsOfURL:self.photoRecord.url)
//6
if self.cancelled {
return
}
//7
if imageData?.length > 0 {
self.photoRecord.image = UIImage(data:imageData!)
self.photoRecord.state = .Downloaded
}
else
{
self.photoRecord.state = .Failed
self.photoRecord.image = UIImage(named: "Failed")
}
}
}
```
**NSOperation**, это абстрактный класс, разработанный для создания производного класса. Каждый производный класс представляет собой конкретную задачу, как показано на рисунке выше.
Вот то, что происходит на каждом из пронумерованных комментариев в коде:
1. Добавьте постоянную ссылку к объекту **PhotoRecord**, относящуюся к операции.
2. Создайте указываемый инициализатор позволяющий передавать записи фото.
3. main является методом, который Вы переопределяете в производных классах **NSOperation** для выполнения работы. Вы делаете пул автовыпуска, так как Вы работаете вне пула, создаваемого основным потоком.
4. Проверьте на отмену перед запуском. Операции должны регулярно проверять были ли они отменены перед долгой и интенсивной работой.
5. Загрузите изображение.
6. Проверьте на отмену.
7. Если есть данные, создайте объект изображения, и добавьте его к записи и переместите состояние вперед. Если нет никаких данных, отметьте запись, как неудавшеюся и установите соответствующее изображение
Далее, вы создадите еще одну операцию, чтобы следить за применением фильтра! Добавьте следующий код в конец **PhotoOperations.swift**:
```
class ImageFiltration: NSOperation {
let photoRecord: PhotoRecord
init(photoRecord: PhotoRecord) {
self.photoRecord = photoRecord
}
override func main () {
if self.cancelled {
return
}
if self.photoRecord.state != .Downloaded {
return
}
if let filteredImage = self.applySepiaFilter(self.photoRecord.image!) {
self.photoRecord.image = filteredImage
self.photoRecord.state = .Filtered
}
}
}
```
Это выглядит похожим на операцию загрузки, за исключением применения фильтра к изображению **(с помощью еще нереализованного метода, отсюда и ошибка компилятора)** вместо его загрузки.
Добавить отсутствующий метод **ImageFiltration** который будет обрабатывать изображение в класс:
```
func applySepiaFilter(image:UIImage) -> UIImage? {
let inputImage = CIImage(data:UIImagePNGRepresentation(image)!)
if self.cancelled {
return nil
}
let context = CIContext(options:nil)
let filter = CIFilter(name:"CISepiaTone")
filter!.setValue(inputImage, forKey: kCIInputImageKey)
filter!.setValue(0.8, forKey: "inputIntensity")
let outputImage = filter!.outputImage
if self.cancelled {
return nil
}
let outImage = context.createCGImage(outputImage!, fromRect: outputImage!.extent)
let returnImage = UIImage(CGImage: outImage)
return returnImage
}
```
Обработка изображения — та же реализация, которую мы использовали ранее в **ListViewController**. Она была перемещена сюда, чтобы ее можно было использовать как отдельную операцию в фоновом режиме. Опять же, Вы должны проверять на отмену часто; со временем вы будете делать это на автомате до и после любого вызова метода. После окончания действия, Вы установите значения экземпляра фото записи.
**Отлично!** Теперь у вас есть все инструменты и основа, которые Вам понадобятся для того, чтобы выполнить операции как фоновые задачи. Пора вернуться к контроллеру представления и изменить его, чтобы воспользоваться всеми этими новыми преимуществами.
Перейдите к **ListViewControllerи** удалите объявления свойств **lazy var photos**. Затем добавьте следующие объявления вместо этого:
```
var photos = [PhotoRecord]()
let pendingOperations = PendingOperations()
```
Они будут содержать массив объектов **PhotoDetails**, которые Вы создали ранее, и объект **PendingOperations** для управления операциями.
Добавьте новый метод к классу, чтобы загрузить список фотографий:
```
func fetchPhotoDetails() {
let request = NSURLRequest(URL:dataSourceURL!)
UIApplication.sharedApplication().networkActivityIndicatorVisible = true
NSURLConnection.sendAsynchronousRequest(request, queue: NSOperationQueue.mainQueue()) {response,data,error in
if data != nil {
let datasourceDictionary = (try! NSPropertyListSerialization.propertyListWithData(data!, options:NSPropertyListMutabilityOptions.MutableContainersAndLeaves, format: nil)) as! NSDictionary
for(key, value) in datasourceDictionary {
let name = key as? String
let url = NSURL(string:value as? String ?? "")
if name != nil && url != nil {
let photoRecord = PhotoRecord(name:name!, url:url!)
self.photos.append(photoRecord)
}
}
self.tableView.reloadData()
}
if error != nil {
let alert = UIAlertView(title:"Oops!",message:error!.localizedDescription, delegate:nil, cancelButtonTitle:"OK")
alert.show()
}
UIApplication.sharedApplication().networkActivityIndicatorVisible = false
}
}
```
Этот метод создает асинхронный запрос, который, по окончанию, выполнит комплишен блок в основном потоке. Когда загрузка завершена, данные будут извлечены из **NSDictionary** и затем будет снова обработан в массив объектов **PhotoRecord**. Вы не использовали **NSOperation** непосредственно, но вместо этого Вы получили доступ к основной очереди, используя **NSOperationQueue.mainQueue()**.
Вызовите новый метод в конце **viewDidLoad**:
```
fetchPhotoDetails ()
```
Затем, найдите метод **tableView(\_:cellForRowAtIndexPath:)** и замените следующей реализацией:
```
override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCellWithIdentifier("CellIdentifier", forIndexPath: indexPath)
//1
if cell.accessoryView == nil {
let indicator = UIActivityIndicatorView(activityIndicatorStyle: .Gray)
cell.accessoryView = indicator
}
let indicator = cell.accessoryView as! UIActivityIndicatorView
//2
let photoDetails = photos[indexPath.row]
//3
cell.textLabel?.text = photoDetails.name
cell.imageView?.image = photoDetails.image
//4
switch (photoDetails.state){
case .Filtered:
indicator.stopAnimating()
case .Failed:
indicator.stopAnimating()
cell.textLabel?.text = "Failed to load"
case .New, .Downloaded:
indicator.startAnimating()
if (!tableView.dragging && !tableView.decelerating) {
self.startOperationsForPhotoRecord(photoDetails, indexPath: indexPath)
}
}
return cell
}
```
Найдите время и прочитайте объяснения отмеченных разделов ниже:
1. Чтобы предоставить обратную связь пользователю, создайте **UIActivityIndicatorView** и установите ее в качестве представление аксессуара ячейки.
2. Источник данных содержит экземпляры **PhotoRecord**. Выберите один правильный, основываясь на текущей строке indexPath.
3. Текстовая метка ячейки — (почти) всегда одинакова, и изображение устанавливается соответственно на **PhotoRecord**, поскольку она обрабатывается, таким образом, Вы можете установить их обоих здесь, независимо от состояния записи.
4. Осмотрите запись. Настройте индикатор активности и текст по мере необходимости, и начните операции (еще не реализованные).
Вы можете удалить реализацию метода **applySepiaFilter**, так как его не нужно будет больше вызывать. Добавьте следующий метод к классу, чтобы начать операции:
```
func startOperationsForPhotoRecord(photoDetails: PhotoRecord, indexPath: NSIndexPath){
switch (photoDetails.state) {
case .New:
startDownloadForRecord(photoDetails, indexPath: indexPath)
case .Downloaded:
startFiltrationForRecord(photoDetails, indexPath: indexPath)
default:
NSLog("do nothing")
}
}
```
Здесь, вы передадите экземпляр **PhotoRecord** вместе с индексом. В зависимости от состояния фото Вы начнете загрузку фотографий или применение фильтра к изображению.
**Примечание:** *методы загрузки и применения фильтра к изображению реализуются отдельно, так как есть вероятность того, что в то время как изображение загружается, пользователь может далеко его прокрутить, а вы не еще применили фильтр изображения. Так что в следующий раз, когда пользователь зайдет на той же ряд, вам не нужно повторно загружать изображение; вам нужно только применить фильтр к изображению! Эффективность рулит!*
Теперь Вы должны реализовать методы, которые Вы вызывали в методе выше. Помните, что Вы создали пользовательский класс, **PendingOperations**, чтобы отслеживать операции; теперь принимайтесь за использование! Добавьте следующие методы к классу:
```
func startDownloadForRecord(photoDetails: PhotoRecord, indexPath: NSIndexPath){
//1
if let _ = pendingOperations.downloadsInProgress[indexPath] {
return
}
//2
let downloader = ImageDownloader(photoRecord: photoDetails)
//3
downloader.completionBlock = {
if downloader.cancelled {
return
}
dispatch_async(dispatch_get_main_queue(), {
self.pendingOperations.downloadsInProgress.removeValueForKey(indexPath)
self.tableView.reloadRowsAtIndexPaths([indexPath], withRowAnimation: .Fade)
})
}
//4
pendingOperations.downloadsInProgress[indexPath] = downloader
//5
pendingOperations.downloadQueue.addOperation(downloader)
}
func startFiltrationForRecord(photoDetails: PhotoRecord, indexPath: NSIndexPath){
if let _ = pendingOperations.filtrationsInProgress[indexPath]{
return
}
let filterer = ImageFiltration(photoRecord: photoDetails)
filterer.completionBlock = {
if filterer.cancelled {
return
}
dispatch_async(dispatch_get_main_queue(), {
self.pendingOperations.filtrationsInProgress.removeValueForKey(indexPath)
self.tableView.reloadRowsAtIndexPaths([indexPath], withRowAnimation: .Fade)
})
}
pendingOperations.filtrationsInProgress[indexPath] = filterer
pendingOperations.filtrationQueue.addOperation(filterer)
}
```
Хорошо! Вот краткий список, чтобы убедиться, что вы понимаете, что происходит в коде который вы добавили только что:
1. Прежде всего, проверьте на наличие конкретного **indexPath** чтобы увидеть, есть ли уже операция в **downloadsInProgress** для него. Если это так, проигнорируйте его.
2. Если нет, создайте экземпляр **ImageDownloader**, используя указываемый инициализатор.
3. Добавьте блок завершения, который будет выполняться, когда операция будет завершена. Это — неплохое место, где могла бы завершиться операция. Важно отметить, что блок завершения выполняется, даже если операция отменена, таким образом, Вы должны проверить это свойство в первую очередь. Вы также не знаете точно, через который поток перенаправляется завершения блока, таким образом, Вы должны использовать **GCD**, чтобы инициировать перезагрузку табличного представления на основном потоке.
4. Добавьте операцию к **downloadsInProgress**, чтобы отслеживать действия.
5. Добавьте операцию в очередь загрузки. Таким образом, вы запускаете операции – очередь следит за планированием, как только Вы добавляете операцию.
Метод применения фильтра к изображениям происходит таким же образом, за исключением использования **ImageFiltration** и **filtrationsInProgress** для отслеживания операции. В качестве упражнения, вы можете попробовать избавиться от дублирования кода в этой секции.
**Поздравляю!** Ваша работа завершена. Скомпилируйте и запустите приложение, и Вы увидите сделанные улучшения в действии! При прокрутке таблицы, приложение не будет больше притормаживать, и начнете загружать изображения и применять фильтры к ним, как только они будут загружены, и отображаемым ячейкам.
Разве это не круто? Всего немного усилий и приложение стало более отзывчивым – и пользователь получит море положительных эмоций!
**Тонкая настройка**
Вы узнали много полезного из этой статьи! Ваш небольшой проект стал более отзывчивым и показывает лучшую производительность по сравнению с оригинальной версией. Однако есть все еще некоторые маленькие детали, над которыми еще нужно поработать. Вы же хотите стать великим программистом, не только хорошим!
Вы, возможно, заметили, что при прокрутке таблицы, ячейки которые ушли с поля видимости все еще загружаются и причиняют фильтр к изображению. Если вы прокрутите быстро, приложение будет занято загрузкой и фильтрацией изображения для ячеек дальше по списку, даже если они не видны. В идеале, приложение должно отменить операцию для ячеек которые не видны и дать приоритет ячейкам, которые отображаются в данный момент.
Разве Вы не реализовали методы для отмены загрузки и наложения фильтра в своем коде? Да, Вы сделали это — теперь Вам следует использовать их!
Вернитесь к **Xcode** и откройте файл **ListViewController**. Перейдите к реализации метода **tableView(\_:cellForRowAtIndexPath:)**, и перенесите вызов метода **startOperationsForPhotoRecord** с использование логического оператор следующим образом:
```
if (!tableView.dragging && !tableView.decelerating) {
self.startOperationsForPhotoRecord(photoDetails, indexPath: indexPath)
}
```
Вы сообщаете таблице запустить операции, только если таблица не скроллится. На самом деле, это свойства класса **UIScrollView**, и потому что класс **UITableView** является наследником **UIScrollView**, он автоматически наследуете эти свойства.
Затем добавьте реализацию следующего метода делегата **UIScrollView** в классе:
```
override func scrollViewWillBeginDragging(scrollView: UIScrollView) {
//1
suspendAllOperations()
}
override func scrollViewDidEndDragging(scrollView: UIScrollView, willDecelerate decelerate: Bool) {
// 2
if !decelerate {
loadImagesForOnscreenCells()
resumeAllOperations()
}
}
override func scrollViewDidEndDecelerating(scrollView: UIScrollView) {
// 3
loadImagesForOnscreenCells()
resumeAllOperations()
}
```
Быстрое пошаговое руководство вышеупомянутого кода показывает следующее:
1. Как только пользователь начинает прокручивать, Вы захотите приостановить все операции и взглянуть на то, что хочет видеть пользователь. Вы осуществите suspendAllOperations через минуту.
2. Если значение замедления ложное, то значит, что пользователь прекратил перетаскивать табличное представление. Поэтому необходимо возобновить приостановленные операции, отменить операций для внеэкранных ячеек, и начать операции для экранных ячеек. Вы будете осуществлять loadImagesForOnscreenCells и resumeAllOperations через некоторое время также.
3. Этот метод делегата сообщит Вам, что табличное представление прекратило прокручиваться, так что вам нужно опять следовать пункту #2.
Теперь добавьте реализацию этих недостающих методов к ListViewController.swift:
```
func suspendAllOperations () {
pendingOperations.downloadQueue.suspended = true
pendingOperations.filtrationQueue.suspended = true
}
func resumeAllOperations () {
pendingOperations.downloadQueue.suspended = false
pendingOperations.filtrationQueue.suspended = false
}
func loadImagesForOnscreenCells () {
//1
if let pathsArray = tableView.indexPathsForVisibleRows {
//2
var allPendingOperations = Set(pendingOperations.downloadsInProgress.keys)
allPendingOperations.unionInPlace(pendingOperations.filtrationsInProgress.keys)
//3
var toBeCancelled = allPendingOperations
let visiblePaths = Set(pathsArray)
toBeCancelled.subtractInPlace(visiblePaths)
//4
var toBeStarted = visiblePaths
toBeStarted.subtractInPlace(allPendingOperations)
// 5
for indexPath in toBeCancelled {
if let pendingDownload = pendingOperations.downloadsInProgress[indexPath] {
pendingDownload.cancel()
}
pendingOperations.downloadsInProgress.removeValueForKey(indexPath)
if let pendingFiltration = pendingOperations.filtrationsInProgress[indexPath] {
pendingFiltration.cancel()
}
pendingOperations.filtrationsInProgress.removeValueForKey(indexPath)
}
// 6
for indexPath in toBeStarted {
let indexPath = indexPath as NSIndexPath
let recordToProcess = self.photos[indexPath.row]
startOperationsForPhotoRecord(recordToProcess, indexPath: indexPath)
}
}
}
```
**suspendAllOperations** и **resumeAllOperations** имеют простейшую реализацию. **NSOperationQueues** может быть приостановлен, установив свойство **suspended** к **true**. Оно будет приостанавливать все операции в очереди, и Вы не сможете приостановить операции индивидуально.
**loadImagesForOnscreenCells** немного более сложен. Вот что происходит:
1. Начните с массива, содержащего индексные пути всех видимых строк в данный момент в табличном представлении.
2. Создайте ряд всех незаконченных операций, объединив все загрузки + все фильтры.
3. Создайте ряд всех индексных путей с операциями, которые будут отменены. Начните со всех операций, и затем удалите индексные пути видимых строк. Это оставит набор операций, включающих внеэкранныее строки.
4. Создайте ряд индексных путей, которым нужны их запущенные операции. Начните со всех видимых строк индексных путей, и затем удалите те, где операции ждут своей очереди
5. Пройдитесь в цикле по тем операциям, которые будут отменены, отмените их, и удалите их ссылку с PendingOperations.
6. Пройдитесь в цикле по тем операциям, которые будут запущены, и вызовите startOperationsForPhotoRecord для каждой из них.
Скомпилируйте и запустите приложение, и у вас должно получиться еще более отзывчивое и лучшее в управлении ресурсами приложения!
Заметьте, что, когда Вы заканчиваете скроллить таблицу, изображения на видимых ячейках сразу же обрабатываться.
**И что же дальше?**
[Это «финальная» версия проекта на Swift 1.2.](http://cdn2.raywenderlich.com/wp-content/uploads/2014/10/ClassicPhotos-Final63.zip) b и [Swift 2.0](https://github.com/yarmolchuk/ClassicPhotos-Final)
Если Вы завершили этот проект и уделили время, чтобы действительно понять его, тогда поздравляем! Вы можете считать себя намного более ценным **iOS** разработчиком, чем Вы были в начале этой статьи! Большинство компаний, которые специализируются на разработке аппаратного обеспечения, могут гордиться, если у них есть один или два человека, которые действительно знаются на этом.
Но будьте осторожны, безвозмездное использование многопоточности может сделать проект нечитаемым для других разработчиков, которые должны будут поддерживать ваш код. Потоки могут представлять трудно находимые ошибки в программе, которые могут никогда не появляться, пока к Вас хороший интернет, или код запущен на более быстром (или медленном) устройстве. Тестируйте очень тщательно, и всегда использует **Инструменты** (или Ваши собственные наблюдения), чтобы проверить, что представление потоков действительно улучшились.
Полезная функция для операций, о которой здесь не рассказывается, является зависимость. Вы можете сделать операцию зависящей от одной или более других операций. Эта операция не запустится, пока операции, от которых она зависит, не завершатся. Например:
```
// MyDownloadOperation is a subclass of NSOperation
let downloadOperation = MyDownloadOperation()
// MyFilterOperation is a subclass of NSOperation
let filterOperation = MyFilterOperation()
filterOperation.addDependency(downloadOperation)
```
Для удаления зависимости:
```
filterOperation.removeDependency(downloadOperation)
```
Можно ли упростить и улучшить код в этом проекте с помощью зависимостей? Примените Ваши навыки на практике и испробуйте это сделать. **Важно отметить, что зависимая операция все равно будет запускаться, даже если операции, от которых она зависит, будут отменены, а также если они завершатся естественно.** Вы должны принять это во внимание. | https://habr.com/ru/post/267843/ | null | ru | null |
# Helmwave v0.12.8
Прошло уже 8 месяцев с момента первой и пока единственной статьи о инструменте для композинга helm чартов – [helmwave](https://github.com/helmwave/helmwave).
За это время:
* Преодолели планку в 100 звезд;
* Вышло 7 минорных обновлений;
* Появился сайт с документацией;
* Перешли на goreleaser.
Поэтому цель статьи:
* прервать молчание;
* рассказать о новых возможностях;
* поделиться примерами;
* набрать звёздочек на Github;
* рассказать про планы на будущее.
### Ломая совместимость
Добравшись до 0.11.0 версии. Пришло осознание что так больше продолжаться не может. Все версии до 0.5.0 были проверкой гипотезы. Версия 0.5.0 стала отличным инструментом. Который очень быстро начал обрастать дополнительными фичами. И начиная с 0.12.0 у нас новый ямл для конфигурации.
**Было**
```
version: 0.9.6
project: my-project
releases:
- name: my-release
chart: my-chart-repo/my-app
values:
- values.yml
options:
install: true
namespace: my-namespace
```
**Стало**
```
version: 0.12.8
project: my-project
releases:
- name: my-release
chart:
name: my-chart-repo/my-app
values:
- values.yml
namespace: my-namespace
createnamespace: true
```
Поэтому пришлось разделить документацию на до и после.
Также обновился cli. Мы пошли по пути упрощения. И в последних релизах еще избавились от алиасов для команд.
| Было | Стало |
| --- | --- |
| `helmwave render` | `helmwave yml` |
| `helmwave deploy` | `helmwave up` |
| `helmwave plan $sub` | `helmwave build` |
| `helmwave planfile` | `helmwave build` |
**В планах:**
* `helmwave up --build` Опции для билда и поднятия одновременно.
* Вероятно будем избавляться от helmwave.yml.tpl. В пользу только helmwave.yml
### Features
#### Create Namespace с 0.12.x
Раньше helmwave всегда создавал namespace в kubernetes. Теперь эту опцию можно выключить.
```
createnamespace: false
```
#### Plan Diff с 0.12.x
Helmwave сверяет новый план с предыдущим.
**Какие изменения отслеживает plan diff?**
* Видит изменение в манифестах. Это удается достичь благодаря [helm-diff](https://github.com/databus23/helm-diff);
* Отслеживает новые релизы в списке;
* Показывает `warning` если релиз не найден в списке. Позволяет не терять релизы.
Запрос на эту фичу мы получили в нашем телеграм [чате](https://t.me/helmwave).
Открыть asciinema cast
https://asciinema.org/a/433171**Планы:**
* Добавить diff с live-окружением.
#### Remote values с 0.11.x
helmwave теперь умеет забирать values для чартов удаленно.
Какие схемы поддерживаются?
* Пока только http.
```
version: 0.12.8
repositories:
- name: bitnami
url: https://charts.bitnami.com/bitnami
releases:
- name: nginx
chart:
name: bitnami/nginx
namespace: test
values:
- https://raw.githubusercontent.com/helmwave/helmwave/main/tests/06_values.yaml
```
**Планы:**
* Новые схемы s3/consul/etc
* remote helmwave.yml
#### depends\_on c 0.9.x
Позволяет указать последовательность установки релизов. Примерно как в docker-compose.
> Допустим есть 4 приложения. И нужно установить их в следующей последовательности.
>
>
Соответсвенно helmwave.yml будет иметь следующий вид:
```
version: 0.12.8
.options: &options
createnamespace: true
namespace: my-namespace
releases:
- name: queue
chart:
name: some/queue
<<: *options
- name: db
chart:
name: some/db
<<: *options
- name: backend
chart:
name: some/backend
<<: *options
depends_on:
- db@my-namespace
- queue@my-namespace
- name: frontend
chart:
name: some/frontend
<<: *options
depends_on:
- backend@my-namespace
```
Как видно из кода выше. Формат зависимостей – `$RELEASE_NAME@$NAMESPACE`.
#### Graph view
После того как добавили `depends_on`. Была добавленна возможность увидеть в консоли порядок деплоя.
Помимо этого. Граф также сохраняется в формате markdown в директории плана.
```
cat .helmwave/graph.md
# Depends On
...
```
#### Kubedog с 0.8.x
[Kubedog](https://github.com/werf/kubedog) – библиотека коллег из [Фланта](https://habr.com/ru/company/flant/blog/434160/) для отслеживания ресурсов в kubernetes.
Kubedog глубоко уходит корнями в werf и logboek. Ворфлоу с аннотациями здесь такой же как в [werf](https://werf.io/documentation/v1.2/reference/deploy_annotations.html#show-service-messages): *Просто добавляете нужную аннотацию к ресурсу.*
```
apiVersion: apps/v1
kind: Deployment
...
spec:
template:
metadata:
annotations:
helmwave.dev/show-service-messages: "true"
...
```
**Планы:**
* Новые аннотации.
* Более стабильная работа. На текущий момент нужно включать этот функционал отдельно.
### Что дальше?
Проект тесно связан с helm. Если появится новый функционал в helm, то будем стараться приносить его и в helmwave.
**Пока планируем сфокусироваться на базовых вещах:**
* Больше документации <https://helmwave.github.io/docs/>;
* Больше интеграционных-тестов;
* Больше стабильности. | https://habr.com/ru/post/575646/ | null | ru | null |
# Backbone.js для «чайников»
Как то поздним вечерком мне пришла мысль изучить Backbone.js и привязать его к уже написанному на jQuery сервису. Сервис уже серьёзно расширился и меня достало это нагромождение обработчиков кликов, запросов и логики. Поэтому, я как усердный школьник полез в официальную документацию. Но либо я тупой, либо мой английский меня подкачал, либо то и другое вместе, но я не черта не понял. Я прочитал уже второй раз, внимательно, и для особо одарённых мест использовал google translate. Прочитал также и пример ToDo List. Всё показалось понятно, ровно до той поры пока я не стал писать. После чего я взял всё что нашел по этой библиотеке, как на английском так и [переводы](http://habrahabr.ru/blogs/javascript/118782/). Прочтя кипу документации я решил, что сейчас вроде всё понял. Я напрягся, но… Не вышел каменный цветок у мастера Данилы, т.е. вышло, но это явно был не цветок, и камень как то неправильно пах. Тогда, как прилежный ученик, я решил написать «Hello, ~~Kitty~~World» с нуля. Попутно комментируя и сохраняя шаги в hg, у меня получилось введение в backbone.js framework для таких как я, особо одарённых.
#### Задача.
Выберем простую задачу. Написать Hello, World? Слишком просто, также как и написать Hello, <имярёк>. Может напишем клиент GTD с авторизацией и оффлайн хранилищем? Такое уже есть и оно не помогает понять нашу “хребтовую кость”. Сделаем проще. Создадим страницу с 3 состояниями. В первом состоянии человек вводит имя пользователя, во втором состоянии его поздравляют, если введённое имя найдено, в третьем состоянии огорчают, если имя не найдено. По-моему, данная задача учебней и проще некуда, да и в общем позволит посмотреть и проверить почти всё что есть в backbone.
Все шаги сохраним через [mercurial](http://mercurial.selenic.com/). Поэтому, читая какой либо шаг вы можете распаковать [zip архив](http://narod.ru/disk/22868808001/backbone%20%D0%B4%D0%BB%D1%8F%20%D1%87%D0%B0%D0%B9%D0%BD%D0%B8%D0%BA%D0%BE%D0%B2.zip.html) (+ [dropbox](http://dl.dropbox.com/u/2183289/backbone%20%D0%B4%D0%BB%D1%8F%20%D1%87%D0%B0%D0%B9%D0%BD%D0%B8%D0%BA%D0%BE%D0%B2.zip), если на народе удалят), зайти в каталог и перейти на нужную ревизию при помощи команды
```
hg update --rev <номер ревизии>
```
После чего посмотреть на код и понять то, что вам не понятно :)
#### Шаг 0. Структура и шаблон (rev 0)
Структуру будем использовать академическую, такую как на картинке. Сознаюсь, я не знаю кто автор этой священной пули, у кого я слизал эту корову, но использую во всех заготовках. Один файл index.html. В папке css лежат стили, в папке i лежат картинки, в js — скрипты. Одновременно закинем в скрипты jquery, underscore и backbone к скриптам.
Шаблон html — пустая страничка. Т.е. страничка с пустым body и подключенными скриптами и стилем.
Т.е. как вы видите, в отличии от некоторых современных javascript mvc framework проект не требует особого подготовления, поэтому уже существующий проект может быть “переписан” на backbone.
#### Шаг 1. Начальная вёрстка (rev 1)
Наша страница, в соответствии с задачей, должна иметь 3 состояния: ввод имени пользователя, состояние при удачном сравнении, состояние при неудачном сравнении. Для начала сверстаем 3 дива, каждому состоянию по своему месту.
```
Имя пользователя:
Ошибка такой пользователь не найден.
Пользователь найден.
```
Блоки #error и #success скроем от глаз подальше при помощи CSS.
```
#error, #success
{
...
display: none;
}
```
На этом шаге мы полностью подготовили всё для внедрения backbone. Эти шаги идентичные для многих реализаций одностраничных сайтов.
#### Шаг 2. Внедряем Router (rev 2)
Раньше до 0.5.0 этот класс звали Controller. Его назначение обработка хеш навигации в приложении. Т.е. он никогда не был в полном понимании контроллером, просто хеш навигация это контроллер приложения. Видно логика разработчиков взяла верх и теперь мы имеем класс Router.
Что такое location.hash для чего он используется, и как его использовать правильно вы можете прочитать на хабре ([тут](http://habrahabr.ru/blogs/javascript/123106/), [тут](http://habrahabr.ru/blogs/AJAX/114911/) или [тут](http://habrahabr.ru/search/?q=location.hash&target_type=posts)).
Для начала, на время создадим импровизированное меню в index.html
```
* [Start](#!/)
* [Success](#!/success)
* [Error](#!/error)
```
А потом легким движением руки добавляем работу роутинга в пример:
```
var Controller = Backbone.Router.extend({
routes: {
"": "start", // Пустой hash-тэг
"!/": "start", // Начальная страница
"!/success": "success", // Блок удачи
"!/error": "error" // Блок ошибки
},
start: function () {
$(".block").hide(); // Прячем все блоки
$("#start").show(); // Показываем нужный
},
success: function () {
$(".block").hide();
$("#success").show();
},
error: function () {
$(".block").hide();
$("#error").show();
}
});
var controller = new Controller(); // Создаём контроллер
Backbone.history.start(); // Запускаем HTML5 History push
```
Вот таким простым кодом мы создали простейший tab-орентированный сайт с возможностью делать закладки на страницы.
#### Шаг 3. Простейшее View (rev 3)
View в backbone это смесь контроллера и View из стандартной MVC модели. Можно сказать проще, View тут это widget/component на странице, который умеет себя отображать, реагировать на события и создавать события. Будем наедятся, что создатели задумаются и переименуют View в Widget (или component), как ранее они сделали с Router.
У нас есть сформировавшийся widget проверки имени пользователя, это блок start. Давайте сделаем так, что если введено имя “test”, то перейдём на хеш тег #!/success, который покажет блок success. А если введено что-то иное, то перейдём на хеш тег #!/error, который покажет, соответственно, блок error. Кстати, заодним уберем меню, оно нам больше не понадобится.
```
var Start = Backbone.View.extend({
el: $("#start"), // DOM элемент widget'а
events: {
"click input:button": "check" // Обработчик клика на кнопке "Проверить"
},
check: function () {
if (this.el.find("input:text").val() == "test") // Проверка текста
controller.navigate("success", true); // переход на страницу success
else
controller.navigate("error", true); // переход на страницу error
}
});
var start = new Start();
```
Кстати, вы заметили, что после того, как вы перешли на страницу результата, вы можете спокойно вернуться назад нажав кнопку Backspace? Это магия хеш навигации.
#### Ремарка. JQuery way (rev 4)
Вы заметили сколько кода мы уже написали? Я так и думаю, многие уже из тех кто дочитал до этого предложения ~~получат коньяк~~ воскликнули: “На jQuery это делается быстрее и проще”. Не спорю. Код который надо написать на начальную вёрстку очень прост:
```
$("#start input:button").click(function () { // Обработчик нажатия кнопки
var username = $("#username").val(); // Получаем значение введенное пользователем
$("#start").hide(); // Скрываем основной экран
if (username == "test")
$("#success").show(); // Показываем успех
else
$("#error").show(); // Показываем ошибку
});
```
Но… Данный код не поддерживает хеш навигацию, плохо расширяется и очень плохо поддерживается.
Не для кого не секрет, что программист в своей работе занимается созданием новых приложений всего 20% времени. 80% же своего времени он состыкует модули, занимается исправлением ошибок и расширяет функционал уже созданных проектов. А поддержка jQuery лапши может очень дорого стоить. Очевидный способ избежать геморроя на пальцах, это заняться декомпозицией проектов, для чего в основном изобретают велосипеды. Backbone уже готовый велосипед. Зачем придумывать что то новое, когда за вас это сделал добрый дядя?
#### Шаг 4. Работа со View через Template (rev 5)
View было бы не View, а контролером, если бы не умела себя отображать. В backbone нет своего механизма для этого. Смешно? Нисколько… Его назначение не давать инструмент для создания приложения, а дать шаблон, используя который можно было бы создать максимально поддерживаемую систему. Поэтому в backbone можно использовать различные template движки. Например, встроенный в underscore.js движок от John Resig. Или подключить Microsoft Template. А если хитрожопно извернуться то можно реализовать всё через Knockout.js (хотя меня напрягает его свалка логики и шаблонов)
Мы не будем напрягаться и просто используем \_.template из underscore.js для реализации своих идей. Для этого создадим один пустой блок на странице, а все “наполнители” вынесем в шаблоны. Соответственно изменятся и стили страницы.
```
<div class="start">
<div class="userplace">
<label for="username">Имя пользователя: </label>
<input type="text" id="username" />
</div>
<div class="buttonplace">
<input type="button" value="Проверить" />
</div>
</div>
<div class="error">
Ошибка. Пользователь <%= username %> не найден.
<a href="#!/">Go back</a>
</div>
<div class="success">
Пользователь <%= username %> найден.
<a href="#!/">Go back</a>
</div>
```
Для того чтобы показать динамику, мы добавили в шаблоны результатов имя пользователя.
Хранить имя пользователя и передавать его в шаблон мы будем в переменной AppState
```
var AppState = {
username: ""
}
```
Напишем View для каждого шаблона.
```
var Views = { };
var Start = Backbone.View.extend({
el: $("#block"), // DOM элемент widget'а
template: _.template($('#start').html()),
events: {
"click input:button": "check" // Обработчик клика на кнопке "Проверить"
},
check: function () {
AppState.username = this.el.find("input:text").val(); // Сохранение имени пользователя
if (AppState.username == "test") // Проверка имени пользователя
controller.navigate("success", true); // переход на страницу success
else
controller.navigate("error", true); // переход на страницу error
},
render: function () {
$(this.el).html(this.template());
}
});
var Success = Backbone.View.extend({
el: $("#block"), // DOM элемент widget'а
template: _.template($('#success').html()),
render: function () {
$(this.el).html(this.template(AppState));
}
});
var Error = Backbone.View.extend({
el: $("#block"), // DOM элемент widget'а
template: _.template($('#error').html()),
render: function () {
$(this.el).html(this.template(AppState));
}
});
Views = {
start: new Start(),
success: new Success(),
error: new Error()
};
```
***Замечание.** У нас 3 View сылаются на один и тот же DOM элемент. В реальности такого быть не должно. Логически, это должен быть один widget. Я сознательно неверно спроектировал данный шаг, для того чтобы показать возможность работы нескольких View. Позднее я покажу как избежать данный прокол.*
Контроллер тоже претерпит небольшие изменения
```
var Controller = Backbone.Router.extend({
routes: {
"": "start", // Пустой hash-тэг
"!/": "start", // Начальная страница
"!/success": "success", // Блок удачи
"!/error": "error" // Блок ошибки
},
start: function () {
if (Views.start != null) {
Views.start.render();
}
},
success: function () {
if (Views.success != null) {
Views.success.render();
}
},
error: function () {
if (Views.error != null) {
Views.error.render();
}
}
});
```
Вот таким образом мы добавили динамики к нашему приложению.
#### Шаг 5. Проверка на несколько пользователей (rev 6)
Самым простым способом проверки не только на test, но и на других пользователей, это проверка на нахождения имени в массиве пользователей.
Создадим массив Family, в который и забьем все имена.
```
var Family = ["Саша", "Юля", "Елизар"]; // Моя семья
```
А проверку сделаем в коде вьюшки Start. Т.к. underscore уже включено в приложение, сделаем через \_.detect
```
...
if (_.detect(Family, function (elem) { return elem == AppState.username })) // Проверка имени пользователя
...
```
Какие проблемы есть у данного решения? Основная проблема в том, что если завтра нам нужно будет сменить физическое расположение массива пользователей (сервер, localstore и т.д.), то нам придётся менять логику работы View. Т.е. View настолько завязана на метод доступа к данным, что придётся менять его код при малейшем чихе.
#### Ремарка 2. jQuery way. Продолжение (rev 7)
А намного ли кода нам пришлось добавить в jQuery код чтобы поддерживать нескольких пользователей? Очень мало:
```
$(function () {
var Family = ["Саша", "Юля", "Елизар"];
$("#start input:button").click(function () { // Обработчик нажатия кнопки
var username = $("#username").val(); // Получаем значение введенное пользователем
$("span.username").text(username);
$("#start").hide(); // Скрываем основной экран
$("#" + ($.inArray(username, Family) != -1 ? "success" : "error")).show();
});
$("#error a, #success a").click(function () {
$(".block").hide();
$("#start").show();
});
});
```
Ну и соответственно подправить вёрстку макета:
```
...
Ошибка. Пользователь не найден.
[Go back](javascript:void(0);)
Пользователь найден.
[Go back](javascript:void(0);)
...
```
Помните я говорил, что то про поддержку, 80/20% и прочую муть? Так вот. Забудьте. Для данного приложения нет ничего постыдного написать код в стиле jQuery way. Вы потратите времени в 10-20 раз меньше, чем писать это всё через Backbone. А размеры кода позволяют поддерживать это приложение хоть ночью после пол-литры. Нет ничего постыдного писать таким способом и зарабатывать свои $5. Кто не согласен, пусть засунет своё мнение в комментарий.
Я люблю повторять фразу, что все framework’и служат 2 целям, делать из миллиардного проекта, проект на миллион, и из проекта за $100 — проект на пару миллионов. Пользуетесь тем что эффективнее сэкономит ваше время и деньги.
#### Шаг 6. Контроллер приложения через Модель (rev 8)
Замечательная функция Backbone это возможность связать модель и представление. Если создать представление с параметром model, то в методе initialize представления можно подписаться на возникновение события изменения модели. После чего, View будет получать сообщения, при каждом изменении модели либо ее части. И уже на это сообщение привязать определенное поведение предоставления, например полную либо частичную его перерисовку.
Помните я говорил, что некрасиво, когда один и тот же блок обрабатывается несколькими View. Попробуем отвязаться от этого засилья обработчиков.
Для начала, из объекта AppState создадим модель, которая будет содержать имя пользователя и состояние приложения:
```
var AppState = Backbone.Model.extend({
defaults: {
username: "",
state: "start"
}
});
var appState = new AppState();
```
Вторым шагом, удалим вьюшки Success и Error, а view Start переименуем в Block, т.к. она будет обрабатывать несколько состояний, а не только стартовое. Во оставшимся view переименуем поле template в templates в котором будут храниться все шаблоны для различных состояний
```
var Block = Backbone.View.extend({
templates: { // Шаблоны на разное состояние
"start": _.template($('#start').html()),
"success": _.template($('#success').html()),
"error": _.template($('#error').html())
},
```
В инициализаторе представления подпишемся на событие изменения модели. На данное событие повесим перерисовку блока.
```
initialize: function () { // Подписка на событие модели
this.model.bind('change', this.render, this);
},
```
Функция перерисовки (render) будет “отрисовывать” нашу главную модель соответствующим шаблоном, зависящим от поля state модели:
```
render: function () {
var state = this.model.get("state");
$(this.el).html(this.templates[state](this.model.toJSON()));
return this;
}
```
Изменится также функция check. Она будет устанавливать соответствующие поля модели:
```
check: function () {
var username = this.el.find("input:text").val();
var find = (_.detect(Family, function (elem) { return elem == username })); // Проверка имени пользователя
appState.set({ // Сохранение имени пользователя и состояния
"state": find ? "success" : "error",
"username": username
});
},
```
Кстати, после всех этих дел у нас ничего не отобразится, т.к. модель была создана до того как мы описали View. Поэтому возбудим событие change уже после того как мы создадим View:
```
var block = new Block({ model: appState });
appState.trigger("change");
```
Если бы у нас не было бы хеш навигации, я бы закончил этот шаг. Но у нас полетела навигация. Восстановим её. Для этого перепишим код роутера.
```
var Controller = Backbone.Router.extend({
routes: {
"": "start", // Пустой hash-тэг
"!/": "start", // Начальная страница
"!/success": "success", // Блок удачи
"!/error": "error" // Блок ошибки
},
start: function () {
appState.set({ state: "start" });
},
success: function () {
appState.set({ state: "success" });
},
error: function () {
appState.set({ state: "error" });
}
});
```
Ручная навигация заработала, но при нажатии на кнопку Проверить не меняется хеш адреса страницы. Исправим этот досадный недостаток при помощи подписки на событие изменения поля state у модели:
```
appState.bind("change:state", function () { // подписка на смену состояния для контроллера
var state = this.get("state");
if (state == "start")
controller.navigate("!/", false); // false потому, что нам не надо
// вызывать обработчик у Router
else
controller.navigate("!/" + state, false);
});
```
События это отдельная песня в backbone. Простейшие события, DOM-события и события изменения модели или коллекции, могут переплетаться с событиями описанными пользователем, образуя чудесный винтаж объектно-орентированного и событийно-орентированного программирования. Советую изучить их прежде чем начинать использовать Backbone.js в своём проекте.
Вот и всё с самым большим рефакторингом в этом маленьком проекте. И на будущее, начинайте проектирование системы с моделей, а не с View как это сделал я и ваши волосы будут, просто будут.
#### Шаг 7. Проверка на несколько пользователей через коллекцию (rev 9)
То что мы реализовали на 5 шаге имеет свой недостаток. Мы смешали логику отображения с логикой управления данными. Мы не сможем сейчас просто, не перестраивая логику работы View, заменить наш массив на обращение к сервису. Именно для этих целей в Backbone используются коллекции.
Коллекция в данном framework’е это сортированный набор моделей, который умеет обращаться с этими моделями, фильтровать или сортировать их. Также коллекции умеют из коробки работать с сервисами по REST интерфейсу. Фактически это прослойка между widget’ом и способами доступа к базе данных.
Вернёмся от рассуждений к нашей задаче. Создадим модель UserNameModel. Единственным обязательным полем данной модели будет поле Name, которое по умолчанию имеет пустое значение.
```
var UserNameModel = Backbone.Model.extend({ // Модель пользователя
defaults: {
"Name": ""
}
});
```
Создадим коллекцию Family из моделей UserNameModel
```
var Family = Backbone.Collection.extend({ // Коллекция пользователей
model: UserNameModel,
});
```
Добавим в коллекцию метод проверки нахождения пользователя с указанным именем в данной коллекции
```
checkUser: function (username) { // Проверка пользователя
var findResult = this.find(function (user) { return user.get("Name") == username })
return findResult != null;
}
```
Создадим экземпляр коллекции Family
```
var MyFamily = new Family([ // Моя семья
{ Name: "Саша" },
{ Name: "Юля" },
{ Name: "Елизар" }
]);
```
После чего проверка пользователя во View сокращается до вызова метода проверки в экземпляре MyFamily
```
var find = MyFamily.checkUser(username); // Проверка имени пользователя
```
#### Вывод
В процессе статьи мы создали учебный проект, который ни фига не делает, но который не мой взгляд всесторонне охватывает данный framework. В результирующем файле примерно 200 строк кода. Это больше чем в варианте с jQuery, но это хорошие легко расширяемые строки. Объекты знают о друг друге необходимый минимум и не больше того.
Backbone на удивление оказался хорошим продуктом позволяющим построить хребет для своего сервиса. Он даёт платформу для создания одностраничных сервисов и различных крупных динамических приложений. Как уже показано в ремарках, использовать его иногда, на маленьких проектах, бывает невыгодно. Но как только мы разрастаемся, и сложность поддержки нашего приложение растёт по экспоненте, то используя backbone можно значительно сократить трудозатраты на поддержку, оставляя время для наработку нового функционала. | https://habr.com/ru/post/127049/ | null | ru | null |
# CVE-2017-5689 — уязвимость Intel AMT в подробностях
В начале 2017-го года Максим Малютин (Maksim Malyutin) из компании Embedi обнаружил уязвимость в Intel AMT, которая была официально оглашена Intel первого мая и получила номер CVE-2017-5689 (INTEL-SA-00075 в кодификации Intel). Уязвимости был присвоен тип «повышение прав» (Elevation of Privilege) и критический уровень опасности. Многие СМИ в ответ разразились заголовками что-то типа «серверные чипсеты Intel 9 лет имели уязвимость», видимо отталкиваясь от фразы «This vulnerability does not exist on Intel-based consumer PCs» в описании. Однако это не совсем так с переходом в совсем не так. Потому далее подробное техническое описание уязвимости, её реализация и, главное, способы защиты для систем, не имеющих обновления прошивки.
### Intel ME, AMT, ISM, SBT
Без углубления в подробности что такое технология Intel Active Management Technology (AMT), всё же, нужно отметить, что не стоит путать Intel ME и Intel AMT, т.к. AMT всего лишь один из модулей (условно говоря — плагин), работающий на «движке» Intel ME. Мажорная версия Intel ME меняется с каждым поколением процессоров, вместе с ней, меняется и мажорная версия Intel AMT. Затронуты уязвимостью все версии начиная с Intel AMT 6 (соответственно Intel ME 6 и выше) — вплоть до самых новых (Intel ME 11.6 на момент написания статьи).
Также нужно добавить, что Intel Standard Manageability (ISM) — это урезанная версия Intel AMT (с ограниченным функционалом, но это AMT), а вот Intel Small Business Technology (SBT) — это технология, которая использует функционал AMT для своей работы (неточное определение но в общем смысл такой), но ею никак не является (это другой, отдельный плагин в составе движка Intel ME).
### Hardware
Для поддержки Intel AMT требуется наличие трёх составляющих:
1. Поддержка AMT в чипсете
2. Поддержка AMT в процессоре
3. Поддержка AMT в BIOS
Только наличие всех трёх даёт полноценную поддержку Intel AMT. Грубо (без совсем старых и деления на мобильные/десктоп) чипсеты Intel можно поделить на:
1. Обычные — чипсеты Hxx и Zxx
2. Малый бизнес — чипсеты с Bxx
3. Бизнес/Корпоратив — чипсеты Qxx
4. «Для энтузиастов» — чипсеты Xxx
5. Серверные — чипсеты C2xx
Технологию Intel AMT поддерживают лишь чипсеты из 3-го и 5-го пункта, а технологию Intel SBT из 2-го — только этих сегментов касается уязвимость CVE-2017-5689. Если же уточнить, то из-за «непрямого» отношения SBT к AMT 2-й пункт рассматривать можно лишь условно, а поддерживающий на уровне чипсета 5-й пункт обычно отпадает, т.к. серверные чипсеты рассчитаны на использование BMC-контроллеров для удалённого управления, в многом дублируя функционал Intel AMT (или наоборот), потому реализовывать и поддержку BMC и поддержку AMT в BIOS вендоры особенно не спешат, в то время как для поддержки Intel AMT требуется и поддержка всех трёх условий (см. выше).
Соответственно, почти всегда в случае наличия Intel AMT речь будет идти лишь о чипсетах Qxx.
В системах SoC (System on Chip — когда процессор и чипсет интегрированы) узнать поддержку AMT сложней, т.к. это зависит от конкретной модели. В общем случае процессоры, поддерживающие Intel AMT можно найти на [ark.intel.com/ru/Search/Advanced?ExtendedPageTables=True](https://ark.intel.com/ru/Search/Advanced?ExtendedPageTables=True), выбрав в самом низу галку «Intel vPro Technology» (но также стоит не забывать про требования поддержки в BIOS).
### Доступ
Уязвимостью можно воспользоваться:
1. Локально на AMT-компьютере — требуется наличие установленных драйверов AMT, в частности драйвера LMS
2. В локальной сети — firewall при этом не защищает, т.к. технология AMT перехватывает трафик ДО его обработки ОС. Кроме того, компьютер может быть вообще выключен (но подключён к сети+электросети)
3. По интернету — в случае того, если компьютер был настроен на [работу AMT через Intel MPS](https://vpro.by/nastroyka-intel-mps-dlya-raboty-intel-amt-cira) (плюс ранее указанное в пункте 2)
Во всех случаях требуется, чтобы технология AMT уже была проинициализирована/сконфигурирована.
Отдельной неприятной вещью является тот факт, что несконфигурированный компьютер, начиная с Intel AMT версии 7 и выше можно программно проинициализировать локально в клиентский режим (т.е. даже из расконфигурированного состояния). Потому в рекомендациях от Intel по борьбе с уязвимостью CVE-2017-5689, кроме различных телодвижений из разряда «всё выключить» есть опциональные «Disable CCM» — отключить клиентский режим и «Disable HBE» — отключить автоматическую инициализацию AMT (неприменимо для обычных компьютеров-ноутбуков — это лишь для встраиваемых систем). Потому как с помощью данных возможностей, предназначенных для упрощения программной инициализации, эту процедуру можно сделать на любой системе с поддержкой AMT (исключение — запрещённое AMT в BIOS).
### Дизассемблирование
Все подробности нахождения уязвимости указаны в [первоисточнике](https://www.embedi.com/files/white-papers/Silent-Bob-is-Silent.pdf), они сделаны на примере Intel AMT 9 системы. Если коротко, то была дизассемблированная часть, обрабатывающая запросы к встроенному в Intel AMT web-серверу по характерным заголовкам (username, realm, nonce и т.д.) процесса аутентификации:
При исследовании на выходе функции проверки авторизации (заголовок «Authorization»), где сравниваются пароли (переданный с установленным) был обнаружен код проверки пароля:
```
ld r1, [sp:user_response+10ch]; проверяемый пароль → в регистр r1 (второй аргумент strncmp)
mov r0, r13 ; АМТ-пароль → в регистр r0 (первый аргумент strncmp)
ld r2, [sp:a4h] ; длина проверяемого пароля → в регистр r2 (третий аргумент strncmp)
bl strncmp ; call strncmp()
```
В результате получается, что в третий аргумент для функции *strncmp()* — количество сравниваемых символов, загружается длина из нашего ответа, а значит, при нулевом значении *strncmp* всегда будет давать *true*.
Понятно, что это ошибка разработчика, который должен был указать в качестве проверяемой длины пароля не длину передаваемого авторизующимся юзером (который можно сделать любым, в т.ч. передать значение нулевой длины), а установленного (админского) пароля.
Практическая проверка уязвимости AMT-систем
-------------------------------------------
В документе от Embedi был описан простой вариант с локальным доступом при сконфигурированном AMT без использования TLS — когда используется AMT-порт 16992. Чтобы не повторяться, будет приведён другой случай — доступ к расположенному в локальной сети компьютеру с поддержкой AMT, сконфигурированному на использование TLS (т.е. через AMT-порт 16993).
Подключаемся к системе с поддержкой AMT (т.к. при подключении по TLS будет проверяться имя сервера, то используется FQDN, а не IP):
Залогиниться со стандартным логином admin и оставив поле пароля пустым не получится (что понятно):
Теперь произведём манипуляцию с HTTP-заголовками, для этого используем расширение для Firefox [HttpRequester](https://addons.mozilla.org/en-us/firefox/addon/httprequester/).
Делаем пробный запрос (данные не важны), чтобы просто узнать *realm* из ответа (в ошибке в заголовке **WWW-Authenticate** будет нужный для составления дальнейшего запроса параметр:
Теперь добавляем вручную заголовок «Authorization»:
А в качестве значения указываем полученный ранее *realm* и следующие параметры:
> Digest username=«admin», realm=«Digest:EB580000000000000000000000000000», uri="/index.htm", qop=auth, nc=, cnonce="", opaque=""
После чего жмём Add и отправляем запрос.
Нас интересует параметр *nonce*, который уникален для каждой сессии. Добавляем его в заголовок (для этого придётся удалить старый и добавить новый), должно получиться что-то типа:
> Digest username=«admin», realm=«Digest:EB580000000000000000000000000000», nonce=«dh8jcw1CAQCTmvMOLG5UghjzJper6NvS», uri="/index.htm", qop=auth, nc=, cnonce="", **response=""**, opaque=""
С поправкой на каждый раз разный *nonce* и свой *realm*.
Сама уязвимость выделена жирным — пустое значение пароля, чтобы после была проверка по его нулевой длине.
Отправляем составленный таким образом (но достаточно быстро — пока не истекла сессиия):
Есть логин, теперь можно открыть страницу в Firefox:
Никаких при этом запросов на пароль не было.
Защита действующих AMT-систем (с ошибкой CVE-2017-5689 в firmware) с помощью настройки аутентификации по сертификату (mutual auth)
----------------------------------------------------------------------------------------------------------------------------------
Рекомендации Intel по защите от CVE-2017-5689 в основном заключаются в отключении AMT на поддерживающих её системах. Но, во-первых, многие (например, я) с удовольствием пользуются и хотят пользоваться впредь этой реально удобной технологией удалённого администрирования (особенно освоив её работу через интернет) и потому нет никакого желания отказываться от этого, банально выключая AMT в BIOS. Во-вторых, по опыту прошлых проблем различных вендоров с отключением AMT в BIOS, несложно предположить аналогичные и в будущем — когда отключённая в BIOS технология Intel AMT почему-то работала или могла быть активирована (несмотря на «Disabled» в BIOS Setup). Зная это, всегда наиболее правильной рекомендацией является проинициализовать и правильно настроить AMT — как раз для защиты систем с поддержкой Intel AMT (в противоположность «отключить и/или расконфигурировать»). В правильную настройку в том числе входит использование сертификатов для аутентификации (в дополнение к парольной) — сколько уж говорилось про ненадёжность парольной защиты, глупо повторяться.
Для этого можно использовать различные утилиты, например, официальный [Manageability Commander от Intel](https://downloadcenter.intel.com/download/26375/Intel-Manageability-Commander) (или другой удобной, я предпочитаю [MeshCommander](http://www.meshcommander.com/open-manageability)).
*(На «Invalid TLS» обращать внимания не стоит, т.к. используется самоподписанный сертификат)*
Закрываем доступ для не-TLS соединений и включаем клиентскую аутентификацию и для локального (через LMS) и для удалённого доступа (по сети и интернету), предварительно создав и загрузив нужные сертификаты.
Теперь при попытке зайти сначала (до парольной уязвимости) будет запрос на сертификат:
И только предоставив корректный сертификат, хэш рута которого был предварительно добавлен в хранилище сертификатов AMT данного компьютера и DNS которого был прописан в списке разрешённых — будет получен доступ к системе. Где уже дальше будет запрос на пароль (подвержённый уязвимости).
Таким образом AMT-система будет защищена и ею можно привычно пользоваться, даже если обновление прошивки с исправлением уязвимости CVE-2017-5689 так и не будет выпущено производителем вашей системы.
Ссылки:
* [security-center.intel.com/advisory.aspx?intelid=INTEL-SA-00075&languageid=en-fr](https://security-center.intel.com/advisory.aspx?intelid=INTEL-SA-00075&languageid=en-fr)
* [downloadmirror.intel.com/26754/eng/INTEL-SA-00075%20Mitigation%20Guide-Rev%201.1.pdf](https://downloadmirror.intel.com/26754/eng/INTEL-SA-00075%20Mitigation%20Guide-Rev%201.1.pdf)
* [www.embedi.com/files/white-papers/Silent-Bob-is-Silent.pdf](https://www.embedi.com/files/white-papers/Silent-Bob-is-Silent.pdf)
* [downloadcenter.intel.com/download/26375/Intel-Manageability-Commander](https://downloadcenter.intel.com/download/26375/Intel-Manageability-Commander) | https://habr.com/ru/post/328232/ | null | ru | null |
# Как серверу на Django знать своих клиентов на React в лицо, практическое руководство
В [предыдущей статье](https://habr.com/ru/post/512526/) я писал веб-приложение и совершенно бездумно реализовал там авторизацию, построенную на JWT. В этой статье я хотел бы устроить небольшое погружение в технические детали того, как это устроено, перебрать разные альтернативы.
Достаточно несложно в React нарисовать форму, где можно позволить пользователям вводить свои учетные данные, включающие в себя логин и пароль. Не стоит практически никаких усилий, чтобы на Django сверить пароль, соответствующий логину в базе данных. Но что дальше? Обзор получился достаточно объемный с примерами кода, которые помогут воссоздать реализацию всех схем аутентификации/авторизации.
Системе важно понять, кто послал запрос — идентифицировать по нику, электронной почте, номеру телефона, не важно. Убедиться, что никто не выдает себя за кого-то другого — аутентифицировать по паролю, сертификату или, например, токену. Последним шагом проверяются полномочия пославшего запрос, которые зафиксированы заранее. Именно от последнего шага будет зависеть пройдет ли запрос на следующие стадии обработки. Нельзя же читать не свои личные документы или редактировать чужие публикации и важно сразу выявлять подобные попытки.
После успешной аутентификации пользователя клиентское приложение (будь то браузер или нативное приложение) должны получить что-то взамен, своего рода пропуск, чтобы узнать вас в следующий раз и не спрашивать ничего снова, ведь это было бы достаточно неудобно. Именно с этим пропуском мы получаем доступ к ресурсам.
Стоит заметить, что во всех рассмотренных в статье схемах авторизации будет происходить обмен секретными данными, которые будут передаваться в открытом виде. Хотя бы поэтому использование https становится обязательным для правильной организации доступа к защищенным ресурсам, с помощью него устанавливается безопасное шифрованное соединение.
Предустановка
=============
Мы напишем приложение, которое будет отображать данные профиля пользователя, их сможет просматривать только владелец профиля, знающий логин и пароль. Для простоты сами профили будут создаваться и заполняться только с помощью встроенной django-админки. Для начала определимся с папкой и создадим в ней виртуальное окружение python и тут же активируем его, все это для удобства работы.
Затем установим необходимые зависимости
```
pip install django
pip install django-rest-framework
```
На момент написания статьи установлен системный python 3.7.2, django 3.2.7, django-rest-framework 3.12.4.
Теперь создаем django-проект `server` и django-приложение `core`. Базу данных будем использовать сразу ту, которая указана по-умолчанию, а именно движок SQLite и хранилище в файле `db.sqlite3` в корне проекта. Наконец, применяем миграции и создаем первого пользователя. Для демонстрации используется пароль `pass1234!`.
```
django-admin startproject server
cd server
django-admin startapp core
python3 ./manage.py migrate
python3 ./manage.py createsuperuser --username admin --email admin@example.com
```
И вот настала пора написать немного кода. Обязательно открываем `server/server/settings.py` и актуализируем `INSTALLED_APPS`
```
INSTALLED_APPS = [
+ 'core',
+ 'rest_framework',
'django.contrib.admin',
'django.contrib.auth',
```
В папке `server/core` создаем файл `serializers.py` и определяем [сериализатор](https://www.django-rest-framework.org/tutorial/1-serialization/#creating-a-serializer-class), который будет записывать в ответе сервера интересующие нас поля из модели.
```
from rest_framework.serializers import ModelSerializer
from django.contrib.auth.models import User
class UserSerializer(ModelSerializer):
class Meta:
model = User
fields = ['username', 'first_name', 'last_name', 'email', 'date_joined']
```
Избавляемся от содержимого файла server/core/views.py и пишем в нем простейший обработчик:
```
from rest_framework.request import Request
from rest_framework.response import Response
from rest_framework.decorators import api_view
from core.serializers import UserSerializer
@api_view()
def user(request: Request):
return Response({
'data': UserSerializer(request.user).data
})
```
Обновляем server/server/urls.py, чтобы определить endpoint, в который будет ходить клиент.
```
from django.contrib import admin
from django.urls import path
+from core import views
urlpatterns = [
path('admin/', admin.site.urls),
+ path('api/user', views.user, name='user')
]
```
Из папки `server` запускаем
```
python3 ./manage.py runserver
```
Проверяем в браузере `http://localhost:8000/api/users/`. В ответе получим `{"data": {"username": ""}}`, потому что сервер воспринимает нас как анонима. В клиентской части отображать пока нечего, поэтому давайте не будем ей пока заниматься. Вместо этого займемся тем, чтобы сервер узнал нас как пользователя с именем `admin`.
Basic
=====
Рассмотрим схему под названием Basic. Это простейшая схема, но это [не про безопасность](https://www.rfc-editor.org/rfc/rfc7617.html#section-4) и встретить данный подход можно лишь в каких-то внутрикорпоративных legacy.
Какая тут была бы уместна аналогия… Ах да, если бы голова отсоединялась от туловища, то она и была бы пропуском в систему. Проблемы тут такие же, голову можно забыть где-нибудь, её могут украсть и если это случится, то достать точно такую же голову или даже просто другую становится делом невыполнимым.
В общем, берем логин и пароль, склеиваем эти две строки по двоеточию, вот так `admin:pass1234!`, кодируем в base64, получаем `YWRtaW46cGFzczEyMzQh`. Полученную последовательность символов складываем в заголовок `Authorization`. Как-то так:
```
Authorization: Basic YWRtaW46cGFzczEyMzQh
```
Сервер извлечет заголовок из запроса, раскодирует его, найдет пользователя, сверит пароль и лишь затем выполнит целевое действие. Стоит заметить, что закодирован — не значит зашифрован, ведь нет использования секретного ключа. Поэтому обязательно трафик должен быть зашифрован.
### Реализуем схему на сервере
Нашему обработчику `user` в файле `server/core/views.py` надо сообщить две вещи: не пускать анонимов и использовать схему Basic. В этом нам помогут пара декораторов и несколько встроенных в django-rest-framework классов, вот так:
```
from rest_framework.response import Response
-from rest_framework.decorators import api_view
+from rest_framework.decorators import api_view, permission_classes, authentication_classes
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.authentication import BasicAuthentication
from core.serializers import UserSerializer
@api_view()
+@permission_classes([IsAuthenticated])
+@authentication_classes([BasicAuthentication])
def user(request: Request):
```
В настоящих проектах, скорее всего придется пользоваться настройками [DEFAULT\_AUTHENTICATION\_CLASSES](https://www.django-rest-framework.org/api-guide/settings/#default_authentication_classes) и [DEFAULT\_PERMISSION\_CLASSES](https://www.django-rest-framework.org/api-guide/settings/#default_permission_classes), это просто полезное замечание.
Если мы откроем в браузере адрес <http://localhost:8000/api/users/> покажется встроенное в браузер всплывающее окно для ввода логина/пароля.
Если ничего не вводить, а нажать на кнопку отмены, то мы получим в ответ следующее:
```
HTTP 401 Unauthorized
Allow: OPTIONS, GET
Content-Type: application/json
Vary: Accept
WWW-Authenticate: Basic realm="api"
{
"detail": "Authentication credentials were not provided."
}
```
Как браузер понял, что надо показать всплывающее окно для ввода учетных данных? По ответу. Код 401 значит, что пользователь не авторизован, следовательно, не может выполнять данное действие, потому что мы его не узнали. Это важно, ведь в этом случае сервер предоставляет возможность клиенту представиться и подтвердить свою идентичность, другими словами, аутентифицироваться, то возможно, что операция пройдет успешно.
Тут мы сталкиваемся с тем, что во многих материалах в интернете [(допустим, в этом отличном видео, которое я готов рекомендовать посмотреть от начала до конца)](https://youtu.be/fN25fMQZ2v0?t=2879) код ошибки 401 задействуют абсолютно везде, игнорируя тот факт, что сервер обязан сообщить приемлемый способ аутентификации в заголовке ответа `WWW-Authenticate` [[RFC7235 3.1]](https://datatracker.ietf.org/doc/html/rfc7235#section-3.1). Авторы либо забывают это сделать, хотя можно бы, либо используют этот код возврата в ситуациях, где в заголовок поместить просто нечего.
Вообще, все это сильно напоминает общение между людьми.
* К: Дай мне доступ к ресурсу,
* С: Не дам!
* К: Почему? *Вопрос повисает в воздухе*
Мы как бы в неприличной форме указываем клиенту куда ему следует идти. А прикладывая заголовок `WWW-Authenticate`, мы на первый вопрос отвечаем: "Будьте добры, покажите, пожалуйста, свой пропуск, выписанный нашей организацией".
В упомянутом выше примере ответа мы видим, что в заголовке `WWW-Authenticate` содержится название используемой схемы, а именно Basic, а также [realm](https://www.rfc-editor.org/rfc/rfc7235#section-2.2), контекст, для которого используются свои учетные данные. Эту информацию можно будет использовать в клиенте, чтобы быстро сориентировать пользователя в возникшей ситуации, браузер так и делает, но на это могут заложить свою логику и разные мобильные клиенты. При этом источником правды будет сервер, клиенту не придется ничего придумывать от себя.
Но бывает так, что ответить кодом 401 нельзя, тогда вступает в игру код 403 и разговор приобретает следующий вид:
* К: Дай мне доступ к ресурсу,
* С: Вам сюда нельзя! Идите, куда подальше!
Тогда клиент будет понимать, что любой следующий запрос будет отвергнут и ничего с этим нельзя сделать… Кроме как сходить и попросить себе больше привелегий в сервисе.
Если мы введем логин/пароль и нажмем кнопку подтверждения, то получим доступ к ресурсу. А в отладочной панели браузера на вкладке с сетевыми запросами мы увидим, что в запросе будет ожидаемый заголовок Authorization.
```
{
"data": {
"username": "admin",
"first_name": "",
"last_name": "",
"email": "admin@example.com",
"date_joined": "2021-09-11T09:55:18.424800Z"
}
}
```
Имя и фамилия для пользователя, созданного из командной строки не заданы. Чтобы в клиенте было что отображать, я рекомендую зайти во встроенную django-админку `http://localhost:8000/admin` и задать эти поля.
### Создадим клиент
Предварительно необходимо будет установить npm и [create-react-app](https://create-react-app.dev/docs/getting-started/). Находясь в корневой папке, создадим react-приложение.
```
create-react-app client
```
На момент написания статьи версии следующие: npm 6.14.15, yarn 1.22.5, react 17.0.2.
В папке `client` в файле `package.json` нужно задать поле `proxy` для того, чтобы не мучиться с CORS и задавать относительные пути для запросов на бэкенд. Так отладочный сервер узнает про бэкенд и поймет, куда перенаправить запрос, если он сам не знает, что это за адрес.
```
"eject": "react-scripts eject"
},
+ "proxy": "http://localhost:8000",
"eslintConfig": {
"extends": [
```
Открываем файл `client/src/App.js` и сверстаем в нем простейшую страницу с информацией о профиле, попутно забирая её с бэкенда. Ниже — реализация функции `App`, а в начале файла не забываем про импорт `import { useState, useEffect } from 'react';`.
```
const [ firstName, setFirstName] = useState('')
const [ lastName, setLastName] = useState('')
const [ username, setUsername] = useState('')
const [ email, setEmail] = useState('')
const [ dateJoined, setDateJoined] = useState('')
const [ error, setError] = useState()
useEffect(() => {
fetch('/api/user')
.then(response => {
if (response.ok) {
return response.json()
} else {
throw Error(`Something went wrong: code ${response.status}`)
}
})
.then(({data}) => {
setFirstName(data.first_name)
setLastName(data.last_name)
setUsername(data.username)
setEmail(data.email)
setDateJoined(data.date_joined)
})
.catch(error => {
console.log(error)
setError('Ошибка, подробности в консоли')
})
}, [])
return (
{error?
{error}
:
{firstName} {lastName}
======================
{username}
----------
email: {email}
Профиль создан {dateJoined}
}
);
```
В терминале из новой вкладки в папке `client` запускаем команду
```
yarn start
```
При этом сервер на python тоже должен продолжать работать.
Проверяем `http://localhost:3000/`.
Введя логин и пароль, увидим сайт, который отображает профиль зарегистрированного пользователя.
Не шибко полезное приложение, кроме просмотра информации нельзя ничего сделать без доступа к django-админке, даже загеристрироваться на сайте самостоятельно нельзя. Но этого достаточно, чтобы объяснить суть.
Из возможных плюсов — нам не потребовалось верстать форму для ввода логина и пароля. Также не потребовалось самим снабжать запросы внутри страницы заголовком `Authorization`, нигде не пришлось сохранять base64-строчку. Браузер предоставил все необходимые механизмы сам, мы один раз ввели логин и пароль в специальное всплывающее окно и в пределах одного realm все запросы будут автоматически снабжаться всеми данными, необходимыми для авторизации. Однако подобная пользовательская сессия будет забыта непосредственно, как будет закрыто окно браузера и учетные данные надо будет вводить снова.
И это правильно, получается. [В документации django-rest-framework рекомендуют](https://www.django-rest-framework.org/api-guide/authentication/#basicauthentication) просить клиентов каждый раз вводить свои учетные данные заново. Что бы мы ни придумали, в любом случае будут серьезные риски безопасности, поэтому этот вариант не для нас. Хотя, в свое время, когда только-только налаживалось взаимодействие клиента и сервера, приходилось это использовать, как самая простая опция. Лишь потом я задумался...
Token
-----
Нет, про этот способ я даже не знал. По-моему, он весьма логичное развитие предыдущего и я поставил его вторым по счету. Я для себя замечу, что он имеет мало отношения к документу от IEFT ["HTTP Authentication: Token Access Authentication"](https://tools.ietf.org/id/draft-hammer-http-token-auth-01.html), потому что там речь идет о токенах bearer, т.е. на предъявителя. Они выпущены доверенной системой и сразу содержат в себе закодированную информацию, а также подписаны с помощью секретного ключа, но об этом позже.
Само слово token с английского переводится как знак, жетон, метка. Т.е. это некоторое обозначение некоторой сущности. Этой сущностью в рассматриваемой схеме является сессия или сеанс пользователя, в течение которого пользователь работает с системой. Поэтому токен сессии, айдишник сессии — это все одно. Схема очень похожа на предыдущую тем, что мы тоже передаем секретную строку в заголовке, но сначала мы в явном виде прямо в теле POST-запроса присылаем системе учетные данные, чтобы проверить их корректность. Затем, генерируется токен, пусть это будет 40 случайных букв в нижнем регистре или цифр и возвращается в ответе. То же самое записывается в базу данных, так система будет принимать следующие запросы только с заголовком `Authorization: Token ${token}`. Получая этот токен, клиент может его сложить в какое-то хранилище и отправлять при каждом следующем обращении.
Прекрасной аналогией будет бумажный пропуск со специальным секретным номером, который выписывают только в вашем личном присутствии, а перед самим обращением в систему специально обученные сотрудники сверяют на предмет наличия его в их собственной книге учета пропусков для подтверждения доступа. Если вы потеряете пропуск, не беда: обратившись лично, можно выписать новый, а старый вычеркнуть из книги, тогда нашедший/похитивший пропуск не сможет им воспользоваться.
Мы один раз проверили пароль и больше его не спрашиваем, не передаем, не храним ни в каком виде на клиенте. Узнать токен — не то же самое, что узнать пароль, у нас появится больше возможностей минимизировать масштаб разрушений, например, удалив токен из таблицы соответствия. А профиль останется за тем, кто знает пароль.
### Как это встроить в наше приложение?
Со стороны сервера здесь весьма тривиальное исправление. Первым делом нужно создать модель для хранения токенов. И тут все уже сделано за нас, в django-приложении `rest_framework.authtoken`, добавим его в `ISTALLED_APPS` в файле `server/server/settings.py`:
```
INSTALLED_APPS = [
'core',
'rest_framework',
+ 'rest_framework.authtoken',
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
```
У добавленного приложения есть свои миграции, не забудем их применить:
```
python3 ./manage.py migrate
```
Ну и в нашем обработчике `server/core/views.py` заменим `BasicAuthentication` на `TokenAuthentication`. Сначала в импортах:
```
-from rest_framework.authentication import BasicAuthentication
+from rest_framework.authentication import TokenAuthentication
```
Затем в декораторах:
```
-@authentication_classes([BasicAuthentication])
+@authentication_classes([TokenAuthentication])
```
Проверяем `http://localhost:8000/api/user`
Ответили нам ошибкой 401, очень похожей на предыдущую, но разница есть:
```
HTTP 401 Unauthorized
Allow: GET, OPTIONS
Content-Type: application/json
Vary: Accept
-WWW-Authenticate: Basic realm="api"
+WWW-Authenticate: Token
{
"detail": "Authentication credentials were not provided."
}
```
Токен можно выписать себе опять пока только с помощью django-админки. Давайте попробуем это сделать, чтобы протестировать. Переходим на `http://localhost:8000/admin/`, затем щелкаем по "Tokens" и потом "Add token". Выбираем нашего суперпользователя и жмем "Save". У вас получится свой токен, у меня получился такой `559b614f17c0450c4e28e2f55ec6cc7a473da822`, его и надо будет передать в заголовке. На красивой странице, сгенерированной силами Django REST Framework это сделать не получится, но можно в командной строке вот так:
```
curl -H "Authorization: Token 559b614f17c0450c4e28e2f55ec6cc7a473da822" http://localhost:8000/api/user
```
Что же… Все работает нормально, мы так сможем получать профиль пользователя. Но нужно научиться с помощью нашего клиента себе самому выписывать эти токены. Обеспечим эту возможность с помощью отправки JSON с полями `username` и `password` с помощью POST-запроса по адресу `/api/login`.
В файле `server/core/serializers.py` добавляем несколько сериализаторов для валидации входных и выходных данных:
```
@@ -1,5 +1,6 @@
-from rest_framework.serializers import ModelSerializer
+from rest_framework.serializers import Serializer, ModelSerializer, CharField
from django.contrib.auth.models import User
+from rest_framework.authtoken.models import Token
class UserSerializer(ModelSerializer):
@@ -7,3 +8,17 @@
class Meta:
model = User
fields = ['username', 'first_name', 'last_name', 'email', 'date_joined']
+
+
+class IssueTokenRequestSerializer(Serializer):
+ model = User
+
+ username = CharField(required=True)
+ password = CharField(required=True)
+
+
+class TokenSeriazliser(ModelSerializer):
+
+ class Meta:
+ model = Token
+ fields = ['key']
```
Затем в `server/core/views.py` реализуем обработчик нашего логина, который примет учетные данные пользователя, проверит их на соответствие и выдаст либо существующий токен, либо заведет новый.
```
@@ -1,9 +1,26 @@
from rest_framework.request import Request
from rest_framework.response import Response
from rest_framework.decorators import api_view, permission_classes, authentication_classes
-from rest_framework.permissions import IsAuthenticated
+from rest_framework.permissions import IsAuthenticated, AllowAny
from rest_framework.authentication import TokenAuthentication
-from core.serializers import UserSerializer
+from core.serializers import UserSerializer, IssueTokenRequestSerializer, TokenSeriazliser
+from rest_framework.authtoken.models import Token
+from django.contrib.auth import authenticate
+
+
+@api_view(['POST'])
+@permission_classes([AllowAny])
+def issue_token(request: Request):
+ serializer = IssueTokenRequestSerializer(data=request.data)
+ if serializer.is_valid():
+ authenticated_user = authenticate(**serializer.validated_data)
+ try:
+ token = Token.objects.get(user=authenticated_user)
+ except Token.DoesNotExist:
+ token = Token.objects.create(user=authenticated_user)
+ return Response(TokenSeriazliser(token).data)
+ else:
+ return Response(serializer.errors, status=400)
@api_view()
```
Не забываем зарегистрировать обработчик в `server/server/urls.py`, чтобы потом можно было делать запросы:
```
urlpatterns = [
path('admin/', admin.site.urls),
path('api/user', views.user, name='user'),
+ path('api/login', views.issue_token, name='issue_token'),
]
```
Ну а в клиенте в файле `client/src/App.js` верстаем форму для входа в систему, реализуем её корректную отправку и отображение данных после ввода правильных данных.
```
@@ -2,6 +2,10 @@
import './App.css';
function App() {
+ const [token, setToken] = useState()
+ const [loading, setLoading] = useState()
+ const [formUsername, setFormUsername] = useState()
+ const [formPassword, setFormPassword] = useState()
const [ firstName, setFirstName] = useState('')
const [ lastName, setLastName] = useState('')
const [ username, setUsername] = useState('')
@@ -10,7 +14,16 @@
const [ error, setError] = useState()
useEffect(() => {
- fetch('/api/user')
+ if (token) {
+ fetch(
+ '/api/user',
+ {
+ headers: {
+ 'Content-Type': 'application/json;charset=utf-8',
+ 'Authorization': `Token ${token}`,
+ },
+ }
+ )
.then(response => {
if (response.ok) {
return response.json()
@@ -24,24 +37,69 @@
setUsername(data.username)
setEmail(data.email)
setDateJoined(data.date_joined)
+ setError(null)
+ })
+ .catch(error => {
+ console.log(error)
+ setError('Ошибка, подробности в консоли')
+ })
+ }
+ }, [token])
+
+ const submitHandler = e => {
+ e.preventDefault();
+ setLoading(true);
+ fetch(
+ '/api/login',
+ {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json;charset=utf-8',
+ },
+ body: JSON.stringify({
+ username: formUsername,
+ password: formPassword,
+ })
+ }
+ )
+ .then(response => {
+ if (response.ok) {
+ return response.json()
+ } else {
+ throw Error(`Something went wrong: code ${response.status}`)
+ }
+ })
+ .then(({key}) => {
+ setToken(key)
+ setError(null)
})
.catch(error => {
console.log(error)
setError('Ошибка, подробности в консоли')
})
- }, [])
+ .finally(setLoading(false))
+ }
return (
- {error?
- {error}
+ {error? {error}
: null}
+ {!token?
+ loading? "Загрузка..." :
+
+ setFormUsername(e.target.value)} placeholder="Username"/>
+ setFormPassword(e.target.value)} placeholder="Password"/>
+
+
:
+ !error?
{firstName} {lastName}
======================
{username}
----------
email: {email}
Профиль создан {dateJoined}
+ :
+ null
}
);
```
В приведенном примере токен сохраняется прямо в переменную состояния компонента `token`. Так получается даже хуже, чем в Basic, ведь при перезагрузке страницы токен теряется и надо входить в систему заново.
Заносить в localstorage тоже не выход. Так мы повышаем удобство, но жертвуем безопасностью. Для приложений с высокими требованиями к надежности настоятельно не рекомендуют такие критичные данные, как токены складывать в localstorage.
Насколько я хорошо осведомлен, схема с токеном весьма актуальна и широко применяется для мобильных и десктопных приложений. Почему? Ранее мне казалось, что их сложнее взломать. Но дело, скорее, совсем не в этом — мобильное приложение не умеет работать с cookies!
Session
-------
Так мы подошли к самой распространенной среди сайтов за прошедшие десятилетия схеме. После успешной проверки логина и пароля, токен сессии выставляется в куках браузера и браузер автоматически шлет их при каждом следующем запросе, а сервер делает все то же самое, что и в прошлой схеме.
### Давайте переделаем приложение, чтобы задействовать эту схему.
Первым делом меняем `TokenAuthentication` на `SessionAuthentication` в импорте:
```
-from rest_framework.authentication import TokenAuthentication
+from rest_framework.authentication import SessionAuthentication
```
И в декораторе:
```
-@authentication_classes([TokenAuthentication])
+@authentication_classes([SessionAuthentication])
```
Проверяем, что изменится на `http://localhost:8000/api/user`
```
HTTP 403 Forbidden
Allow: GET, OPTIONS
Content-Type: application/json
Vary: Accept
{
"detail": "Authentication credentials were not provided."
}
```
Теперь код ответа 403, потому что аутентификация происходит не средствами самого протокола HTTP, теперь эти функции больше переложены на само приложение.
Django по-умолчанию предоставляет механизм сессий. Т.е. когда мы впервые заходим на сайт нам генерируется случайная строка фиксированной длины, такая же как для токена из прошлого раздела и заносится в cookie. Теперь среди всех запросов мы можем определить какие сделал один и тот же пользователь и отследить его цепочку.
Что теперь будет, если он введет свои логин/пароль? Мы просто свяжем номер его сессии и его данные на сервере. Сами данные по поводу того, какой это пользователь, мы можем хранить по-разному: в базе данных, в файлах, в cookies (криптографически подписанных).
В любом случае, мы можем определить от какого именно пользователя поступают запросы, и к каким данным он имеет доступ.
Из клиента к этим данным не будет никакого доступа, если мы не меняли значение [SESSION\_COOKIE\_HTTPONLY](https://docs.djangoproject.com/en/3.2/ref/settings/#std:setting-SESSION_COOKIE_HTTPONLY) по-умолчанию, поэтому внедрение вредоносного кода в приложение не будет иметь тяжелых последствий. Однако, все остается необходимость использовать CSRF-токены и, тем самым, подтверждать, что запрос сделан именно от нашего клиента, а не по вредоносной ссылке со стороннего сайта.
В файле `server/core/serializers.py` уберем ненужный сериализатор `TokenSeriazliser`, а `IssueTokenRequestSerializer` переименуем просто в `LoginRequestSerializer`. Функцию `issue_token` из файла `server/core/views.py` придется удалить и вместо неё написать функцию `login` со следующей реализацией:
```
@api_view(['POST'])
@permission_classes([AllowAny])
def login(request: Request):
serializer = LoginRequestSerializer(data=request.data)
if serializer.is_valid():
authenticated_user = authenticate(**serializer.validated_data)
if authenticated_user is not None:
login(request, authenticated_user)
return Response({'status': 'Success'})
else:
return Response({'error': 'Invalid credentials'}, status=403)
else:
return Response(serializer.errors, status=400)
```
И не забываем про импорты:
```
-from rest_framework.authentication import TokenAuthentication
+from rest_framework.authentication import SessionAuthentication
-from core.serializers import UserSerializer, IssueTokenRequestSerializer, TokenSeriazliser
+from core.serializers import UserSerializer, LoginRequestSerializer
-from rest_framework.authtoken.models import Token
-from django.contrib.auth import authenticate
+from django.contrib.auth import authenticate, login
```
Как не забываем и про обновление `server/server/urls.py`:
```
urlpatterns = [
path('admin/', admin.site.urls),
path('api/user', views.user, name='user'),
- path('api/login', views.issue_token, name='issue_token'),
+ path('api/login', views.login, name='login'),
]
```
Чтобы адаптировать клиент `client/src/App.js` понадобится не запрашивать токен, а просто управлять флагом `isLoggedIn`, обязательно брать из `document.cookie` токен для защиты от CSRF-атак и отправлять его вместе с запросом на логин в заголовке `X-CSRFToken`:
```
@@ -1,8 +1,16 @@
import { useState, useEffect } from 'react';
import './App.css';
+
+function getCookie(name) {
+ const value = `; ${document.cookie}`;
+ const parts = value.split(`; ${name}=`);
+ if (parts.length === 2) return parts.pop().split(';').shift();
+}
+
+
function App() {
- const [token, setToken] = useState()
+ const [isLoggedIn, setIsLoggedIn] = useState(true)
const [loading, setLoading] = useState()
const [formUsername, setFormUsername] = useState()
const [formPassword, setFormPassword] = useState()
@@ -12,15 +20,15 @@
const [ email, setEmail] = useState('')
const [ dateJoined, setDateJoined] = useState('')
const [ error, setError] = useState()
+ const csrftoken = getCookie('csrftoken')
useEffect(() => {
- if (token) {
+ if (isLoggedIn) {
fetch(
'/api/user',
{
headers: {
'Content-Type': 'application/json;charset=utf-8',
- 'Authorization': `Token ${token}`,
},
}
)
@@ -42,9 +50,10 @@
.catch(error => {
console.log(error)
setError('Ошибка, подробности в консоли')
+ setIsLoggedIn(false)
})
}
- }, [token])
+ }, [isLoggedIn])
const submitHandler = e => {
e.preventDefault();
@@ -55,6 +64,7 @@
method: 'POST',
headers: {
'Content-Type': 'application/json;charset=utf-8',
+ 'X-CSRFToken': csrftoken,
},
body: JSON.stringify({
username: formUsername,
@@ -70,7 +80,7 @@
}
})
.then(({key}) => {
- setToken(key)
+ setIsLoggedIn(true)
setError(null)
})
.catch(error => {
@@ -83,7 +93,7 @@
return (
{error? {error}
: null}
- {!token?
+ {!isLoggedIn?
loading? "Загрузка..." :
setFormUsername(e.target.value)} placeholder="Username"/>
```
Кажется, на данном этапе должна получиться достаточно надежная система, которая будет знать своих пользователей в лицо. Однако нет предела развитию технологий и может так случиться, что это уже может не подходить.
JWT
---
А здесь у нас последнее слово техники — веб-токены, они бывают разные, но мы рассмотрим [JSON Web Token](https://jwt.io/introduction). Серверу уже не нужно идти в базу данных и проверять, какому пользователю соответствует данный токен, вся информация зашита в нем самом.
Драйверами развития подобной технологии стало распространение микросервисного подхода к проектированию и появлению по-настоящему больших ресурсов, ведь база данных для проверки валидности сессий имеет свою пропускную способность по запросам к ней. К тому же, стали появляться конгломераты сервисов, живущих на разных доменах, но имеющие единую форму входа.
Как выглядит JWT и как он зашивает с себе всю информацию? Это три закодированные последовательности символов, записанные через точку: в первых двух частях в base64 кодируются два JSON-объекта — заголовок и пользовательские данные; третья генерируется на основе первых двух и секретного ключа — это цифровая подпись. Теперь сам токен в открытом виде содержит всю необходимую информацию для авторизации, а цифровая подпись не позволяет что-то в токене поменять. Когда система принимает запрос, она знает секретный ключ и может сама сгенерировать подпись и проверить, совпадает ли она с тем, что нам передали.
Самая лучшая аналогия — паспорт. Паспорт выпускается государством, как доверенной организацией и необязательно сверяться ни с каким источником, чтобы пропустить вас в систему по нему. Его крайне сложно подделать, в случае неудачи это будет заметно. Но что, если он будет потерян или его похитят? Надежный способ не представляется таким уж простым, каждое новшество, которое усиливает безопасность, порождает новые вопросы и технические вызовы.
Для минимизации ущерба на данный момент придумано встраивать в пользовательские данные или payload время, до которого токен действителен. Тогда сервер не пропустит запрос с токеном с истекшим сроком действия. Чем более важные вопросы решает система, тем более короткие должны быть токены. Но как его обновлять? Неужели придется каждый раз оказываться на форме с логином паролем? Нет, над этим тоже подумали и придумали выпускать параллельно второй токен, который будет предназначен только для того, [чтобы обновлять первый](https://habr.com/ru/company/Voximplant/blog/323160/). Первый называется access token, а второй refresh token
Но куда их складывать? Допустим, access живет 10 минут, его не критично занести в localstorage. С refresh все становится сложнее, ведь если обращаться с ним также, у нас добавляется много сложностей по разработке и поддержке системы и не возникает почти никаких преимуществ в безопасности и удобстве. Я однажды сам догадался складывать их в localstorage, но оно того не стоит, из-за этого родился этот весьма длинный обзор.
Из приложенных ссылок я узнал, что есть следующая схема работы, описанная ниже.
В ответ на запрос с логином и паролем, клиент получает пару токенов: access и refresh. Их мы заносим в localstorage, почему — об этом позже. access мы прикладываем при каждом запросе к бэкенду в заголовке `Authorization: Bearer ${access_token}`. Сервер проверяет подпись и срок действия токена и ему больше не нужно обращаться ни к каким хранилищам. Когда у access истекает срок действия, клиент отправляет запрос на специальный адрес `api/refresh` и получает новую пару токенов. При этом старый refresh заносится в черный список и больше не может быть использован. Обращаться к внешнему хранилищу все-таки надо, но уже не так часто.
### Реализуем данный подоход в нашем приложении
Встроенной в `django-rest-framework` поддержки JWT нет, но есть популярная библиотека, установим её.
```
pip install djangorestframework-simplejwt
```
На момент написания статьи установилась версия 4.8.0. Затем, как мы уже привыкли, меняем файл `server/core/views.py`. Импортируем нужный класс:
```
-from rest_framework.authentication import SessionAuthentication
+from rest_framework_simplejwt.authentication import JWTAuthentication
```
И меняем его в декораторе:
```
-@authentication_classes([SessionAuthentication])
+@authentication_classes([JWTAuthentication])
```
Как мы это сделаем, проверим `http://localhost:8000/api/user`, поймаем ошибку 401:
```
HTTP 401 Unauthorized
Allow: OPTIONS, GET
Content-Type: application/json
Vary: Accept
WWW-Authenticate: Bearer realm="api"
{
"detail": "Authentication credentials were not provided."
}
```
`Bearer` — это значит тут нужен токен на предъявителя. В том же файле `server/core/views.py` можно удалить обработчик `login` совсем, мы будем пользоваться уже встроенными средствами. Также избавимся от лишних импортов, оставив в итоге только обработчик, выдающий информацию о пользователе.
В `server/server/urls.py` мы добавим два пути: `/api/token/obtain` и `/api/token/refresh`, которые вызывают уже встроенные в `django-rest-framework-simplejwt` обработчики.
```
from core import views
+from rest_framework_simplejwt.views import (
+ TokenObtainPairView,
+ TokenRefreshView,
+)
urlpatterns = [
path('admin/', admin.site.urls),
path('api/user', views.user, name='user'),
- path('api/login', views.login, name='login'),
+ path('api/token/obtain', TokenObtainPairView.as_view(), name='token_obtain'),
+ path('api/token/refresh', TokenRefreshView.as_view(), name='token_refresh'),
]
```
Наконец, воспользуемся тем, что сама библиотека предлагает нам средства для занесения токенов в черный список. Достаточно лишь открыть файл `server/server/settings.py` и добавить в `INSTALLED_APPS` приложение `rest_framework_simplejwt.token_blacklist`. В том же файле добавить две настройки со значением True: [ROTATE\_REFRESH\_TOKENS](https://django-rest-framework-simplejwt.readthedocs.io/en/latest/settings.html#rotate-refresh-tokens) и [BLACKLIST\_AFTER\_ROTATION](https://django-rest-framework-simplejwt.readthedocs.io/en/latest/settings.html#blacklist-after-rotation). Первая будет заставлять запрос на обновление access обновлять также и refresh, а вторая занесет использованный refresh в черный список и им больше нельзя будет воспользоваться. Стоит также определить для себя значения `ACCESS_TOKEN_LIFETIME` и `REFRESH_TOKEN_LIFETIME`.
Ну, и наконец-то, обновляем клиент `client/src/App.js`, здесь придется много чего учесть, мне довелось сделать это как-то так:
```
@@ -10,7 +10,9 @@
function App() {
- const [isLoggedIn, setIsLoggedIn] = useState(true)
+ const [access, setAccess] = useState(localStorage.getItem('accessToken'))
+ const [refresh, setRefresh] = useState(localStorage.getItem('refreshToken'))
+ const [refreshRequired, setRefreshRequired] = useState(false)
const [loading, setLoading] = useState()
const [formUsername, setFormUsername] = useState()
const [formPassword, setFormPassword] = useState()
@@ -20,15 +22,15 @@
const [ email, setEmail] = useState('')
const [ dateJoined, setDateJoined] = useState('')
const [ error, setError] = useState()
- const csrftoken = getCookie('csrftoken')
useEffect(() => {
- if (isLoggedIn) {
+ if (access) {
fetch(
'/api/user',
{
headers: {
'Content-Type': 'application/json;charset=utf-8',
+ 'Authorization': `Bearer ${access}`,
},
}
)
@@ -36,6 +38,9 @@
if (response.ok) {
return response.json()
} else {
+ if (response.status === 401) {
+ throw Error('refresh')
+ }
throw Error(`Something went wrong: code ${response.status}`)
}
})
@@ -48,23 +53,59 @@
setError(null)
})
.catch(error => {
- console.log(error)
- setError('Ошибка, подробности в консоли')
- setIsLoggedIn(false)
+ if (error.message === 'refresh') {
+ setRefreshRequired(true)
+ } else {
+ console.log(error)
+ setError('Ошибка, подробности в консоли')
+ }
})
}
- }, [isLoggedIn])
+ }, [access])
+
+
+ useEffect(() => {
+ if (refreshRequired) {
+ fetch(
+ '/api/token/refresh',
+ {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json;charset=utf-8',
+ },
+ body: JSON.stringify({ refresh })
+ }
+ )
+ .then(response => {
+ if (response.ok) {
+ return response.json()
+ } else {
+ throw Error(`Something went wrong: code ${response.status}`)
+ }
+ })
+ .then(({access, refresh}) => {
+ localStorage.setItem('accessToken', access)
+ setAccess(access)
+ localStorage.setItem('refreshToken', refresh)
+ setRefresh(refresh)
+ setError(null)
+ })
+ .catch(error => {
+ console.log(error)
+ setError('Ошибка, подробности в консоли')
+ })
+ }
+ }, [refreshRequired])
const submitHandler = e => {
e.preventDefault();
setLoading(true);
fetch(
- '/api/login',
+ '/api/token/obtain',
{
method: 'POST',
headers: {
'Content-Type': 'application/json;charset=utf-8',
- 'X-CSRFToken': csrftoken,
},
body: JSON.stringify({
username: formUsername,
@@ -79,8 +120,11 @@
throw Error(`Something went wrong: code ${response.status}`)
}
})
- .then(({key}) => {
- setIsLoggedIn(true)
+ .then(({access, refresh}) => {
+ localStorage.setItem('accessToken', access)
+ setAccess(access)
+ localStorage.setItem('refreshToken', refresh)
+ setRefresh(refresh)
setError(null)
})
.catch(error => {
@@ -93,7 +137,7 @@
return (
{error? {error}
: null}
- {!isLoggedIn?
+ {!access?
loading? "Загрузка..." :
setFormUsername(e.target.value)} placeholder="Username"/>
```
Важные выводы
-------------
Раньше мне казалось, что авторизация на сессиях в одностраничниках на react строится гораздо сложнее, чем есть на самом деле. А управлять двумя токенами оказалось похоже на overkill, не добавляющий ничего хорошего в систему, кроме бремени поддержки. Я свои выводы сделал и пойду дорабатывать свое приложение. Пусть каждому выводу предшествует достаточно глубокое исследование, укладывающееся в дедлайны.
Полезные ссылки
---------------
[0] [Обзор способов и протоколов аутентификации в веб-приложениях](https://habr.com/ru/company/dataart/blog/262817/)
[1] [RFC7235: Hypertext Transfer Protocol (HTTP/1.1): Authentication](https://datatracker.ietf.org/doc/html/rfc7235)
[2] [RFC2617: HTTP Authentication: Basic and Digest Access Authentication](https://datatracker.ietf.org/doc/html/rfc2617)
[3] [RFC7617: The 'Basic' HTTP Authentication Scheme](https://www.rfc-editor.org/rfc/rfc7617.html#section-4)
[4] [The OAuth 2.0 Authorization Framework: Bearer Token Usage](https://www.rfc-editor.org/rfc/rfc6750.html)
[5] [Introduction to JSON Web Tokens](https://jwt.io/introduction)
[6] [Пять простых шагов для понимания JSON Web Tokens (JWT)](https://habr.com/ru/post/340146/)
[7] [О хранении JWT токенов в браузерах](https://habr.com/ru/post/502702/)
[8] [Про токены, JSON Web Tokens (JWT), аутентификацию и авторизацию. Token-Based Authentication](https://gist.github.com/zmts/802dc9c3510d79fd40f9dc38a12bccfc)
[9] [Зачем нужен Refresh Token, если есть Access Token?](https://habr.com/ru/company/Voximplant/blog/323160/)
[10] [Добавляем Refresh Token](https://habr.com/ru/post/466929/) | https://habr.com/ru/post/512746/ | null | ru | null |
# Создание REST API с Node.js и базой данных Oracle
Привет, Хабр! представляю вашему вниманию перевод статьи [«Creating a REST API: Web Server Basics»](https://jsao.io/2018/03/creating-a-rest-api-web-server-basics/).
#### Часть 1. Создание REST API: основы веб-сервера
Веб-сервер является одним из наиболее важных компонентов REST API. В этом посте вы начнете свой проект API REST, создав несколько начальных каталогов и файлов. Затем вы создадите модуль веб-сервера и подключите его так, чтобы веб-сервер запускался и правильно выключался.
Код в этом проекте будет организован с использованием общей структуры каталогов, которая может быть скорректирована и с течением времени построена по мере необходимости.
```
cd ~
mkdir hr_app
cd hr_app/
touch index.js
mkdir config
touch config/web-server.js
mkdir controllers
mkdir db_apis
mkdir services
touch services/web-server.js
```
Файл index.js можно рассматривать как «основной» файл в приложении. Он будет точкой входа в приложение. Мы будем добавлять код в этот файл и файлы web-server.js в каталогах config и services.
Вставьте следующий код в файл **Home > hr\_app > config>web-server.js**
```
module.exports = {
port: process.env.HTTP_PORT || 3000
};
```
В Node.js объект процесса имеет свойство env, которое содержит пользовательскую среду. Я использую это, чтобы установить значение порта в значение переменной среды HTTP\_PORT. Если эта переменная среды не определена, значением по умолчанию будет 3000.
Вставьте следующий код в файл **Home > hr\_app > services>web-server.js**
```
const http = require('http');
const express = require('express');
const webServerConfig = require('../config/web-server.js');
let httpServer;
function initialize() {
return new Promise((resolve, reject) => {
const app = express();
httpServer = http.createServer(app);
app.get('/', (req, res) => {
res.end('Hello World!');
});
httpServer.listen(webServerConfig.port)
.on('listening', () => {
console.log(`Web server listening on localhost:${webServerConfig.port}`);
resolve();
})
.on('error', err => {
reject(err);
});
});
}
module.exports.initialize = initialize;
```
**Строки 1-3:** требуется несколько модулей. Модуль http включен в Node.js, но модуль Express необходимо будет установить через npm.
**Строки 7-27:** объявлена функция с именем initialize. Функция немедленно возвращает promise, которое разрешается или отклоняется в зависимости от того, успешно ли запущен веб-сервер.
**Строки 9-10:** создается новое экспресс-приложение (которое на самом деле является просто функцией), а затем используется для создания http-сервера через модуль http.
**Строки 12-14:** метод get приложения используется для добавления обработчика для запросов GET, которые приходят по корневому пути (/). Функция обратного будет вызываться при получении такого запроса, и она будет использовать параметр «res» (res) для отправки ответа «Hello World!» Клиенту.
**Строки 16-24:** метод прослушивания сервера используется для привязки к указанному порту и запуска прослушивания входящих запросов.
**Строка 28:** экспорт модуля чтоб можно было использовать извне
Вставьте следующий код в файл **Home > hr\_app > index.js**
```
const webServer = require('./services/web-server.js');
async function startup() {
console.log('Starting application');
try {
console.log('Initializing web server module');
await webServer.initialize();
} catch (err) {
console.error(err);
process.exit(1); // Non-zero failure code
}
}
startup();
```
Подключаем модуль веб-сервера, а затем он определяет и вызывает асинхронную функцию startup. Поскольку функция initialize веб-сервера возвращает promise, вы можете использовать его с async / await и обернуть его в блок try-catch. Если функция initialize завершается успешно, веб-сервер будет работать; в противном случае любые исключения будут перехвачены и обработаны. Все, что вам нужно сделать сейчас, это инициализировать npm и установить Express — тогда вы можете запустить приложение. Выполните следующие команды в терминале из каталога hr\_app.
```
npm init -y
npm install express -s
node .
```
Команда npm init используется для создания файла package.json, который npm использует как manifest файл (флаг -y принимает параметры по умолчанию). Команда npm install используется для установки express (флаг -s добавляет express в список зависимостей в package.json). Npm хранит установленные вами модули в каталоге node\_modules. Он также создает файл с именем package.lock.json, чтобы обеспечить идентичное дерево для команды разработчиков.
Вы видите сообщение **Web server listening on localhost:3000?** Поздравляем, вы создали экспресс-сервер на базе!
И вот он, еще один «Hello World». Хотя это и не особенно увлекательно, это важный первый шаг для вашего API.
Когда будете готовы, можете выключить сервер, вернувшись к терминалу и нажав ctrl + c.
#### Контролируемый shutdown
Во время выключения нажатием Ctrl + C у вас нет контроля над тем, как это произошло. Чтобы контролировать процесс завершения работы, вам необходимо явно закрыть веб-сервер и выйти из процесса Node.js.
Вставьте следующий код в файл **Home > hr\_app >services>web-server.js**
```
// *** previous code above this line ***
function close() {
return new Promise((resolve, reject) => {
httpServer.close((err) => {
if (err) {
reject(err);
return;
}
resolve();
});
});
}
module.exports.close = close;
```
Функция close возвращает promise, который разрешается при успешном закрытии веб-сервера. Метод httpServer.close останавливает установление новых соединений, но не заставляет закрывать уже открытые соединения. В зависимости от того, сколько соединений открыто и что они делают, вам может потребоваться немного подождать, пока не сработает обратный вызов. Хотя вы не будете делать это в этом модуле, для принудительного закрытия открытых соединений можно использовать пользовательский код или модули npm, такие как http-shutdown.
Вставьте следующий код в файл **Home > hr\_app > index.js**
```
// *** previous code above this line ***
async function shutdown(e) {
let err = e;
console.log('Shutting down');
try {
console.log('Closing web server module');
await webServer.close();
} catch (e) {
console.log('Encountered error', e);
err = err || e;
}
console.log('Exiting process');
if (err) {
process.exit(1); // Non-zero failure code
} else {
process.exit(0);
}
}
process.on('SIGTERM', () => {
console.log('Received SIGTERM');
shutdown();
});
process.on('SIGINT', () => {
console.log('Received SIGINT');
shutdown();
});
process.on('uncaughtException', err => {
console.log('Uncaught exception');
console.error(err);
shutdown(err);
});
```
События SIGINT и SIGTERM относятся к сигналам, которые могут быть отправлены процессу для его выключения, например, когда нажаты ctrl + c. Событие uncaughtException произойдет, когда ошибка JavaScript генерируется, но не перехватывается и обрабатывается с помощью оператора try-catch. Попробуйте запустить и снова закрыть приложение. Вы узнаете, что все работает правильно, когда увидите сообщения «выключения» в терминале.
#### Регистрация на сервере
Есть еще одна вещь, которая завершает наш модуль веб-сервера: HTTP logging. Существуют различные модули, которые вы можете использовать для этого типа логинига, но morgan Один из простых. Давайте установим morgan с помощью npm.
```
npm install morgan -s
```
Затем добавьте следующую строку в services / web-server.js под строкой, которая требует express (строка 2):
```
const morgan = require('morgan');
```
Теперь вы можете включить функцию morgan в качестве промежуточного программного обеспечения, через которую все запросы будут обрабатываться с помощью app.use. Добавьте эту строку перед вызовом app.get, который выдает сообщение «hello world».
```
// Combines logging info from request and response
app.use(morgan('combined'));
// *** app.get call below this line ***
```
Обратите внимание, что app.use создает конвейер (pipeline) функций промежуточного программного обеспечения (middleware), которые могут взаимодействовать с HTTP-запросами и ответами. Функции middleware будет выполняться в том порядке, в котором они включены. Перезапустите приложение и установите терминал так, чтобы вы могли видеть его и браузер одновременно. Каждый раз, когда вы перезагружаете страницу, вы должны видеть, что в терминале появляется новая запись в журнале. По умолчанию morgan передает информацию журнала в STDOUT (который отображается в терминале).
[Следующая статья](https://habr.com/ru/post/473346/) будет посвящена основам работы с базами данных, включая пулы соединений, которые помогут вам понять и построить API REST для Node.js. | https://habr.com/ru/post/473234/ | null | ru | null |
# Сказки старого DBA
Хотите легкого чтива под новый год? Вот крошечные истории про случаи из моей работы, или случаи, свидетелем которых я стал.
Свинья
------
Моя первая длительная работа была в фирме *"Ниеншанц"*, царствие ей небесное. Она работала на самописной **ERP**, которую писали мы - группа из 3-4 человек. Это были 90е годы, мы варились в собственном соку и не слышали про **QA**. То есть, девелоперская версия кода у нас крутилась отдельно, а база была одна-единственная, она же **PROD**. В горячие времена мы могли испечь и выкатить несколько релизов в день, без всяких новомодных *DevOps, CD, CI*.
Вскоре после моего ухода одного из моих коллег нашли рыдающим на клавиатуре. Он повторял одно слово - *свинья*. К счастью, рыдал он от смеха. Отлаживаясь на **PROD**, я заводил документы и, чтобы не пересекаться с реальными документами, заводил фиктивных клиентов, товары и услуги.
Так возникла доверенность на некую **Свинью**, которая умудрилась получить **доверенность** на **Хрюкание**. Аудиторы тоже очень удивлялись. Но они чаще плакали.
О форматах данных
-----------------
Немного [повторюсь](https://habr.com/ru/post/543218/), эта история из моей работы в Америке, где я работал, в том числе, в стартапе под названием Softlock.
Как образовалась там вакансия DBA? Взлет Softlock совпал с продажей книги Стивена Кинга *"Riding the bullet"* в формате PDF за символический 1 доллар через Softlock. В час X должна пойти реклама. Разумеется, за несколько недель до часа X программисты днюют и ночуют на работе. За пять минут до рекламы DBA вносит самое последнее изменение. В команде **DELETE** он забывает **WHERE** и удаляет все данные в важной таблице. *Бэкап!* кричит он. *Поздно, мы в эфире* - говорят ему. *Как идут продажи?*спрашивают менеджеры.
Короче, кое что им удалось подправить, наделав кучу костылей. DBA все исправил, но, не выдержав позора, покинул фирму. Я же разгребал его костыли вместе с коллегами из страны, где очень любят петь и танцевать. Один коллега, например, хранил суммы в колонке varchar() примерно так: '$123.45'. Я спросил его - зачем? Он пояснил, что это очень удобно, когда сумму отображаешь для пользователя, то не надо делать никаких преобразований.
Шоу для французов
-----------------
Во Франции вскоре после начала работы меня спросили, насколько я могу ускорить их систему. Я решил выглядеть профессионально, не говорить сразу - в 10 раз, а сказал - процентов на 30-40%. В итоге я ускорил систему более чем в 10 раз - у них для списков не было даже элементарного *pagination*, но это другая история.
Дело было в пятницу и французы что-то отмечали. Меня спросили, правда ли русские могут пить водку, как показывают в фильмах? Я налил водку в пластиковый стаканчик и продемонстрировал. О, сейчас других позовем - не уходи! И я показал еще и еще.
А потом на меня посмотрели и сказали - "он же сам домой не дойдет". Посадили в машину моего шефа, меня укачало, и я ее облевал. До сих пор стыдно. Зато меня зауважали как специалиста.
Динозавры
---------
Время от времени мне доводилось консультировать разных клиентов. Среди них тогда, в 2000х, еще встречались "динозавры". Я их узнавал по двум характерным вещам:
* Поставить базу в **FULL RECOVERY**, не делать бэкапов, дождаться, когда LDF файл станет 100Gb, спросить "почему база так быстро растет"
* Жаловаться на "утечки памяти SQL", что он "занимает всю память" и перезапускать его все время
Сейчас таких уже почти не встречается, но тогда это были два самых частых вопроса
Рулетка
-------
У одного клиента стояла задача читать из таблицы случайную запись. Это не причуда - это был сайт с тестами, и вопросы надо было рандомизировать. Это делалось замечательным кодом:
```
SELECT TOP 1 * FROM table ORDER BY newid()
```
Работало это прекрасно, вот только медленно: сервер должен сгенерить newid() для **всех** записей таблицы и потом их упорядочить. Как ни элегантно было это решение синтаксически, мне пришлось от него избавиться.
Заветы Oracle
-------------
В одной конторе люди, которые танцуют и поют, очевидно, пришли из Oracle (да какая им разница на чем лабать код?). После вставки записи им надо было получить @@IDENTITY. Они пишут
```
SELECT @@IDENTITY
```
и дальше их клинит. Потому что в Oracle надо обязательно писать FROM, для этого есть даже специальная табличка DUAL. Первое что им приходит в голову - указать имя самой таблицы, допустим, это была таблица FACTS:
```
SELECT @@IDENTITY FROM FACTS
```
В этом случае значение IDENTITY копируется столько раз, сколько записей в таблице. Люди, которые танцуют и поют "элегантно" заметают это под ковер:
```
SELECT DISTINCT @@IDENTITY FROM FACTS
```
И все замечательно работает... Некоторое время. Пока записей не становится много, и все встает колом. SQL генерит огромный dataset каждый раз, сортирует его и делает distinct.
Параноя
-------
С этим столкнулся мой коллега. Фирма - в России. Некая самописка плохо поддерживаемая. Тормоза. Быстрый анализ показывает, что очень помогут несколько индексов. Индексы создаются и... система отказывается стартовать!
Анализ SQL profiler показывает код, который при старте системы считывает все из sysobjects, sysindexes, syscolumns, и параноидально вычисляет checksums всего, чтобы не дай бог не изменили колонку или таблицу. Ну и индексы в том числе.
Представляю как, наверное, девелопер расчесал свое ЧСВ этим кодом!
Suicide jobs
------------
Нет, это не о камикадзе. Очень интересная система, опять написаная друзьями с юга, имела функциональность асинхронных расчетов на SQL. Тут без сарказма - ребята молодцы, создавали SQL agent jobs, которые выполняли расчеты и потом выпиливались (не ребята, а SQL jobs) - да, в SQL job может удалить саму себя!
Все это работало, но когда количество порождений jobs превысило 3-5 в секунду, пошли deadlocks со стороны SQL agent - он просто не расчитан на такой стиль использования. Я все это переписал на статические асинхронные "worker threads"
Безумная сортировка
-------------------
Очередная тормозящая система. Порядковые номера документов хранятся почему-то в char(9) *центрированными* - да, центрированными! То есть '127' будет выглядеть как <три пробела>127<еще три пробела подразумеваются>. А значит, на лету:
```
ORDER BY convert(int,ltrim(Docnum))
```
со всеми сопутствующими тормозами. Попутно дата-время хранилось не в datetime, а в двух колонках - одна дата в datetime с уcеченным временем, а время по моему в виде текста. Чтобы найти документ после какого-то точного времени надо писать:
```
(DATE>'дата' OR (DATE='дата' AND TIME>'время')
```
со всем радостным, что приносит для поиска OR. Тот, кто ко мне обратился, говорил, что систему писали голландцы (видимо, под веществами)
И еще абсолютно убойный случай
------------------------------
Один раз сотрудник нашей компании (назовем этого парня ), где я сейчас работаю, умудрился , да так, что , а потом еще , в итоге его самого , а потом догнали, и еще по самые . Кто работает у нас, разумеется, знает эту историю (совсем как "анекдот номер 187... ну нельзя же при женщинах"), а я ее рассказать сейчас не могу.
Может лет через 10 расскажу... А пока почитайте [предыдущую статью](https://habr.com/ru/post/592261/). | https://habr.com/ru/post/598611/ | null | ru | null |
# Поднимаем сложный проект на Django с использованием Docker
Добрый день, коллеги.
Сегодня я расскажу о не совсем простой концепции быстрого (до часа после нескольких тренировок) развёртывания проекта для работы команды, состоящей как минимум из отдельных фронтенд и бэкенд разработчиков.
Исходные данные у нас такие: начинается разработка проекта, в которой планируется «тонкий бэкенд». Т.е. бэк у нас состоит из закешированных страниц (рендерятся любым шаблонизатором), объёмных моделей с сопутствующей логикой (ORM) и REST API, выполняющего роль контроллера. Фактически, View в такой системе редуцировано и вынесено в JS, благо есть разные реакты, ангуляры и прочие вещи, которые позволяют фронтендщикам считать себя «белыми людьми».
Среда разработки у нас выглядит так: Ubuntu LTS (14.04), PyCharm, Python любой версии (мы возьмём 2.7 для запуска виртуальной среды, на которой будет стоять аналогичная версия). Django (1.8)
Решаем мы следующие проблемы:
1. Необходимо полностью эмулировать пространство Production, а ещё лучше — поставлять код участникам процесса разработки вместе со средой.
2. Необходимо отделить среду выполнения нашего проекта от среды операционной системы. Нам нафиг не нужны проблемы с версиями пайтона, настройками node.js или развёртыванием БД. Пусть наша настольная система будет чистой и светлой.
3. Необходимо автоматизировать развёртывание проекта, над которым будет трудиться ещё и гуру JS, и, возможно, крутой верстальщик. Да так, чтобы проект можно было поднять и у тестировщика, и у менеджера с начальными знаниями в технической области.
4. Необходимо без особых проблем отделить dev версию от production. Даунтайм должен быть минимальным. Никто не будет ждать, пока ведущий программист исправит все переменные в settings и пофиксит прочие проблемы.
5. Нужно сделать так, чтобы участники разработки не решали проблемы друг-друга. JS разработчик не должен вникать в тонкости запуска Celery, слияния JS файлов и т.д. Верстальщика не должно интересовать что компилирует его Sass код и т.д. Это относится к автоматизации развёртывания, но важно подчеркнуть, что эти проблемы могут создать неудобство и потребуется тратить время на написание подробной инструкции по развёртыванию, если оно будет происходить в ручном режиме.
Установка Docker
----------------
Для нашего приложения мы будем использовать [Docker](https://www.docker.com/). Об этом инструменте на Хабре сказано много. Сразу оговорюсь, что мы пока не планируем усложнять Production сервер. Нам важно построить среду разработки с заделом на последующее применение концепции CI. Но, в рамках текущей статьи будем работать только с docker-compose и не затронем методы быстрого деплоймента. Благо, у Docker таковых имеется в избытке.
Docker может с переменным успехом устанавливаться на Mac и Windows машины. Но мы рассмотрим его установку на Ubuntu 14.04. Есть [инструкция](http://docs.docker.com/engine/installation/ubuntulinux/) по установке Docker на этой системе, но она может вызвать проблемы. От части, можно списать их на нотик из этой инструкции:
> Note: Ubuntu Utopic 14.10 exists in Docker’s apt repository but it is no longer officially supported.
Поэтому, не выпендриваемся и ставим так, как рекомендует [другая инструкция](http://docs.docker.com/linux/step_one/):
```
$ sudo apt-get update
$ sudo apt-get install wget
wget -qO- https://get.docker.com/ | sh
```
И проверяем установку командой:
```
$ docker run hello-world
```
Теперь создадим виртуальную среду для запуска Docker:
```
$ mkdir ~/venvs
$ virtualenv ~/venvs/docker
$ source ~/venvs/docker/bin/activate
(docker) $ pip install docker-compose
(docker) $ docker-compose -v
```
Создаём проект
--------------
Откроем PyCharm и создадим проект для работы.
Проект создаём для любого интерпретатора. Пусть это будет pure python проект. На схеме выше вы видите минимальный состав проекта. За запуск сервера у нас будет отвечать supervisord. Файлы .gitignore и .dockerignore позволят указать те файлы, которые не будут закоммичены в репозиторий проекта или не будут смонтированы в docker контейнеры. Контейнерами будет управлять файл docker-compose.yml, поскольку он прост как палка и эффективен как автомат Калашникова. Для основного проекта мы дополнительно создадим Dockerfile, чтобы установить отсутствующие библиотеки.
Папка dockerfiles имеет подпапку pgdata — в ней у нас будет храниться БД от PostgreSQL на случай, если мы захотим перенести данные из одного места в другое. В dockerfiles/sshdconf поместим настройки для SSH сервера. Для прямого соединения он нам не понадобится, но для настройки окружения в PyCharm — ещё как. Ключ id\_rsa.pub позволит PyCharm соединяться с контейнером без плясок вокруг пароля. Всё что вам нужно — это создать связку SSH ключей и скопировать (или перенести) публичный ключ в директорию dockerfiles.
Директория src — корень нашего проекта. Сейчас наша задача — развернуть контейнеры.
Создаём контейнеры
------------------
Файл docker-compose.yml будет у нас выглядеть так:
```
postgresql:
image: postgres:9.3
env_file: .env
volumes:
- ./dockerfiles/pgdata:/var/lib/postgresql/data/pgdata
ports:
- "5433:5432"
project:
build: ./
env_file: .env
working_dir: /opt/project
command: bash -c "sleep 3 && /etc/init.d/ssh start && supervisord -n"
volumes:
- ./src:/opt/project
- ./dockerfiles/sshdconf/sshd_config:/etc/ssh/sshd_config
- ./dockerfiles/id_rsa.pub:/root/.ssh/authorized_keys
- /home/USERNAME/.pycharm_helpers/:/root/.pycharm_helpers/
- ./supervisord.conf:/etc/supervisord.conf
- ./djangod.conf:/etc/djangod.conf
links:
- postgresql
ports:
- "2225:22"
- "8005:8000"
```
Обратите внимание на первый контейнер — postgresql. Ему мы однозначно передаём .env для формирования первичных данных. Директива ports отвечает за проброс портов. Первая цифра перед двоеточием — номер порта, по которому будет доступна эта база в нашей убунте. Вторая цифра — это номер порта, который пробрасывается с контейнера. Дефолтный PostgreSQL порт
Второй контейнер будем собирать из Dockerfile. Поэтому, здесь стоит build. Команда запуска идёт с небольшой задержкой — на случай, если нам нужно будет время для запуска БД и других инструментов внутри контейнеров. Здесь же видим все подключаемые директории и файлы. При пробросе портов имеем порт 2225 — для SSH и 8005 — для сервера. В sshd\_config нам нужно настроить под себя вот эти директивы:
PermitRootLogin without-password
StrictModes no
RSAAuthentication yes
PubkeyAuthentication yes
AuthorizedKeysFile %h/.ssh/authorized\_keys
Помните, что всё это добро будет работать только у команды разработчиков. На продакшн мы это не выложим. Хотя, в принципе, ssh сервер будет доступен только локально.
/home/USERNAME/.pycharm\_helpers/:/root/.pycharm\_helpers/ — Эта команда на монтирование позволит нам запускать тесты и дебаг прямо из PyCharm. Не забудьте прописать тут свой USERNAME
**В supervisord.conf пропишем следующее:**
[unix\_http\_server]
file=/opt/project/daemons/supervisor.sock; path to your socket file
[supervisord]
logfile=/opt/project/logs/supervisord.log; supervisord log file
logfile\_maxbytes=50MB; maximum size of logfile before rotation
logfile\_backups=10; number of backed up logfiles
loglevel=info; info, debug, warn, trace
pidfile=/opt/project/daemons/supervisord.pid; pidfile location
nodaemon=false; run supervisord as a daemon
minfds=1024; number of startup file descriptors
minprocs=200; number of process descriptors
user=root; default user
childlogdir=/opt/project/logs/; where child log files will live
[rpcinterface:supervisor]
supervisor.rpcinterface\_factory = supervisor.rpcinterface:make\_main\_rpcinterface
[supervisorctl]
serverurl=unix:///opt/project/daemons/supervisor.sock; use unix:// schem for a unix sockets.
[include]
# Uncomment this line for celeryd for Python
files=djangod.conf
**В djangod.conf:**
[program:django\_project]
command=python /opt/project/manage.py runserver 0.0.0.0:8000
directory=/opt/project/
stopasgroup=true
stdout\_logfile=/opt/project/logs/django.log
stderr\_logfile=/opt/project/logs/django\_err.log
Тот кто внимательно читает конфиги, должен обратить внимание на то, что мы объявили две не созданные ещё папки. Так что создадим в src директории logs и daemons. В .gitignore добавим соответственно /src/logs/\* и /src/daemons/\*
Обратите внимание на то, что в django, обычно, stdout\_logfile не пишется. Все логи осыпаются в stderr\_logfile. Настройка была взята из какой-то готовой инструкции, а удалять строчку не слишком хочется, ведь stdout\_logfile — довольно стандартная директива.
**Теперь не забудем про наш .env файл:**
POSTGRES\_USER=habrdockerarticle
POSTGRES\_DB=habrdockerarticle
POSTGRES\_PASSWORD=qwerty
POSTGRES\_HOST=postgresql
POSTGRES\_PORT=5432
PGDATA=/var/lib/postgresql/data/pgdata
C\_FORCE\_ROOT=true
Его можно добавить или не добавлять в .gitignore — значения не имеет.
В конце заполним Dockerfile
FROM python:2.7
RUN apt-get update && apt-get install -y openssh-server \
&& apt-get purge -y --auto-remove -o APT::AutoRemove::RecommendsImportant=false -o APT::AutoRemove::SuggestsImportant=false $buildDeps
COPY ./src/requirements.txt ./requirements.txt
RUN pip install -r requirements.txt
[Docker Hub](https://github.com/docker-library/python/blob/5909006206b117a7e9d1a329abdde6031e7342c5/2.7/Dockerfile) не скрывает от нас того, что наш контейнер будет обслуживаться Debian Jessie. В Dockerfile мы запланировали установку ssh сервера, чистку ненужных нам списков пакетов и установку requirements. Кстати, файл зависимостей у нас ещё не создан. Надо исправить этот недочёт и создать requirements.txt в папке src:
Django==1.8
psycopg2
supervisor
Первый запуск
-------------
Проект готов к первому запуску! Запускать будем поочерёдно. Сперва выполним:
```
(docker) $ docker-compose run --rm --service-ports postgresql
```
Эта операция скачает нам образ, необходимый для запуска postgresql сервера. Сервер запустится, пользователь и база, указанные в .env создадутся автоматически. Команда заблокирует нам ввод данных, но пока не будем её останавливать. Убедимся в наличии базы и ролей входа, подключившись через pgadmin
Как мы видим, всё уже создано для работы:
Теперь комбинацией клавиш ctrl+C в консоли остановим процесс. Нам надо собрать образ проекта. Так что выполним:
```
(docker) $ docker-compose build project
```
Эта команда соберёт нам проект, а также, выполнит все команды из Dockerfile. Т.е. у нас будет установлен ssh сервер, а также, установлены зависимости из requirements.txt. Теперь у нас возникает вопрос создания Django проекта. Создать его можно нескольким способами. Самый пуленепробиваемый — это поставить в нашу docker virtualenv на убунте нужную версию Django:
```
(docker) $ pip install django==1.8
(docker) $ cd ./src
(docker) $ django-admin startproject projectname
(docker) $ cd ../
```
Django из venv можно удалить или оставить для других проектов. Всё что нам осталось — это перенести внутренности проекта в корень папки src.
Теперь нам следует проверить наш проект и настроить соединение с БД. Сперва поменяем настройки в settings.py:
```
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': os.getenv('POSTGRES_DB'),
'USER': os.getenv('POSTGRES_USER'),
'PASSWORD': os.getenv('POSTGRES_PASSWORD'),
'HOST': os.getenv('POSTGRES_HOST'),
'PORT': int(os.getenv('POSTGRES_PORT'))
}
}
```
Потом запустим контейнеры проекта:
```
(docker) $ docker-compose up -d
```
И убедимся в положительном результате:
Для остановки проекта и удаления временных файлов можно использовать:
```
(docker) $ docker-compose stop && docker-compose rm -f
```
Если у нас меняется что-то в requirements.txt, используем следующую команду для быстрого пересбора
```
(docker) $ docker-compose stop && docker-compose rm -f && docker-compose build --no-cache project && docker-compose up -d
```
Давайте, проверим какая структура проекта у нас получилась:
Папка root в моём коде содержит готовые helpers PyCharm'а.
Подключаем контейнер для JS программиста
----------------------------------------
Теперь можно сделать то, ради чего мы всё это и затевали — подключить Gulp для управления статикой. Файл docker-compose.yml теперь будет выглядеть так:
```
...
gulp:
build: ./src/gulp
command: bash -c "sleep 3 && gulp"
volumes:
- ./src/gulp:/app
- ./src/static/scripts:/app/build
project:
...
links:
- postgresql
- gulp
...
```
Я добавил новый контейнер и указал его в зависимостях к project.
Теперь мне нужно создать папку gulp в src для исходников и static/scripts для скомпилированных файлов. В папке src/gulp создадим файл package.json со следующим содержимым:
```
{
"name": "front",
"version": "3.9.0",
"description": "",
"main": "gulpfile.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "",
"license": "BSD-2-Clause",
"devDependencies": {
"gulp": "~3.9.0",
"gulp-uglify": "~1.4.2",
"gulp-concat": "~2.6.0",
"gulp-livereload": "~3.8.1",
"gulp-jade": "~1.1.0",
"gulp-imagemin": "~2.3.0",
"tiny-lr": "0.2.1"
}
}
```
Создадим gulpfile.js. в папке src/gulp. Я использовал свой старый файл для образца:
```
/**
* Created by werevolff on 18.10.15.
*/
var gulp = require('gulp'),
uglify = require('gulp-uglify'),
concat = require('gulp-concat'),
refresh = require('gulp-livereload'),
lr = require('tiny-lr'),
server = lr();
/**
* Mainpage
*/
gulp.task('mainpage', function () {
gulp.src(['./front/jquery/*.js', './front/bootstrap/*.js', './front/angularjs/angular.min.js',
'./front/angularjs/i18n/angular-locale_ru-ru.js', './front/project/**/*.js'])
.pipe(uglify())
.pipe(concat('mainpage.js'))
.pipe(gulp.dest('./build'))
.pipe(refresh(server));
});
/**
* Rebuild JS files
*/
gulp.task('lr-server', function () {
server.listen(35729, function (err) {
if (err) return console.log(err);
});
});
/**
* Gulp Tasks
*/
gulp.task('default', ['mainpage', 'lr-server'], function () {
gulp.watch('./front/**/*.js', ['mainpage']);
});
```
Как мы видим из конфига, нам следует залить в папку src/gulp/front некоторые популярные библиотеки и создать папку src/gulp/front/project для написанных JS программистом скриптов. Также, не забываем о создании Dockerfile в src/gulp
FROM neo9polska/nodejs-bower-gulp
COPY package.json ./package.json
COPY node\_modules ./node\_modules
RUN npm install --verbose
Теперь довольно важный вопрос — node\_modules. Без этой папки контейнер с Gulp будет откровенно лажать. Здесь у нас два варианта получения этой папки:
1. Собрать проект на локальной машине и перенести из него папку с модулями
2. Убрать из Dockerfile всё что ниже директивы FROM, выполнить docker-compose run --rm gulp npm install --verbose, а потом поменять права на директорию с node\_modules и вернуть то, что было ниже FROM обратно.
Однако, менять права не обязательно. Просто разработчики будут вынуждены постоянно выполнять команду на пересборку gulp. Впрочем, весь код, описанный в статье, я выложу на Github и можно взять node\_modules оттуда. Проблема эта связана с docker-compose. Но победить её легко.
Итак, в результате запуска контейнеров
```
(docker) $ docker-compose up -d
```
Мы должны получить вот такой скомпилированный файл:
.
Готово! Проект можно залить в git и начинать работать с ним.
Полная команда перезапуска с пересборкой выглядит так:
```
(docker) $ docker-compose stop && docker-compose rm -f && docker-compose build --no-cache gulp && docker-compose build --no-cache project && docker-compose up -d
```
Для запуска проекта у нового участника процесса достаточно выполнить:
```
(docker) $ docker-compose build --no-cache gulp && docker-compose build --no-cache project && docker-compose up -d
```
Для просмотра основного журнала контейнера с запущенным приложением:
```
(docker) $ docker-compose logs CONTAINER NAME
```
Логи Django из project пишутся в папку src/logs.
Исходный код проекта вы можете посмотреть в [моём GitHub](https://github.com/werevolff/habr-docker-article).
P.S. Ещё один важный аспект — настройка интерпретатора python в PyCharm. Для этой настройки достаточно добавить remote interpreter:
И обратите внимание на то, что PyCharm имеет плагин для интеграции с Docker. Мы же используем SSH соединение, поскольку не затрагивали вопрос развёртывания проекта на docker-machine. | https://habr.com/ru/post/272811/ | null | ru | null |
# Написание программного обеспечения с функционалом клиент-серверных утилит Windows, part 02
Продолжая начатый цикл статей, посвященный кастомным реализациям консольных утилит Windows нельзя не затронуть TFTP (Trivial File Transfer Protocol) — простой протокол передачи файлов.
Как и в прошлой раз, кратко пробежимся по теории, увидим код, реализующий функционал, аналогичный требуемому, и проанализируем его. Подробнее — под катом
Не буду копипастить справочную информацию, ссылки на которую традиционно можно найти в конце статьи, скажу лишь, что по своей сути TFTP — упрощенная вариация протокола FTP, в которой убрана настройка контроля доступа, да и по сути тут нет ничего кроме команд получения и передачи файла. Однако, дабы сделать нашу реализацию чуть более изящной и адаптированной к нынешним принципам написания кода, синтаксис немного изменен — принципов работы это не изменяет, но интерфейс, ИМХО, становится чуть более логичным и сочетает в себе положительные стороны FTP и TFTP.
В частности, при запуске клиент запрашивает ip адрес сервера и порт, на котором открыт кастомный TFTP (в силу несовместимости с стандартным протоколом я счел уместным оставить возможность выбора порта пользователю), после чего происходит соединение, в результате которого клиент может оправить одну из команд — get или put, для получения или отправки файла на сервер. Все файлы отправляются в бинарном режиме — в целях упрощения логики.
Для реализации протоола мною было использовано традиционно 4 класса:
* TFTPClient
* TFTPServer
* TFTPClientTester
* TFTPServerTester
В силу того, что тестирующие классы существуют только для отладки основных, разбирать я их не буду, но код будет находиться в репозитории, с ссылкой на него можно ознакомиться в конце статьи. А основные классы сейчас разберу.
#### TFTPClient
Задача этого класса — подключиться к удаленному серверу по его ip и номеру порта, считать с входного потока (в данном случае — клавиатуры) команду, распарсить ее, передать серверу, и, в зависимости от того, требуется передача или получение файла, передать его или получить.
Код запуска клиента на подключение к серверу и ожидание команды с потока ввода выглядит так. Ряд глобальных переменных, которые тут используются, описываются за пределами статьи, в полном тексте программы. В силу их тривиальности я не привожу, дабы не перегружать статью.
```
public void run(String ip, int port)
{
this.ip = ip;
this.port = port;
try {
inicialization();
Scanner keyboard = new Scanner(System.in);
while (isRunning) {
getAndParseInput(keyboard);
sendCommand();
selector();
}
}
catch (Exception e) {
System.out.println(e.getMessage());
}
}
```
Пробежимся по методам, вызываемым в данном блоке кода:
Тут происходит отправка файла — с помощью сканера мы представляем содержимое файла как массив байтов, которые поочередно пишем в сокет, после чего закрываем его и открываем заново (не самое очевидное решение, но оно гарантирует освобождение ресурсов), после чего выводим на экран сообщение об успешной передаче.
```
private void put(String sourcePath, String destPath)
{
File src = new File(sourcePath);
try {
InputStream scanner = new FileInputStream(src);
byte[] bytes = scanner.readAllBytes();
for (byte b : bytes)
sout.write(b);
sout.close();
inicialization();
System.out.println("\nDone\n");
}
catch (Exception e) {
System.out.println(e.getMessage());
}
}
```
Данный фрагмент кода описывает получение данных с сервера. Все опять-таки тривиально, интерес представляет лишь первый блок кода. Для того, что бы понимать, сколько именно байт нужно считать с сокета, нужно знать, сколько весит передаваемый файл. Размер файла на сервере представляется длинным целым числом, поэтому тут принимается 4 байта, которые в последствии конвертируются в одно число. Это не очень Джавный подход, такое скорее подобно для СИ, но свою задачу оно решает.
Дальше все тривиально — мы получаем известное число байтов с сокета и записываем их в файл, после чего выводим сообщение об успехе.
```
private void get(String sourcePath, String destPath){
long sizeOfFile = 0;
try {
byte[] sizeBytes = new byte[Long.SIZE];
for (int i =0; i< Long.SIZE/Byte.SIZE; i++)
{
sizeBytes[i] = (byte)sin.read();
sizeOfFile*=256;
sizeOfFile+=sizeBytes[i];
}
FileOutputStream writer = new FileOutputStream(new File(destPath));
for (int i =0; i < sizeOfFile; i++)
{
writer.write(sin.read());
}
writer.close();
System.out.println("\nDONE\n");
}
catch (Exception e){
System.out.println(e.getMessage());
}
}
```
В случае, если в окно клиента была введена команда, отличная от get или put, будет вызвана функция showErrorMessage, показывающая некорректность инпута. В силу тривиальности — не привожу. Несколько интереснее функция получния и разбиения входной строки. В нее мы передаем сканер, от которого ожидаем получить строку, разделенную двумя пробелами и содержащую в себе команду, адрес источник и адрес назначения.
```
private void getAndParseInput(Scanner scanner)
{
try {
input = scanner.nextLine().split(" ");
typeOfCommand = input[0];
sourcePath = input[1];
destPath = input[2];
}
catch (Exception e) {
System.out.println("Bad input");
}
}
```
Отправка команды — передача введенной с сканера команды в сокет и принудительная отправка ее
```
private void sendCommand()
{
try {
for (String str : input) {
for (char ch : str.toCharArray()) {
sout.write(ch);
}
sout.write(' ');
}
sout.write('\n');
}
catch (Exception e) {
System.out.print(e.getMessage());
}
}
```
Селектор — функция, которая определяет действия программы в зависимости от введенной строки. Тут все не очень красиво и используется не самый хороший прием с принудительным выходом за пределы блока кода, но основной причиной этого является отсутствие в Джаве некоторых вещей, как делегаты в С#, указатели на функцию из C++ или хотя бы страшный и ужасный goto, которые позволяют реализовать это красиво. Если знаете, как сделать код чуть более изящным — жду критику в комментариях. Мне кажется, что тут нужен словарь String-delegate, но делегата нету…
```
private void selector()
{
do{
if (typeOfCommand.equals("get")){
get(sourcePath, destPath);
break;
}
if (typeOfCommand.equals("put")){
put(sourcePath, destPath);
break;
}
showErrorMessage();
}
while (false);
}
}
```
#### TFTPServer
Функционал сервера отличается от функционала клиента по большому счету лишь тем, что команды на него приходят не с клавиатуры, а из сокета. Часть методов вообше совпадает, поэтому приводить их я не буду, затрону лишь различия.
Для запуска тут используется метод run, получающий на вход порт и обрабатывающий входные данные с сокета в вечном цикле.
```
public void run(int port) {
this.port = port;
incialization();
while (true) {
getAndParseInput();
selector();
}
}
```
Метод put, являющийся оберткой метода writeToFileFromSocket, открывающего поток записи в файл и записывающего все байты ввода с сокета, после заверщения записи выводит сообщение об успешном завершении передачи.
```
private void put(String source, String dest){
writeToFileFromSocket();
System.out.print("\nDone\n");
};
private void writeToFileFromSocket()
{
try {
FileOutputStream writer = new FileOutputStream(new File(destPath));
byte[] bytes = sin.readAllBytes();
for (byte b : bytes) {
writer.write(b);
}
writer.close();
}
catch (Exception e){
System.out.println(e.getMessage());
}
}
```
Метод get обеспечивает получение файла сервера. Как уже говорилось в разделе о клиентской стороне программы, для успешной передачи файла нужно знать ее размер, хранящийся в длинном целом, поэтому я осуществляю его разбиение на массив из 4 байт, побайтово передаю их в сокет, а потом, получив и собрав их на клиенте в число обратно, передаю все байты, составляющие файл, считанные из потока ввода из файла.
```
private void get(String source, String dest){
File sending = new File(source);
try {
FileInputStream readFromFile = new FileInputStream(sending);
byte[] arr = readFromFile.readAllBytes();
byte[] bytes = ByteBuffer.allocate(Long.SIZE / Byte.SIZE).putLong(sending.length()).array();
for (int i = 0; i
```
Метод getAndParseInput совпадает с аналогичным в клиенте, с той лишь разницей, что он считывает данные с сокета, а не с клавиатуры. Код в репозитории, как и selector.
В данном случае инициализация вынесена в отдельный блок кода, т.к. в рамках данной реализации после окончания передачи ресурсы освобождаются и снова занимаются заново — опять-таки с целью обеспечения защиты от утечки памяти.
```
private void incialization()
{
try {
serverSocket = new ServerSocket(port);
socket = serverSocket.accept();
sin = socket.getInputStream();
sout = socket.getOutputStream();
}
catch (Exception e) {
System.out.print(e.getMessage());
}
}
```
Резюмируя:
Только что мы написали свою вариацию на тему простого протокола передачи данных и разобрались в том, как он должен работать. В принципе, Америки я тут не открыл и сильно нового не написал, но — аналогичных статей на Хабре не было, а в рамках написания цикла статей о утилитах cmd нельзя было его не затронуть.
Ссылки:
[Репозиторий с исходным кодом](https://github.com/Toxa-p07a1330/Temviewer/tree/master/src)
[Кратко о TFTP](https://www.lifewire.com/definition-of-tftp-817576)
[Тоже самое, но на русском](http://www.netza.ru/2013/03/tftp.html) | https://habr.com/ru/post/461083/ | null | ru | null |
# Детектирование позы человека при помощи библиотеки OpenPose
Привет, Хабр! Сегодня расскажу о решении важной для многих из нас и ставшей уже классической задачи - детектировании позы человека на изображении. Решать её я предлагаю с использованием библиотеки OpenPose. Всё самое интересное ― под катом. Сразу скажу, что статья небольшая, но наглядная ― я постаралась без лишних слов показать возможности библиотеки. В первую очередь она предназначена для начинающих специалистов, но, возможно, и профи найдут что-то полезное для себя.
Определить позу человека на изображении? А в чём проблема?
----------------------------------------------------------
Но каждый, кто писал программы распознавания объектов, используя opencv, знает, что выделение опорных точек и построение выпуклой оболочки ― наименьшего выпуклого множества, содержащего опорные точки, дело часто тяжёлое и неблагодарное.
Для примера давайте решим нашу классическую задачу и определим опорные точки на изображении.
```
image = cv.imread(“C:/Users/User/anaconda3/libs/openpose/examples/media/COCO_val2014_000000000192.jpg”)
im = image.copy() / 255.
im = im / 255
im = rgb2gray(im)
contours, hierarchy = cv2.findContours(img_as_ubyte(im), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)
ma = 0
cnt = 0
for cont in contours:
ar = cv2.contourArea(cont)
if ma < ar:
ma = ar
cnt = cont
hull = cv2.convexHull(cnt, returnPoints = False)
defects = cv2.convexityDefects(cnt,hull)
m = cv2.moments(cnt)
cx = int(m[“m10”]/m[“m00”])
cy = int(m[“m01”]/m[“m00”])
fng = []
for point in defects:
point = point[0]
s, e, f = cnt[point[0]][0], cnt[point[1]][0], cnt[point[2]][0]
d = point[3] / 256.0
fng.append([tuple(s), tuple(e), tuple(f), d])
for point in fng:
cv.circle(image, point[0], 5, [255,0,0], -1)
cv.circle(image, point[1], 5, [255,0,0], -1)
cv. circle(image, point[2], 5, [255,1,0],-1)
```
Для того чтобы оптимально решить задачу, сначала лучше преобразовать изображение. А именно ― нормализовать и перевести в серый, после чего определить контуры, построить выпуклую оболочку и вывести на изображение опорные точки. Казалось бы, всё просто ― чтобы узнать позу человека, нужно связать только крайние точки тела, к тому же с ближайшими соседями. Но это только кажется, что всё просто. Даже с обычным изображением не всё гладко, а ведь может быть и множество нюансов. Ну например, если на изображении видно не всё тело?
Работы здесь просто вагон и маленькая тележка, может, и не одна. К счастью, для облегчения задач в этом направлении есть несколько крутых решений, которые упрощают нам жизнь. Одно из них ― как раз OpenPose.
Что это такое и как работает?
-----------------------------
Одна из первых, если не первая, систем для обнаружения человеческого тела в многомерном пространстве в реальном времени ― всего используется 135 ключевых точек. Они обычно соответствуют «сочленениям», если так можно выразиться, с определённой степенью свободы на человеческом теле. Пример ― шея, плечо, локоть, запястье и т. д.
Впервые модель была предложена исследователями из Университета Carnegie Mellon. На сегодняшний день OpenPose используют в работе тысячи специалистов из крупных и мелких компаний. Например, с ней работает [Disney](https://nplus1.ru/news/2018/07/19/disney) для точной передачи позы человека персонажами, а создатели алгоритма из [Carnegie Mellon University](http://edurobots.ru/2017/12/openpose-dancing-robot/) научили робота копировать движения человека. Есть и другие проекты на базе OpenPose ― так, команда учёных из [Университета Женевы](https://www.techexplorist.com/using-ai-scientists-developed-device-detect-autism/41062/) применяет систему для диагностики аутизма у детей.
Теперь давайте посмотрим, как всё это работает. Ниже ― изображение для наглядности.
Вход модели представляет собой цветную картинку размера h\*w. Далее ― 10 слоёв VGGNet (Very Deep Convolutional Network), они используются для создания карты признаков (feature maps) входного изображения.
Затем карта признаков обрабатывается в многоэтапном конвейере CNN (Convolutional neural network) для создания карт достоверности (Confidence Maps) и поля сходства деталей (Part Affinity Fields).
Карта достоверности ― набор матриц или «тепловая карта» для каждой ключевой точки. Каждая матрица отражает достоверность появления определённой ключевой точки в пикселе. Чем выше значение на карте, тем выше вероятность появления опорной точки в этой части изображения.
Поле сходства деталей ― набор матриц, который отражает степень близости для найденных ранее опорных точек и отвечает за кодирование 2D-вектора положения, а также направления конечностей в области изображения.
После получения карт достоверности (Confidence Maps) и поля сходства деталей (Part Affinity Fields) применяется Венгерский алгоритм (Двудольное соответствие в теории графов ― максимальное количество совпадений рёбер среди всех совпадений графа), чтобы найти связь частей и соединить суставы одного и того же человека. Из-за векторной природы самого PAF сгенерированные совпадения объединяют общий скелет человека.
Примеры? Они есть у меня
------------------------
Всё это красивая теория, но давайте посмотрим, что у нас с практическим применением системы. Скачиваем последнюю версию библиотеки с [github](https://github.com/CMU-Perceptual-Computing-Lab/openpose/releases).
1. OpenPose можно запустить из командной строки, указав путь к изображениям или видео:
`bin\OpenPoseDemo.exe --image_dir examples\media\`
Программа сама откроет окно с результатами:
2. Можно работать с OpenPose так же, как с обычной библиотекой Указываем путь до директории с библиотекой и импортируем её.
```
sys.path.append(dir_path + ‘/../../python/openpose/Release’);
os.environ[‘PATH’] = os.environ[‘PATH’] + ‘;’ + dir_path + ‘/../../x64/Release;’ + dir_path + ‘/../../bin;’
import pyopenpose as op
```
Запускаем модель, передав ей необходимые параметры.
```
# Starting OpenPose
opWrapper = op.WrapperPython()
opWrapper.configure(params)
opWrapper.start()
```
На этом этапе приступаем к обработке изображения.
```
# Process Image
Datum = op.Datum()
imageToProcess = cv2.imread(args[0].image_path)
datum.cvInputData = imageToProcess
opWrapper.emplaceAndPop(op.VectorDatum([datum]))
```
Выводим изображение с добавлением полученных опорных точек.
```
#Display Image
print(“Body keypoints: \n” + str(datum.poseKeypoints))
cv2.imshow(“OpenPose 1.7.0 – Tutorial Python API”, datum.cvOutputData)
cv.waitKey(0)
```
Возможностей просто море!
-------------------------
OpenPose способна детектировать позы сразу нескольких людей на изображении плюс покадрово обрабатывать видео, распознавать точки на лице или пальцах рук. При этом модель, как было показано выше, является невероятно простой в использовании, избавляя от необходимости самому разбираться с opencv и отбором необходимых точек. Это просто глоток свежего воздуха в атмосфере множества рутинных задач по обработке изображений. | https://habr.com/ru/post/683090/ | null | ru | null |
# Основы Linux от основателя Gentoo. Часть 3 (1/4): Документация
Первый отрывок третьей части серии руководств для новичков. Практически всё, что нужно знать, чтобы найти справочную информацию по вашей системе. Короче, RTFM и не задавайте глупых вопросов.
>
>
> [](http://www.gnu.org/graphics/3dbabygnutux.html)
>
> ##### **Навигация по основам Linux от основателя Gentoo:**
>
>
>
> ###### Часть I: [1](/post/99041/ "BASH: основы навигации (вступление)"), [2](/post/99291/ "Управление файлами и директориями"), [3](/post/99653/ "Ссылки, а также удаление файлов и директорий"), [4](/post/99827/ "Glob-подстановки (итоги и ссылки)")
>
>
>
> ###### Часть II: [1](/post/102442/ "Регулярные выражения (вступление)"), [2](/post/105495/ "Назначения папок, поиск файлов"), [3](/post/105657/ "Управление процессами"), [4](/post/105926/ "Обработка текста и перенаправления"), [5](/post/107981/ "Модули ядра (итоги и ссылки)")
>
>
>
> ###### Часть III
>
> 1. **Документация** (вступление)
> 2. [Модель прав доступа](/post/109392/)
> 3. [Управление аккаунтами](/post/110012/)
> 4. [Настройка окружения](/post/110697/) (итоги и ссылки)
>
>
>
>
Предисловие
-----------
### Об этом руководстве
Встречайте «Администрирование для продолжающих», третье из четырех пособий, созданных для подготовки к экзамену «Linux Professional Institute's 101» (2-ая редакция). Данная часть идеальна для тех, кто хочет улучшить свои знания фундаментальных основ администрирования Linux. Мы охватим ряд тем, включая системную и интернет документацию, модель прав доступа в Linux, управление аккаунтами пользователей и настройку окружения входа в систему.
Если вы новичок в Linux, рекомендуем начать с Частей [1](/post/99041/) и [2](/post/102442/). Для некоторых большая часть информации, изложенной в самоучителе, будет новой, но более опытные пользователи могут использовать его для того, чтобы отточить свои навыки администрирования Linux.
В конце серии этих руководств (всего их восемь, подготавливающих к экзаменам LPI 101 и 102) у вас будут все знания, необходимые для того, чтобы стать системным администратором Linux систем, а так-же вы будете готовы к получению сертификата LPIC уровня 1 от института Linux Professional.
Системная и сетевая документация
--------------------------------
### Типы системной документации в Linux
Существует три основных источника документации в Linux системах: страницы руководств (маны), info-страницы и поставляемая с приложениями документация в */usr/share/doc*. В этом разделе мы рассмотрим каждый из этих источников, перед тем, как обращаться во внешний мир за дополнительной информацией.
### Страницы руководств
Страницы руководств, или “man (от англ. manual — руководство) страницы”, ман-страницы, далее просто маны — это классическая форма справочной документации UNIX и Linux. В идеале, вы можете найти ман для любой команды, конфигурационного файла или библиотеки. Однако, на практике, Linux это бесплатное программное обеспечение и некоторые страницы руководств не были написаны или устарели. Тем не менее, маны остаются первым местом, куда следует обращаться за помощью.
Для доступа к ману просто введите man, а затем ваш запрос. Запустится программа-пейджер (просмотрщик, обычно less или more) со справочной информацией. Для того, чтобы закрыть её, нажмите клавишу q. Например, чтобы посмотреть информацию о команде ls, введите:
`$ **man ls**`
Знание структуры мана поможет быстро перемещаться к необходимой вам информации. Обычно, вы найдете следующие разделы в мане:
| | |
| --- | --- |
| NAME (ИМЯ) | Имя и однострочное описание команды |
| SYNOPSIS (ОБЗОР) | Краткий обзор |
| DESCRIPTION (ОПИСАНИЕ) | Углублённое описание функционала команды |
| EXAMPLES (ПРИМЕРЫ) | Советы по использованию |
| SEE ALSO (СМОТРИ ТАКЖЕ) | Связаные темы (обычно также ман-страницы) |
### Секции ман-страниц
Файлы, содержащие информацию манов хранятся в */usr/share/man* (или в */usr/man* на некоторых старых системах). В этой директории вы найдёте страницы руководств, упорядоченные по следующим секциям:
| | |
| --- | --- |
| man1 | Пользовательские программы |
| man2 | Системные вызовы |
| man3 | Библиотечные функции |
| man4 | Специальные файлы |
| man5 | Форматы файлов |
| man6 | Игры |
| man7 | Другое |
### Многочисленные ман-страницы
Некоторые темы существуют более чем в одной секции. Для демонстрации этого воспользуюемся командой whatis, показывающей доступные маны по теме:
````
$ **whatis printf**
printf (1) - format and print data
printf (3) - formatted output conversion
````
В данном случае, man printf по-умолчанию обратится к странице в секции 1 (Пользовательские программы). Если мы пишем программу на языке C, нас вероятно больше интересует страница из секции 3 (Библиотечные функции). Вы можете вызывать ман необходимой секции указав это в командной строке, так для вызова printf(3) мы введём:
`$ **man 3 printf**`
### Поиск нужного мана
Иногда сложно найти правильную ман-страницу по заданной теме. В этом случае можно воспользоваться man -k для поиска по разделам «ИМЯ» ман-страниц. Но будьте осторожны, поскольку осуществляется поиск по подстроке и что-то, навроде man -k ls, выдаст очень много всего! Вот пример использования уточняющего запроса:
````
$ **man -k whatis**
apropos (1) - search the whatis database for strings
makewhatis (8) - Create the whatis database
whatis (1) - search the whatis database for complete words
````
### Всё об “apropos”
Предыдущий пример не случаен. Во-первых, команда apropos полностью соответствует команде man -k. (На самом деле, я даже вам раскрою небольшой секрет. Когда вы запускаете man -k, фактически «за кулисами» стартует apropos). Во-вторых, существует команда makewhatis, которая сканирует все страницы в вашей Linux системе и создает базу данных для whatis и apropos. Обычно она запускается периодически из-под рута, чтобы поддерживать базу в актуальном состоянии:
`# **makewhatis**`
Для более подробной информации о команде «man» и её друзьях, вам стоит начать с изучения её собственной ман-страницы:
`$ **man man**`
### MANPATH
По умолчанию, программа man будет искать ман-страницы в */usr/share/man*, */usr/local/man*, */usr/X11R6/man*, и быть может в */opt/man*. Возможно, вы захотите добавить новый пункт в этом пути поиска. Для этого, просто откройте */etc/man.conf* в текстовом редакторе и добавьте строчку вроде такой:
`MANPATH /opt/man`
С этого момента, страницы руководств в директориях /opt/man/man\* также будут найдены. Помните, что вам необходимо запустить makewhatis, чтобы добавить новые маны в базу whatis.
### GNU info
Одно из ограничений страниц руководств это то, что они не поддерживают гипертекст, так что у вас не получится просто переходить от одного руководства к другому. Ребята из GNU увидели этот недостаток и ввели другой формат документации: инфо-страницы. Многие из программ GNU идут с расширенной документацией в формате инфо-страниц. Вы можете приступить к чтению инфо-страниц при помощи комманды «info»:
`$ **info**`
Простой вызов команды info даст список доступных инфо-страниц в вашей системе. Вы можете перемещаться по нему используя стрелки, переходить по ссылкам (которые обозначены звездочкой) с помощью клавиши Enter и выйти нажав q. Навигация основана на таковой в Emacs, так что если вы знакомы с этим редактором, вам будет легко освоиться. Чтобы познакомиться с Emacs, посмотрите руководство на developerWorks: [Living in Emacs](http://www-106.ibm.com/developerworks/edu/l-dw-linuxemacs-i.html).
Вы также можете указать нужную инфо-страницы в командной строке:
`$ **info diff**`
Чтобы получить больше информации об использовании просмотрщика инфо-страниц, попробуйте прочитать его собственную инфо-страницу. Вы сможете перемещаться по документу просто используя несколько клавиш о которых я уже упоминал:
`$ **info info**`
### /usr/share/doc
Есть еще один источник помощи в вашей системе Linux. Большинство программ поставляются с дополнительной документацией в других форматах, таких как: простые текстовые файлы, PDF, PostScript, HTML. Посмотрите в каталоге usr/share/doc (или /usr/doc на более старых системах). Вы найдете длинный список директорий, каждая из которых идет с определенным приложением на вашей системе. Поиск по этой документации может навести вас на очень ценную информацию, которая не доступна в манах или инфо-страницах, такую как учебники или дополнительная технической документация. Беглый взгляд указывает на то, что здесь очень много материала для чтения:
`$ **cd /usr/share/doc**
$ **find . -type f | wc -l**
7582`
Фьюу! Вашим домашним заданием на этот вечер будет прочитать всего лишь половину (3791) этих документов. Учтите, завтра будет опрос. ;-)
### Linux Documentation Project
В дополнение к системной документации, в интернете существует ряд отличных ресурсов посвященных Linux. "[Linux Documentation Project](http://www.tldp.org/)" (LDP) — это группа добровольцев, которые занимаются составлением полного набора свободной документации по Linux. Данный проект существует чтобы собрать различные части документации по Linux в определенным месте, где её будет легко искать и использовать.
### Обзор LDP
LDP состоит из следующих разделов:
* Guides (руководства) — большие, очень серьезные пособия, такие как [The Linux Programmer's Guide](http://www.tldp.org/LDP/lpg/index.html) (Руководство программиста Linux)
* HOWTOs — помощь по конкретной теме, например [DSL HOWTO](http://www.tldp.org/HOWTO/DSL-HOWTO/index.html)
* FAQs — сборники ответов на часто задаваемые вопросы, навроде этого [Brief Linux FAQ](http://www.tldp.org/FAQ/faqs/BLFAQ)
* Man pages — помощь по конкретной команде (это те же самые маны, что вы видите в вашей системе, когда используете команду man).
Если вы не уверены какой раздел смотреть, вы можете воспользоваться богатыми возможностями поиска, который позволит найти всё, что есть по теме.
LDP в добавок предоставляет доступ к списку ссылок и ресурсов, таких как [Linux Gazette](http://www.tldp.org/LDP/LG/current/) и [Linux Weekly News](http://www.lwn.net), а также к спискам рассылки и архивам новостей.
### Списки рассылки
Списки рассылки являются, вероятно, самым важным средством взаимодействия разработчиков Linux. Зачастую проекты разрабатываются участниками живущими на большом расстоянии друг от друга, возможно даже на противоположных сторонах земного шара. Списки рассылки представляют метод взаимодействия, в котором каждый разработчик проекта может связаться со всеми остальными и вместе дискутировать посредством электронной почты. Один из самых известных списков рассылки разработчиков, это [Linux Kernel Mailing List](http://www.tux.org/lkml/) (список рассылки ядра Linux).
### Еще о списках рассылки
В дополнение к разработке, списки рассылки могут предоставлять возможность задавать вопросы и получать ответы от знающих разработчиков или даже других пользователей. К примеру, отдельные дистрибутивы часто предоставляют список рассылки для новичков. Вы можете проверить на сайте вашего дистрибутива информацию о том, какие списки рассылки он предлагает.
Если вы уделили время чтобы прочитать LKML FAQ по ссылке выше, то возможно заметили, что подписчики на списки рассылок часто недружелюбно относятся к вопросам, которые часто повторяются. Всегда разумно поискать в архивах рассылки перед тем, как задавать свой вопрос. Есть шансы, что это сэкономит и ваше время тоже!
### Группы новостей
Новостные группы (англ. newsgroups) в интернете похожи на списки рассылки, но основаны на другом протоколе, который называется NNTP (Network News Transfer Protocol, что в переводе «Сетевой протокол передачи новостей»), а не на обмене электронной почтой. Чтобы иметь возможность общаться, вам придется установить NTTP-клиент, например slrn или pan. Основным преимуществом является тот факт, что вы можете принять участие в дискуссии, когда вам это нужно, а не постоянно смотреть как она ломится в ваш почтовый ящик :-)
Наибольший интерес представляют новостные группы начинающиеся с comp.os.linux. Посмотреть [список групп](http://www.tldp.org/links/#ng) вы можете на сайте LDP.
### Сайты поставщиков и прочие
Сайты различных дистрибутивов Linux зачастую предоставляют обновленную документацию, инструкции по установке, информацию о совместимости или несовместимости с оборудованием и другие средства поддержки, такие как поиск по базе знаний. Например:
* **[Redhat Linux](http://www.redhat.com/)**
* **[Debian Linux](http://www.debian.org/)**
* **[Gentoo Linux](http://www.gentoo.org/)**
* **[SuSE Linux](http://www.suse.com/)**
* **[Caldera](http://www.caldera.com/)**
* **[Turbolinux](http://www.turbolinux.com/)**
### Поставщики аппаратного и программного обеспечения
В последние годы, многие поставщики устройств и программного обеспечения добавили поддержку Linux для своих продуктов. На их сайтах вы можете найти информацию о том, какое оборудование поддерживает Linux, найти инструменты разработки программ, исходники, скачать драйвера для Linux под конкретное устройство, а также, узнать о других всевозможных Linux-проектах. Например:
* **[IBM и Linux](http://www.ibm.com/linux/)**
* **[HP и Linux](http://www.hp.com/products1/linux/)**
* **[Sun и Linux](http://www.sun.com/linux/)**
* **[Oracle и Linux](http://technet.oracle.com/tech/linux/content.html)**.
*Перевод выполнил коллективный разум с помощью [notabenoid.com](http://notabenoid.com/). Спасибо хабравчанам (в алф. порядке): [DMinsky](https://habrahabr.ru/users/dminsky/), [habrrich](https://habrahabr.ru/users/habrrich/) и **kindacute** (на хабре?). Их карма заслуживает плюсов. Если кого не упомянул, напишите в личку или в комментариях.*
**[Продолжение...](/post/109392/)**
---
Об авторах
----------
### Daniel Robbins
Дэниэль Роббинс — основатель сообщества Gentoo и создатель операционной системы Gentoo Linux. Дэниэль проживает в Нью-Мехико со свой женой Мэри и двумя энергичными дочерьми. Он также основатель и глава [Funtoo](http://www.funtoo.org/), написал множество технических статей для [IBM developerWorks](http://www.ibm.com/developerworks/), Intel Developer Services и C/C++ Users Journal.
### Chris Houser
Крис Хаусер был сторонником UNIX c 1994 года, когда присоединился к команде администраторов университета Тэйлора (Индиана, США), где получил степень бакалавра в компьютерных науках и математике. После он работал во множестве областей, включая веб-приложения, редактирование видео, драйвера для UNIX и криптографическую защиту. В настоящий момент работает в Sentry Data Systems. Крис также сделал вклад во множество свободных проектов, таких как Gentoo Linux и Clojure, стал соавтором книги [The Joy of Clojure](http://joyofclojure.com).
### Aron Griffis
Эйрон Гриффис живет на территории Бостона, где провел последнее десятилетие работая в Hewlett-Packard над такими проектами, как сетевые UNIX-драйвера для Tru64, сертификация безопасности Linux, Xen и KVM виртуализация, и самое последнее — платформа [HP ePrint](http://hpeprint.com/). В свободное от программирования время Эйрон предпочитает размыщлять над проблемами программирования катаясь на своем велосипеде, жонглируя битами, или болея за бостонскую профессиональную бейсбольную команду «Красные Носки». | https://habr.com/ru/post/108764/ | null | ru | null |
# Роботы на карантине
Тут недавно мужики на Хабре рассказывали про Flipper и отладку на осциллографе по видеосвязи.
И это, конечно, победа вне конкурса! Но и у нас был интересный опыт отладки робота, находящегося в 2000 км от нас в лодочном гараже на норвежском побережье. Под катом рассказ о том, как мы делали зрение и правили “облачные мозги” роботам во время карантина удаленно:
Весной мы сделали прототип всей системы удаленного управления по 3D стриму и [обучения роботом на двуруком YuMi](https://www.youtube.com/watch?v=6Hgi_BYp0Os) и познакомились норвежской компанией, чье решение нам очень кстати для трансляции 3D потока Realsense камер — Aivero. Так что после не самого простого рабочего периода планы казались безоблачными: слетать в Италию на месяц зимы с семьей, оттуда поездить по выставкам робототехники в Европе и закончить все остановкой на пару недель в городе с прекрасными фьордами в округе — Ставангер, где и обсудить интеграцию 3D кодеков в нашу систему и попробовать убедить Aivero собрать пару роботов вместе.
Что могло пойти не так в этом замечательном плане…
Сидя 2 недели на карантине после возвращения (не без приключений) из итальянского локдауна, пришлось сдуть пыль со своего разговорного и письменного английского и исполнять вторую часть плана уже в Zoom-е, а не в антураже фьордов.
Хотя, тут как взглянуть. Карантин заставил многих всерьез начать работать над возможными способами автоматизацией там, где человека не сложно заменить. Тем более для западных стран, в которых минимальная зарплата выше 1500 Евро, где роботизация простого ручного труда актуальна и без текущей эпидемиологической обстановки.
### Подключаем разных роботов
Напомню, мы сделали обучение роботов по записям удаленного управления. Т.е. робот подключается к интернету, к нашему облаку и начинает слать 3D картинки и показания датчиков. Обратно получает команды и исполняет их. В такой логике наша задача научить ML процессор вести себя также, как оператор. 3D нужно, чтобы отрисовать оператору сцену в виртуальной реальности. Это удобно, да и ML становится намного точнее при хватании объектов, когда есть карта глубин.
По задумке, мы можем подключать разнообразных роботов к нашему облаку, но создавать их все разнообразие самим — это очень тернистый путь. Мы же фокусируемся на их мозгах, на обучении.
В итоге договорились с Aivero о создании универсального однорукого робота с 3D глазами их силами, назовем его “Юнит”, а весь облачный Robotics достается делать нам.
В приоритете была простота и цена решения для конечного заказчика. И, конечно, универсальность. Мы хотим минимизировать порог входа для автоматизации простого ручного труда. В идеале, чтобы даже владелец малого бизнеса, не обладающий специальными навыками, мог купить или арендовать наш “Юнит”, поставить его на рабочем месте и запустить.
Подумали пару недель, потестировали гипотезы пару месяцев и вот, что получилось (версия с Jetson AGX в основании и другой обзорной камерой, чем на заглавной):
И прожектор поближе:
Состав:
* Jetson NX
* 2 3D камеры Realsense (одна обзорная, другая для рабочей области)
* прожектор
* вакуумный насос, если нужен
* роборука (Eva / UR / ABB YuMi) с вакуумным или механическим захватом
* интернет WiFi или проводной
Такая телескопическая стойка с вычислителем и вакуумным насосом в основании ставится рядом с рабочей областью робота, подключается к интернету (например по QR коду к WiFi), и сразу начинает решать поставленную задачу практически без настройки.
Здесь можно сразу оценить и стоимость. Самая доступная роборука Eva — 8000 Евро (в России не поставляется), а UR10 уже обойдется почти в 50 000 Евро, но тут нужно отметить, что UR заявляет значительно большую надежность, так что в долгосрочной перспективе может оказаться и не сильно дороже. Да и дешевеют они последнее время. Остальной комплект обходится еще около 2000 Евро.
### ABB YuMi IRB 14050
Мы раньше [имели дело с двуруким YuMi](https://habr.com/ru/company/recognitor/blog/486680/), но здесь попробовали новую версию IRB14050, которая по сути просто одна оторванная рука.
Кратко, чем понравилась:
* точность и механическое качество исполнения
* высокая чувствительность к коллизиям и демпферы на суставах
и не понравилось:
* тяжело удаленно разрешать коллизии и нештатные ситуации
* малый угловой ход некоторых суставов делает траектории довольно сложными для, казалось бы, простых движений, которые для кинематики других 6-ти координатных рук не представляют сложности
* малая грузоподъемность в сравнении с аналогами
* дополнительно требует заливать (а порою и отлаживать) программу на своем языке программирования от ABB, которая обрабатывает команды по TCP от компьютера
И не кратко.
Здесь мы потратили больше всего времени. Рецепт, как запускать, совсем не простой:
1. Возьмите машину с Windows, т.к. иначе не получится установить RobotStudio от ABB.
2. Идем в репу <https://github.com/BerkeleyAutomation/yumipy> и добываем там RAPID (это язык программирования от ABB) файл для загрузки в робота (у нас одна рука, так что левая или правая подойдут одинаковые), заодно переделываем python API для однорукого YuMi IRB 14050 вместо двурукого IRB 14000.
3. Если хотим планирование траектории, то находим IRB14000 urdf файл описания геометрии робота и его кинематики для ROS moveit. Удаляем одну руку и корпус робота IRB14000, так и получаем IRB14050.
4. Забираем из планировщика ROS moveit нужную траекторию и с помощью слегка модифицированного Python API запускаем.
5. В случае коллизии или иных происшествий запускаем FlexPendant for OmniCore, сбрасываем состояние и визуально разрешаем проблему.
Но, конечно, это лишь возможная траектория того, как можно заставить YuMi повиноваться, да и всех мелочей, где можно споткнуться, тут не упомянуть, конечно.
### Eva
Кратко, чем понравилось:
* Конечно, цена
* API простое и лаконичное
И минусы:
* нет детекции коллизий (заявлено в релизе осенью)
* точность позиционирования — над ней еще нужно поработать производителю, но нам хватает
Конечно, простота управления подкупает:
```
pip install evasdk
```
и
```
import evasdk
eva = evasdk.Eva(host_ip, token)
with eva.lock():
eva.control_wait_for_ready()
eva.control_go_to([0, 0, 0, 0, 0, 0])
```
И роборука вжух! и исполняет.
Нет, конечно, потом мы смогли переполнить логи в контроллере руки, после чего она переставала слушаться. Но надо отдать должное производителю — создание issue в их гите хватило, чтобы они разобрались в причинах (и привело к паре созвонов с целым консилиумом о наших проблемах).
И в целом, Automata (производитель Eva) большие молодцы! Надеюсь у них получится расти и развиваться на рынке робототехники и дальше, делая роботов сильно доступнее и проще, чем они есть сейчас.
### UR
Понравилось:
* отлично сделана по механике и высокая точность
* большие диапазоны углов в суставах, что делает планировку траектории заметно проще
* коллизии можно разрешить в VNC Viewer, подключившись к компьютеру роборуки
* хорошо отлажена в инфраструктуре ROS
Минусы:
* устаревшая ОС на контроллере UR, где-то уже полтора года нет никаких обновлений безопасности
* все-таки не самый современный способ коммуникации, хотя он неплохо прикрыт доступными открытыми библиотеками
Из питона роборука доступна в двух основных сценариях:
1. Установить <https://github.com/SintefManufacturing/python-urx> и наслаждаться. Немного длиньше листинг, чем в случае evasdk, так что не буду приводить. Также есть известные проблемы совместимости с новыми роборуками, судя по issue-трекеру. Кое что пришлось так же поправить под себя, т.к. не все режимы перемещения были имплементированы в библиотеке, но это тонкости.
2. Пойти по особому “ROS-до” (<https://github.com/ros-industrial/universal_robot>). Для тех, кто в ROS как рыба, тут все просто: немного магии с загрузкой некого скрипта в тушку UR и вы можете использоваться moveit (очень полезный кусок ROS, который позволяет, например, планировать траекторию в условиях наличия препятствий).
Мы стараемся избегать ROS, т.к. частично его функции (брокер сообщений) выполняет rabbitmq в нашей системе, да и происходит серьезное усложнение стека используемых технологий. Так что для случая, когда нужно объезжать препятствия, мы инскапсулируем ROS в микросвервис на серверной стороне.
А теперь трюк!
Чтобы вы понимали, UR это:
Т.е. любой чих разрешается на тач-панели робота. И чтобы не 5 раз на дню мучать нашего коллегу из Aivero, гоняя в лодочный гараж, нужно как-то влезть туда удаленно.
Оказалось, что на UR контроллере установлен linux (и кстати не самый слабый x86 процессор).
Набираем ssh IP… user: root, password: easybot.
И вы в Debian Wheezy.
Так что берем и ставим VNC server и обнаруживаем себя полным хозяином робота! (Тут надо только заметить, что Wheezy уже 2 года как не обновляется и просто взять и поставить vnc сервер у вас не получится из-за устаревших регистров. Но [тут есть ссылка](https://dof.robotiq.com/discussion/553/remote-control-of-universal-robots-user-interface/p2) на “magic file”, который позволяет это сделать).
Кстати, в Universal Robots, когда мы им показали наше демо, сказали, что подобное удаленное управление требует новой процедуры сертификации безопасности. Справедливо. Очень любопытно, как в Smart Robotics с этим обстоят дела в целом. Не могу представить, чтобы переменные целеуказания от компьютерного зрения могли бы быть 100% безопасны для окружающих.
### Пришло время учить робота хватать коробочки
Напомню, мы же показываем что делать роботу в VR:
Т.е. у нас по каждому перемещению записано, как выглядела сцена и что за команда была, например такая:
```
{“op": "pickup_putdown_box",
"pos1": [441.1884, -112.833069, 151.29303],
"pos2": [388.1267, 91.0179138, 114.847595],
"rot1": [[0.9954941, 0.06585537, -0.06822499], [0.0917332, -0.851038456, 0.517028868], [-0.0240128487, -0.52095747, -0.85324496]],
"rot2": [[0.992139041, 0.102700718, -0.07150351], [0.100485876, -0.99436, -0.0339238755], [-0.0745842, 0.026472155, -0.996863365]],
"calibration": [[-0.01462146, 0.9814359, -0.191232175, 551.115051], [0.9987302, 0.0051134224, -0.0501191653, -6.613386], [-0.0482108966, -0.191722155, -0.9802644, 771.933167]],
"box": [[474.331482, -180.079529, 114.765076], [471.436157, -48.88102, 188.729553], [411.868164, -180.27713, 112.670532], [476.105164, -148.54512, 58.89856]],
"source": "operator"}
```
В общем этого нам достаточно, чтобы обучить сеточки определять bounding box объекта в пространстве и где его хватать.
Так что сидим полчаса и показываем роботу как жонглировать 4-мя типами коробок, получаем около 100 примеров. Нажимаем магическую кнопку… ну точнее**sudo docker run -e INPUT\_S3\_FOLDER=… OUTPUT\_S3\_FOLDER=… rembrain/train\_all\_stages:dev**. И идем спать. С утра докер отправляет сообщение ML-процессору обновить веса, и мы с замиранием сердца (роботов хоть и дали бесплатно тестировать производители, стоят денег прямо серьезных), запускаем и…
УПС…
Надо сказать, что ни один робот при отладке не пострадал. Я думаю исключительно благодаря невероятному везению.
Однажды мой двухлетний сын подошел и решил поиграться с VR трекером. Залез на стул, взял его с подоконника… И отправил UR10 в невообразимое путешествие, отодвинув штангу с камерой и заведя роборуку в довольно хитрое положение. Так что пришлось добавить немного предохранителей в управление. И вторую обзорную камеру, т.к. иначе порою просто не видно куда уехала рука и можно ли ею двигать.
А если без шуток, то точность детекции таких не сложных коробок в наших тестах превышала 99.5% даже при небольшой обучающей выборке из нескольких сотен примеров. Основной источник проблем здесь уже не компьютерное зрение, а сопутствующие сложности: например, какие-то аномалии в исходной укладки объектов, или непредусмотренные помехи в кадре. Но затем мы и делаем обучающуюся систему с операторами в цикле, чтобы быть готовым ко всему, разрешая проблемы, не вовлекая живых людей на месте.
**Еще об одном алгоритме, о том, что меня в backend и промахе в UI frontend-е**
**Проблема плотной упаковки**
Иногда bin-picking применения соседствуют с задачей «bin-stuffing», ну т.е. разумной упаковкой в корзину. В случае одинаковых объектов — это не проблема. Но если мы говорим даже о коробочках разного размера, это реально сложная задача упаковки.
Можно эту задачу решать через планирование, но в нашем случае мы не можем гарантировать, что все легло ровно как мы планируем. Поэтому придется играть в тетрис. Т.е. смотреть что у нас сейчас в корзине, куда все складываем, и думать куда поставить задетектированный объект. Такой жадный подход здесь не самый лучший, но иначе все становится сильно сложнее.
Таким образом, мы переводим трассируем луч по пикселю карты глубин и заполняем воксельный объем корзины. А затем ищем самое лучшее место, где расположить новую коробку (на деле самую нижнюю точку, ближнюю к одному углу корзины). Как-то так:
Иногда получается ерунда, т.к. не под частью коробки просто нет опоры, например как здесь:
**Backend**
Мы придерживаемся прежней схемы, когда каждому роботу отдали по серверу ретрансляции на websocket-ах, как на этой схеме:
Единственное, сервис Coordinator стал разрастаться в кластер с кучей сервисов внутри. Например, свое место там заняли брокер сообщений Rabbit и mongoDB, сборка логов, как у людей (и это кстати правда удобно в распределенной системе). Так же пришлось добавить активный сервис мониторинга, который активно проверяет целостность всей системы и отвечает о текущем статусе каждого робота.
Но и в целом, конечно, работы по backend-у так много, что позаниматься ML частью системы уже за счастье.
**И вот у нас слишком сложный UI**
Смиритесь. Если вы разработчик и думаете, что вы сделали UI уже для человеков, то нет. Сходите к человеку и попросите его этим воспользоваться.
Мы привыкли к AWS console, Yandex console, начинает казаться, что и для управления роботами нужно вот именно это, разве что для телефона, а не на десктопе. Не так то и удобно монтировать робота и бегать к компьютеру или ноутбуку.
Казалось, что получилось невероятно круто и понятно.
Вот консоль с роботами, где прямо все про него -> можно зайти в стрим и командовать им -> а если хочется озадачить, то идем в задания, делаем задание, выбирая один из темплейтов -> и даже здесь надо просто обвести пальцем и определить область откуда брать предметы, и куда класть.
Однако, нет “потока”. Тесты показали, что все несколько контринтуитивно и UX нужно менять. Вот он новый интересный опыт — преодолеем и это. А пока что назовем текущий UI robot Console и оставим его для себя.
### Что дальше
Снимаем видео монтажа и настройки робота за 2 минуты, готовим материалы для продвижения на нескольких типах задач.
Параллельно ищем новые практические применения помимо понятного и популярного bin-picking (лично я мечтаю о применении роботов на стройке).
Думаю через несколько месяцев мы ~~станем более лучше одеваться~~ научимся продавать наше решение в максимально разнообразные применения и будем кирпичик за кирпичиком строить наш облачный мозг в чудовищно конкурентной обстановке компаний, делающих роботов умными, что не может не радовать.
Так что карантин пошел на пользу! | https://habr.com/ru/post/513696/ | null | ru | null |
# Как сделать alter table в высоконагруженной таблице
Ещё лет 5 назад на собеседованиях с backend-разработчиками был популярен вопрос: как переименовать колонку в высоконагруженной таблице (возможны вариации: как сделать любой другой *alter table*)? Ответ мог быть примерно следующий:
> Для начала создаём новую колонку (или даже таблицу с нужной структурой). Далее делаем триггеры на старую колонку, которые вносят все поступающие изменения на новую колонку. Параллельно с этим синхронизируем уже добавленные данные из старой колонки в новую. Через какое-то время данные актуализируются, и задача будет решена.
>
>
Вопрос всё ещё часто звучит на собесах. И актуальность его выросла, так как за последние 5 лет стало намного больше масштабных проектов с высокой нагрузкой.
В MySQL существуют специальные инструменты для решения подобных задач: [pt-online-schema-change](https://www.percona.com/doc/percona-toolkit/LATEST/pt-online-schema-change.html) и [gh-ost](https://github.com/github/gh-ost). Принцип их действия практически такой же, как описанный выше.
Хочу рассказать, как мы делали *alter table* в нашем микросервисе с высоконагруженной таблицей (*golang + postgres*, *~1500rps*, *~15 млн. записей*).
### Постановка задачи
В одном из проектов, над которым мы работаем в Каруне, задача стояла немного сложнее, чем просто "переименовать колонку": необходимо было захешировать данные одной колонки. Мы решили сделать это через создание новой колонки и перенести функционал на неё.
### Шаг 1. Добавляем колонку
Для начала мы создали колонку и повесили на неё индекс:
```
ALTER TABLE my_table ADD COLUMN IF NOT EXISTS field_encrypted TEXT;
CREATE UNIQUE INDEX CONCURRENTLY IF NOT EXISTS field_encrypted_unique_idx
ON my_table (field_encrypted);
```
Выполненные операции не создавали никаких блокировок.
### Шаг 2. Переливаем старые данные
Перезалив данных из старой колонки в новую мы реализовали через [cron библиотеку](https://github.com/robfig/cron) языка *golang*. Такое решение приняли из-за удобного логирования возникающих проблем и возможности быстрого реагирования на них. Да и сторонников делать через логику базы данных у нас не нашлось.
Конечно, сразу же возникли трудности следующего вида. В принципе, аффектить базу данных сильно нельзя — это увеличивает время ответа сервиса (*>1 sec* — это уже плохо) и количество блокировок. Зависимые сервисы могут не обработать ответы, появится неконсистентность. Или может спровоцироваться ещё более сильная нагрузка на базу данных, и сервис может не выдержать.
Среднее время ответа сервисаПоэтому:
* Все изменения для новой колонки делались батчами, а не по одной записи (batch insert, batch update).
* У нас запущено несколько инстансов этого микросервиса. Поэтому необходимо было не допустить многократный запуск этого скрипта в одно время. Тут нам помогла [advisory lock для postgres](https://www.postgresql.org/docs/9.1/functions-admin.html#FUNCTIONS-ADVISORY-LOCKS) (каждый инстанс проверял блокировку и только 1 выполнял джобу):
```
SELECT pg_try_advisory_xact_lock(1);
```
* Периодически для базы запускался достаточно тяжелый VACUUM:
Время работы vacum'aВо время его работы также нежелательно запускать скрипты по описанной выше причине. Поэтому мы должны были проверять, не запущен ли он.
```
SELECT check_vacuum('my_table');
```
Сама функция *check\_vacuum*:
```
CREATE FUNCTION check_vacuum(name text) RETURNS boolean
LANGUAGE sql SECURITY DEFINER
AS $_$
SELECT count(*)::int > 0
FROM pg_stat_progress_vacuum
WHERE relid::regclass = $1::regclass OR
relid::regclass::text in (
SELECT reltoastrelid::regclass::text FROM pg_class WHERE relname = $1
);
$_$;
```
После того, как мы перегнали все данные, необходимостью стало переключение на работу с новой колонкой.
### ШАГ 3. Вешаем constraint
Для новой колонки требовался constraint ***not null***. Но напрямую сделать этого нельзя, иначе можно надолго заблокировать таблицу, что недопустимо. Поэтому в *postgres* существует следующий механизм:
```
ALTER TABLE my_table ADD CONSTRAINT field_ecnrypted_not_null
CHECK (field_encrypted IS NOT NULL) NOT VALID;
```
Он позволяет повесить ограничение ***not null***, но не валидировать существующие записи сразу, а сделать это следующим шагом и без блокировок:
```
ALTER TABLE my_table VALIDATE CONSTRAINT field_ecnrypted_not_null;
```
Ну и в заключение мы сделали то, к чему шли:
```
ALTER TABLE my_table DROP COLUMN old_field;
```
### Заключение
Данные шаги позволили бесшовно, незаметно для пользователей нашего микросервиса переименовать колонку и добавить хеширование к ней. Данный подход мы реализовали примерно за неделю — у нас не было дедлайна. Но если вдруг вы едете на горящем велосипеде, и всё вокруг горит, то можно справиться и за пару дней.
Интересно узнать, как вы решаете похожие задачи на MySQL. Пишите в комменты, с удовольствием почитаю и подключусь к обсуждению. | https://habr.com/ru/post/568240/ | null | ru | null |
# Концепции, лежащие в основе Web Audio API
Доброго времени суток, друзья!
В этой статье объясняются некоторые концепции из теории музыки, на основе которых работает Web Audio API (WAA). Зная эти концепции, вы сможете принимать взвешенные решения при проектировании аудио в приложении. Статья не сделает вас опытным инженером по звуку, но поможет понять, почему WAA работает так, как работает.
### Аудио схема
Суть WAA заключается в выполнении некоторых операций со звуком внутри аудио контекста (audio context). Этот API был специально разработан для модульной маршрутизации (modular routing). Основные операции со звуком представляют собой узлы (audio nodes), связанные между собой и формирующие схему маршрутизации (audio routing graph). Несколько источников — с разными типами каналов — обрабатываются внутри единого контекста. Такая модульная схема обеспечивает необходимую гибкость для создания сложных функций с динамическими эффектами.
Аудио узлы связаны между собой через входы и выходы, формируют цепь, которая начинается от одного или нескольких источников, проходит через один или несколько узлов, и заканчивается в пункте назначения (destination). В принципе, можно обойтись и без пункта назначения, например, если мы хотим просто визуализировать некоторые аудио данные. Типичный рабочий процесс для веб аудио выглядит примерно так:
1. Создаем аудио контекст
2. Внутри контекста создаем источники — такие как , [осциллятор (генератора звука)](https://ru.wikipedia.org/wiki/%D0%93%D0%B5%D0%BD%D0%B5%D1%80%D0%B0%D1%82%D0%BE%D1%80_%D1%81%D0%B8%D0%B3%D0%BD%D0%B0%D0%BB%D0%BE%D0%B2) или поток
3. Создаем узлы эффектов, такие как [реверберация](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), биквадратный фильтр, паннер или компрессор
4. Выбираем пункт назначения для аудио, такой как колонки компьютера пользователя
5. Устанавливаем соединение между источниками через эффекты к пункту назначения
### Обозначение канала
Количество доступных аудио каналов часто обозначается в числовом формате, например, 2.0 или 5.1. Это называется обозначением канала. Первая цифра означает полный диапазон частот, которые включает сигнал. Вторая цифра означает количество каналов, зарезервированных для выходов низкочастотного эффекта — [сабвуферов](https://ru.wikipedia.org/wiki/%D0%A1%D0%B0%D0%B1%D0%B2%D1%83%D1%84%D0%B5%D1%80).
Каждый вход или выход состоит из одного или более каналов, построенных по определенной аудио схеме. Существуют различные дискретные структуры каналов, такие как моно, стерео, квадро, 5.1 и т.д.
Аудио источники могут быть получены разными способами. Звук может быть:
* Сгенерирован JavaScript-кодом посредством аудио узла (такого как осциллятор)
* Создан из необработанных данных с помощью [ИКМ (импульсно-кодовой модуляции)](https://ru.wikipedia.org/wiki/%D0%98%D0%BC%D0%BF%D1%83%D0%BB%D1%8C%D1%81%D0%BD%D0%BE-%D0%BA%D0%BE%D0%B4%D0%BE%D0%B2%D0%B0%D1%8F_%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D1%8F%D1%86%D0%B8%D1%8F)
* Получен из медиа элементов HTML (таких как или )
* Получен из медиа потока WebRTC (такого как вебкамера или микрофон)
### Аудио данные: что находится в [семпле](https://ru.wikipedia.org/wiki/%D0%A1%D0%B5%D0%BC%D0%BF%D0%BB)
[Семплирование](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D1%81%D0%BA%D1%80%D0%B5%D1%82%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F) означает преобразование непрерывного сигнала в дискретный (разделенный) (аналогового сигнала в цифровой). Другими словами, непрерывная звуковая волна, такая как живой концерт, преобразуется в последовательность семплов, что позволяет компьютеру обрабатывать аудио отдельными блоками.
### Аудио буфер: кадры, семплы и каналы
AudioBuffer в качестве параметров принимает количество каналов (1 для моно, 2 для стерео и т.д.), длину — количество кадров семпла внутри буфера, и частоту дискретизации — количество кадров в секунду.
Семпл — это простое 32-битное значение с плавающей точкой (float32), представляющее собой значение аудио потока в конкретный момент времени и в конкретном канале (левый или правый и др.). Кадр или кадр семпла — это набор значений всех каналов, воспроизводимых в определенный момент времени: все семплы всех каналов, воспроизводимые в одно и тоже время (два для стерео, шесть для 5.1 и т.д.).
Частота дискретизации — это количество семплов (или кадров, поскольку все семплы кадра проигрываются в одно время), воспроизводимые за одну секунду, измеряется в герцах (Гц). Чем выше частота, тем лучше качество звука.
Давайте посмотрим на моно и стерео буферы, каждый длиной в одну секунду, воспроизводимые с частотой 44100 Гц:
* Моно буфер будет иметь 44100 семплов и 44100 кадров. Значением свойства «length» будет 44100
* Стерео буфер будет иметь 88200 семплов, но также 44100 кадров. Значением свойства «length» будет 44100 — длина равняется количеству кадров
Когда начинается воспроизведение буфера, мы сначала слышим крайний левый кадр семпла, затем ближайший к нему правый и т.д. В случае стерео, мы слышим оба канала одновременно. Кадры семпла не зависят от количества каналов и предоставляют возможность для очень точной обработки аудио.
Заметка: чтобы получить время в секундах из количества кадров необходимо разделить количество кадров на частоту дискретизации. Чтобы получить количество кадров из количества семплов, делим последние на количество каналов.
Пример:
```
let context = new AudioContext()
let buffer = context.createBuffer(2, 22050, 44100)
```
Заметка: в цифровом аудио 44100 Гц или 44.1 кГц — это стандартная частота семплирования. Но почему 44.1 кГц?
Во-первых, потому что диапазон слышимых частот (частот, различимых человеческим ухом) варьируется от 20 до 20000 Гц. Согласно теореме Котельникова частота дискретизации должна более чем в два раза превышать наибольшую частоту в спектре сигнала. Поэтому частота семплирования должна быть больше 40 кГц.
Во-вторых, сигналы должны быть отфильтрованы с помощью [фильтра нижних частот](https://ru.wikipedia.org/wiki/%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%BD%D0%B8%D0%B6%D0%BD%D0%B8%D1%85_%D1%87%D0%B0%D1%81%D1%82%D0%BE%D1%82) перед семплированием, в противном случае будет иметь место наложение спектральных «хвостов» (подмена частот, маскировка частот, алиасинг) и форма восстановленного сигнала будет искажена. В идеале, фильтр нижних частот должен пропускать частоты ниже 20 кГц (без ослабления) и отбрасывать частоты выше 20 кГЦ. На практике требуется некоторая переходная полоса (между полосой пропускания и полосой подавления), где частоты частично ослабляются. Более легким и экономичным способом это сделать является применение противоподменного фильтра. Для частоты дискретизации равной 44.1 кГц переходная полоса составляет 2.05 кГц.
В приведенном примере мы получим стерео буфер с двумя каналами, воспроизводимый в аудио контексте с частотой 44100 Гц (стандарт), длиной 0.5 секунды (22050 кадров / 44100 Гц = 0.5 с).
```
let context = new AudioContext()
let buffer = context.createBuffer(1, 22050, 22050)
```
В данном случае мы получим моно буфер с одним каналом, воспроизводимый в аудио контексте с частотой 44100 Гц, произойдет его передискретизация до 44100 Гц (и увеличение кадров до 44100), длиной 1 секунда (44100 кадров / 44100 Гц = 1 с).
Заметка: аудио передискретизация («ресемплирование») очень похоже на изменение размеров («ресайзинг») изображений. Допустим, у нас есть изображение размером 16х16, однако мы хотим заполнить этим изображением область размером 32х32. Мы делаем ресайзинг. Результат будет менее качественным (может быть размытым или рваным в зависимости от алгоритма увеличения), но это работает. Ресемплированное аудио — это тоже самое: мы сохраняем пространство, но на практике едва ли получится добиться высокого качества звучания.
### Планарные и чередующиеся буферы
В WAA используется планарный формат буфера. Левый и правый каналы взаимодействуют следующим образом:
```
LLLLLLLLLLLLLLLLRRRRRRRRRRRRRRRR (для буфера, состоящего из 16 кадров)
```
В данном случае каждый канал работает независимо от других.
Альтернативой является использование чередующегося формата:
```
LRLRLRLRLRLRLRLRLRLRLRLRLRLRLRLR (для буфера, состоящего из 16 кадров)
```
Такой формат часто используется для декодирования MP3.
В WAA используется только планарный формат, поскольку он лучше подходит для обработки звука. Планарный формат преобразуется в чередующийся, когда данные отправляются на звуковую карту для воспроизведения. При декодировании MP3 происходит обратное преобразование.
### Аудио каналы
Разные буферы содержат разное количество каналов: от простых моно (один канал) и стерео (левый и правый каналы) до более сложных наборов, таких как квадро и 5.1 с разным количеством семплов в каждом канале, что обеспечивает более насыщенное (богатое) звучание. Каналы обычно представлены аббревиатурами:
| | |
| --- | --- |
| Моно | 0: М: моно |
| Стерео | 0: L: левый
1: R: правый |
| Квадро | 0: L: левый
1: R: правый
3: SL: дополнительный левый (левый канал, создающий окружение; surround left)
4: SR: дополнительный правый (surround right) |
| 5.1 | 0: L: левый
1: R: правый
2: C: центральный
3: LFE: сабвуфер
4: SL: дополнительный левый
5: SR: дополнительный правый |
### Смешивание вверх (up-mixing) и вниз (down-mixing)
Когда количество каналов на входе и выходе не совпадает, применяют смешивание вверх или вниз. Смешивание контролируется свойством AudioNode.channelInterpretation:
| Входные каналы | Выходные каналы | Правила смешивания |
| --- | --- | --- |
| Стандартные схемы смешивания каналов — используются, когда свойство channelInterpretation устанавливается для speakers (колонок). |
| 1 (Моно) | 2 (Стерео) | Смешивание вверх из моно в стерео.
Входной канал М используется для обоих выходных каналов (L и R).
output.L = input.M
output.R = input.M |
| 1 (Моно) | 4 (Квадро) | Смешивание вверх из моно в квадро.
Входной канал М используется для основных каналов (L и R). Дополнительные каналы заглушаются.
output.L = input.M
output.R = input.M
output.SL = 0
output.SR = 0 |
| 1 (Моно) | 6 (5.1) | Смешивание вверх из моно в 5.1.
Входной канал М используется для центрального канала ©. Остальные каналы (L, R, LFE, SL и SR) заглушаются.
output.L = 0
output.R = 0
output.C = input.M
output.LFE = 0
output.SL = 0
output.SR = 0 |
| 2 (Стерео) | 1 (Моно) | Смешивание вниз из стерео в моно.
Оба входных канала (L и R) объединяется в один выходной (M).
output.M = 0.5 \* (input.L + input.R) |
| 2 (Стерео) | 4 (Квадро) | Смешивание вверх из стерео в квадро.
Входные каналы L и R используются для основных выходных каналов (L и R). Дополнительные каналы (SL и SR) заглушаются.
output.L = input.L
output.R = input.R
output.SL = 0
output.SR = 0 |
| 2 (Стерео) | 6 (5.1) | Смешивание вверх из стерео в 5.1.
Входные каналы L и R используются для основных выходных каналов (L и R). Дополнительные выходные каналы (SL и SR), центральный канал © и сабвуфер (LFE) заглушаются.
output.L = input.L
output.R = input.R
output.C = 0
output.LFE = 0
output.SL = 0
output.SR = 0 |
| 4 (Квадро) | 1 (Моно) | Смешивание вниз из квадро в моно.
Все четыре входных канала (L, R, SL и SR) объединяются в один выходной канал (M).
output.M = 0.25 \* (input.L + input.R + input.SL + input.SR) |
| 4 (Квадро) | 2 (Стерео) | Смешивание вниз из квадро в стерео.
Оба левых входных канала (L и SL) объединяются в один выходной левый канал (L). Оба правых (R и SR) — в правый ®.
output.L = 0.5 \* (input.L + input.SL)
output.R = 0.5 \* (input.R + input.SR) |
| 4 (Квадро) | 6 (5.1) | Смешивание вверх из квадро в 5.1.
Входные каналы L, R, SL и SR используются для соответствующих выходных каналов. Центральный входной канал © и сабвуфер (LFE) заглушаются.
output.L = input.L
output.R = input.R
output.C = 0
output.LFE = 0
output.SL = input.SL
output.SR = input.SR |
| 6 (5.1) | 1 (Моно) | Смешивание вниз из 5.1 в моно.
Левые (L и SL), правые (R и SR) и центральный (С) входные каналы объединяются в один. Дополнительные каналы ослабляются, мощность основных боковых каналов снижается, что позволяет считать их одним каналом — это достигается путем умножения на √2 / 2. Сабвуфер (LFE) исключается.
output.M = 0.7071 \* (input.L + input.R) + input.C + 0.5 \* (input.SL + input.SR) |
| 6 (5.1) | 2 (Стерео) | Смешивание вниз из 5.1 в стерео.
Центральный канал © прибавляется к каждому боковому дополнительному каналу (SL и SR) и смешивается с каждым из основных боковых каналов (L и R). Для снижения мощности каждая комбинация центрального и дополнительного бокового каналов умножается на √2 / 2. Сабвуфер (LFE) исключается.
output.L = input.L + 0.7071 \* (input.C + input.SL)
output.R = input.R + 0.7071 \* (input.C + input.SR) |
| 6 (5.1) | 4 (Квадро) | Смешивание вниз из 5.1 в квадро.
Центральный канал (С) смешивается с боковыми основными каналами (L и R). В каждой паре снижается мощность центрального канала посредством умножения на √2 / 2. Дополнительные боковые каналы остаются неизменными. Сабвуфер (LFE) исключается.
output.L = input.L + 0.7071 \* input.C
output.R = input.R + 0.7071 \* input.C
output.SL = input.SL
output.SR = input.SR |
| Нестандартные схемы смешивания каналов — используются, когда свойство channelInterpretation устанавливается для discrete. |
| любой (x) | любой (y), когда x
Дискретизация каналов вверх.
Каждый выходной канал объединяется с его входным аналогом (имеющим тот же индекс). Каналы, не имеющие соответствующих входных каналов, заглушаются. |
|
| любой (x) | любой (y), когда x>y | Каждый выходной канал объединяется с его входным аналогом (имеющим тот же индекс). Каналы, не имеющие соответствующих выходных каналов, отбрасываются. |
### Визуализация
Визуализация зиждется на получении выходных аудио данных, таких как данные об амплитуде или частоте, и их последующей обработке с помощью каких-либо графических технологий. В WAA имеется AnalyzerNode (анализатор), который не искажает проходящий через него сигнал. При этом он способен извлекать данные из аудио и передавать их дальше, например, в <canvas>.
Для извлечения данных могут быть использованы следующие методы:
* AnalyzerNode.getFloatByteFrequencyData() — копирует текущие данные о частоте в массив Float32Array
* AnalyzerNode.getByteFrequencyData() — копирует текущие данные о частоте в массив Uint8Array (байтовый массив без знака)
* AnalyserNode.getFloatTimeDomainData() — копирует текущие данные о форме волны или шаге дискретизации в массив Float32Array
* AnalyserNode.getByteTimeDomainData() — копирует текущие данные о форме волны или шаге дискретизации в массив Uint8Array
### Спатиализация
Аудио спатиализация (обрабатываемая PannerNode и AudioListener) позволяет моделировать позицию и направление сигнала в конкретной точке пространства, а также позицию слушателя.
Позиция паннера описывается с помощью правосторонних картезианских координат; для движения используется вектор скорости, необходимый для создания [эффекта Доплера](https://ru.wikipedia.org/wiki/%D0%AD%D1%84%D1%84%D0%B5%D0%BA%D1%82_%D0%94%D0%BE%D0%BF%D0%BB%D0%B5%D1%80%D0%B0), для направления используется конус направленности. Этот конус может быть очень большим в случае разнонаправленных источников звука.
Позиция слушателя описывается так: движение — с использованием вектора скорости, направление, где находится голова слушателя — с использованием двух векторов направленности, спереди и сверху. Привязка осуществляется к верхней части головы и носу слушателя под прямым углом.
### Соединение и разветвление
Соединение описывает процесс, в ходе которого ChannelMergerNode принимает несколько входных моно источников и соединяет их в один многоканальный сигнал на выходе.
Разветвление представляет собой обратный процесс (осуществляется посредством ChannelSplitterNode).
Пример работы с WAA можно посмотреть [здесь](https://codepen.io/igor_agapov/pen/abzKLvM). Исходный код примера находится [здесь](https://github.com/harryheman/Web-Audio-API-Progress-and-Visualizer). [Вот](https://habr.com/ru/post/487574/) статья про то, как все это работает.
Благодарю за внимание. | https://habr.com/ru/post/495690/ | null | ru | null |
# Deep Learning, теперь и в OpenCV
Данная статья является кратким обзором возможностей dnn — модуля OpenCV, предназначенного для работы с нейросетями. Если вам интересно, что это такое, что оно умеет и как быстро работает, добро пожаловать под кат.
Пожалуй, многие согласятся, что OpenCV является наиболее известной библиотекой компьютерного зрения. За долгое время своего существования она приобрела обширную аудиторию пользователей и стала, де-факто, стандартом в области компьютерного зрения. Множество алгоритмов, работающих «из коробки», открытость исходного кода, замечательная поддержка, большое сообщество пользователей и разработчиков, возможность пользоваться библиотекой на языках C, C++, Python (а также Matlab, C#, Java) под различными операционными системами — это далеко не полный список того, что позволяет OpenCV оставаться востребованной. Но OpenCV не стоит на месте — постоянно добавляется функционал. И сегодня я хочу рассказать о новых возможностях OpenCV в области Deep Learning.
Загрузка и получение результатов (предсказаний) с помощью моделей, созданных в любом из трех популярных фреймворков (Caffe, TensorFlow, Torch), быстрая работа на CPU, поддержка основных слоев нейронных сетей и, как всегда, кроссплатформенность, открытость исходного кода и поддержка — об этом я собираюсь рассказать в данной статье.
Прежде всего, хотелось бы представиться. Меня зовут Рыбников Александр. Я являюсь инженером компании Intel и занимаюсь реализацией функциональности Deep Learning в библиотеке OpenCV.
Пару слов о том, как устроена OpenCV. Эта библиотека представляет собой набор модулей, каждый из которых связан с определенной областью компьютерного зрения. Существует стандартный набор модулей — так сказать, «must have» для любой задачи компьютерного зрения. Реализуя известные алгоритмы, данные модули хорошо проработаны и протестированы. Все они представлены [в основном репозитории OpenCV](https://github.com/opencv/opencv). Также существует [репозиторий](https://github.com/opencv/opencv_contrib) с дополнительными модулями, реализующими экспериментальную или новую функциональность. Требования к экспериментальным модулям, по понятным причинам, мягче. И, как правило, когда какой-то из таких модулей становится достаточно развитым, сформировавшимся и востребованным, он может быть перенесен в основной репозиторий.
Данная статья связана с одним из модулей, совсем недавно занявшим почетное место в основном репозитории — с модулем dnn (далее просто dnn).
(N+1)-й фреймворк для deep learning, это вообще зачем?
------------------------------------------------------
Зачем вообще понадобился Deep Learning в OpenCV? В последние годы во многих областях глубокое обучение (в некоторых источниках глубинное обучение) показывает результаты, значительно превосходящие аналогичные у классических алгоритмов. Это касается и области компьютерного зрения, где масса задач решается с применением нейронных сетей. В свете данного факта кажется логичным дать пользователям OpenCV возможность работы с нейросетями.
Почему был выбран путь написания чего-то своего вместо использования уже существующих реализаций? Этому есть несколько причин.
Во-первых, так можно добиться легковесности решения. Оставляя только возможность выполнения прямого прохода (forward pass) по сети, можно упростить код, ускорить процесс установки и сборки.
Во-вторых, имея свою реализацию, можно свести внешние зависимости к минимуму. Это упростит распространение приложений, использующих dnn. И, если ранее в проекте использовалась библиотека OpenCV, не составит труда добавить в такой проект поддержку глубоких сетей.
Так же, разрабатывая свое решение, есть возможность сделать его универсальным, не привязанным к какому-то конкретному фреймворку, его ограничениям и недостаткам. При наличии собственной имплементации доступны все пути для оптимизации и ускорения кода.
Собственный модуль для запуска глубоких сетей значительно упрощает процедуру создания гибридных алгоритмов, сочетающих в себе быстроту классического компьютерного зрения и замечательную обобщающую способность глубоких нейронных сетей.
Стоит заметить, что модуль не является, строго говоря, полноценным фреймворком для глубокого обучения. На данный момент в модуле представлена исключительно возможность получения результатов работы сети.
Основные возможности
--------------------
Основная возможность dnn заключается, конечно же, в загрузке и запуске нейронных сетей (inference). При этом модель может быть создана в любом из трех фреймворков глубокого обучения — Caffe, TensorFlow или Torch; способ ее загрузки и использования сохраняется независимо от того, где она была создана.
Поддерживая сразу три популярных фреймворка, мы можем достаточно просто комбинировать результаты работы загруженных из них моделей без необходимости создавать все заново в одном единственном фреймворке.
При загрузке происходит конвертация моделей во внутреннее представление, близкое к используемому в Caffe. Так произошло в силу исторических причин — поддержка Caffe была добавлена самой первой. Однако взаимно однозначного соответствия между представлениями нет.
Поддерживаются все основные слои: начиная от базовых (Convolution и Fully connected) и заканчивая более специализированными — всего более 30.
**Список поддерживаемых слоев**AbsVal
AveragePooling
BatchNormalization
Concatenation
Convolution (with dilation)
Crop
DetectionOutput
Dropout
Eltwise
Flatten
FullConvolution
FullyConnected
LRN
LSTM
MaxPooling
MaxUnpooling
MVN
NormalizeBBox
Padding
Permute
Power
PReLU
PriorBox
ReLU
RNN
Scale
Shift
Sigmoid
Slice
Softmax
Split
TanH
Если вы не обнаружили в этом списке слой, который требуется именно вам, не стоит отчаиваться. Вы можете создать [запрос](https://github.com/opencv/opencv/issues/new) на добавление поддержки интересующего вас слоя (и наша команда постарается помочь вам в ближайшее время), либо реализовать все самостоятельно и подать pull request.
Кроме поддержки отдельных слоев, важна также и поддержка конкретных архитектур нейронных сетей. Модуль содержит примеры для классификации ([AlexNet](https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf), [GoogLeNet](https://arxiv.org/pdf/1409.4842.pdf), [ResNet](https://arxiv.org/pdf/1512.03385.pdf), [SqueezeNet](https://arxiv.org/pdf/1602.07360.pdf)), сегментации ([FCN](https://arxiv.org/pdf/1411.4038.pdf), [ENet](https://arxiv.org/pdf/1606.02147.pdf)), детектирования объектов ([SSD](https://arxiv.org/pdf/1512.02325.pdf)); многие из указанных моделей проверены на исходных датасетах, но об этом позднее.
Сборка
------
Если вы — опытный пользователь OpenCV, то можете смело пропустить этот раздел. Если нет, то я постараюсь максимально кратко рассказать о том, как же получить работающие примеры из исходного кода для Linux или Windows.
**Краткая инструкция по сборке**Предварительно потребуется установить git (либо Git Bash для Windows), [cmake](http://cmake.org) и компилятор С++ (Visual Studio под Windows, Xcode на Mac, clang либо gcc под Linux). Если вы собираетесь использовать OpenCV из Python, то нужно также установить сам Python (подойдут последние версии 2.7.x или 3.x) и соответствующую ему версию numpy.
Начнем с клонирования репозитория:
```
mkdir git && cd git
git clone https://github.com/opencv/opencv.git
```
На Windows клонирование репозиториев также можно выполнить, например, с помощью TortoiseGit или SmartGit. Далее, приступим к генерации файлов для сборки:
```
cd ..
mkdir build && cd build
cmake ../git/opencv -DBUILD_EXAMPLES=ON
```
(для Windows здесь и далее нужно заменить cmake на полный путь до запускаемого файла cmake, например на «C:\Program Files\CMake\bin\cmake.exe» или использовать cmake GUI)
Теперь непосредственно сборка:
```
make -j5 (Linux)
cmake --build . --config Release -- /m:5 (Windows)
```
После этого dnn готов к использованию.
Приведенная выше инструкция достаточно краткая, поэтому приведу также ссылки на пошаговые инструкции по установке OpenCV на [Windows](http://docs.opencv.org/3.2.0/d3/d52/tutorial_windows_install.html) и [Linux](http://docs.opencv.org/3.2.0/d7/d9f/tutorial_linux_install.html).
Примеры использования
---------------------
По хорошей традиции, каждый модуль OpenCV включает в себя примеры использования. dnn — не исключение, примеры на С++ и Python доступны в поддиректории [samples](https://github.com/opencv/opencv/tree/master/samples/dnn) в репозитории с исходным кодом. В примерах присутствуют комментарии, да и в целом все достаточно просто.
Приведу здесь краткий пример, выполняющий классификацию изображений с помощью модели GoogLeNet. На языке Python наш пример будет выглядеть следующим образом:
```
import numpy as np
import cv2 as cv
# read names of classes
with open('synset_words.txt') as f:
classes = [x[x.find(' ') + 1:] for x in f]
image = cv.imread('space_shuttle.jpg')
# create tensor with 224x224 spatial size and subtract mean values (104, 117, 123)
# from corresponding channels (R, G, B)
input = cv.dnn.blobFromImage(image, 1, (224, 224), (104, 117, 123))
# load model from caffe
net = cv.dnn.readNetFromCaffe('bvlc_googlenet.prototxt', 'bvlc_googlenet.caffemodel')
# feed input tensor to the model
net.setInput(input)
# perform inference and get output
out = net.forward()
# get indices with the highest probability
indexes = np.argsort(out[0])[-5:]
for i in reversed(indexes):
print('class:', classes[i], ' probability:', out[0][i])
```
Данный код загружает картинку, проводит небольшую предобработку и получает для изображения выход сети. Предобработка заключается в масштабировании изображения таким образом, чтобы наименьшая из сторон стала равной 224, вырезании центральной части и вычитании среднего значения из элементов каждого канала. Данные операции необходимы, так как модель была натренирована на изображениях заданного размера (224 x 224) с именно такой предобработкой.
Выходной тензор интерпретируется как вектор вероятностей принадлежности изображения к тому или иному классу и имена для 5 классов с наибольшими вероятностями выводятся в консоль.
Выглядит несложно, не так ли? Если записать то же самое на C++, код получится немного более длинным. Однако, самое главное — имена функций и логика работы с модулем — останутся одними и теми же.
Точность
--------
Как понять, что одна натренированная модель лучше другой? Необходимо сравнить метрики качества для обеих моделей. Очень часто борьба на вершине рейтинга лучших моделей идет за доли процентов качества. Поскольку dnn читает и преобразует модели из различных фреймворков в свое внутреннее представление, возникают вопросы сохранения качества после преобразования модели: не «испортилась» ли модель после загрузки? Без ответов на эти вопросы, а значит без проверки сложно говорить о полноценном использовании dnn.
Я провел тестирование моделей из имеющихся примеров для различных фреймворков и различных задач: AlexNet (Caffe), GoogLeNet (Caffe), GoogLeNet (TensorFlow), ResNet-50 (Caffe), SqueezeNet v1.1 (Caffe) для задачи классификации объектов; FCN (Caffe), ENet (Torch) для задачи семантической сегментации. Результаты приведены в Таблицах 1 и 2.
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| Модель (исходный фреймворк) | Опубликованное значение acc@top-5 | Измеренное значение acc@top-5 в исходном фреймворке | Измеренное значение acc@top-5 в dnn | Средняя разница на элемент между выходными тензорами фреймворка и dnn | Максимальная разница между выходными тензорами фреймворка и dnn |
| [AlexNet](http://dl.caffe.berkeleyvision.org/bvlc_alexnet.caffemodel) (Caffe) | [80.2%](https://github.com/BVLC/caffe/tree/master/models/bvlc_alexnet) | 79.1% | 79.1% | 6.5E-10 | 3.01E-06 |
| [GoogLeNet](http://dl.caffe.berkeleyvision.org/bvlc_googlenet.caffemodel) (Caffe) | [88.9%](https://github.com/BVLC/caffe/tree/master/models/bvlc_googlenet) | 88.5% | 88.5% | 1.18E-09 | 1.33E-05 |
| [GoogLeNet](https://storage.googleapis.com/download.tensorflow.org/models/inception5h.zip) (TensorFlow) | — | 89.4% | 89.4% | 1.84E-09 | 1.47E-05 |
| [ResNet-50](https://onedrive.live.com/?authkey=%21AAFW2-FVoxeVRck&id=4006CBB8476FF777%2117887&cid=4006CBB8476FF777)
(Caffe) | [92.2%](https://github.com/KaimingHe/deep-residual-networks#models) | 91.8% | 91.8% | 8.73E-10 | 4.29E-06 |
| [SqueezeNet v1.1](https://github.com/DeepScale/SqueezeNet/tree/master/SqueezeNet_v1.1)
(Caffe) | [80.3%](https://github.com/DeepScale/SqueezeNet/tree/master/SqueezeNet_v1.1) | 80.4% | 80.4% | 1.91E-09 | 6.77E-06 |
*Таблица 1. Результаты оценки качества для задачи классификации. Измерения проводились на валидационном наборе ImageNet 2012 (ILSVRC2012 val, 50000 примеров).*
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| Модель (фреймворк) | Опубликованное значение mean IOU | Измеренное значение mean IOU в исходном фреймворке | Измеренное значение mean IOU в dnn | Средняя разница на элемент между выходными тензорами фреймворка и dnn | Максимальная разница между выходными тензорами фреймворка и dnn |
| [FCN](http://dl.caffe.berkeleyvision.org/fcn8s-heavy-pascal.caffemodel) (Caffe) | [65.5%](https://github.com/shelhamer/fcn.berkeleyvision.org) | 60.402874% | 60.402879% | 3.1E-7 | 1.53E-5 |
| [ENet](https://www.dropbox.com/sh/dywzk3gyb12hpe5/AAD5YkUa8XgMpHs2gCRgmCVCa) (Torch) | [58.3%](https://arxiv.org/pdf/1606.02147.pdf) | 59.1368% | 59.1369% | 3.2E-5 | 1.20 |
*Таблица 2. Результаты оценки качества для задачи семантической сегментации. Объяснение большой максимальной разницы для ENet далее в тексте.*
Результаты для FCN вычислены для валидационного набора сегментационной части [PASCAL VOC 2012](http://host.robots.ox.ac.uk/pascal/VOC/voc2012/) (736 примеров). Результаты для ENet вычислены на валидационном наборе [Cityscapes](https://www.cityscapes-dataset.com/) (500 примеров).
Следует сказать несколько слов о том, какой смысл имеют указанные выше числа. Для задач классификации общепринятой метрикой качества моделей является точность для топ-5 ответов сети (accuracy@top-5, [1]): если правильный ответ имеется среди 5 ответов сети с максимальными показателями уверенности (confidence), то данный ответ сети засчитывается как верный. Соответственно, точность — это отношение числа верных ответов к числу примеров. Данный способ измерения позволяет учесть не всегда корректную разметку данных, когда, например, отмечается объект, занимающий далеко не центральное положение на кадре.
Для задач семантической сегментации используются несколько метрик — попиксельная точность (pixel accuracy) и среднее по классам отношение пересечения к объединению (mean intersection over union, mean IOU) [5]. Попиксельная точность — это отношение количества правильно классифицированных пикселей к количеству всех пикселей. mean IOU — более сложная характеристика: это усредненное по классам отношение правильно отмеченных пикселей к сумме числа пикселей данного класса и числа пикселей, отмеченных как данный класс.
Из таблиц следует, что для задач классификации и сегментации разница в точности между запусками модели в оригинальном фреймворке и в dnn отсутствует. Этот замечательный факт означает, что модуль можно смело использовать, не опасаясь непредсказуемых результатов. Все скрипты для тестирования также доступны [здесь](https://github.com/opencv/opencv/tree/master/modules/dnn/test), так что можно самостоятельно убедиться в правильности полученных результатов.
Разницу между опубликованными и полученными в экспериментах числами можно объяснить тем, что авторы моделей проводят все вычисления с использованием GPU, в то время как я использовал CPU-реализации. Также было замечено, что различные библиотеки могут по-разному декодировать формат jpeg. Это могло сказаться на результатах для FCN, так как датасет PASCAL VOC 2012 содержит изображения именно данного формата, а модели для семантической сегментации оказываются достаточно чувствительны к изменению распределения входных данных.
Как вы заметили, в Таблице 2 присутствует аномально большая максимальная разница выходов dnn и Torch для модели ENet. Меня также заинтересовал данный факт и далее я кратко расскажу о причинах его возникновения.
**Почему возникает большое различие между dnn и Torch для ENet?**Модель ENet использует несколько операций MaxPooling. Данная операция выбирает максимальный элемент в окрестности каждой позиции и записывает в выходной тензор это максимальное значение, а также передает далее индексы выбранных максимальных элементов. Эти индексы далее используются операцией, в некотором смысле обратной данной — MaxUnpooling. Эта операция записывает элементы входного тензора в позиции выходного, соответствующие тем самым индексам. В этом месте и возникает большая ошибка: в определенной окрестности операция MaxPooling выбирает элемент с неправильным индексом; при этом разница между правильным выходом Torch и выходом dnn для данного слоя лежит в пределах вычислительной погрешности (10E-7), а разница в индексах соответствует соседним элементам окрестности. То есть, в результате небольшой флуктуации соседний элемент стал несколько больше, чем элемент с правильным индексом. Результат операции MaxUnpooling, при этом, зависит не только от выхода предыдущего слоя, но и от индексов соответствующей операции MaxPooling, которая располагается намного раньше (в начале вычислительного графа модели). Таким образом, MaxUnpooling записывает элемент с правильным значением в неверную позицию. В результате, накапливается ошибка.
К сожалению, устранить данную ошибку не представляется возможным, так как первопричины ее появления связаны, скорее всего, с немного различающимися реализациями алгоритмов, использованных при тренировке и при inference и не связаны с наличием ошибки в реализации.
Однако, справедливо отметить, что средняя ошибка на элемент выходного тензора остается низкой (см. Таблицу 2) — то есть ошибки в индексах возникают достаточно редко. Более того, наличие данной ошибки не приводит к ухудшению качества работы модели, о чем свидетельствуют числа в той же Таблице 2.
Производительность
------------------
Одна из целей, которую мы ставим перед собой, разрабатывая dnn, заключается в достижении достойной производительности модуля на различных архитектурах. Не так давно была проведена оптимизация под CPU, в результате чего сейчас dnn показывает неплохие результаты по скорости работы.
Я провел замеры времени работы для различных моделей при их использовании — результаты в Таблице 3.
| | | | |
| --- | --- | --- | --- |
| Модель (исходный фреймворк) | Разрешение изображения | Производительность исходного фреймворка, CPU (библиотека акселерации); потребление памяти | Производительность dnn, CPU (ускорение относительно исходного фреймворка); потребление памяти |
| [AlexNet](http://dl.caffe.berkeleyvision.org/bvlc_alexnet.caffemodel) (Caffe) | 227x227 | 23.7 мс (MKL); 945 МБ | 14.7 мс (1.6x); 713 МБ |
| [GoogLeNet](http://dl.caffe.berkeleyvision.org/bvlc_googlenet.caffemodel) (Caffe) | 224x224 | 44.6 мс (MKL); 197 МБ | 20.1 мс (2.2x); 172 МБ |
| [ResNet-50](https://onedrive.live.com/?authkey=%21AAFW2-FVoxeVRck&id=4006CBB8476FF777%2117887&cid=4006CBB8476FF777) (Caffe) | 224x224 | 70.2 мс (MKL); 386 МБ | 58.8 мс (1.2x); 224 МБ |
| [SqueezeNet v1.1](https://github.com/DeepScale/SqueezeNet/blob/master/SqueezeNet_v1.1/squeezenet_v1.1.caffemodel)
(Caffe) | 227x227 | 12.4 мс (MKL); 113 МБ | 5.3 мс (2.3x); 38 МБ |
| [GoogLeNet](https://storage.googleapis.com/download.tensorflow.org/models/inception5h.zip) (TensorFlow) | 224x224 | 17.9 мс (Eigen); 310 МБ | 21.1 мс (0.8x); 135 МБ |
| [FCN](http://dl.caffe.berkeleyvision.org/fcn8s-heavy-pascal.caffemodel) (Caffe) | различное (500x350 в среднем) | 3873.6 мс (MKL);
4453 МБ | 1229.8 мс (3.1x);
1332 МБ |
| [ENet](https://www.dropbox.com/sh/dywzk3gyb12hpe5/AAD5YkUa8XgMpHs2gCRgmCVCa) (Torch) | 1024x512 | 1105.0 мс; 828 МБ | 218.7 мс (5.1x); 190 МБ |
*Таблица 3. Результаты замеров времени работы различных моделей. Эксперименты проводились с использованием Intel Core i7-6700k.*
Замеры времени производились с усреднением по 50-ти запускам и выполнялись следующим образом: для dnn использовался встроенный в OpenCV таймер; для Caffe использовалась утилита caffe time; для Torch и TensorFlow использовались существующие функции замера времени.
Как следует из Таблицы 3, dnn в большинстве случаев превосходит по производительности оригинальные фреймворки. Актуальные данные по производительности dnn из OpenCV на различных моделях в сравнении с другими фреймворками также можно найти [здесь](https://github.com/opencv/opencv/wiki/DNN-efficiency-measurements).
Дальнейшие планы
----------------
Глубокое обучение заняло в компьютерном зрении значительное место и, соответственно, у нас есть большие планы по развитию этой функциональности в OpenCV. Они касаются улучшения удобства использования, переработки внутренней архитектуры самого модуля и улучшения производительности.
В улучшении user experience мы ориентируемся, в первую очередь, на пожелания самих пользователей. Мы стремимся добавить функциональность, которая требуется разработчикам и исследователям в реальных задачах. Помимо этого, в планах есть добавление визуализации сетей, а также расширение набора поддерживаемых слоев.
Что касается производительности, то несмотря на многие выполненные оптимизации, у нас все еще есть идеи, как улучшить результаты. Одна из таких идей — уменьшить разрядность вычислений. Данная процедура носит название квантизации. Грубо говоря, выкинуть часть разрядов у входа и весов слоя перед вычислением сверток (fp32→fp16), либо вычислить масштабирующие коэффициенты, переводящие диапазон входных чисел в диапазон int или short. При этом возрастет скорость (за счет использования более быстрых операций с целыми числами), но, возможно, немного пострадает точность. Однако [публикации](https://arxiv.org/pdf/1510.00149.pdf) и эксперименты в этой области показывают, что даже достаточно сильная квантизация в определенных случаях не приводит к заметному падению качества.
Параллельное выполнение слоев — еще одна из идей оптимизации. В текущей реализации в каждый момент времени работает только один слой. Каждый слой по возможности максимально использует распараллеливание при проведении вычислений. Однако, в некоторых случаях граф вычислений может быть распараллелен на уровне самих слоев. Потенциально это может дать каждому потоку больше работы, уменьшив тем самым накладные расходы.
Сейчас к релизу готовится нечто достаточно интересное. Думаю, немногие слышали о языке программирования [Halide](http://halide-lang.org/). Он не является Тьюринг-полным — некоторые конструкции реализовать на нем не получится; возможно поэтому он и не пользуется популярностью. Однако указанный недостаток является одновременно и его преимуществом — написанный на нем исходный код может быть автоматически превращен в высокооптимизированный под разные «железки»: CPU, GPU, DSP. При этом нет нужды быть гуру оптимизации — специальный компилятор все сделает за вас. Уже сейчас Halide позволяет получить ускорение некоторых моделей — и, например, семантическая сегментация с моделью ENet работает 25 fps для разрешения 512x256 на Intel Core i7-6700k (против 22 fps у dnn без Halide). И, что самое приятное, без переписывания кода можно задействовать интегрированную в процессор GPU, получив дополнительно еще пару кадров в секунду.
В действительности, мы возлагаем большие надежды на Halide. Благодаря своим уникальным характеристикам он позволит получать ускорение работы, не требуя от пользователя дополнительных манипуляций. Мы стремимся к тому, чтобы для использования Halide вместе с OpenCV у пользователя не возникало необходимости в установке дополнительного программного обеспечения для использования Halide — принцип работы «из коробки» должен сохраняться. И, как показывают наши эксперименты, у нас есть все шансы реализовать это.
Заключение
----------
Уже сейчас dnn имеет все, чтобы оказаться полезным. И с каждым днем все большее число пользователей открывает для себя его возможности. Тем не менее, нам еще есть над чем трудиться. Я продолжу свою работу над модулем, расширяя его возможности и совершенствуя функционал. Надеюсь, что данная статья оказалась для вас интересной и полезной.
Если у вас есть вопросы, появились предложения, возникли проблемы или вы хотите внести свой вклад путем подачи pull request — добро пожаловать в [github-репозиторий](https://github.com/opencv), а также на наш [форум](http://answers.opencv.org/), где я и мои коллеги постараемся вам помочь. Если ни один из указанных способов не подошел, на нашем [сайте](http://opencv.org/) можно найти дополнительные пути коммуникации. Я всегда буду рад сотрудничеству, конструктивным замечаниям и предложениям. Спасибо за внимание!
P.S. Выражаю огромную благодарность моим коллегам за помощь в работе и написании данной статьи.
Ссылки
------
1. [ImageNet Classification with Deep Convolutional Neural Networks](https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf)
2. [Going deeper with convolutions](https://arxiv.org/pdf/1409.4842.pdf)
3. [Deep Residual Learning for Image Recognition](https://arxiv.org/pdf/1512.03385.pdf)
4. [SqueezeNet: AlexNet-level accuracy with 50x fewer parameters and <0.5MB model size](https://arxiv.org/pdf/1602.07360.pdf)
5. [Fully Convolutional Networks for Semantic Segmentation](https://people.eecs.berkeley.edu/~jonlong/long_shelhamer_fcn.pdf)
6. [ENet: A Deep Neural Network Architecture for Real-Time Semantic Segmentation](https://arxiv.org/pdf/1606.02147.pdf)
7. [SSD: Single Shot MultiBox Detector](https://arxiv.org/pdf/1512.02325.pdf)
8. [Deep Compression: Compressing Deep Neural Networks with Pruning, Trained Quantization and Huffman Coding](https://arxiv.org/pdf/1510.00149.pdf)
9. [OpenCV github](https://github.com/opencv/)
10. [Официальный сайт OpenCV](http://opencv.org/)
11. [Форум OpenCV](http://answers.opencv.org/)
12. [Halide](http://halide-lang.org/)
13. [Caffe](http://caffe.berkeleyvision.org/)
14. [TensorFlow](https://www.tensorflow.org/)
15. [Torch](http://torch.ch/) | https://habr.com/ru/post/333612/ | null | ru | null |
# Применение машинного обучения для увеличения производительности PostgreSQL
Машинное обучение занимается поиском скрытых закономерностей в данных. Растущий рост интереса к этой теме в ИТ-сообществе связан с исключительными результатами, получаемыми благодаря ему. Распознавание речи и отсканированных документов, поисковые машины — всё это создано с использованием машинного обучения. В этой статье я расскажу о текущем проекте нашей компании: как применить методы машинного обучения для увеличения производительности СУБД.
В первой части этой статьи разбирается существующий механизм планировщика PostgreSQL, во второй части рассказывается о возможностях его улучшения с применением машинного обучения.
### Что такое план выполнения SQL-запроса?
Напомним, что SQL — декларативный язык. Это означает, что пользователь указывает только то, какие операции должны быть проделаны с данными. За выбор способа выполнения этих операций отвечает СУБД. Например, запрос
```
SELECT name FROM users WHERE age > 25;
```
можно выполнить двумя способами: прочесть все записи из таблицы users и проверить каждую из них на выполнение условия age > 25 или использовать индекс по полю age. Во втором случае мы не просматриваем лишние записи, зато тратим больше времени на обработку одной записи из-за операций с индексами.
Рассмотрим более сложный запрос
```
SELECT messages.text FROM users, messages WHERE users.id = messages.sender_id;
```
Этот JOIN можно выполнить уже тремя способами:
* Вложенный цикл (NestedLoopJoin) просматривает все возможные пары записей из двух таблиц и проверяет для каждой пары выполнение условия.
* Слияние (MergeJoin) отсортирует обе таблицы по полям id и sender\_id соответственно, а затем использует метод двух указателей для поиска всех пар записей, удовлетворяющих условию. Этот метод аналогичен методу сортировки слиянием (MergeSort).
* Хеширование (HashJoin) строит хэш-таблицу по полю наименьшей таблицы (в нашем случае это поле users.id). Хеш-таблица позволяет для каждой записи из messages быстро найти запись, в которой users.id = messages.sender\_id.
Если же в запросе требуется выполнить более одной операции Join, то можно также выполнять их в разном порядке, например, в запросе
```
SELECT u1.name, u2.name, m.text FROM users as u1, messages as m, users as u2
WHERE u1.id = m.sender_id AND u2.id = m.reciever_id;
```
Дерево выполнения запроса называется *планом* выполнения запроса.
Посмотреть тот план, который выбирает СУБД для конкретного запроса, можно, используя команду `explain`:
```
EXPLAIN SELECT u1.name, u2.name, m.text FROM users as u1, messages as m, users as u2
WHERE u1.id = m.sender_id AND u2.id = m.reciever_id;
```
Для того, чтобы выполнить запрос и посмотреть выбранный для него план, можно использовать команду `explain analyse`:
```
EXPLAIN ANALYSE SELECT u1.name, u2.name, m.text FROM users as u1, messages as m, users as u2
WHERE u1.id = m.sender_id AND u2.id = m.reciever_id;
```
Время выполнения разных планов одного и того же запроса может отличаться на много порядков. Поэтому правильный выбор плана выполнения запроса оказывает серьезное влияние на производительность СУБД. Разберемся подробнее, как происходит выбор плана в PostgreSQL сейчас.
### Как СУБД ищет оптимальный план выполнения запроса?
Можно разделить процесс поиска оптимального плана на две части.
Во-первых, нужно уметь оценивать *стоимость* любого плана — количество ресурсов, необходимых для его выполнения. В случае, когда на сервере не выполняются другие задачи и запросы, оцениваемое время выполнения запроса прямо пропорционально количеству потраченных на него ресурсов. Поэтому можно считать, что стоимость плана — это его время выполнения в некоторых условных единицах.
Во-вторых, требуется выбрать план с минимальной оценкой стоимости. Легко показать, что число планов растет экспоненциально с увеличением сложности запроса, поэтому нельзя просто перебрать все планы, оценить стоимость каждого и выбрать самый дешевый. Для поиска оптимального плана используются более сложные алгоритмы дискретной оптимизации: динамическое программирование по подмножествам для простых запросов и генетический алгоритм для сложных.
В нашем проекте мы сосредоточились на первой задаче: по данному нам плану надо предсказать его стоимость. Как это можно сделать, не запуская план на выполнение?
**На самом деле**В PostgreSQL для плана предсказываются две стоимости: стоимость запуска (start-up cost) и общая стоимость (total cost). Стоимость запуска показывает, сколько ресурсов план потратит до того, как выдаст первую запись, а общая стоимость — сколько всего ресурсов потребуется плану для выполнения. Однако это не принципиально для настоящей статьи. В дальнейшем под стоимостью выполнения будем понимать общую стоимость.
Эта задача также разделяется на две подзадачи. Сначала для каждой вершины плана (plan node) предсказывается, сколько кортежей будет отобрано в ней. Затем на основе этой информации оценивается стоимость выполнения каждой вершины, и, соответственно, всего плана.
Мы провели небольшое исследование, чтобы установить, какая из двух подзадач в PostgreSQL решается хуже.
Каждая точка на рисунках ниже соответствует одной вершине плана. Для каждой вершины были предсказаны количество отобраных в ней кортежей и стоимость ее выполнения, а затем измерены реальное количество отобранных кортежей и время выполнения. На правой картинке отображены только те вершины, для которых количество кортежей предсказано правильно, поэтому по ней можно судить о качестве оценки стоимости.
| | |
| --- | --- |
| Зависимость истинного количества кортежей от предсказанного | Зависимость времени работы плана от стоимости,
если количество кортежей предсказано правильно |
На первом рисунке видно, что результат решения первой подзадачи отличается от истинного на несколько порядков. На втором рисунке видно, что при правильном решении первой подзадачи модель PostgreSQL достаточно адекватно оценивает стоимость выполнения того или иного плана, поскольку видна сильная корреляция со временем выполнения. В итоге было установлено, что от неточных решений *обоих* подзадач страдает производительность СУБД, но от неверно установленного количества кортежей в каждой вершине она страдает больше.
Рассмотрим использующееся в PostgreSQL решение первой подзадачи.
### Как СУБД оценивает количество кортежей в вершинах?
Для начала попытаемся предсказать количество кортежей, отбираемых простым запросом
```
SELECT name FROM users WHERE age < 25;
```
Для того, чтобы была хоть какая-то возможность это сделать, нам нужна какая-то информация о данных, статистика по ним. В PostgreSQL в качестве этой информации о данных используются гистограммы.
Используя гистограмму, мы легко можем восстановить долю тех пользователей, которые младше 25 лет. Для каждой вершины плана доля всех отобранных кортежей по отношению ко всем обработанным кортежам называется *выборочностью (selectivity)*. В приведенном примере выборочность SeqScan будет равна примерно 0.3. Для получения количества кортежей, отбираемых вершиной, достаточно будет умножить выборочность вершины на количество обрабатываемых кортежей (в случае SeqScan'а это будет количество записей в таблице).
Рассмотрим более сложный запрос
```
SELECT name FROM users WHERE age < 25 AND city = 'Moscow';
```
В этом случае с помощью гистограмм по возрасту и городам мы сможем получить только *маргинальные* выборочности, то есть долю пользователей младше 25 лет и долю москвичей среди пользователей. В модели PostgreSQL все условия (кроме пар условий вида `5 < a AND a < 7`, которые автоматически превращаются в условие `5 < a < 7`), считаются *независимыми*. Математики называют два условия A и B независимыми, если вероятность того, что выполняются оба условия одновременно, равна произведению их вероятностей: P(A и B) = P(A)P(B). Однако в прикладном смысле можно понимать независимость двух величин как то, что от значения одной величины не зависит распределение на другую величину.
### В чем же проблема?
В некоторых случаях предположение о независимости условий не выполняется. В таких случаях модель PostgreSQL работает не очень хорошо. Есть два способа бороться с этой проблемой.
Первый способ заключается в построении многомерных гистограмм. Проблема этого способа заключается в том, что с увеличением размерности многомерная гистограмма требует экспоненциально растущее количество ресурсов для сохранения той же точности. Поэтому приходится ограничиваться гистограммами маленькой размерности (2-8 измерений). Отсюда следует вторая проблема этого метода: нужно каким-то образом понять, для каких пар (или троек, или четверок...) столбцов имеет смысл строить многомерные гистограммы, а для каких необязательно.
Чтобы решить эту проблему, требуется либо хороший администратор, который будет изучать планы ресурсоемких запросов, определять корреляции между столбцами и вручную указывать, какие гистограммы нужно достроить, либо программное средство, которое с помощью статистических тестов попытается найти зависимые друг от друга столбцы. Однако не для всех зависимых столбцов имеет смысл строить гистограммы, поэтому программное средство также должно анализировать совместную встречаемость столбцов в запросах. В настоящий момент существуют патчи, позволяющие использовать в PostgreSQL многомерные гистограммы, но в них администратору требуется вручную задавать, для каких столбцов эти многомерные гистограммы должны быть построены.
### Используем машинное обучение для оценки выборочности
Однако эта статья посвящена альтернативному подходу. Альтернативный подход — это применение машинного обучения для нахождения совместной выборочности нескольких условий. Как уже говорилось выше, машинное обучение занимается поиском закономерностей в данных. Данные — это набор объектов. В нашем случае объектом является совокупность условий в одной вершине плана. По этим условиям и их маргинальным выборочностям нам требуется предсказать совместную выборочность.
Наблюдаемыми признаками вершины плана будут являться маргинальные выборочности всех её условий. Будем считать эквивалентными между собой все условия, отличающиеся только в константах. Можно рассматривать данное допущение как типичный прием машинного обучения — hashing trick — примененный для уменьшения размерности пространства. Однако за этим стоит более мощная мотивация: мы предполагаем, что вся необходимая для предсказания информация о константах условия содержится в его маргинальной выборочности. Можно показать это строго для простых условий вида a < const: здесь по выборочности условия мы можем восстановить значение константы, то есть потери информации не происходит.
Получившаяся задача машинного обучения будет выглядеть так, как представлено на рисунке.
Мы должны предсказать самый левый столбец по известным значениям во всех остальных столбцах. Такая задача, в которой требуется предсказать некоторое вещественное число, в машинном обучении называется задачей регрессии. Метод, решающий её, называется, соответственно, регрессором.
Перейдем к логарифмам во всех столбцах. Заметим, что, если теперь использовать линейную регрессию, то в качестве частного случая мы получим текущую модель PostgreSQL.
Линейная регрессия:
В случае, когда все настраиваемые параметры равны 1, получаем стандартную модель выборочности PostgreSQL:
Стандартный метод гребневой регрессии предлагает искать параметры с помощью минимизации следующего функционала:
Для тестирования различных подходов мы использовали бенчмарк TPC-H.
В качестве простых регрессоров были использованы следующие методы:
* Гребневая линейная регрессия + стохастический градиентный спуск. Этот метод хорош тем, что позволяет использовать динамическое обучение (online learning), поэтому не требует хранить никаких наблюдаемых объектов.
* Множество гребневых линейных регрессий + стохастический градиентный спуск. Здесь предполагается, что для каждого набора условий создается отдельный гребневый линейный регрессор. Этот метод, как и прошлый, хорош тем, что позволяет использовать динамическое обучение, поэтому не требует хранить никаких наблюдаемых объектов, однако работает несколько точнее предыдущего, поскольку содержит существенно больше настраиваемых параметров.
* Множество гребневых линейных регрессий + аналитическое решение методом Гаусса. Этот метод требует хранить все наблюдаемые объекты, но при этом, в отличие от двух предыдущих, гораздо быстрее настраивается под данные.
Однако в этом же и его минус: он ведет себя достаточно нестабильно.
Объясним природу нестабильности, возникающей при аналитическом решении. Ответы нашего регрессора являются входными значениями для оптимизатора, который ищет оптимальный план. Наблюдаемые нами объекты (исполняемые планы), являются выходными значениями оптимизатора. Поэтому наблюдаемые нами объекты зависят от ответов регрессора. Такие системы с обратной связью намного сложнее для изучения, чем системы, в которых регрессор не влияет на окружающую среду. Именно в этих терминах аналитическое решение методом Гаусса является нестабильным — оно быстро обучается, но предлагает более рискованные решения, поэтому в целом система работает хуже.
После детального изучения линейной модели мы обнаружили, что она недостаточно полно описывает данные. Поэтому наилучшие результаты из опробованных нами методов показал kNN.
* kNN. Существенный минус этого метода заключается в необходимости сохранения в памяти всех объектов с последующей организацией быстрого поиска по ним. Существенно улучшить эту ситуацию можно, используя алгоритм отбора объектов. Идея наивного алгоритма отбора объектов: если предсказание на объекте достаточно хорошее, то запоминать этот объект не нужно.
Также этот метод является более стабильным, чем линейная регрессия: для сходимости на бенчмарке TPC-H требуется всего 2 цикла обучения, приведенных на рисунке выше.
### К чему приводит использование машинного обучения
Приведем полученные результаты для алгоритма kNN.
| | |
| --- | --- |
| | |
| До машинного обучения | После машинного обучения |
Можно видеть, что предложенный подход в самом деле ускоряет время работы СУБД. На одном из типов запросов бенчмарка ускорение составляет 30-45%, на другом — в 2-4 раза.
### Какие есть пути развития?
Есть ещё много направлений для дальнейшего улучшения имеющегося прототипа.
1. Проблема поиска планов. Текущий алгоритм гарантирует, что в тех планах, к которым сходится алгоритм, предсказания выборочности будут правильными. Однако это не гарантирует глобальной оптимальности выбранных планов. Поиск глобально оптимальных планов или хотя бы лучшего локального оптимума — это отдельная задача.
2. Режим прерываний для прекращения исполнения неудачного плана. В стандартной модели PostgreSQL нам не имеет смысл прерывать выполнение плана, поскольку у нас есть всего один наилучший план, и он не меняется. С внедрением машинного обучения мы можем прервать выполнение плана, в котором были допущены серьезные ошибки в предсказании выборочности, учесть полученную информацию и выбрать новый лучший план для выполнения. В большинстве случаев новый план будет существенно отличаться от предыдущего.
3. Режимы устаревания информации. В процессе работы СУБД меняются данные и типичные запросы. Поэтому данные, которые были получены в прошлом, могут быть уже неактуальны. Сейчас в нашей компании ведется работа над хорошей системой определения актуальности информации, и, соответственно, «забывания» устаревшей информации.
### Что это было?
В этой статье мы:
* разобрали механизм работы планировщика PostgreSQL;
* отметили проблемы в текущем алгоритме оценки выборочности;
* показали, как можно использовать методы машинного обучения для оценки выборочности;
* экспериментально установили, что использование машинного обучения ведет к улучшению работы планировщика и, соответственно, ускорению работы СУБД.
Спасибо за внимание!
### Литература
* Про планировщик PostgreSQL
+ [Explaining the Postgres Query Optimizer, Bruce Momjian](https://momjian.us/main/writings/pgsql/optimizer.pdf)
+ [Материалы для разработчиков PostgreSQL](http://www.postgresql.org/developer/coding/)
+ [Доклады про внутреннее устройство PostgreSQL, Neil Conway](http://www.neilconway.org/talks/hacking/)
* Про машинное обучение (из курса лекций К. В. Воронцова)
+ [Введение в машинное обучение](http://www.machinelearning.ru/wiki/images/f/fc/Voron-ML-Intro-slides.pdf)
+ [Метрические методы](http://www.machinelearning.ru/wiki/images/c/c3/Voron-ML-Metric-slides.pdf)
+ [Линейные модели и стохастический градиент](http://www.machinelearning.ru/wiki/images/5/53/Voron-ML-Lin-SG.pdf) | https://habr.com/ru/post/273199/ | null | ru | null |
# Страх и ненависть в переговорке: курим VideoSDK API, Vosk и Python
Каждый год — новая полоса препятствий для человечества. И IT не исключение, а полноценный участник этого забега, особенно в нашей стране.
Серьёзные испытания для совместной работы и коммуникаций начались в 2019: коронавирус (он, между прочим, ещё вроде как есть) показал, насколько сложно переходить от офисов и аудиторий к удалённой работе и учёбе. В 2022 иностранные IT-гиганты ушли из России и прихватили с собой известные продукты и сервисы, не раз выручавшие всех нас. Тем не менее, количество пользователей видеосвязи во всём мире постоянно растёт, да и переговорные комнаты никуда не делись вопреки трендам на удалёнку и работу с импровизированных рабочих мест. Так или иначе мы адаптировались под новые условия. А вот адаптировать эти условия под себя — задача не из простых.
Сегодня поговорим о кастомных решениях для видеоконференцсвязи (далее — ВКС) с минимальными затратами человеко-часов и финансов на их создание. ~~Я параноик~~ Брать готовый open-source – меня не устраивает, всем известны случаи встраивания back door в проекты с открытым исходным кодом с целью нанести ущерб пользователям из России. Поэтому за основу берём что-то отечественное с корпоративным уклоном, с открытым API и подходом «без регистрации и смс».
Меня зовут Антон Бааджи и сегодня на примере Python, Vosk и TrueConf VideoSDK я покажу, как можно адаптировать корпоративный продукт под себя. Неважно, чем вы занимаетесь — администрированием сетей видеосвязи или разработкой ПО, главное, чтобы вас, как и меня, не устраивало текущее положение дел. *Поехали!*
> **Цель:** знакомимся c TrueConf VideoSDK, смотрим как работает и что можно сделать.
>
>
**VideoSDK** – это видео движок для создания кастомных решений для встраиваемых систем (видеокиосков, терминалов самообслуживания), который не имеет своего графического интерфейса для управления. Сам по себе движок не является готовым решением под ключ, но выполняет роль инструмента для интеграции со сторонними приложениями и управления с помощью API. Варианты его применения также включают в себя и переговорные комнаты, и один из примеров ниже это покажет.
### Список используемых модулей
* pyVideoSDK;
* websocket-client;
* orjson, просто потому что он быстрее json ([тут](https://github.com/tktech/json_benchmark) и [тут](https://habr.com/ru/company/stm_labs/blog/670576/));
* queue — для создания очередей;
* Levenshtein — вычисление сходства строк;
* vosk — распознавание речи (speech-to-text);
* pyttsx3 — генерация речи из текста для Windows;
* pyfestival — генерация речи из текста для Linux;
* sounddevice — захват звука с микрофона и вывода звука на динамики;
* soundfile — чтение звуковых (WAV) файлов.
Как это работает?
-----------------
VideoSDK управляется API по обыкновенной схеме запрос-ответ. Для отправки запросов и получения ответов используется WebSocket, по которому осуществляется обмен сообщениями в формате **JSON**.
Описание запросов и их ответов доступно в документации [API TrueConf VideoSDK](https://docs.trueconf.com/videosdk/introduction/common). Исходя из нее мы будем именовать запросы — ***командами***, а ответы — ***уведомлениями***.
#### Команды
Для выполнения какого-либо действия нужно послать команду (запрос), например:
* [accept](https://docs.trueconf.com/videosdk/commands/accept) – принять вызов;
* [call](https://docs.trueconf.com/videosdk/commands/call) – позвонить пользователю или послать запрос на участие в групповой конференции;
* [getAbook](https://docs.trueconf.com/videosdk/commands/getAbook) – получить адресную книгу.
Уведомления
-----------
Уведомления делятся на два типа:
1. Ответы на запрос.
2. Уведомления, генерируемые в следствии наступления какого-то события.
Ответ на запрос будет содержать поле `method` с названием команды и поле `result`, которое в свою очередь будет содержать `true` либо, в других случаях, результат выполнения команды. Если произошла ошибка выполнения команды (внутренняя или некорректный запрос), `result` будет содержать `false` и дополнительное поле error с текстовым описанием ошибки.
**Пример ответа:**
```
{
"method" : "getAbook",
"result" : true,
"abook":[{данные пользователей из адресной книги}]
}
```
Уведомление будет содержать поле `method : "event"` и поле `event` с названием произошедшего события.
**Пример уведомления:**
```
{
"event": "audioCapturerMute",
"mute": false,
"method": "event"
}
```
Разработчиками VideoSDK подготовлены библиотеки для взаимодействия с ним на Python ([pyVideoSDK](https://github.com/TrueConf/pyVideoSDK)) и на С++ ([videosdk](https://github.com/TrueConf/videosdk)). То есть вам не понадобится писать свою обертку для отправки/получения с API. Удобно, правда? Все примеры в статье будут показаны на Python.
Получение авторизационных данных
--------------------------------
В [@TrueConfSDKPromoBot](https://t.me/TrueConfSDKPromoBot) нужно нажать кнопку **Free Accounts**. Вам будет выдан один основной аккаунт и два дополнительных. **Free Accounts with QR** выдаст эти же данные, но с QR-кодом. Его можно показать в камеру VideoSDK и он автоматически авторизуется на [тестовом сервере](http://connect.trueconf.com) от разработчиков. VideoSDK воспроизведет звуковое уведомление, если считывание и авторизация прошли успешно.
Как запускать VideoSDK и где взять его IP?
------------------------------------------
Всегда в первую очередь нужно запускать VideoSDK с [параметром --pin](https://docs.trueconf.com/videosdk/introduction/commandline#pin), а потом уже запускать код. Так происходит, потому что, скрипт подключается (создает сессию) к запущенному экземпляру VideoSDK. В качестве пина можно использовать любую строку.
**Windows:**`"C:\Program Files\TrueConf\VideoSDK\VideoSDK.exe" --pin 123`
**Linux:**`trueconf-videosdk --pin 123`
После этого на экране у вас отобразится окно VideoSDK c данными для подключения (`IP:port`).
Начало
------
> VideoSDK является клиентом для сервера TrueConf Server, поэтому для работы с ним требуется наличие развернутого сервера. В [@TrueConfSDKPromoBot](https://t.me/TrueConfSDKPromoBot) можно получить доступ к развернутому экземпляру TrueConf Server.
>
>
В своих примерах я использую отдельный файл`config.py`с [настройками подключения](#how-to-run-VideoSDK) и [авторизации](#get-auth-data).
```
# Connection settings
IP: str = "192.168.1.5"
PORT: int = 88
PIN: str = "123"
DEBUG: bool = False # Write more debug information to the console and to the log-file
# Authorization settings
# IP or DNS TrueConf Server
TRUECONF_SERVER: str = "connect.trueconf.com"
# TrueConf ID of administrator, operator or user
TRUECONF_ID: str = "name@connect.trueconf.com"
# TrueConf ID of administrator, operator or user
PASSWORD: str = "MyVeryStrongPassword"
```
Помимо настроек в этом файле есть еще список слов для голосовых команд, словарь для преобразования слов в числа и фразы для обратной связи VideoSDK с пользователем, а также класс для воспроизведения звуковых уведомлений.
Импорт модулей
--------------
Пакет pyVideoSDK состоит из нескольких составляющих модулей:
* основной модуль **init.py**. Создает сессию на websocket, устанавливает соединение, производит логирование, регистрирует пользовательские хендлеры.
`import pyVideoSDK`
* **мethods.py**. В этом модуле все API-команды инкапсулированы в методы класса Methods для удобной работы с ними.
`from pyVideoSDK.methods import Methods`
* **consts.py**. Здесь описаны все наименования команд и уведомлений, а также их параметры.
`from pyVideoSDK.consts import EVENT, METHOD_RESPONSE`
`import pyVideoSDK.consts as C`
Также импортируем конфигурационный модуль:
`import config`
Инициализация объектов
----------------------
Для работы с VideoSDK, создайте экземпляр класса VideoSDK используя функцию **open\_session** из модуля **pyVideoSDK**:
```
sdk = pyVideoSDK.open_session(ip = config.IP, port = config.PORT, pin = config.PIN, debug = config.DEBUG)
```
Функция создаст экземпляр, установит соединение, и вернет объект для дальнейшей работы.
Аналогично этому создайте экземпляр класса для работы с командами, передав ему переменную `sdk`:
```
methods = Methods(sdk)
```
Такая вот небольшая подготовительная работа. Дальше я покажу, как надо зарегистрировать обработчик (хендлер) событий для уведомлений и команд.
Как понять, что происходит?
---------------------------
Каждая команда после выполнения, а также уведомления присылают ответ в формате **JSON**. Чтобы отловить конкретное событие из всего потока уведомлений, нужно зарегистрировать хендлер.
Хендлер (обработчик) – это функция, которая вызывается какой-либо программной системой в ответ на наступление какого-либо события.
Чтобы зарегистрировать хендлер, нужно обернуть функцию-обработчик декоратором:
```
@sdk.handler([C.])
def on\_getSomeInfo():
pass
```
`type_of_response` — может содержать только один из двух типов событий:
* **METHOD\_RESPONSE** — ответ API, вызванный на выполнение команды;
* **EVENT** — уведомление об изменении состояния в работе VideoSDK.
`C.name_of_response` — имя обрабатываемого события. Имена событий отличаются по префиксу, для **method\_response** — `M_`, а для **event-ов** — `EV_`:
```
@sdk.handler(METHOD_RESPONSE[C.M_getMonitorsInfo])
@sdk.handler(EVENT[C.EV_appStateChanged])
```
Декорированная функция всегда должна принимать один позиционный параметр, назовем его **response**.
```
@sdk.handler(type_of_response[C.name_of_response])
def on_getSomeInfo(response):
pass
```
После добавления обработчика можно выполнить команду. Для примера приведен код получения [информации о мониторах](https://docs.trueconf.com/videosdk/commands/getMonitorsInfo#getmonitorsinfo):
```
@sdk.handler(METHOD_RESPONSE[C.M_getMonitorsInfo])
def on_getMonitorInfo(response):
print(response['currentMonitor'])
### SOME OF YOUR CODE
if __name__ == '__main__':
methods.getMonitorsInfo()
sdk.run()
```
Метод `run()` держит предварительно созданную сессию открытой, пока есть подключение к VideoSDK (см. раздел **Инициализация объектов** выше). На самом деле здесь все просто. В методе крутится бесконечный цикл и каждую 0,2 секунды проверяет соединение.
```
def run(self):
print("\nPress Ctrl+c for exit.\n")
try:
while True:
if not self.isConnected():
break
time.sleep(0.2)
except KeyboardInterrupt:
print('Exit by Ctrl + c')
except CustomSDKException as e:
print('VideoSDK error: {e}')
```
Итак, мы разобрались как добавлять обработчики и вызывать команды, ниже мы рассмотрим несколько “боевых” примеров.
Примеры использования
---------------------
### Авторизация на сервере
Авторизоваться на сервере можно, если мы к нему подключены. Поэтому нужно отловить уведомление [**serverConnected**](https://docs.trueconf.com/videosdk/notifications/serverConnected), которое возникает только при успешном присоединении к серверу, и выполнить команду [**login**](https://docs.trueconf.com/videosdk/commands/login) c параметрами `login` и `password`.
```
@sdk.handler(EVENT[C.EV_serverConnected])
def on_serverConnected(response):
"""Need to login"""
methods.login(config.TRUECONF_ID, config.PASSWORD)
```
### Автоматический перенос окна с контентом на второй монитор
Предположим, что наша переговорная комната участвует в конференции и один из пользователей показывает контент в отдельном потоке. Тогда, если у нас подключено два экрана, очень удобно выводить окно с показом контента сразу на второй (не занятый окнами из конференции) дисплей. В этом поможет тот факт, что такой контентный поток будет помечен особым тегом "**#contentSharing**". Для переноса видеоокна подойдет команда [**moveVideoSlotToMonitor**](https://docs.trueconf.com/videosdk/commands/moveVideoSlotToMonitor) с двумя параметрами:
* **callId** – идентификатор слота (окна), который нужно вынести;
* **monitorIndex** – числовой индекс монитора.
Чтобы перевести слот на второй монитор, нужно узнать какой монитор свободен. Для этого надо:
1. Выполнить команду **getMonitorsInfo** (ранее рассматривалась в данной статье).
2. Проверить чему равно поле **currentMonitor**.
3. Вывести слот на противоположный.
```
@sdk.handler(METHOD_RESPONSE[C.M_getMonitorsInfo])
def on_getMonitorInfo(response):
global IndexSlideshowMonitor
for monitor in response['monitors']:
if monitor['index'] == response['currentMonitor']:
continue
IndexSlideshowMonitor = monitor['index']
break
```
```
@sdk.handler(EVENT[C.EV_videoMatrixChanged])
def on_moveVideoSlotToMonitor(response):
methods.getMonitorsInfo()
for i in response["participants"]:
if '#contentSharing' in i['peerId']:
methods.moveVideoSlotToMonitor(callId=i['peerId'], monitorIndex=IndexSlideshowMonitor)
break
```
Голосовой вызов абонента
------------------------
Весь код я расписывать не буду, только логику. Для голосового распознавания я использую Vosk API, т.к. он работает оффлайн. Я думаю, все понимают как работает голосовой вызов, например, в том же Google Assistant или Siri. Нам нужно:
1. Получить список абонентов.
2. Распознать речь и отделить команду **Набери** от ее параметров **Ивана Петрова**.
3. Сопоставить введенные ФИО с адресной книгой из VideoSDK.
4. Вызвать найденного абонента по его логину (в терминологии производителя решения TrueConf ID).
### Получение списка абонентов
Для получения списка абонентов я выполнил команду [**getABook**](https://docs.trueconf.com/videosdk/commands/getAbook), “словил” уведомление с помощью функции `on_getAbook` и сохранил полученные данные в словарь **Abook** в формате **ключ** (peerDn, отображаемое имя, DisplayName) : **значение** (peerId, TrueConf ID).
**on\_getAbook**
```
@room.handler(METHOD_RESPONSE[C.M_getAbook])
def on_getAbook(response):
global Abook
Abook = {}
for user in response['abook']:
try:
Abook[user['peerDn']] = user['peerId']
except IndexError:
continue
```
Использование глобальных переменных считается плохой практикой, но иногда это оправдано. Выходит, что мне нужно сохранить список абонентов в словарь для дальнейшего использования. Функция, которая выполняет это действие, отдекорирована хендлером, который принимает только один параметр, что в свою очередь накладываетограничения – мы не можем вызвать нашу функцию, и передать в нее “кастомные” аргументы. Хендлер работает как коллбек. Было создано событие (getABook) – отработала функция, события нет – функция “спит”.
Поэтому я использую глобальные переменные, чтобы была возможность работать с полученными данными в других функциях.
**Структура словаря Аbook:**
```
{'Алексей Клинц': 'klintz@example.server.com',
'Алиса Лесова': 'elisa@example.server.com',
'Анастасия Лебедева': 'lebedeva@example.server.com',
'Андрей Ковалев': 'kovalev@example.server.com',
'Анна Швец': 'shvets@example.server.com',
'Борис Макаров': 'makarov@example.server.com',
'Виктория Листьева': 'listeva@example.server.com'}
```
### Распознавание речи
Как было уже написано, я использую Vosk для распознавания речи. Про него достаточно много написано информации, например, тут [на Хабре](https://habr.com/ru/search/?q=vosk&target_type=posts&order=relevance), поэтому сильно углубляться не будем. Но некоторые моменты затрону:
1. Vosk сильно привередлив к звуку и постороннему шуму. Поэтому в идеале нужно организовать в помещении звукоизоляцию или внедрить шумоподавление для улучшения распознавания голосового ввода.
2. Мы используем русскоязычную облегченную модель, которая подходит для Android/iOS и RPi. Эта модель не требовательна к ресурсам и может работать на устройствах с VideoSDK. Но точность распознавания речи по сравнению с полной моделью может быть снижена. Не популярные имена и фамилии, а также окончания слов распознаются плохо.
### Сопоставление данных
Т.к. используемая облегченная модель неидеально распознает некоторые окончания в русском языке, то нужно решать и эту проблему. Дополнительная сложность заключалась в том, что я не знал, какие данные могут быть в адресной книге. Метод **getABook** возвращает отображаемое имя (DisplayName), оно имеет ограничение в 64 символа и по сути может быть любым. Из-за этого нельзя просто проверить, находится ли ключ (ФИО) в словаре и вызвать абонента с таким отображаемым именем по логину (TrueConf ID).
Я подумал: “А что если сравнивать строки на схожесть?”. Было принято использовать алгоритм неточного сравнения строк — [Сходство Джаро-Винклера](https://ru.wikipedia.org/wiki/%D0%A1%D1%85%D0%BE%D0%B4%D1%81%D1%82%D0%B2%D0%BE_%D0%94%D0%B6%D0%B0%D1%80%D0%BE_%E2%80%94_%D0%92%D0%B8%D0%BD%D0%BA%D0%BB%D0%B5%D1%80%D0%B0). Что это и какие алгоритмы существуют, можно почитать на [Хабре](https://habr.com/ru/post/671136/). Для Python существует модуль, в котором реализован алгоритм Джаро - Винклера. Он называется [**Levenshtein**](https://pypi.org/project/Levenshtein/)и его также надо не забыть импортировать через `import Levenshtein`.
```
def contact_diff(response):
match_list = {}
for name in Abook:
match_list[name] = Levenshtein.jaro_winkler(response, name)
return max(match_list, key=buf.get,default=0)
```
Отображаемое имя может иметь вид:
1. Иванов Владимир
2. Иванов Владимир Андреевич
3. 999-000
4. +79081234567
5. любая другая строка не больше 64 символов.
Vosk числа распознает отлично, но в результате он их записывает строкой, а не цифрами. Например, фразу `Набери 123-456-789` он распознает как `Набери один два три четыре пять шесть семь восемь девять` или как `Набери сто двадцать три четыреста пятьдесят шесть семьсот восемьдесят девять`, в зависимости от способа произношения фразы. И для алгоритма Джаро-Винклера это имеет значение. Поэтому потребовалось дописать функцию проверки строкового числа и перевода его в **цифровое** представление.
```
def text_to_number(text_with_number: tuple):
numbers = config.NUMERIC[config.LANG]
return "".join([str(numbers[i]) if i in numbers else i for i in text_with_number])
```
Далее, в процессе тестирования стало ясно, что некоторые фамилии Vosk делит на части, предполагая, что это разные слова.
**Пример распознавания некоторых фамилий:**
```
Дугинец → ['дуги', 'нет']
Мастеровенко → ['мастера', 'венка']
Якупов → ['я', 'кубов']
```
Поэтому пришла мысль конкатенировать все аргументы, которые идут после команды набора (в примере используются ключевые слова "набери" и "позвони"). В итоге получилось так:
```
Николай Мастеровенко → ['николай', 'мастера', 'венка'] → 'николаймастеравенка'
```
Алгоритм Джаро-Винклера рассчитывает минимальное число одно-символьных преобразований, которое необходимо для изменения одного слова на другое, поэтому конкатенация строк повысила точность расчета сходства получившихся в итоге слов.
Результат распознавания Vosk всегда возвращает в нижнем регистре, в свою очередь у отображаемого имени (DispayName) нет каких-либо требований на этот счет. Пользователь может задать себе имя, например, **С0нЯ КОшкин@**. Конечно, в корпоративной среде так делать никто не будет, но мы пишем универсальный код, который будет работать в разных ситуациях и результат не будет меняться. Смотрим — чувствителен ли алгоритм Джаро-Винклера к регистру? И таки да, чувствителен.
**Пример схожести строк в разном регистре:**
```
борисмакаров --- БорисМакаров = 0.888888888888889
борисмакаров --- борисмакаров = 1.0
```
Процент совпадения, как вы видите, меняется аж на целых 12%, и это много. Поэтому нужно к каждое отображаемое имя из адресной книги нужно перевести к нижнему регистру, благо есть функция **lower()**:
```
display_name.lower()
```
После сопоставления входных данных (ФИО) с данными из адресной книги мы получаем словарь со значениями степени совпадения строк. По логике вещей, кандидат на вызов тот, у кого выше степень похожести. И все бы ничего, но и тут снова возник маленький нюанс. Алгоритм Джаро-Винклера для двух строк разного размера, но совпадающих на 6 букв, выдает результат схожести 84%.
```
сергейалександровичковалев --- сергейпетров = 0.8435897435897436
```
Таким образом, мы видим, что нельзя “по логике вещей” брать контакт с максимальным совпадением. Поэтому я добавил дополнительную проверку процента схожести, если совпадение больше 85%, то совершить вызов. Вынес этот параметр в отдельную переменную **SIMILARITY\_PERCENTAGE** в config.py, так его легко можно править при необходимости в зависимости от особенностей формирования адресной книги.
В результате вышеизложенного наша функция **contact\_diff** обросла дополнительным функционалом и приобрела такой вид:
```
def contact_diff(response):
match_list = {}
for display_name in Abook:
concat_name = ''.join(display_name.split()).lower()
match_list[display_name] = Levenshtein.jaro_winkler(
text_to_number(response), concat_name)
return max(match_list.items(), key=lambda x: x[1])
```
Функция возвращает наиболее подходящего абонента для вызова, а именно его **DisplayName** и процент схожести.
### Вызов абонента
Для вызова абонента надо выполнить команду [**call**](https://docs.trueconf.com/videosdk/commands/call) с аргументом `peerId`.
**peerId** - уникальный идентификатор пользователя ([TrueConf ID](https://trueconf.ru/blog/wiki/trueconf-id)), которому нужно позвонить.
```
methods.call(TrueConfID)
```
### Вызов абонента с помощью собственного интерфейса PyQT
Используя QT (PyQT), вы можете разработать собственный брендированный интерфейс для звонков через VideoSDK. Разработчики заботливо подготовили для всех желающих сэмпл с кнопкой для вызова консультанта. Это будет полезно, например, в видеотерминалах или как еще их называют – информационных киосках. Они могут быть размещены на вокзалах, в аэропортах, банках, торговых центрах. А еще в системе "умного города" – скажем, для туриста, который ищет куда бы сходить. Такой терминал решает вопрос удалённой помощи – путешественник при необходимости может получить помощь от консультанта по вопросам посещения культурных мест, заселения в гостиницу и т.п.
**GIF с наглядным применением сэмпла CallButton:**
Как запустить этот сэмпл?
1. Получить [авторизационные данные](#get-auth-data).
2. Запустить VideoSDK c параметром `--pin` (см. [правило запуска](#how-to-run-VideoSDK)).
3. Авторизоваться в VideoSDK.
4. В **main.py** прописать IP, порт VideoSDK и PIN и TrueConf ID в переменную `CALL_ID`.
5. Запустить скрипт.
Вывод
-----
Итак, сегодня мы познакомились с VideoSDK и его API, узнали как начать работу с ним и как получить данные для теста. Поэтому, если у вас есть немного свободного времени, желание и начальные знания программирования, то стоит попробовать. Таким образом можно решить многие бизнес-задачи:
1. Вызов работника банка с помощью одной кнопки в терминале/банкомате.
2. Вызов консультанта в информационном киоске.
3. Голосовое управление в переговорной комнате.
4. Внедрить видеосвязь в свое приложение написанное на QT, например, для связи с доктором в приложение больницы.
Ссылки на сэмплы
----------------
1. Голосовой вызов и автоматический перенос контента на второй экран:
<https://github.com/TrueConf/pyVideoSDK-VoiceControl>
2. CallButton – вызов с помощью кнопки PyQT:
<https://github.com/TrueConf/CallButton> | https://habr.com/ru/post/710524/ | null | ru | null |
# Node.js для начинающих: основы работы с файлами
Сегодня мы поговорим о том, как работать с файловой системой средствами Node.js, рассмотрим базовые операции, выполняемые с файлами. К таким операциям относятся следующие:
* Создание файла
* Чтение файла
* Запись данных в файл
* Удаление файла
* Переименование файла
Необходимость в выполнении подобных операций возникает в самых разных ситуациях.
[](https://habr.com/ru/company/ruvds/blog/452566/)
Модуль fs
---------
В Node.js имеется стандартный модуль, `fs` (сокращение от File System), дающий разработчику средства для работы с файловой системой. Импортировать его в проект можно так:
```
var fs = require(‘fs’);
```
Методы этого модуля представлены в синхронной и асинхронной формах. Функции обратного вызова, передаваемые асинхронным методам, принимают в качестве первого параметра объект ошибки, а в качестве второго — данные, возвращённые при успешном выполнении операции. Рассмотрим пример:
```
function fileHandler(){
fs.readFile('textFile.txt', 'utf8', (err, data) => {
if(err) throw err;
console.log(data);
});
}
```
Метод `.readFile()`, о котором мы ещё поговорим, предназначен для чтения файлов. В этом примере у функции обратного вызова есть два параметра — `err` и `data`. В первый параметр попадают ошибки, которые могут возникнуть при попытке чтения файла, во втором оказываются данные, полученные после успешного выполнения операции. Обратите внимание на то, что `.readFile()` — это асинхронный метод модуля `fs`. Его синхронная версия называется `.readFileSync()`. Похожий подход используется и для именования других методов модуля.
Создание нового файла
---------------------
Начнём с примера:
```
function fileHandler(){
fs.open('testFile.txt', 'w', (err) => {
if(err) throw err;
console.log('File created');
});
}
```
Здесь метод `fs.open()` используется для создания нового файла. В качестве первого аргумента он принимает имя файла. Его второй аргумент представляет собой флаг, указывающий системе на то, что именно мы хотим сделать с файлом. В данном случае это флаг `w` (сокращение от writing), который указывает на то, что мы хотим открыть файл для записи. Метод `.open()` может принимать различные флаги. Вот некоторые из них:
1. `r`: открыть файл для чтения
2. `r+`: открыть файл для чтения и записи
3. `rs`: открыть файл для чтения в синхронном режиме
4. `w`: открыть файл для записи
5. `a`: открыть файл для записи данных в конец файла
6. `a+`: открыть файл для чтения и для записи данных в конец файла
Теперь, прежде чем переходить к следующему примеру, отредактируем только что созданный файл `testFile.txt` с помощью какого-нибудь текстового редактора. Внесём в него следующий текст:
```
This is a test file.
We're learning about Node.js File System.
The End.
```
Запись данных в файл
--------------------
Поговорим о том, как дописать что-нибудь в файл:
```
function fileHandler(){
fs.appendFile('testFile.txt', ' This line is beyond the end.', (err) => {
if(err) throw err;
console.log('Data has been added!');
});
}
```
Здесь мы используем метод `.appendFile()` для добавления данных в конец существующего файла. В качестве первого аргумента этот метод принимает имя файла, в качестве второго — данные, которые нужно добавить в конец файла. Третий аргумент — это, как обычно, функция обратного вызова.
После того, как код, показанный выше, успешно отработает, содержимое файла будет выглядеть так:
```
This is a test file.
We're learning about Node.js File System.
The End. This line is beyond the end.
```
Существует и другой способ записи данных в файл. Он подразумевает использование метода `.writeFile()`. Этот метод очень похож на `.appendFile()`, но у него есть одно важное отличие. Дело в том, что с помощью метода `.appendFile()` мы добавляем в файл новые данные после тех данных, которые в нём уже есть. А при использовании метода `.writeFile()` содержимое файла заменяется на новое. Испытаем этот метод:
```
function fileHandler(){
fs.writeFile('testFile.txt', "I'm the replacement you've been looking for.", (err) => {
if(err) throw err;
console.log('Data has been replaced!');
});
}
```
После успешного выполнения операции в файле окажется следующий текст:
```
I'm the replacement you've been looking for.
```
Как видно, содержимое файла полностью заменено новым.
Чтение файла
------------
Для чтения файлов модуль `fs` предоставляет метод `.readFile()`, пример использования которого мы уже видели. В качестве первого параметра он принимает имя файла, в качестве второго — кодировку. Третий параметр — функция обратного вызова. Попытаемся вывести в консоль содержимое файла `testFile.txt` с помощью этого метода:
```
function fileHandler(){
fs.readFile('testFile.txt', 'utf8', (err, data) => {
if(err) throw err;
console.log('--------- [File Data] ---------');
console.log(data);
console.log('--------- [File Data] ---------');
});
}
```
Вот что у нас получится.
*Данные файла, выведенные в консоль*
Теперь поговорим о переименовании файлов.
Переименование файла
--------------------
Для переименования файлов используется метод `.rename()`:
```
function fileHandler(){
fs.rename('testFile.txt', 'newTestFile.txt', (err) => {
if(err) throw err;
console.log('File renamed successfully!');
});
}
```
Первый аргумент метода представляет собой имя существующего файла, второй — новое имя этого файла. После успешного вызова этого метода файл `testFile.txt` превращается в `newTestFile.txt`.
Удаление файла
--------------
Для удаления файлов используется метод `.unlink()`:
```
function fileHandler(){
fs.unlink('newTestFile.txt', (err) => {
if(err) throw err;
console.log('File deleted successfully!');
});
}
```
Успешный вызов этого метода приводит к удалению файла `newTestFile.txt`.
Итоги
-----
В этом материале мы рассмотрели основы работы с файловой системой в среде Node.js. Если вы хотите более глубоко освоить эту тему — взгляните на [этот](https://habr.com/ru/company/ruvds/blog/424969/) материал из цикла публикаций по Node.js, почитайте [документацию](https://nodejs.org/api/fs.html) по модулю `fs` и постарайтесь испробовать на практике всё, о чём узнаете.
**Уважаемые читатели!** Используете ли вы для работы с файлами в Node.js стандартный модуль fs или что-то другое?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/452566/ | null | ru | null |
# Профессиональный React стек для создания сложных приложений в 2022 году
Выучить React недостаточно для профессиональной разработки больших приложений. Для этого есть две основные причины. Первая, у React есть огромная экосистема модулей, в которой необходимо разбираться. Вторая, эта экосистема меняется каждый год. Поэтому может быть не просто разобраться во всех тонкостях применения React, и эта статья может стать путеводителем в увлекательный мир современного React.
К этой статье прилагается [GitHub](https://github.com/slava-lu/enterprise-react-2022)репозиторий и [Демо](https://enterprise-react-2022.vercel.app/en/shop) приложение, которые демонстрируют работу упомянутых в этой стать модулей (и некоторых других). GitHub репозиторий можно использовать в качестве boilerplate для вашего следующего профессионального приложения.
*P.S*. Я пишу также статьи на английском языке. Английский вариант этой моей статьи [доступен тут.](https://javascript.plainenglish.io/enterprise-react-in-2022-3126ed43ba58)
---
**Основные модули**
[Next.js](https://nextjs.org/)— React SSR фреймворк
[Redux](https://redux.js.org/) — Central state management
[next-redux-wrapper](https://github.com/kirill-konshin/next-redux-wrapper) — Next and Redux коннектор
[Redux-Saga](https://redux-saga.js.org/) — Async middleware для Redux
[next-translate](https://github.com/vinissimus/next-translate) — Переводы и i18n
[React Hook Form](https://react-hook-form.com/)— Работа с формами
[Chakra UI](https://chakra-ui.com/) — Design system
*Демо*— <https://enterprise-react-2022.vercel.app>
*Репо*— <https://github.com/slava-lu/enterprise-react-2022>
---
Основное изменение по сравнению со стеком популярным пару лет назад является обязательное использование технологии Server-Side Rendering (SSR). Это уже не просто способ улучшить индексируемость поисковыми системами или немного улучшить производительность приложения. Без SSR практически невозможно добиться хороших результатов в новой методике оценки сайтов от Google - [Core Web Vitals.](https://web.dev/vitals/) Core Web Vitals стали настолько важны, что учебный раздел основного SSR фреймворка посветил этой теме [целый раздел](https://nextjs.org/learn/seo/web-performance). Я рекомендую достаточно хорошо изучить Core Web Vitals. При постоянно увеличивающимся объеме информации может быть не просто определить какой сайт лучше исключительно на основе его контента, поэтому основным определяющим фактором для поисковых систем может стать количество усилий, которые вложили разработчики в создание продукта.
Основным фреймворком для создания SSR приложений на React является **Next.js**. В настоящий момент каких-то реальных альтернатив не существует. Next.js достаточно прост и имеют хорошую документацию и обучающий раздел. На нем можно легко создать простое приложение, но создание крупных веб решений может вызвать сложности. Проблемным местом является Redux, который все еще требуется при создании больших приложений. Многочисленные попытки избавиться от Redux или заменить его на что-то другое пока не привели к его исчезновению. Учитывая, как сильно он облегчает работу разработчика, я думаю что Redux будет с нами еще несколько лет.
Сложность при работе с Redux состоит в том, что он предназначен для работы на стороне клиента (в браузере). Каждый раз, когда вы генерите страницу на сервере, вы создаёте новый Redux store, который надо синхронизовать с данными на клиенте. Этот процесс называется Hydration. Hydration может быть не простым и быть подвержен ошибкам. Оптимальным подходом было бы начальная генерация страницы на сервере вместе с созданием нового чистого Redux store, и затем последующая генерация страниц на клиенте. Таким и был изначальный подход Next.js, когда они предложили метод **getInitialProps** для получения данных. По каким-то причинам позже они решили не продвигать этот метод и предложили два новых метода **getServerSideProps** и **getStaticProps** в качестве потенциальной замены изначального `getInitialProps`. Основной посыл компании [Vercel](https://vercel.com/), которая стоит за Next.js заключался в том, что два новых метода могу улучшить производительность приложений. Они не отказались полностью от `getInitialProps`, но старались не упоминать его ни в документации, ни в своих коммуникациях.
Целью метода `getStaticProps` является генерация страницы во время сборки приложения и затем отдача статического контента браузеру. Я сомневаюсь, что крупные приложения имеют много статического контента. Возможно, основной целью `getStaticProps` была попытка конкурировать с фреймворком [Gatsby](https://www.gatsbyjs.com/). Смысл метода `getServerSideProps` менее прозрачен даже после ознакомления с объяснениями от Vercel. Разработчики продолжают спорить о целесообразности использования этого метода вместо `getInitialProps`. Очевидно, однако, что `getInitialProps` работает гораздо лучше с Redux, и полный отказ от этого метода может привести к значительному уменьшению популярности Next.js. Поскольку в мире React других реальных альтернатив нет, то это могло бы мотивировать разработчиков посмотреть в сторону [Vue.js](https://vuejs.org/) и [Nuxt.js](https://nuxtjs.org/) и возможно там и остаться.
На текущий момент пока не очевидно, какой путь выберет Next.js. В Демо приложении я использовал все три метода, чтобы показать, как с ними можно работать. Как можно увидеть из кода, работать с `getInitialProps` гораздо удобней, чем с другими двумя методами.
---
В качестве Redux middleware для работы с REST API (а также WebSocket) я рекомендую использовать старый добрый модуль **Redux-Saga.** Он дает возможность хорошо отделять UI от бизнес-логики, а также позволяет легко реализовывать сложную логику получения данных. Стоит отметить, что процесс начального изучения Redux-Saga может быть трудоемким, но затем вы сможете легко и быстро создать любые асинхронные middleware.
Если вы следите за трендами в мире React, то могли заметить, что иногда высказываются предложения переместить функции получения данных на уровень React компонентов. Однако мне кажется, что это может быть всего лишь очередной попыткой наконец-то избавиться от Redux. Я не вижу особых преимуществ от такого объединения. Наоборот, разделения UI от получения данных позволяет улучшить надежность приложения и облегчает его разработку. Простота и скорость разработки, которая получила свой термин как “*Developer Experience*” становится все более важной в современном мире. Технологии становятся более сложными, а их изучение более трудоемким. Человеку трудно постичь их всех, не говоря уже о том, чтобы овладеть ими. Поэтому простота разработки может стать определяющим фактором в выборе технологии.
Одним из дополнительных преимуществ при использовании Redux-Saga совместно с Next.js является простота выбора стратегии навигации и получения данных. Существует два основных подхода к этому вопросу:
1. Сначала переход на страницу, потом загрузка данных
2. Сначала предзагрузка данных, потом переход на страницу.
Первый способ, на мой взгляд является более популярным, однако его не так легко реализовать на Next.js, поскольку Next.js блокирует навигацию до завершения работы любого из трех методов получения данных, описанных выше. Redux-Saga, однако, позволяет указать, хотите ли вы дожидаться завершения запросов (перевода Promise в статус resolved) до навигации или нет, таким образом реализуя любую из этих двух стратегий. Вы можете посмотреть, как это делается в Демо приложении. Ищите свойство `navigateAfterSaga`.
```
Shop.getInitialProps = async ({ store }) => {
store.dispatch(triggerProductList(10))
return {
navigateAfterSaga: false,
title: 'title#shop_page',
}
}
```
Что касается низкоуровневой функции запроса данных, то я предлагаю использовать [axios](https://axios-http.com/) вместо классического fetch. В большей степени из-за отличного функционала, который предлагает axios при работе с таймаутами как на стороне клиента, так и на стороне сервера. Честно говоря, я даже не знаю, как можно реализовать таймауты на стороне сервера при работе с Next.js и fetch.
---
Одной из новых и приятных функциональностей Next.js является [интернациональная маршрутизация](https://nextjs.org/docs/advanced-features/i18n-routing) (Internationalized Routing). Она предоставляется прямо из коробки и позволяет добавлять префиксы к URL для мультиязычных сайтов. К сожалению, это только маленькая часть того, что нужно разработчикам для создания мультиязычных сайтов. Как минимум необходим еще модуль переводов. Выбирать его следует осторожно, так как не все модули переводов поддерживают все три методы получения данных, предлагаемые Next.js. Я предлагаю использовать **next-translate,** так как он поддерживает `getInitialProps`.
Еще одной полезной функцией, которая требуется мультиязычным сайтам, является функция изменения URL в зависимости от языка. Не только префикса, а всего URL. Так например `en/page` должно стать `de/seite`. Есть примеры реализации этого функционала с помощью настройки [rewrites](https://nextjs.org/docs/api-reference/next.config.js/rewrites). Но это явно не то место, где это должно делаться. Хочется надеяться, что разработчики Next.js обратят внимание на этот вопрос в будущем.
---
Одной из важных задач при выборе стека является выбор UI модуля или Дизайн Системы (Design System). Можно сделать свою собственную, но это достаточно трудоемко. Существуют готовые решения и очевидным лидером среди них на сегодняшней день является **Chakra UI**. Ранее популярной опцией был также Material UI, но он уже несколько приелся, да и развивается не очень активно. Chakra UI предлагает хороший выбор [базовых](https://chakra-ui.com/docs/getting-started) бесплатных элементов, а также [платные](https://pro.chakra-ui.com/) сложные темплейты. С помощью этих темплейтов можно создать дизайн E-Commerce сайта за считанные дни, не прибегая к помощи таких инструментов как Figma или аналогичных. Это очень здорово.
Проблема при использовании этой библиотеки, как в прочем и почти любой другой состоит в том, что она навязывает свой API. Если вы успели выучить наизусть все свойства CSS, то при использовании Chakra UI придется учить их заново. В прочем, вы можете распечатать основные из них и повесить где-нибудь перед собой. Для уникальных или сложных UI компонентов я предлагаю использовать [styled-components.](https://styled-components.com/) Эта библиотека очень гибкая и позволяет использовать стандартный CSS без сокращений или конвертации в Camelcase.
---
Что касается работы с формами, то в экосистеме React появился новый лидер. Некоторое время назад на смену всем известной библиотеки [Redux Form](https://redux-form.com/) пришел [Formik](https://formik.org/). Проблема с Formik заключалась в том, что эта библиотека использует шаблон render props. В свое время этот шаблон был популярен, но не прижился в React сообществе. Мне кажется этот шаблон несколько запутанным, и при разработке больших приложений бывает трудно понять, что происходит в коде.
На фоне сложностей с Formik и другими библиотеками для обработки форм появилась новая - **React Hook Form**, которая очень активно набирает популярность. Она очень проста в использовании, но имеет одну особенность. Она основана на шаблоне неуправляемых компонентов (Uncontrolled Components). Из-за этого становиться непросто отсылать форму не из компонента самой формы, но это возможно. Простота и очень хорошая документация является неоспоримыми преимуществами этой библиотеки.
---
Этот был обзор основных модулей для того, чтобы вы могли начать создавать большие корпоративные приложения на React.
Хочется еще сказать несколько слов про **развертывание** приложений. Если вы создали приложение на Next.js, то я рекомендую рассмотреть возможность его развёртывания на хостинге [Vercel](https://vercel.com/). Вы можете подключить свой репозиторий GitHub к облаку Vercel и развернуть приложение за пару кликов мышкой. Что еще более приятно, так это то, что вы получаете готовый CI/CD из коробки. Как только вы создаете Pull Request (PR), то создается так называемая preview версия приложения на основе этого PR. После принятия этого PR, основное приложение также автоматически обновляется. Если вы когда-либо пытались настроить такой функционал в Jenkins или GitHub Actions, то вам непременно эта функциональность должна понравиться.
Есть еще пара важных тем, которые напрямую не относятся к React, но относятся к области frontend разработки. Я скажу пару слов о них ниже.
**Тестирование**. Тема тестирования является гораздо более запутанной, чем кажется на первый взгляд. С одной стороны, никто не сомневается, что тестирование является важным. Но немногие могу раскрыть, какое тестирование является важным и почему. Большой шум вокруг юнит тестирования пришел к нам из мира backend, где у разработчиков нет возможности мгновенно видеть результат своей работы. Единственным простым и быстрым способом убедиться в качестве написанного кода для backend разработчика является тестирование его юнит тестами. Но это не так в мире frontend. С надежной и производительной технологией [Fast Refresh](https://nextjs.org/docs/basic-features/fast-refresh), которую предлагает Next.js и другие фреймворки, frontend разработчик может мгновенно видеть результат каждой строчки кода, которую он печатает. Если это еще и соединить с компонентным подходом, который разделяет элементы кода (особенно при использовании Redux-Saga), то ценность юнит тестирования становиться совсем неочевидной. Я даже готов сделать смелое утверждение, что юнит тестирование приносит совсем мало пользы при современной разработки React приложений, если только у вас нет файлов с действительно сложной логикой. Но если они есть, то имеет смысл подумать про перенос этой логики на backend.
Но что может быть действительно полезным, так это функциональное тестирование интерфейса. Разработчику часто бывает сложно заметить, что радиус контейнера картинки составляет 2px вместо 4px, или что расстояние между элементами интерфейса увеличилось на 4px. Этот тип тестирования может быть хорошо автоматизирован. Также может быть полезным хаотичное нажатие на ссылки и кнопки. Разработчики обычно проверяют только разумный сценарий, который должны выбрать сознательные пользователи. Случайное нажатие на кнопки может уронить сайт или привести к отображению неправильных данных. Таких проблем лучше избегать.
**Typescript**. Typescript активно пытается стать основным языком разработки frontend приложений, но пока не смог получить этот статус. Утверждается, что Typescript позволяет совершать меньше ошибок при разработке приложений. Возможно, это так, но не стоит забывать про побочные эффекты, такие как менее читаемый код и дополнительный траблшутинг специфичных для Typescript проблем, который отнимает время, но не улучшает при этом само приложение. Можно сравнить Typescript c автопилотом от Tesla. Автопилот Tesla действительно хорош и помогает водителю управлять автомобилем. Проблема, однако, состоит в том, что он стоит 10К+ долларов и водитель все равно не может расслабиться и посмотреть фильм на заднем сидении. Он вынужден держать руки на руле. Возникает вопрос, а в чем тогда ценность этого Автопилота?
Похожие рассуждения можно применить и к Typescript. Вы все равно должны быть хорошим разработчиком, чтобы создавать профессиональные приложения. Но если вы являетесь профессиональным разработчиком, то возможно вам не нужен и Typescript, чтобы помогать вам писать качественный работающий код, и вы можете создавать приложения быстрей без него.
Возможно, часть хайпа вокруг Typescript идет от backend разработчиков, которые приходят в мир frontend и пытаются ООПезировать JavaScript, чтобы чувствовать себя более комфортно.
Typescript может быть полезен при разработке модулей для других разработчиков, так как это позволяет получить подсказки в стиле IntelliSense от IDE. Ценность Typescript при разработке конечных продуктов для меня менее очевидна.
Последняя тема, которую я хотел бы тут затронуть, это сторонние сервисы. Сегодня никто не хочет возиться с настройкой почтовых серверов и других инфраструктурных сервисов. Чтобы сэкономить вам немного времени на поиск информации, я составил свой список предпочтений. Я не буду приводить какие-либо аргументы, чтобы не увеличивать объем статьи, но мы можем обсудить мой выбор в комментариях, если будет желание.
[Cloudinary](https://cloudinary.com/)— хранение мультимедиа и обычных файлов
[Sendgrid](https://sendgrid.com/) — отправка технических emails
[Mailchimp](https://mailchimp.com/) — отправка маркетинговых emails
[Sendbird](https://sendbird.com/) — чаты и другая коммуникация с пользователями
---
Многие могут сказать, что они создали хорошие приложения, используя другой набор модулей. Это скорей всего будет правда. Но что я могу обещать, так это то, что вы не пожалеете, если остановите свой выбор на стеке, представленным здесь.
Надеюсь, что этот обзор был вам полезен и интересен и поможет вам лучше понять экосистему React, даже если вы не согласны со всеми тезисами в этой статье. | https://habr.com/ru/post/646887/ | null | ru | null |
# Пять способов пагинации в Postgres, от базовых до диковинных
Вас может удивить тот факт, что пагинация, распространенная, как таковая, в веб приложениях, с легкостью может быть реализована нерационально. В этой статье мы испробуем различные способы пагинации на стороне сервера и обсудим их удобство при использовании в PostgreSQL. Статья поможет Вам понять, какая техника более уместна в Вашей ситуации, в том числе некоторые Вы, возможно, не видели прежде, а именно те, которые полагаются на физическую кластеризацию и сборщика статистики базы данных.
Перед тем как продолжить, следует упомянуть пагинацию на стороне приложения. Некоторые приложения переносят всю (или большую часть) серверной информации в клиент и разделяют ее на странице там. Для малых объемов данных, пагинация на стороне приложения может быть хорошим выбором, сокращая количество HTTP вызовов. Этот подход становится непрактичным, когда записи начинают исчисляться тысячами. Разбиение на страницы на стороне сервера, имеет следующие достоинства:
* Более быстрая загрузка начальной страницы
* Более высокая точность, когда общие данные изменяются
* Более быстрые операции на больших объемах данных
* Инкапсуляция бизнес-логики
* Более высокая производительность на клиентах с ограниченными ресурсами
PostgreSQL дает нам определенное количество техник пагинации на стороне сервера, которые отличаются по скорости, целостности (не теряют записи), а также поддержку шаблонов доступа к определенным страницам. Не все методы работают не во всех ситуациях, некоторые требуют специальных данных, или запросов. Рассмотрим методы в порядке общности, начиная с тех, которые работают с любыми запросами, и продолжая теми, которые требуют упорядоченных данных. Закончим же мы несколькими экзотическими методами, которые основаны на внутреннем устройстве PostgreSQL.
Разбиение произвольных запросов
-------------------------------
### Limit-Offset
Самый простой метод пагинации, limit-offset, является и самым рискованным. К сожалению, он является одной из основ учебных пособий по веб-разработке. Библиотеки объектно-реляционного отображения (ORM) делают использование этого метода легким и заманчивым, от SQLAlchemy'ого ***.slice(1, 3)*** до ActiveRecord'ого ***.limit(1).offset(3)*** и до Sequelize'ого ***.findAll({ offset: 3, limit: 1 })***. Это не совпадение, что limit-offset используется повсеместно, вы можете прикреплять его к любому запросу без дальнейшей модификации.
ORM методы limit'а и offset'а это одно дело, вспомогательные библиотеки для пагинации могут быть еще более обманчивы. К примеру, популярная Ruby библиотека Kaminari использует limit-offset по-умолчанию, скрывая его за высокоуровневым интерфейсом.
У этой техники есть две больших проблемы, неконсистентность результата и неэффективность смещения. Консистентность связана с тем, что прохождение по результатам должно получать каждый элемент строго единожды, без пропусков или повторений. Неэффективность смещения связана с задержкой, возникающей при сдвиге результатов на большое смещение.
Вот каким образом limit-offset пагинация может быть неконсистентной. Предположим что пользователь переходит со страницы *n* на страницу *n + 1*, пока в тот же момент новый элемент вставлен на страницу *n*. Это вызовет и дублирование (последний элемент со страницы *n* вытеснен на страницу *n + 1*), и пропуск (новый элемент). В качестве альтернативы, предположим что удален элемент *n*, в тот момент, когда пользователь перешел на страницу *n + 1*. Предварительно загруженный начальный элемент страницы *n + 1* сдвинется на страницу *n* и будет пропущен.
Теперь на тему неэффективности. Большие сдвиги в действительности дорого стоит. Даже если присутствует индекс, базе придется просканировать все хранилище, считая строки. Для использования индекса мы должны отфильтровать столбец по значению, но в данном случае нам требуется определенное количество строк, независимо от их значений столбцов. Кроме того, строки не обязаны иметь одинаковый размер при хранении, и некоторые из них могут присутствовать на диске, но быть помечены как удаленные, так что база данных не сможет использовать простую арифметику, чтобы найти место на диске и начать чтение результатов. Давайте измерим замедление.
```
-- Создаем таблицу со случайными строками меняющегося размера
CREATE TABLE medley AS
SELECT
generate_series(1,10000000) AS n,
substr(concat(md5(random()::text), md5(random()::text)), 1, (random() * 64)::integer + 1) AS description;
-- Оповещаем планировщик о кардинально изменившемся размере таблицы
VACUUM ANALYZE;
-- Малые сдвиги освежающе быстры
EXPLAIN ANALYZE SELECT * FROM medley LIMIT 100;
```
Ориентировочная стоимость достаточно низка:
```
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------
Limit (cost=0.00..1.85 rows=100 width=38) (actual time=0.008..0.036 rows=100 loops=1)
-> Seq Scan on medley (cost=0.00..185460.60 rows=9999660 width=38) (actual time=0.007..0.017 rows=100 loops=1)
Planning time: 0.040 ms
Execution time: 0.059 ms
(4 rows)
```
Выбор offset = 1000, меняет его стоимость до 19 и время выполнения до 0.609 мс. Как только offset = 5000000, стоимость становится уже 92734 и время выполнения 758.484 мс.
Эти проблемы не обязательно означают, что limit-offset метод неприменим в Вашем случае. В некоторых приложениях, пользователи, как правило, не проходят много страниц в результатах, и Вы можете даже использовать ограничение количества страниц на стороне сервера. Если неконсистентность данных и ограничение количества страниц не являются проблемой в Вашем приложении, то limit-offset метод вполне подходит для Вас.
**Когда использовать: Limit-Offset.** Приложения с ограниченной глубиной пагинации и терпимые к неконсистентности результата.
### Курсоры
Несмотря на свои недостатки, метод limit-offset имеет плюс в виде отсутствия влияния на сервер. В противоположность этому подходу, имеется другой метод разделения на страницы, курсоры. Как и смещение, курсоры могут быть использованы с любыми запросами, но они отличаются тем, что требуют от сервера отдельного соединения и транзакции через HTTP клиент.
Вот каким образом могут быть использованы курсоры:
```
-- Мы должны находиться в транзакции
BEGIN;
-- Открываем курсор для запроса
DECLARE medley_cur CURSOR FOR SELECT * FROM medley;
-- Получаем 10 строк
FETCH 10 FROM medley_cur;
-- ...
-- Получаем еще 10 строк, с того места, где остановились в прошлый раз
FETCH 10 FROM medley_cur;
-- Все готово
COMMIT;
```
Курсоры имеют желаемое свойство консистентности пагинации на любых запросах, показывая результаты, существующие в базе на момент начала транзакции. [Уровень изоляции](http://www.postgresql.org/docs/9.5/static/transaction-iso.html) транзакции гарантирует что разделенный на страницы результат не изменится.
Каждый подход разделения на страницы имеет свои слабые стороны, и курсоры — не исключение: они зависимы от использования ресурсов и связки клиент-сервер. Каждая открытая транзакция потребляет выделенные ресурсы базы, и не масштабируется для большого количества клиентов. Конечно же, существуют «WITH HOLD» курсоры, которые могут существовать за пределами транзакции, но они должны материализовывать данные.Таким образом, указанные ошибки делают пагинацию курсорами подходящей только для узкого круга ситуаций, например для внутренней сети.
Добавление связи по HTTP до курсоров вносит с собой осложнения. Серверы должны идентифицировать клиентов между запросами, неважно через токен ли, или сохраняя идентификатор, например такой как IP адрес клиента в рамках сессии. Серверы также должны решать, когда освобождать транзакции в связи с их простоем. Наконец, балансирование нагрузки на сервер становится сложным, так как клиент должен подключаться к конкретному серверу каждый раз.
**Когда использовать: Курсоры.** Приложение внутри сети, на единственном сервере, которое должно разделять на страницы запросы с варьируемым и изменяемым порядком, особенно когда важна консистентность результата.
Пагинация упорядоченных запросов
--------------------------------
### Пагинация по набору ключей
Техники, перечисленные выше, могут разделять на страницы результаты запросов любого типа, включая неупорядоченные запросы. Если мы готовы отказаться от этой общности, то мы сможем пожать плоды оптимизации. В частности, при упорядочивании по индексированным колонкам, пользователь может использовать значения с текущей страницы, чтобы выбрать какие объекты показать на следующей странице. Это называется пагинацией по набору ключей.
К примеру, давайте вернется к нашему примеру:
```
-- Добавляем индекс для пагинации (btrees поддерживают неравенство)
CREATE INDEX n_idx ON medley USING btree (n);
SELECT * FROM medley ORDER BY n ASC LIMIT 5;
```
С моими случайными данными он возвращает:
```
n | description
---+-------------------------------------------------------------
1 | 74f70e009396
2 | 8dac5a085eb670a29058d
3 | fce303a32e89181bf5df1601487
4 | fddcced2c12e83516b3bd6cc94f23a012dfd
5 | f51ae548dd27f51147e53e839eeceb6b0c92922145276d668e73d4a6621
(5 rows)
```
Теперь пользователь может посмотреть на максимальный n из результата и использовать его для вызова следующей страницы:
```
SELECT * FROM medley
WHERE n > 5
ORDER BY n ASC
LIMIT 5;
```
Даже при фильтрации с n > 5000000, это работает быстрее, чем в limit-offset примере.
```
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.43..0.62 rows=5 width=38) (actual time=0.101..0.103 rows=5 loops=1)
-> Index Scan using n_idx on medley (cost=0.43..185579.42 rows=5013485 width=38) (actual time=0.100..0.102 rows=5 loops=1)
Index Cond: (n > 5000000)
Planning time: 0.071 ms
Execution time: 0.119 ms
(5 rows)
```
Такая пагинация работает быстро и при этом гарантирует целостность данных. Любые добавления/удаления до текущей страницы оставят результат неизменным. Два слабых места этого метода — это отсутствие произвольного доступа и возможного соединения между клиентом и сервером.
Вообще, нет способа переместиться на выбранную страницу, не посещая предыдущих для определения их максимальных элементов. При определенных условиях, тем не менее, мы можем сделать лучше. Если значения в проиндексированной колонке равномерно распределены (или даже лучше, смежные номера без пробелов), пользователь может произвести некоторые математические расчеты для нахождения интересующей страницы, потому что индекс делает дешевым нахождение наибольшей величины:
```
EXPLAIN ANALYZE SELECT max(n) FROM medley;
QUERY PLAN
------------------------------------------------------------------------------------------------------------
Result (cost=0.46..0.47 rows=1 width=0) (actual time=0.021..0.021 rows=1 loops=1)
InitPlan 1 (returns $0)
-> Limit (cost=0.43..0.46 rows=1 width=4) (actual time=0.018..0.018 rows=1 loops=1)
-> Index Only Scan Backward using n_idx on medley (cost=0.43..284688.43 rows=10000000 width=4) (actual time=0.017..0.017 rows=1 loops=1)
Index Cond: (n IS NOT NULL)
Heap Fetches: 0
Planning time: 0.087 ms
Execution time: 0.042 ms
(8 rows)
```
Другой вопрос пагинации по ключевым значениям, соединение клиент/сервер, требует внимания. Изначально пользователь не знает какие колонки проиндексированы. Сервер, вероятно, предоставит конечную точку с фиксированным результатом, нежели позволит клиенту изменять порядок. Предоставленный клиенту код может не знать какой столбец упорядочен, сервер должен предоставить подсказку как запросить следующую страницу. [RFC5988](https://tools.ietf.org/html/rfc5988) определяет отношение предыдущей и следующей HTTP ссылок для кодирования ссылок для пользователя, по которым он должен перейти.
Так как пользователи, как правило, обращаются к страницам с информацией в линейном виде, пагинация по ключевым значениям обычно предпочтительна для разделения на страницы записей на высоконагруженных веб серверах.
**Когда использовать: Пагинация по ключевым значениям.** Масштабируемые приложения, обслуживающие данные последовательно из столбца(ов), индексированных для сравнения. Поддерживает фильтрацию.
Диковинная, специализированная пагинация
----------------------------------------
### Clustered TID Scan
Мы можем получить нестандартные методы разбивки на страницы для особых ситуаций с использованием функций PostgreSQL низкого уровня. Например, мы можем получить реально случайный доступ к данным, если мы
1. Не требуем от страниц того, чтобы они были одинакового размера
2. Поддерживаем только единственную очередность для разделенных на страницы строк
Трюк заключается в том, чтобы выбрать возвращенные страницы которые связаны со страницами из базы данных на диске, или с определенными частями этих страниц на диске. Каждая таблица в базе данных PostgreSQL содержит в себе секретную колонку, которая называется ctid и идентифицирует ее строку:
```
SELECT ctid, * FROM medley WHERE n <= 10;
ctid | n | description
--------+----+-------------------------------------------------------------
(0,1) | 1 | 74f70e009396
(0,2) | 2 | 8dac5a085eb670a29058d
(0,3) | 3 | fce303a32e89181bf5df1601487
(0,4) | 4 | fddcced2c12e83516b3bd6cc94f23a012dfd
(0,5) | 5 | f51ae548dd27f51147e53e839eeceb6b0c92922145276d668e73d4a6621
(0,6) | 6 | eb9fe1dfe1e421903f96b3b5c5dfe1ee1253582d728c35b4ee7330b
(0,7) | 7 | e95202d7f5c612f8523ae705d
(0,8) | 8 | 6573b64aff262a2b940326
(0,9) | 9 | a0a43
(0,10) | 10 | 82cdc134bd249a612cfddd3088dd09e32de5f4fa33
(10 rows)
```
Каждый ctid представляет из себя следующий вид: (страница, строка). PostgreSQL может получать строки очень быстро по ctid'у, на самом деле, так работают индексы — они связывают значения колонок с ctid'ми.
Следует обратить внимание, хоть PostgreSQL и определяет отношение порядка на основе tid типа, он не может эффективно получить ctid'ы из неравенства
```
EXPLAIN ANALYZE SELECT count(1) FROM medley WHERE ctid >= '(0,1)'::tid AND ctid < '(1,0)'::tid;
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------
Aggregate (cost=235589.00..235589.01 rows=1 width=0) (actual time=1241.851..1241.852 rows=1 loops=1)
-> Seq Scan on medley (cost=0.00..235464.00 rows=50000 width=0) (actual time=477.933..1241.802 rows=116 loops=1)
Filter: ((ctid >= '(0,1)'::tid) AND (ctid < '(1,0)'::tid))
Rows Removed by Filter: 9999884
Planning time: 0.047 ms
Execution time: 1241.889 ms
(6 rows)
```
Запрос диапазонов не работает, но все еще существует способ эффективного запроса всех строк со страницы на диске. Каждая страница содержит current\_setting('block\_size') байтов данных (обычно 8к). Строки связаны 32-битным указателем, так что, в большинстве своем, приходится block\_size/4 строк на страницу. (На самом деле строки, как правило, шире, чем минимальный размер и четверть размера блока обеспечивает верхнюю границу строк на странице.) Следующая последовательность будет генерировать все возможные ctid'ы на j-ой странице
```
SELECT ('(' || j || ',' || s.i || ')')::tid
FROM generate_series(0,current_setting('block_size')::int/4) AS s(i);
```
Давайте воспользуемся ей, чтобы получить все строки в нашем примере на нулевой странице.
```
SELECT * FROM medley WHERE ctid = ANY (ARRAY
(SELECT ('(0,' || s.i || ')')::tid
FROM generate_series(0,current_setting('block_size')::int/4) AS s(i)
)
);
```
Планировщик определил стоимость выполнения этого запроса равной cost=25.03..65.12 и выполняет его за 2.765мс. Запрос страницы под номером 10000 имеет такую же стоимость. Таким образом мы получаем реально произвольный доступ, почему бы его не любить?
Тут имеется три узких места:
1. Когда строки удалены — они оставляют дыры в страницах.
2. Порядок строк не может быть значимым. База данных вставляет строки в дыры, оставленные от удаления строк, что приведет к выпадению строк из последовательности.
3. «Where» не поддерживается
В некоторых ситуациях это не проблема. Один случай — это данные, естественный порядок которых соотносится с порядком добавления в базу, такие как только возрастающие данные интервалов времени. Другой — это данные, которые не меняются часто. Это связано с тем, что мы имеем контроль над расположением строк на страницам через команду CLUSTER.
Давайте вернемся к нашему примеру. Его строки на диске упорядочены по n колонке в возрастающем порядке, так как это порядок, в котором мы добавляли их в базу. Но что если мы хотим отсортировать их по столбцу description? Для этого нам придется физически перестроить таблицу, создав индекс на колонке description и выполнить кластеризацию.
```
CREATE INDEX description_idx ON medley USING btree (description);
CLUSTER medley USING description_idx;
```
Теперь выборка всех строк с первой страницы возвращает нам данные, отсортированные в алфавитном порядке по колонке description. Если таблица изменится, то новые строки выпадут из алфавитного списка, но пока таблица неизменна — возвращаемые объекты будут в полном порядке. Кроме того, она может быть периодически перекластеризована после изменений, несмотря на то, что эта операция блокирует таблицу и не может быть выполнена когда людям нужен к ней доступ.
Наконец, можно определить общее количество страниц для таблицы, используя его общий размер в байтах.
```
SELECT pg_relation_size('medley') / current_setting('block_size')::int;
```
**Когда использовать: TID Scan.** Когда требуется быстрый произвольный доступ и не требуется фильтрация. Особенно хорошо работает с только увеличивающимися данными времени, с практически не изменяющейся шириной строки.
### Набор ключей с оценочными закладками
Как мы видели, обычная пагинация по наборам ключей не позволяет перемещаться на конкретные страницы, кроме случаев с догадками пользователя. Тем не менее, сборщик статистики PostgreSQL поддерживает гистограммы распределения значений по столбцам. Мы можем использовать эти оценки в сочетании с ограничениями и небольшими смещениями, чтобы получить быструю пагинацию с произвольным доступом через гибридный подход.
Для начала давайте взглянем на статистику по нашему примеру:
```
SELECT array_length(histogram_bounds, 1) - 1
FROM pg_stats
WHERE tablename = 'medley'
AND attname = 'n';
```
В моей базе данных колонка n имеет 101 граничный показатель, т.е. 100 диапазонов между ними. Конкретные значения не слишком выбиваются, так как данные равномерно распределены.
```
{719,103188,193973,288794, … ,9690475,9791775,9905770,9999847}
```
Обратите внимание, что значения приблизительные. Первое число это не ровно 0, и последнее это не ровно десять миллионов. Диапазоны разделяют нашу информацию в блок размера B = 10,000,000 / 100 = 100,000 строк.
Мы можем использовать диапазоны гистограмм сборщика статистики PostgreSQL для получения вероятностно правильных страниц. Если мы выбираем размер страницы на клиентской стороне, равный W, то как мы получим i-ую страницу? Она будет находиться в блоке IW / B, со смещением IW% B.
Выбирая W = 20, давайте запросим страницу 270000 из нашей тестовой таблицы.
```
WITH bookmark AS (
SELECT (histogram_bounds::text::int[])[((270000 * 20) / 100000)+1] AS start,
(histogram_bounds::text::int[])[((270000 * 20) / 100000)+2] AS stop
FROM pg_stats
WHERE tablename = 'medley'
AND attname = 'n'
LIMIT 1
)
SELECT *
FROM medley
WHERE n >= (select start from bookmark)
AND n < (select stop from bookmark)
ORDER BY n ASC
LIMIT 20
OFFSET ((270000 * 20) % 100000);
```
Это выполняется сверхбыстро (обратите внимание что сдвиг происходит за время, близкое к нулю в данном случае). Запрос возвращает строки с n=5407259 до 5407278. Истинные значения на странице 270000 равны с n = 5400001 до 5400020. Промах составляет 7239, или приблизительно 0.1%.
Нам повезло с выбором страницы в этом случае. Для контраста, страница 74999 требует смещения на 99980. Мы знаем, что наше смещение будет не более 100000. Верхняя граница находится у нас под контролем, если мы хотим достичь компромисса. Настраивая сборщик статистики PostgreSQL, мы можем получить более точную гистограмму по столбцам.
```
ALTER TABLE medley ALTER COLUMN n SET statistics 1000;
VACUUM ANALYZE;
```
Теперь мы имеем 1000, вместо 100 значений гистограммы. В моей базе данных это выглядит следующим образом:
```
{10,10230,20863, …, 9980444,9989948,9999995}
```
При этом шаг нашего смещения будет не более 10000. Компромисс заключается в том, что планировщик теперь просматривает больше величин, но замедляется. Так что это что-то среднее между неэффективностью смещения и накладными расходами сборщика статистики.
Этот гибридный «набор ключей/смещение» метод вероятно не подходит для многих применений пагинации в реальной жизни. И тут не будет работать условие «where». Кроме того, он неточен и становится только более и более неточным при изменении таблицы и если сборщик статистики давно не запускался.
**Когда использовать: Набор ключей с оценочными закладками.** Когда пользователю нужен глубокий, но приблизительный произвольный доступ, без какой-либо дополнительной фильтрации.
### Выводы
Как и многие другие инженерные решения, выбор техники пагинации требует компромиссов. Можно с уверенностью сказать, что пагинация по набору ключей наиболее применима для среднего сайта с упорядоченным линейным доступом. Однако даже limit/offset метод имеет свои сильные стороны, и более экзотические методы обеспечивают специальные эксплуатационные характеристики для определенных видов данных. Как вы видите, есть довольно много возможностей. Выберите правильный инструмент для работы и не позволяйте пагинации быть закрытой книгой. | https://habr.com/ru/post/301044/ | null | ru | null |
# Google убирает из браузера Chrome строку 'user-agent'
При посещении веб-сайта браузер или другое клиентское приложение обычно посылает веб-серверу информацию о себе. Эта текстовая строка является частью HTTP-запроса. Она начинается с `User-agent:` или `User-Agent:` и обычно содержит название и версию приложения, операционную систему компьютера и язык. Например, Chrome под Android посылает что-то вроде такого:
> `User-Agent: Mozilla/5.0 (Linux; Android 9; Pixel 2 XL Build/PPP3.180510.008) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.87 Mobile Safari/537.36`
Но разработчики Chrome считают, что это слишком подробная информация. Они [объявили о решении отказаться от user-agent](https://github.com/WICG/ua-client-hints) в браузере Chrome. Вместо этого Chrome предложит новый API под названием Client Hints, который позволит лучше контролировать, какая информация передаётся веб-сайтам.
Это делается для защиты приватности, поскольку злоумышленники сейчас активно используют `user-agent` для фингерпринтинга и профилирования пользователей. Вообще ненормальна ситуация, когда `user-agent` транслируется всем подряд в автоматическом режиме.
Строка `User-Agent` впервые появилась в [Mosaic](https://en.wikipedia.org/wiki/Mosaic_(web_browser)), популярном браузере начала 90-х. Тогда браузер отправлял просто строку с названием и версией браузера. Строка выглядела примерно так:
> `Mosaic/0.9`
В первое время от этой информации было мало практической пользы. Через несколько лет вышел браузер Netscape, он перенял у предшественника строку `user-agent` и добавил к неё дополнительные детали, такие как операционная система, язык и т. д. Примерно с этого времени веб-сайты начали учитывать `user-agent`, чтобы выдавать клиенту правильный контент.
Поскольку Mosaic и Netscape поддерживали разный набор функций, веб-сайты должны были использовать строку `user-agent`, чтобы определить тип браузера и избежать использования неподдерживаемых функций (например, фреймы поддерживались только Netscape, но не Mosaic).
В течение многих лет определение версии браузера продолжало играть значительную роль в веб-разработке. Это вызвало неприятные побочные эффекты, когда мелким разработчикам браузеров приходилось имитировать популярные user-agent'ы для корректного отображения веб-сайта, поскольку некоторые компании поддерживали только основные типы `user-agent`.
С ростом популярности JavaScript большинство разработчиков начали использовать библиотеки вроде [Modernizer](https://modernizr.com/), которые определяют конкретный список функций HTML, CSS и JavaScript, которые поддерживает конкретный браузер, обеспечивая гораздо более точные результаты, чем `user-agent`.
В результате основными пользователями `user-agent` остались представители рекламной индустрии, где компании используют характеристики браузера и операционной системы для фингерпринтинга пользователей, а большинство людей не знает, как противостоять этому, а многие даже не осознают угрозы, которую представляет собой тотальная слежка и пожизненное профилирование каждого человека.
По иронии, Google считается одним из главных нарушителей приватности. Именно эта компания собирает самые подробные профили пользователей, собирая данные из электронной почты, GPS-трекеров, операционной системы Android и десятков своих веб-сервисов.
Более того, именно Google в последнее время чаще всех злоупотребляла `user-agent`, блокируя доступ к своим сервисам пользователей с альтернативными браузерами. Чтобы открыть эти сервисы, альтернативным браузерам приходилось подделывать строку `user-agent` и выдавать себя за Chrome. Например, см. [список поддельных user-agent](https://pastebin.com/YURq1BR1) для браузера Microsoft Edge, который тоже вынужден выдавать себя за Chrome на десятках сайтов.
Gmail, Google Maps и другие сервисы работают *медленнее* во всех браузерах, кроме Chrome.
Но бывает, что интересы отдельных разработчиков идут вразрез с интересами работодателя. Возможно, здесь как раз такой случай. Мы и раньше видели, как разработчики Chrome выражали протест некорректными действиями компании, когда она выкатывала сервисы «только для Chrome». Они выражали недовольство в твиттере и во внутренней корпоративной рассылке. Это действительно грамотные специалисты, у которых неадекватные решения руководства Google не могли вызвать ничего, кроме недоумения и фейспалма. Похоже, сейчас пришло время для конкретных действий.
Команда разработчиков браузера Chrome начала поэтапный отказ от `user-agent`, начиная с версии Chrome 81. Отказ от `user-agent` значительно затруднит Google некорректные практики по продвижению своего браузера.
Полностью удалить `user-agent` пока проблематично, поскольку многие сайты ещё полагаются на эту строку, но Chrome **больше не будет обновлять версию браузера и укажет одинаковую версию ОС** в `user-agent` для всех устройств.
В частности, со всех мобильных устройств Chrome будет отправлять такую строку:
> `Mozilla/5.0 (Linux; Android 9; Unspecified Device) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/71.1.2222.33 Mobile Safari/537.36`
Со всех настольных компьютеров строка будет выглядеть следующим образом, независимо от устройства и версии браузера:
> `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.1.2222.33 Safari/537.36`
Переход с `user-agent` на Client Hints планируется завершить к версии Chrome 85, которая должна выйти в сентябре 2020 года. Другие разработчики браузеров, включая Mozilla Firefox, Microsoft Edge и Apple Safari, выразили поддержку этому шагу, хотя пока не огласили свои планы по аналогичным действиям.
Подробнее о предлагаемой альтернативе Client Hints можно почитать в [официальном репозитории Github](https://github.com/WICG/ua-client-hints). Это предложение пока не оформлено в виде стандарта, поэтому точная реализация может измениться к моменту выпуска официальных рекомендаций. Разработчикам рекомендуется следить за изменениями в репозитории, а также за примечаниями, которые публикуются с новыми версиями Chrome.
Главное отличие Client Hints от `user-agent` в том, что сайты больше не будут пассивно получать информацию о браузере пользователя. Они будут вынуждены активно запрашивать её, а браузер может отказать в таком запросе, примерно так же, как сейчас некоторые браузеры блокируют сторонние куки.
---
[](http://miran.ru/) | https://habr.com/ru/post/494362/ | null | ru | null |
# Математический подход к созданию сайтов
«Математика прекрасна». Это может показаться абсурдным, для людей которые при одном только упоминании математики вздрагивают. Однако некоторые из самых красивых вещей в природе и нашей Вселенной — это проецирование математических свойств, от самых маленьких до крупнейших галактик. Один из древних философов, Аристотель сказал: «математическим наукам свойственно выстраивать все по порядку, в симметрии и ограничениях, они являются главными формами прекрасного».
Из-за своей природной красоты, математика является частью искусства и архитектуры. Но **она практически не применяется для дизайна сайтов и приложений.** Это наблюдается из-за того, что многие не сопоставляют математику с дизайном. Хотя, наоборот, математика может быть *инструментом* для производства, поистине волшебных конструкций. Тем не менее, вы не должны полагаться на математику для каждого своего творения. Дело в том, что вы должны рассматривать математику как вашего помощника. Для наглядности мы создали пару сайтов, которые представляют математические принципы, обсуждаемые в этой статье. Мы также создали рекомендации, которые можно использовать в дизайне.
Все рекомендации данные тут, так-же использовались в процессе написания этой статьи и ее примеров. В процессе написания мы убедились, что все дизайнерские приемы показанные в этой статье, имеют математическую природу, то есть они обладают симметрией. Мы также опирались на статью Алгоритм веб-дизайна. Чтобы не усложнять подход, мы старались придерживаться минималистского дизайна, а также предпочли одно-страничные макеты. Очевидно, что примеры в этой статье, должны служить основой для ваших проектов, а не готовыми решениями.
**Золотое сечение «и» Золотой прямоугольник**
Золотое сечение, также известное как божественная пропорция являет собой иррациональную математическую константу со значением примерно 1,618033987. Золотое сечение (золотая пропорция, деление в крайнем и среднем отношении) — деление непрерывной величины на две части в таком отношении, при котором меньшая часть так относится к большей, как большая ко всей величине.
Мы уже опубликовали очень подробную статью «Применение золотого сечения в web-дизайне», которая объясняет, как использовать золотое сечение в веб-дизайне. В сегодняшней статье мы рассмотрим, как использовать золотые прямоугольники в веб-дизайне. Золотой прямоугольник является таковым, если его стороны соответствуют пропорции 1: (один-к-Phi), то есть 1:1.618.
Построить золотой прямоугольник достаточно просто. Во-первых, надо построить квадрат. Затем провести линию от середины одной стороны к противоположному углу и использовать эту линию в качестве радиуса дуги, которая определяет высоту прямоугольника. Наконец, завершить прямоугольник, достроив секцию, где угол, в который проведен радиус, является правым нижним углом секции, а левый верхний угол ограничен дугой.
В качестве примера рассмотрим минималистский дизайн ниже. Он имеет **шесть золотых прямоугольников,** по три прямоугольника в каждой строке. Прямоугольники имеют размеры 299 х 185 пикселей. Таким образом, стороны этих прямоугольников образуют золотое сечение, то есть 299/185 = 1,616. Обратите внимание, что большое количество свободного пространства, окружающего Золотой прямоугольник создает спокойную и простую атмосферу, в которой каждый блок служит своей цели. Хотя используется всего несколько цветов и все блоки очень похожи, навигация является очевидной и простой.
[](http://habrastorage.org/storage2/221/0e0/1ad/2210e01ad0a59d02b43bc678a850a62f.jpg)
Однако, может быть довольно сложно добавить новый блок, сохраняя последовательность конструкции. Вероятно, единственным разумным решением, является добавление блока на третьей строке и использование оставшейся части горизонтального пространства для других целей. Вы можете нажать на картинку ниже, чтобы увидеть увеличенную версию.
[](http://habrastorage.org/storage2/9b2/c6e/a39/9b2c6ea393144392f41c784439d91425.jpg)
#### Возможное применение
Такие прямоугольники хорошо подходят для фото-галерей, презентационных сайтов и каталогов продукции. Они так-же могут быть использованы и в другой последовательности, для получения красивых дизайнов. Например такой подход можно использовать для организации бокового меню и показа рекламы. Естественно такой подход не применяют для создания профессиональных сайтов. Вы также должны работать по сеткам, учитывать выравнивание, соотношение блоков и не терять фокуса на главной цели вашего сайта. Например, интересным дизайнерским решением будет CSS / Jquery основе резинового дизайна, однако мы не рассматриваем эту технику в данной статье.
#### PSD-макет
Мы подготовили архив с [PSD макетами,](http://iteye.ru/wp-content/uploads/2012/05/PSD.zip) в который включен шаблон разработанный в соответствии с «золотым сечением» и «Золотым прямоугольником». Не стесняйтесь использовать его.
### Дизайн Фибоначчи
Как следует из названия, дизайн Фибоначчи основан на последовательности чисел Фибоначчи. По определению, два первых числа Фибоначчи равны 0 и 1, и каждое последующее число равно сумме двух предыдущих. Некоторые источники опускают 0, и начинают последовательность с двух единиц. Итак, два первых числа Фибоначчи равны 0 и 1, и каждое последующее число равно сумме двух предыдущих. Чем больше числа в последовательности Фибоначчи, тем ближе они связаны друг с другом в соответствии с «золотым сечением». Последовательность Фибоначчи выглядит следующим образом:
`0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144...`
В музыке, числа Фибоначчи, иногда используются для настроек, а в изобразительном искусстве, чтобы определить длину или размер содержания или элементов.
Jürgen Schmidhuber, в своем блоге, рассматривает [методологию чисел Фибоначчи в основе дизайна](http://www.idsia.ch/~juergen/fibonacciwebdesign.html). Однако, если вы изучите тот дизайн, который он создал, вы, вероятно, найдете его жестким и немного трудным для понимания и навигации. Действительно, Вам стоит применить творческий подход к математике, а не слепо следовать правилам — математика дает нам возможности, которое мы можем применить.
[](http://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%B0_%D0%A4%D0%B8%D0%B1%D0%BE%D0%BD%D0%B0%D1%87%D1%87%D0%B8)
*Приблизительная и истинная золотые спирали.* *Зеленая спираль построена из четвертей круга касательных к углам каждого квадрата, а красная спираль построена с применением особого типа логарифмической спирали. Перекрытие окрашено желтым цветом.*
Основная идея такой конструкции состоит в использовании Фибоначчи при решении вопроса о размерах и содержании основной и боковой областях. И Фибоначчи и Золотое сечение равнозначны в данном контексте и пусть дизайнеры полагаться то, что им удобнее.
В целом, макет довольно легко построить с использованием последовательности Фибоначчи. Вы выбираете определенную ширину базе первого блока — например, 90px. Затем, при определении размера контейнера, нужно умножить базовую ширину на номер блока из ряда Фибоначчи (1,2,3,5,8…). В зависимости от расчетов вы получаете значения которые являются ширинами блоков, для вашего макета. Давайте посмотрим на примере. Ниже минималистичный макет, созданный на основе веб-дизайна по Фибоначчи.
[](http://habrastorage.org/storage2/f92/be6/af6/f92be6af63a7aeae1f0dd6b12c72c0c1.jpg)
Вы видите, что страница разделена на три колонки. Каждый столбец соответствует числу Фибоначчи. Для этого дизайна, мы использовали базу шириной 90 пикселов. Эта база шириной затем умножается на число Фибоначчи, чтобы получить общую ширину столбца. Например, первая колонка имеет ширину 180 пикселей (90 х 2), вторая колонка имеет ширину 270 пикселей (90 х 3) и третья колонка имеет ширину 720 пикселей (90 х 8). Размер шрифта также соответствует числу Фибоначчи. Заголовок страницы имеет размер 55px; заголовок статьи 34px; а основной текст 21px.
Однако, достаточно трудно адаптировать шаблон, с фиксированной шириной, для использования последовательности Фибоначчи. Но это только в случае выбора ширины, например, 1000px. В этой ситуации проще использовать отношение золотого сечения. Просто умножить вашу ширину 1000px на 0,618 и получить 618px что было бы идеальной шириной для блоков контента. Однако, если вы пытаетесь достичь того же результата с последовательностью Фибоначчи, необходимо сначала выяснить ближайшее к 1000 число.
В соответствии с [калькулятором последовательности Фибоначчи](http://www.math.rutgers.edu/~erowland/fibonacci.html), последовательность будет `...,610, 987, 1597...` И, 987 является хорошим числом, которое наиболее близко к выбранному числу 1000 и вы можете определить ширину для других блоков, используя предыдущие номера в последовательности. Но если ваш макет фиксированной ширины меньше или больше по ширине, то вам потребуется использовать примерные значения. Проблема может возникнуть в резиновом шаблоне но не в фиксированном, но при использовании % у вас гораздо больше свободы.
#### Возможное применение
Дизайн по Фибоначчи лучше всего подходит для блогов и журнальных макетов. Вы можете расположить макет по-разному в соответствии с числами Фибоначчи. В статье [Nombre d'or, suite de Fibonacci et autres grilles de mise en page pour le design web](http://css.4design.tl/nombre-d-or-suite-de-fibonacci-et-autres-grilles-de-mise-en-page-pour-le-design-web) (на французском языке) объясняется более глубокое применение чисел Фибоначчи в веб-дизайне. Опять же, стоит отметить, что вам следует опираться на творческий подход при использовании последовательности Фибоначчи в вашей работе, иначе ваши макеты будут казаться слишком жестким и, следовательно, сложны в использовании и навигации.
#### PSD-макета
Мы подготовили архив с [PSD макетами,](http://iteye.ru/wp-content/uploads/2012/05/PSD.zip) в который включен шаблон разработанный в соответствии с последовательностью Фибоначчи. Пожалуйста, не стесняйтесь использовать его любым способом.
### Пять элементов, или Kundli дизайн
Еще одна интересная техника создания макетов происходит от индийских гороскопов, которые также называются *Kundli.* Вообще, Kundli очень простая фигура которая может быть сделана за три шага. Нарисовать квадрат. Пересечь его двумя диагоналями. Соединить смежные середины сторон. И мы получаем Kundli. У нас получились четыре прямоугольные ромбы на рисунке. Они будут являются основой для нашего дизайна.
Дизайн представленный ниже, разработан на основе геометрического макета Kundli. Стоит отметить, что [чакры](http://ru.wikipedia.org/wiki/%D0%A7%D0%B0%D0%BA%D1%80%D0%B0) также имеют математические свойства *(я не нашел доказательств прим. пер.)*.
[](http://habrastorage.org/storage2/0cf/759/f07/0cf759f0763ece9df942bafe75c14a89.jpg)
Это одно-страничный макет. Кроме того, можно использовать несколько простых анимаций на JQuery или текстовую подсказку, чтобы представить наш сайт в более информативном свете. Еще одним вариантом, могло бы стать применение слайдинга, где анимация используется для отображения различного содержания блоков, вы также можете изменить фон изображения для каждой из областей, чтобы сделать их отличными друг от друга.
На следующем рисунке вы можете увидеть, что наш дизайн достаточно прост: заголовок, три столбца и нижний колонтитул.
#### Возможное применение
Эта конструкция является оптимальной для отображения информации о продукте или для показа профилей. Вы можете украсить шаблон JavaScript анимацией. Например, вы можете обратиться к возможности преобразования цвета, изменяя цвет чакр, используя [библиотеку Рафаэля,](http://raphaeljs.com) или вы можете добавить любую другую анимацию, например используя библиотеку [jsAnim](http://jsanim.com). Можно показать ростка дерева, когда пользователь нажимает на элементе «Земля», или можно показать морских обитателей, при клике на «Воде». Нет пределов, когда дело доходит до анимации с использованием этих библиотек JavaScript *(но не стоит борщить прим. пер.)*.
#### PSD-макет
Мы подготовили архив с [PSD макетами,](http://iteye.ru/wp-content/uploads/2012/05/PSD.zip) в который включен шаблон разработанный в соответствии с дизайном Kundli.
### Синусоидальный дизайн
Когда дело доходит до математики, и вам не хочется придерживаться Золотого сечения или последовательности Фибоначчи. Вы можете поэкспериментировать с формулами из физики, химии и других наук или использовать общие формулы в своих проектах.
Например, давайте рассмотрим **синусоидальную волну,** или синусоиду. Это математическая функция, которая описывает гладкие повторяющиеся колебания. Мы использовали простой макет с синусоидой в качестве основы для простого и оригинального дизайна. Конечно, вы можете использовать тот же подход и в других конструкциях, а не только при создании сайтов, таких как графика или инфографика.
[](http://habrastorage.org/storage2/3b1/ac6/7e4/3b1ac67e450093b0c059b9509e061122.jpg)
Макет снова очень простой, состоящий из заголовка, пяти колонок и футера. Вы можете использовать JQuery, чтобы сделать дизайн более интерактивным.
#### Возможное применение
Эта волновая картина часто встречается в природе, включая океанские волны, звуковые волны, а световые волны. Кроме того, грубо представленную синусоидальную картину можно увидеть при построении среднесуточной температуры, хотя график может напоминать перевернутую волну — косинус. Вы также можете использовать ее, чтобы отображать хронологию событий. Это будет отлично смотреться при горизонтальной навигации. Вы можете сделать его более интерактивным со все тем-же [JQuery](http://www.dailymarkup.com/highlighter/demo1/demo.html).
#### PSD-макет
Мы подготовили архив с [PSD макетами,](http://iteye.ru/wp-content/uploads/2012/05/PSD.zip) в который включен шаблон разработанный в соответствии с дизайном по синусоиде.
### Другие методы
**Правило третей**
Это [правило гласит](http://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D0%BE_%D1%82%D1%80%D0%B5%D1%82%D0%B5%D0%B9), что изображение должно быть представлено как девять равных частей. Строим две равноудаленные горизонтальные линии и две вертикальные линии находящихся на равном удалении, и что важно, композиционное элементы должны быть расположены вдоль этих линий или их пересечений. Она также может быть выражена в виде упрощенного математического подхода, который разделяет макет на трети, слева на право и сверху вниз.
**Музыкальная логика**
Ритмическая или тематическая структура музыкальной композиции может применяться для определения расстояний между элементами в макете, как ABA, ABAC и т.д. Узнайте больше о музыке и математике в этой [статье Википедии.](http://en.wikipedia.org/wiki/Music_and_mathematics)
#### Useful Links and Resources
*Wikipedia articles*
* [Sacred Geometry](http://en.wikipedia.org/wiki/Sacred_geometry)
* [Proportion](http://en.wikipedia.org/wiki/Proportion_(architecture))
* [Canons of Page Construction](http://en.wikipedia.org/wiki/Canons_of_page_construction#cite_note-5)
*Articles*
* [Mathematics in Art and Architecture](http://www.math.nus.edu.sg/aslaksen/teaching/math-art-arch.shtml)
* [Design and Divine Proportion](http://www.markboulton.co.uk/journal/comments/design-and-the-divine-proportion)
* [Create Awesome Geometrical Designs](http://www.myoats.com/create.aspx), Myoats
* [Photographer Loves Math, Graphs Her Images](http://www.wired.com/magazine/2010/01/pl_arts_found/)
* [Typograph: Scale and Rhythm](http://lamb.cc/typograph/)
* [Michael Paunker – Art and Math](http://www.flickr.com/photos/michaelpaukner/)
*Books*
* [Geometry of Design](http://books.google.co.in/books?id=1KI0JVuWYGkC&printsec=frontcover&dq=geometry+of+design&source=bl&ots=8_La32PfXM&sig=oqYAItvbGXuF3qNqTTBRZydtmvo&hl=en&ei=qfZXS9rZEs6GkAXq7rDpBA&sa=X&oi=book_result&ct=result&resnum=1&ved=0CAcQ6AEwAA#v=onepage&q=&f=false)
* [Euclid’s Elements](http://books.google.com/books?id=QSzjUIxs0GwC&printsec=frontcover&dq=euclids'elements&num=4&client=internal-uds&cd=4&source=uds#v=onepage&q=&f=false)
* [Mathematics in Nature](http://books.google.com/books?id=2gO2sBp4ipQC&printsec=frontcover&dq=patterns+in+nature&num=4&client=internal-uds&cd=4&source=uds#v=onepage&q=&f=false)
Мы надеемся, что вам понравилась статья о математике в веб-дизайне. Надеемся, что сейчас вы видите математику, как возможность совершенствовать ваши дизайнерские решения, и она станет вашим другом.
[Оригинал статьи на Английском](http://www.smashingmagazine.com/2010/02/09/applying-mathematics-to-web-design/) | https://habr.com/ru/post/154087/ | null | ru | null |
# Эврика! Моменты озарения при изучении React
Светлана Шаповалова, редактор [«Нетологии»](http://netology.ru/development/programs?utm_source=blog&utm_medium=747&utm_campaign=habr), перевела [статью](https://medium.freecodecamp.com/react-aha-moments-4b92bd36cc4e#.x98mxxjvb) Тайлера МакГинниса, в которой он перечислил основные моменты озарения, которые возникают при изучении React.
Одна из моих главных преподавательских задач — сделать так, чтобы у людей чаще случались моменты озарения. «Эврика!» — это момент внезапного прояснения, когда ранее непонятные факты вдруг обретают смысл. Такое случалось с каждым. Я знаком со многими преподавателями и лучшие из них умеют так преподносить урок, чтобы озарение у учеников возникало намного чаще.
В последние несколько лет я преподавал React всеми возможными методами. Все это время я делал подробные заметки о том, что провоцирует вот такие «Эврика!»-моменты.
Недавно я наткнулся на ветку Reddit, где обсуждалась та же идея. Обсуждение вдохновило меня написать эту статью, в которой я поделился основными инсайтами обучения. Надеюсь, она поможет вам по-новому взглянуть на принципы работы с React.
Озарение №1. Props для компонентов — то же, что и аргументы для функций
-----------------------------------------------------------------------
Что хорошо в React: то самое наитие, которое вы используете для JavaScript-функций, можно применять, чтобы понять, где и когда надо создать компоненты React. Отличие React вот в чем: вместо того чтобы брать некоторые аргументы и возвращать значение, ваша функция будет брать некоторые аргументы и возвращать объектное представление вашего [пользовательского интерфейса (UI)](http://netology.ru/programs/ui-ux?utm_source=blog&utm_medium=747&utm_campaign=habr).
Эту мысль можно выразить формулой fn(d) = V. Читается так: «функция принимает некоторые данные и возвращает представление».
Это прекрасный способ представить себе разработку пользовательских интерфейсов — теперь ваш UI просто состоит из различных вызовов функций. Это похоже на создание приложений. Теперь вы можете использовать все преимущества композиции функций при создании пользовательских интерфейсов.
Озарение №2. В React пользовательский интерфейс вашего приложения полностью построен с использованием композиции функций. JSX — это абстракция над этими функциями
------------------------------------------------------------------------------------------------------------------------------------------------------------------
Наиболее распространенная реакция, которую я вижу у тех, кто впервые использует React, выглядит примерно так: «React — это круто, но вот JSX мне совсем не по душе. Он разрушает разделение ответственностей». JSX не пытается быть [HTML](http://netology.ru/programs/html-verstka?utm_source=blog&utm_medium=747&utm_campaign=habr). И он определенно больше, чем просто язык шаблонов. О JSX надо понять две важные вещи.
Во-первых, JSX — это абстракция над React.createElement — функцией, возвращающей объектное представление DOM.
Всякий раз при трансляции JSX у вас будет объект JavaScript, представляющий собой фактический DOM — или любой другое представление платформы, на которой вы находитесь (iOS, Android и т. д.). Затем React проанализирует этот объект и проанализирует фактический DOM. С помощью diff React может обновить DOM только там, где произошло изменение. Это повышает производительность, но, что более важно, показывает, что JSX на самом деле «просто JavaScript».
Во-вторых, именно из-за того, что JSX — это просто [JavaScript](http://netology.ru/programs/html-javascript?utm_source=blog&utm_medium=747&utm_campaign=habr), вы получаете все преимущества JavaScript: например, композицию, линтинг и отладку. Но вы также по-прежнему получаете декларативность и схожесть с HTML.
Озарение №3. Компоненты не обязательно должны соответствовать узлам DOM
-----------------------------------------------------------------------
Когда вы впервые вникаете в React, вы учите, что «компоненты — это строительные блоки React. Они берут входные данные и возвращают некоторый интерфейс (шаблон дескриптора)».
Означает ли это, что каждый компонент должен напрямую возвращать дескрипторы пользовательского интерфейса, как мы обычно это изучаем? Что, если мы хотим, чтобы компонент отображал другой компонент (шаблон компонента более высокого порядка)? Что, если мы хотим, чтобы компонент управлял некоторой секцией состояния, а затем вместо возвращения дескриптора пользовательского интерфейса возвращал вызов функции в состоянии (шаблон Render Props)? А если бы у нас был компонент, который отвечает за управление звуком, а не за визуальный интерфейс, то что бы он возвратил?
В React хорошо то, что вам не нужно возвращать типичные «представления» из ваших компонентов. До тех пор, пока в результате возвращается элемент React, null или false, все хорошо.
Вы можете возвращать различные компоненты:
```
render () {
return
}
You can return function invocations:
render () {
return this.props.children(this.someImportantState)
}
Or you can return nothing at all:
render () {
return null
}
```
Озарение №4. Когда двум компонентам необходимо разделить состояние, нужно его поднимать, а не синхронизировать
--------------------------------------------------------------------------------------------------------------
Компонентная архитектура, конечно же, усложняет разделение состояний. Если два компонента полагаются на одно и то же состояние, то где оно должно находиться? Это был такой популярный вопрос, что он спровоцировал появление целой экосистемы решений, и в итоге появился Redux.
Решение Redux заключается в помещении этого общего состояния в другое место, называемое «хранилищем». Компоненты могут подписаться на любые части хранилища, в которых они нуждаются, а также могут отправлять «действия» для обновления хранилища.
Решение React должно найти ближайший родительский элемент для обоих этих компонентов и заставить этого родителя управлять общим состоянием, передавая его дочерним компонентам по мере необходимости. У обоих подходов есть свои плюсы и минусы, но важно знать, что оба решения существуют.
Озарение №5. Наследование не нужно в React, а сдерживание и специализацию можно получить при помощи композиции
--------------------------------------------------------------------------------------------------------------
К счастью, React всегда был очень свободомыслящим относительно принципов функционального программирования. Один из примеров перехода React от наследования к композиции — релиз 0.13, когда стало ясно, что React не добавлял поддержку Mixins с классами ES6.
Причина этого в том, что почти все, что можно сделать с помощью Mixins или наследования, вы также можете выполнить через композицию, но с меньшим количеством побочных эффектов. Если вы приходите в React с менталитетом наследования, то новый способ мышления может оказаться сложным и непривычным.
Озарение №6. Разделение контейнерных и презентационных компонентов
------------------------------------------------------------------
Если вы обратите внимание на строение компонента React, то он обычно включает в себя некоторое состояние, некоторые «крюки» жизненного цикла и разметку через JSX.
Что, если вместо размещения всего этого в одном компоненте, вы могли бы разделить состояние и крюки жизненного цикла от разметки? У вас получится два компонента. Первый будет содержать состояние, методы жизненного цикла и отвечать за то, как работает компонент. Второй будет получать данные через props и отвечать за то, как выглядит компонент.
Такой подход позволяет более эффективно повторно использовать ваши презентационные компоненты, поскольку они больше не связаны с данными, которые получают.
Я также обнаружил, что он позволяет и вам, и тем, кто будет вникать в ваш проект, лучше понять структуру приложения. Вы можете заменить реализацию компонента, не видя или не переживая о пользовательском интерфейсе, и наоборот. В результате разработчики могут настраивать пользовательский интерфейс, не беспокоясь, как презентационные компоненты получают данные.
Озарение №7. Если вы пытаетесь сохранить большинство компонентов чистыми (pure), станет намного проще поддерживать элементы без состояния
-----------------------------------------------------------------------------------------------------------------------------------------
Это еще одно преимущество отделения ваших презентационных компонентов от компонентов вашего контейнера. Состояние — товарищ несогласованности. Определив верные линии разделения, вы в значительно улучшите предсказуемость вашего приложения путем инкапсуляции сложности.
Спасибо, что нашли время прочесть мою статью!
От редакции
-----------
Углубленное изучение JavaScript — это долгий путь. И библиотека React — лишь один из многих пунктов в резюме полноценного фронтенд-разработчика, при этом далеко не самый первый.
Если вы хотите к хорошим знаниям JavaScript добавить глубокое понимание Web API, научиться решать задачи на чистом JavaScript, вникнуть в BOM и DOM, изучить асинхронные HTTP-запросы (AJAX) и веб-сокеты (WebSocket) — записывайтесь на наш продвинутый курс [«Front-end разработка: создаем интерактивные веб-страницы»](http://netology.ru/programs/html-javascript?utm_source=blog&utm_medium=747&utm_campaign=habr). | https://habr.com/ru/post/324788/ | null | ru | null |
# Выпуск Rust 1.22 (и 1.22.1)
Команда Rust рада сообщить о двух новых версиях Rust: 1.22.0 и 1.22.1. Rust — это системный язык программирования, нацеленный на безопасность, скорость и параллельное выполнение кода.
> Подождите, две версии? В последний момент мы [обнаружили проблему с новой macOS High Sierra](https://github.com/rust-lang/rust/pull/46183) в версии 1.22.0 и по разным причинам выпустили версию 1.22.0 как обычно, но так же выпустили 1.22.1 с исправлением. Ошибка была найдена в менеджере пакетов Cargo, а не в `rustc`, и затронула только пользователей macOS High Sierra.
Если у вас установлена предыдущая версия Rust, для обновления достаточно выполнить:
```
$ rustup update stable
```
Если же у вас еще не установлен `rustup`, вы можете [установить его](https://www.rust-lang.org/install.html) с соответствующей страницы нашего веб-сайта. С [подробными примечаниями к выпуску Rust 1.22.0](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1220-2017-11-22) и 1.22.1 можно ознакомиться на GitHub.
Что вошло в стабильную версии 1.22.0 и 1.22.1
---------------------------------------------
Самое главное изменение в этой версии, которого многие долго ждали: теперь вы [`можете использовать ?` с `Option`](https://github.com/rust-lang/rust/pull/42526)! Около года назад, в [Rust 1.13](https://blog.rust-lang.org/2016/11/10/Rust-1.13.html), мы ввели оператор `?` для работы с `Result`. С тех пор ведутся дискуссии о том, как далеко оператор `?` должен зайти: Должен ли он остаться только для `Result`? Разрешать ли пользователям расширять его? Должен ли он использоваться с `Option`?
В Rust 1.22, основное использование оператора `?` с `Option` стабилизировано. Теперь такой код соберется:
```
fn try_option_some() -> Option {
let val = Some(1)?;
Some(val)
}
assert\_eq!(try\_option\_some(), Some(1));
fn try\_option\_none() -> Option {
let val = None?;
Some(val)
}
assert\_eq!(try\_option\_none(), None);
```
Однако, эта функциональность по-прежнему немного ограничена. Например, вы не можете написать код, который сочетает `Result`ы и `Option`ы с оператором `?` в одной функции. Это будет реализовано в позже — в ночной версии Rust уже есть такая возможность. Ожидайте новостей об этом в будущих версиях.
Типы, которые реализуют `Drop`, [`теперь разрешено использовать в const` и `static`](https://github.com/rust-lang/rust/pull/44456). Например:
```
struct Foo {
a: u32
}
impl Drop for Foo {
fn drop(&mut self) {}
}
const F: Foo = Foo { a : 0 };
static S: Foo = Foo { a : 0 };
```
Само по себе это изменение не слишком полезно, но по мере улучшения нашей способности выполнять код во время сборки, больше и больше типов будут доступны для использования в `const` and `static`.
Так же, было добавлено несколько приятных мелочей:
[Два](https://github.com/rust-lang/rust/pull/45075) недавних [изменения компилятора](https://github.com/rust-lang/rust/pull/45064) должны ускорить скорость сборки в отладочном режиме. У нас нет точных цифр, но, как и всегда, уменьшение времени сборки остается одной из наших приоритетных задач.
[`T op= &T` теперь работает для примитивных типов](https://github.com/rust-lang/rust/pull/44287), что проще показать на примере:
```
let mut x = 2;
let y = &8;
// раньше это не работало:
x += y;
```
Раньше вам бы пришлось написать `x += *y` чтобы разыменовать ссылку.
[В MacOS улучшены бэктрейсы](https://github.com/rust-lang/rust/pull/44251).
Теперь вы можете [`создавать compile-fail` тесты в Rustdoc](https://github.com/rust-lang/rust/pull/43949), например:
```
/// ```compile_fail
/// let x = 5;
/// x += 2; // не должно собираться!
/// ```
```
Обращаем ваше внимание на то что подобные тесты менее надежны, так как дополнительные возможности Rust могут заставить работать ранее не собиравшийся код. Например, как это было с `?`: код не собирался с Rust 1.21, но теперь работает с Rust 1.22, вызывая падение вашего теста.
Наконец, мы [`убрали поддержку цели le32-unknown-nacl`](https://github.com/rust-lang/rust/pull/45041). Google сам [объявил PNaCl устаревшим](https://blog.chromium.org/2017/05/goodbye-pnacl-hello-webassembly.html), чтобы направить все силы на поддержку [WebAssembly](http://webassembly.org/). Вы уже сейчас можете собрать Rust код в WebAssembly и вы можете ожидать новостей о развитии его поддержи в новых выпусках Rust.
Подробности смотрите [в примечаниях к выпуску](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1220-2017-11-22).
### Стабилизации стандартной библиотеки
В этом выпуске было стабилизировано несколько новых API:
* [`Box` теперь реализует `From>`](https://github.com/rust-lang/rust/pull/44466)
* [`std::mem::Discriminant` теперь гарантированно будет `Send + Sync`](https://github.com/rust-lang/rust/pull/45095)
* [`fs::copy` теперь возвращает длину главного потока на NTFS](https://github.com/rust-lang/rust/pull/44895)
* [`Корректное определение переполнения Instant += Duration`](https://github.com/rust-lang/rust/pull/44220)
* [`Реализация Hasher` для `{&mut Hasher, Box}`](https://github.com/rust-lang/rust/pull/44015)
* [`Реализация fmt::Debug` для `SplitWhitespace`](https://github.com/rust-lang/rust/pull/44303)
Подробности смотрите [в примечаниях к выпуску](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1220-2017-11-22).
### Функциональность Cargo
Если вы хотите показать большой пример пользователям, то у Cargo появилась [возможность создать примеры из нескольких файлов](https://github.com/rust-lang/cargo/pull/4496), создав внутри `examples` поддиректорию с `main.rs`.
Теперь у Cargo есть возможность [локальной подмены (vendoring) git репозиториев](https://github.com/rust-lang/cargo/pull/3992).
Подробности смотрите [в примечаниях к выпуску](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1220-2017-11-22).
Разработчики 1.22.0 и 1.22.1
----------------------------
Множество людей участвовало в разработке Rust 1.22. Мы не смогли бы этого добиться без участия каждого из вас. [Спасибо!](https://thanks.rust-lang.org/rust/1.22.0) (и [снова Спасибо!](https://thanks.rust-lang.org/rust/1.22.1))
*Авторы перевода: [@BORN2LOSE](https://github.com/BORN2LOSE) и [ozkriff](https://habrahabr.ru/users/ozkriff/). Спасибо [vitvakatu](https://habrahabr.ru/users/vitvakatu/) за помощь в переводе* | https://habr.com/ru/post/343058/ | null | ru | null |
# Как обойти некоторые ограничения google translate
Я опишу два финта, с помощью которых можно обойти некоторые ограничения google translate.
1. Ограничение на количество символов у google translate online то ли 3900, то ли 5000 символов. Иногда нужно больше, а создавать html-файл с текстом неохота. Чтобы обойти это ограничение, создайте html-файл следующего содержания:
```
Google translator without limits.
Google translator without limits. Here comes the English text. It is necessary that translator to work.
If you do not translate from English, insert the text in your language. Not in the window, but in html.
var textarea = document.getElementById('test');
var result = document.getElementById('result');
function updateResult() {
result.innerHTML = textarea.value.replace(/\n/g, '<br>');
}
textarea.oninput = updateResult;
``` | https://habr.com/ru/post/501018/ | null | ru | null |
# Хабр Конвертер: чтобы версталось легко
Наверняка многие из вас хотя бы однажды пользовались хабраконвертером, который [официально рекомендован](https://habr.com/ru/info/topics/madskillz/) администрацией Хабра — <https://shirixae.github.io/habraconverter-v2/>. Несколько лет назад его [создал](https://habr.com/ru/post/150407/) хабравчанин [meta4](https://habr.com/ru/users/meta4/), а потом доработал [Shirixae](https://habr.com/ru/users/shirixae/). Принцип простой: открываете гуглодок с постом, Ctrl-A, Ctrl-C и вставляете в окно конвертера. Нажимаете кнопку «Конвертировать» и получаете готовый код вёрстки, который можно вставлять в редактор Хабра и публиковать. Только перед этим нужно пройтись и поправить *кое-какие* мелочи.
И всё бы хорошо, если верстать приходится не слишком часто. Или посты небольшие, несложные. Но если вы верстаете помногу, и в постах есть и картинки, и таблицы, и куски кода, то из раза в раз приходится делать рутину: вставлять нужные пустые строки и убирать лишние, заменять теги на , и т.д. и т.п. Мы решили потратить день, чтобы потом долетать за час, и допилили конвертер.
Новая версия лежит [тут](https://alonecoder.github.io/habrconverter/index.html), а под катом — перечисление доработок.
Код конвертера небольшой, примерно 300 строк. Мы не ставили себе задачи глубоко его переработать, лишь подрихтовать, чтобы после конвертера меньше править руками. Так что сразу обращаем ваше внимание: в нашей версии много костылей и хардкода, и нас это полностью устраивает — своей цели мы достигли, а рефакторить ради красоты и ясности мы и не собирались.
Конечно, когда влезаешь в чужой код и что-то переделываешь, легче лёгкого наделать багов. Изначально список правок был таким:
> 1. После абзацев нужно делать два переноса, чтобы между абзацами появлялась пустая строка.
> 2. То же самое с картинками: теги `![]()` должны сверху и снизу отделяться пустыми строками.
> 3. После нужен только один перенос строки (без пустой строки).
> 4. Закрывающие теги
> хорошо бы помещать не на отдельных строках, а в конце предыдущих, так легче визуально воспринимать код вёрстки. 6. После перенос не делать.
> 7. После один перенос.
> 8. После не надо делать пустые строки, Хабр сам вставит.
> 9. Если строка заканчивается обычным текстом, то делать два переноса.
> 10. После закрывающего тега пустая строка не нужна, Хабр сам вставит.
> 11. То же самое с закрывающим тегом .
>
>
>
>
* Потом мы научили конвертер распознавать, когда нужно вставлять , а когда (это моя любимая доработка).
* Добавили правило, чтобы внутри тегов всегда используется только , а не .
* Заменили на рекомендуемый .
* Принудительно убрали из заголовков жирный текст и теги списков — кому нужно, вставят руками, а обычно это лишнее.
Исправили такие баги:
* Не обрабатывать содержимое `<>`, оно всегда должно оставаться неизменным. **Пример**: код `` в тексте должен после конвертирования остаться таким же.
* Есть какой-то конфликт, когда соседствуют и — возникают ненужные пустые строки между ними.
* По ходу дела наш конвертер вдруг начинал вставлять лишние строки там, где их быть не должно. Потом в какой-то момент в тегах картинок стали добавляться лишние кавычки-ёлочки, тоже пришлось это выпиливать: ``
* Побороли неожиданное поведение, когда у первой картинки в вёрстке вставлялся атрибут `аlign="center"`, а у всех остальных `аlign="middle"`.
Ах да, и добавили над окном конвертирования кнопку «Копировать». Если вы хоть раз пробовали выделить получившийся результат на смартфоне, чтобы скопировать, то вы поймёте, что это чуть ли не лучшая наша доработка.
Сейчас после нашего конвертера приходится в разы меньше править мелкие недочёты, на которые при нашем месячном объёме публикаций тратилась куча времени. Как и все предыдущие версии, конвертер доступен всем желающим — pull request’ы и issue приветствуются.
Исходник: <https://github.com/AloneCoder/habrconverter>
Морда: <https://alonecoder.github.io/habrconverter/> | https://habr.com/ru/post/490968/ | null | ru | null |
# Пример создания одного chrome extension
Приветствую социум! Проработал 7 лет техническим директором. Понял, насколько это сильно бьет по нервам и решил начать жизнь с чистого листа. Пойти javascript-разработчиком.
Почему: потому что люблю писать на этом языке. Он веселый и может влет решать множество реальных задач. *Да, да, веселый, ведь он настолько не типизирован, что объект может иметь свойство в виде самого себя ) Причем при обращении к этому свойству мы реально изменяем сам объект.*
**Веселый JS**
```
primer = {};
primer["svoistvo1"] = "reddis";
primer["svoistvo2"] = primer;
primer["svoistvo2"]["svoistvo2"]["svoistvo2"]["svoistvo2"]["svoistvo1"] = "dadada";
console.log(primer);
```
Конечно без серверной части тяжеловато. Но современные браузеры легко позволяют хранить данные на клиенте. Для решения узконаправленных задач это самое то.
В это статье я покажу, как можно создать chrome extension.
Так первым делом создаем пустой проект.
**Как создать пустой проект 'Расширение хром'**1. Вариант.
[Github](https://github.com/rinatusmanov/empryChromeExtension)
2. Вариант.
Ручками.
Создаем такую структуру.
* content\_scripts (*Папка*)
+ end.js(*Файл*)
* images (*Папка*)
+ empty\_16.png(*Файл*)
+ empty\_32.png(*Файл*)
+ empty\_48.png(*Файл*)
+ empty\_64.png(*Файл*)
+ empty\_128.png(*Файл*)
* popup (*Папка*)
+ popup.html(*Файл*)
+ popup.js(*Файл*)
* manifest.json (*Файл*)
Пояснение по структуре.
content\_scripts — Папка где хранятся файлы которые будут добавляться к телу страницы открытой в браузере.
images — Папка где хранятся иконки расширения
popup — Папка где хранятся само расширение которое отображается при нажатии на иконку.
Загрузим наше пустое расширение в браузер.
**Как загрузить пустое расширение в браузер**Для этого переходим на страницу «chrome://extensions/».
Выбираем «Режим разработчика».
Нажимаем кнопку «Загрузить распакованное расширение».
Выбираем папку где храниться расширение и нажимаем кнопку «OK».
Если расширение создано правильно, то мы видим его в списке расширений.
В итоге мы получаем пустое расширение которое работает на всех адресах браузера.
Так, теперь о идее практической пользы будущего расширения. Ну не знаю может будет транслировать gif-ку где Шэрон Стоун, перекидывает ноги? Конечно потребитель расширения найдется, но целевая группа будет не большой…
**Пример этого расширения**
[Само расширение](https://github.com/rinatusmanov/SharonStoneChromeExtension)
Не долго думая решил реализовать что то похожее на «Заметки». Но так чтобы и времени немного ушло и расширение на веб приложение было похоже.
**Описание логической структуры расширения как я его вижу до момента написания кода.**1. Создание, редактирование и удаление заметок.
2. Создание, редактирование и удаление категорий заметок.
3. Поиск заметок по описанию и по самим заметкам.
C чего начну. Рисую прототип. [Здесь](https://pidoco.com/).
Я не дизайнер, так что сильно не заморачиваюсь. Просто кидаю нужные мне элементы на экран.
**То что у меня получилось...**Вначале это.
А потом вспомнил что:
Max Width: 792 pixels
Max Height: 584 pixels.
Для того, чтобы категории заметок отображались красиво, создал класс и поигрался стилями.
**JS Класс возвращающий DIV с возможностью редактирования**
```
'use strict';
class Folders {
constructor(
isReturn,
folders = [
["Мои заметки",0],
["Музыка",0],
["Видео",0],
["Документы",0],
["Изображения",0],
["Сайты",0],
["Прочее",0],
],
saveFolders = console.log,
selectFunc = console.log,
deleteFunc = console.log
) {
if (!isReturn)
return;
this.selectFunc = selectFunc;
this.deleteFunc = deleteFunc;
this.selected = false;
this.folders = folders;
this.saveFolders = saveFolders;
this.div = document.createElement("DIV");
this.div.links = this;
this.div.className = "folderDivVT";
this.divMenu = document.createElement("DIV");
this.divMenu.className = "folderMenuVT";
this.divMenu.innerHTML = "";
this.divMenu.links = this;
this.result = document.createElement("DIV");
this.result.appendChild(this.divMenu);
this.result.appendChild(this.div);
this.div.addEventListener("click",function (e) {
try {
this.links.clickP(this.querySelector("p:focus"));
} catch (ex) {}
});
this.div.addEventListener("dblclick",function (e) {
try {
this.links.clickP(this.querySelector("p:focus"));
this.querySelector("p:focus").parentNode.classList.toggle("active");
} catch (ex) {}
});
this.div.addEventListener("keydown",function (e) {
var parentN = this.querySelector("p:focus").parentNode;
var th = false;
var divs = this.querySelectorAll("DIV");
for (var i = 0; i < divs.length; i++)
if (divs[i] == parentN)
th = i;
var rep = -1;
var objBounding = false;
switch(true) {
case (e.keyCode == 40) && (e.which == 40):
for (var i = th + 1; i < divs.length; i++) {
objBounding = divs[i].getBoundingClientRect();
if (rep == -1)
if ((objBounding["top"] == 0) && (objBounding["bottom"] == 0) && (objBounding["left"] == 0) && (objBounding["right"] == 0) && (objBounding["width"] == 0))
rep = -1;
else
rep = i;
}
if (rep == -1)
for (var i = 0; i < th; i++) {
objBounding = divs[i].getBoundingClientRect();
if (rep == -1) {
if ((objBounding["top"] == 0) && (objBounding["bottom"] == 0) && (objBounding["left"] == 0) && (objBounding["right"] == 0) && (objBounding["width"] == 0))
rep = -1;
else
rep = i;
}
}
this.links.clickP(divs[rep].querySelector("p"));
break;
case (e.keyCode == 38) && (e.which == 38):
for (var i = th - 1; i > -1; i--) {
objBounding = divs[i].getBoundingClientRect();
if (rep == -1)
if ((objBounding["top"] == 0) && (objBounding["bottom"] == 0) && (objBounding["left"] == 0) && (objBounding["right"] == 0) && (objBounding["width"] == 0))
rep = -1;
else
rep = i;
}
if (rep == -1)
for (var i = divs.length - 1; i > th - 1; i--) {
objBounding = divs[i].getBoundingClientRect();
if (rep == -1) {
if ((objBounding["top"] == 0) && (objBounding["bottom"] == 0) && (objBounding["left"] == 0) && (objBounding["right"] == 0) && (objBounding["width"] == 0))
rep = -1;
else
rep = i;
}
}
this.links.clickP(divs[rep].querySelector("p"));
break;
case (e.keyCode == 39) && (e.which == 39):
if (!parentN.classList.contains("active"))
parentN.classList.add("active");
break;
case (e.keyCode == 37) && (e.which == 37):
if (parentN.classList.contains("active"))
parentN.classList.remove("active");
break;
case (e.keyCode == 113) && (e.which == 113):
this.links.renameFolder(this.links);
this.links.contextDiv.style.display = "none";
break;
case (e.keyCode == 46) && (e.which == 46):
this.links.deleteFolder(this.links);
this.links.contextDiv.style.display = "none";
break;
case (e.keyCode == 45) && (e.which == 45):
this.links.addNewFolder(this.links);
this.links.contextDiv.style.display = "none";
break;
case (e.keyCode == 107) && (e.which == 107):
var divs = this.links.div.querySelectorAll("DIV.folder");
for (var i = 0; i < divs.length; i++)
if (!divs[i].classList.contains("active"))
divs[i].classList.add("active");
this.links.contextDiv.style.display = "none";
break;
case (e.keyCode == 109) && (e.which == 109):
var divs = this.links.div.querySelectorAll("DIV.folder:not(:first-child)");
for (var i = 0; i < divs.length; i++)
if (divs[i].classList.contains("active"))
divs[i].classList.remove("active");
this.links.div.querySelector("DIV.folder:first-child > p").focus();
this.links.contextDiv.style.display = "none";
break;
}
});
this.div.addEventListener("contextmenu",function (e) {
try {
var p = this.querySelector("p:focus");
this.links.clickP(p);
this.links.contextDiv.style.display = "block";
this.links.contextDiv.style.left = (p.getBoundingClientRect()["left"]+ 50) + "px";
this.links.contextDiv.style.top = (p.getBoundingClientRect()["top"]+ 10) + "px";
e.returnValue = false;
} catch (ex) {}
});
this.contextDiv = document.createElement("DIV");
this.contextDiv.className = "folderContext";
this.contextDiv.links = this;
this.contextDiv.style.display = "none";
this.contextDiv.innerHTML = 'Ins Создать подпапкуF2 ПереименоватьDEL Удалить Отмена';
this.contextDiv.addEventListener("click",function () {
switch (this.querySelector("DIV:focus").className) {
case "addFolder":
this.links.addNewFolder(this.links);
this.links.contextDiv.style.display = "none";
break;
case "renameFolder":
this.links.renameFolder(this.links);
this.links.contextDiv.style.display = "none";
break;
case "deleteFolder":
this.links.deleteFolder(this.links);
this.links.contextDiv.style.display = "none";
break;
case "Cancel":
this.style.display = "none";
break;
}
});
this.divMenu.addEventListener("click",function () {
switch (this.querySelector("DIV:focus").className) {
case "addFolder":
this.links.addNewFolder(this.links);
this.links.contextDiv.style.display = "none";
break;
case "renameFolder":
this.links.renameFolder(this.links);
this.links.contextDiv.style.display = "none";
break;
case "deleteFolder":
this.links.deleteFolder(this.links);
this.links.contextDiv.style.display = "none";
break;
case "expandFolder":
var divs = this.links.div.querySelectorAll("DIV.folder");
for (var i = 0; i < divs.length; i++)
if (!divs[i].classList.contains("active"))
divs[i].classList.add("active");
this.links.contextDiv.style.display = "none";
break;
case "foldFolder":
var divs = this.links.div.querySelectorAll("DIV.folder:not(:first-child)");
for (var i = 0; i < divs.length; i++)
if (divs[i].classList.contains("active"))
divs[i].classList.remove("active");
this.links.div.querySelector("DIV.folder:first-child > p").focus();
this.links.contextDiv.style.display = "none";
break;
}
});
document.body.appendChild(this.contextDiv);
this.createFolders();
}
selectP(p) {
var selecteds = this.div.querySelectorAll("p.selected");
for (var i = selecteds.length - 1; i > -1; i--)
selecteds[i].classList.remove("selected");
p.classList.add("selected");
this.selectFunc(this.div.querySelectorAll("p.selected").dataset.id);
}
clickP(p) {
p.focus();
this.selectP(p);
this.selected = p;
this.contextDiv.style.display = "none";
}
createFolders() {
this.div.innerHTML = "";
for (var i = 0; i < this.folders.length; i++) {
try {
var div = document.createElement("DIV");
div.className = "folder";
div.id = "folder" + i;
div.dataset.id = i;
div.dataset.parent = this.folders[i][1];
div.innerHTML = "" + this.folders[i][0] + "
";
div.querySelector("P").addEventListener("focus",function () {
this.click();
});
this.div.appendChild(div);
} catch (ex) {}
}
for (var i = 0; i < this.folders.length; i++) {
try {
this.div.querySelector("#folder" + this.folders[i][1]).appendChild(this.div.querySelector("#folder" + i));
} catch (ex) {}
}
try {
this.clickP(this.div.querySelector("DIV.folder:first-child > p"));
} catch (ex) {}
}
addNewFolder(links) {
var newFolder = prompt("Введите название новой папки\r\n");
if ((newFolder != "") && (newFolder != null)) {
var ln = links.folders.length
links.folders[ln] = [newFolder,links.selected.parentNode.dataset.id];
var div = document.createElement("DIV");
div.className = "folder";
div.id = "folder" + ln;
div.dataset.id = ln;
div.dataset.parent = links.selected.parentNode.dataset.id;
div.innerHTML = "" + newFolder + "
";
links.div.querySelector("#folder" + links.selected.parentNode.dataset.id).appendChild(div);
links.saveFolders(links.folders);
if (!links.div.querySelector("#folder" + links.selected.parentNode.dataset.id).classList.contains("active"))
links.div.querySelector("#folder" + links.selected.parentNode.dataset.id).classList.add("active");
links.clickP(div.querySelector("p"));
}
}
renameFolder(links){
var newFolder = prompt("Введите новое название папки\r\n" + links.selected.innerHTML,links.selected.innerHTML);
if ((newFolder != "") && (newFolder != null)) {
links.selected.innerHTML = newFolder;
links.folders[links.selected.parentNode.dataset.id][0] = newFolder;
links.saveFolders(links.folders);
}
}
deleteFolder(links){
var id = links.selected.parentNode.dataset.id;
if (id == 0) {
alert("Нельзя удалять главную папку");
return;
}
var delFolder = confirm("Вы точно хотите удалать папку '" + links.selected.innerHTML + "' и все ее содержимое?\r\n\r\nВложенные папки и их содержимое удалено не будет.\r\n");
if (delFolder) {
var parendDiv = links.selected.parentNode.parentNode.id;
links.folders[links.selected.parentNode.dataset.id] = null;
links.createFolders();
var div = links.div.querySelector("#" + parendDiv);
div.classList.add("active");
while (true) {
div = div.parentNode;
if (div.classList.contains("folderDivVT"))
break;
div.classList.add("active");
}
links.clickP(links.div.querySelector("#" + parendDiv + " > P"));
links.deleteFunc(id);
links.saveFolders(links.folders);
}
}
}
```
**Стили для класса**
```
.folderDivVT div > p.selected {
background:#4DB6AC;
color:#f5f5f5;
}
.folderDivVT div > p.selected:focus,.folderDivVT div > p:focus {
background:Teal;
color:#fff;
}
p:first-letter {
//color:Teal;
}
.folderDivVT div {
margin:5px;
margin-left:15px;
width:100%;
}
.folderDivVT div > p {
margin:0;
cursor:pointer;
padding:3px;
display:inline-block;
white-space: normal;
word-break: break-word;
max-width:calc(100% - 22px);
}
.folderDivVT div > div {
display:none;
}
.folderDivVT div.active > div {
display:block;
}
#foldersDiv {
position:fixed;
left:0;
top:50px;
padding:10px;
width:300px;
overflow:auto;
height:calc(100% - 50px);
z-Index:1000;
}
.folderDivVT div:before {
content: " ";
color: #fff;
background-image: url('data:image/png;base64,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');
display:inline-block;
width: 16px;
height: 16px;
background-size: cover;
margin-right:5px;
float: left;
}
.folderDivVT div.active:before {
background-image: url('data:image/png;base64,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');
}
.folderDivVT {
overflow: auto;
height: calc(100% - 28px);
}
.folderMenuVT {
text-align:center;
width:100%;
border-bottom:1px solid #999;
}
.folderMenuVT > div:before {
content: "";
color: #fff;
display:inline-block;
width: 24px;
height: 24px;
background-size: cover;
margin:0;
margin-right:5px;
cursor:pointer;
}
.folderMenuVT > div {
display:inline-block;
}
.replaceFolder:before {
background-image:url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAYAAADDPmHLAAAAAXNSR0IArs4c6QAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAAN1wAADdcBQiibeAAAAAd0SU1FB9gKDRYJKQG4CHkAACAASURBVHja7X1psBzXdd53b2+zvXn7igcQxCqC4AISpGhSlLhbZmQpZUuyLFsJ7Ti25MQpxymnXLGrnMSx9SM/4nipkiqxK15k2apYkiVam0lakimS4k4sJABiIbZHAG+bvbfb9+ZHd8+703O7ex4I2QTzblXXzPR095vXZ/vOd869DWyMjbExNsbG2BgbY2NsjI2xMTbGxtgYG2NjbIyNsTE2xsbYGBtjY2yMjbExNsbG2BgbY2NsjI2xMTbGxtgYG2NjbIyrfpDLOenXPnbzvzqzcOk/HblE5ppBqfB2/MdMOMGmarC8ZXb0V/73o4c/tyHqK6QAQgjtkx+8sVHXN5XMyiTKlQoMw4CmaSCEgFLas8n7kt8TQrr74vdpG4DU90IIEEIghIDv+xBCYHFxEU9+5wlUsew++r3XC+9kIc7NzRUIIaRQKHgnTpwIfuAe4EMPP8BHp+ZJp9N5296UO++8E0tLS3jxhefwta9/k7wTBb99+/Y5QshdQRBcxxgjAM7ruv7EqVOnTg56Df1y/nC95ZCJWQ2c87ftzXnyySexe/dueK77jrT6a6+99j5K6Scope8nhMwAQBAEHc75X2/btu3TJ0+efO0HpgBcCAgh3vY3qdFovOMEPzExMVOpVD6u6/rPaJq2Vw69nueVhBCfALC0e/fu/3b06NGVvOvR9f6AT//83XsCLq6Km9VqteC6Lj79C+/d8U4Q/uzs7EOVSuUPDMP4bcMw9uq6Dk3ToGkaLMuCZVkxFvs5IcSDVxQD/PYv3DOGwN3zt8+9+TWtOj+0c+cu1Gq1t/UN0zQNCwsLEK3zTcLZbz58544/+fXPfnvlKrR6y7KsT5mm+XOmaV6v63oPGNZ1HZRSBEEA13Xh+z4AHNI07eNHjx49eLkKQAAU771ly39ebJNfYTC0csFAsTyM4dFxjI2Nod1uv+1vnuu6WF1dRbvVhOM44AJXRfiKRxAE4JxD0zSYptm1eCEEXNeFpmkoFovQ9TCae54H27bBGANj7Fu+7//swsLCAgCxXgWgAH70/fe/94t6sUpjLRsaGoLv+3Ac56q5iZqmYWRkBKVSCaZpQtf17mYYBmRXKqeksYVJKbAqLe7ZL3+OQXK8L7lxzvveB0EAIQQ6nQ6OHz+O06dPo91u96XaAOD7ftf9a5rWVZhOpxMqOw+E63q/VygUfu3kyZPOoCCQRFu5aBnX1Ts+LYq1dO/t7vbTxvLy8lXzW23bxurqKnzfh67rME1TyaPERhkrRKx4hmGAMQbXDYimaT/t+/7Xq9XqtxuNhh95ApGmACTaZwIYAlBptVqwbXuDMvtHFH7s2mOXTykFYwyEkK6nkj1B7G1ibxLjAt/3EQTBuBDilw3DOAXgPAAPAIuVgCSErwEo/syPXP/PTf/Srz97dGXXWXu0J0zILjEVPLyFYwY5dz3HvZVzLgcrDHJO2jGEEBiG0UX0stXH4SRWCpkFTYaSOBQ4jhOFAo4bpt36ltnJ3/7so69+BoANIAAg+u7I3/3Ovb+2dOTvP61RwNIBjUYxgYSvlETvSfQeCN2QboBQHYTq0DQdRNNBNR1EC/dTzQCoDqppIHTtWGi64rMOUB2I9iPeiA5oRvga7RMk+Wp0PwtqhPuJDhF9J7rvdXC9EoId1gIRDISz8FX4IJwBIvrM/e73kL+LXsHDjQgGcL/7WfD4Ox8QDCJY2y84gwjCY1853cKf/EMNxy4JWJYFwzCUNHrsAWSAmIYvYlrccRx4noeizvCzN63gxn23/c4H/stTv64EgY/97k9Odg5//tJ4CZiphgrQFT6JtTQBFkjCjZDe70I1BQjtPY+StUAUgw4RnUPj99ErJfnINc24yWWSwGmGrNovco4T0j4h/W81h+Bzr5Txl4eqaAVFmKYJwzC6Fh0DP1kJZKtnjMG2bWiaBsMwlCDT8zy4rgvGGN69ycbHrq9jYt/Hph745c8v9mOA9sKnpirAZAVoucByW7J42QskvELPK+n3GLEgKOlXEnmfrDRJRUpTsjQhZwmeJIRH0nIklTBFv1Dla6m+jwUff2YcOLWq438+M4yXL5VhmAUUCmvClmM5pbTH6pPuPnb58THy90KI7vmMMTx91sInbgrlDOC/9imAaL/5Pi6AS801IQuFxYloZ9r3UNzg+LykYHq+j70F6T9WdR2RMLGe40W6Ioi8zxnWL3KsXKUc8ueGS/DtUwX8/rOjsLkF0zJgGGaPlRuG0XX3MsKPhR0LmRCCQqGgtHy5ThNfm3MOjYRyVmcBIjD9IHT9aQJIU4j4WFk5+r5TCEtIF+4KVVKCHvNMmG7PdXMUYRDvkOf2RZ7gRa8XCOsmseUCF9sUn32+im+cqMI0TRSLZo91y0qgsnrf97ukkMw3JLkHz/MQBEEPWKSUgkCEt1AEploBqNmKXVbyJspWKd8QWQgkw0skBRwLlKiunyLgpOuW777KI6QJfFBwn7T49Qo/ft/xgEOXTPzuMyN4o1FCoWB20bwQAoyxbk6vQvixYCOKt490UpFJQRB0gaMQAgQC913bgakJgJotpQIIataF6iYTtZtXCT2pEElh9llowrPISkAS1+SiFxAmw0JSEYhCaHmgUCV0ldLIH2MrVwn/Uoviq0dL+MvDVdi8gELB7KL82L3Hgk9L7+LXWGFUyiHHfvk6nHPo8HH7pjY+cXMbpgYE1KyneACjFd+A9cT9PreN/jguHxMLMi10JD1Nj5UnQ4hC2H2hISPg92GQARF9nrK4DDh40cDnDw3he+cqMAwTxaLVQzcnO6Vkq2aMgXPeI8iYK5CFHVt7r1cIj2WMYcxy8d4tLTy8q4OKGf4uUEPtAaAZdZH4x5JpX1p4QIpikIww0uctEkqgVAjSjwHSvIHS/efrRDoWyPIIkhdY7hB8/fUS/vq1Ki7aa1YfC0x29apYH/P8cbyP3bgKCAZB0GUJ4wwiCDgC5mHvRAfv39HGjTMMpi7JVTPUHkBAb2WBP+VNJmohA2tWrvIcIgW0qaxSFWaUgDLNc2W4/zRvk+cRRIrwT6xo+NyBCv7+9BAYKaBYNLvxPY7hsvWnpXdyQSqZ2smfZYYzxgmGcPC+LW18eK+D8ZJQZCl6igegetcDpFlrqsWlCHmgFE/hhzNBYcLvCyEJnqTn/YOQO4PwASKFH/juaQufOzCEg4tlGKYFK6o0xgK3LCs1vYtZPZkWji1atnrGWE8TbHwOYwy+7+NdYzbu29bBHZt9DFlhuBVJnoLqaRgg9ACAGoQhI58fJCVUufu8vF8WtixoJcZQhIYsoeYRQGmCTwq/bhN8+UgJXzpSxSWnCKuwlt7FoCxZwJEtmjEGz/O6XkFO6ZJWzxjrEj/xZ9/3MWR4uGd3Bw9sc7BllENu1yQRUO3+ZpriAQTR6mloH2KtfEQGAIdJRchSCmQoCFlH5iFrORkE8Q9IA2cpyetLGv7iUBXfOV2BB6sL9GRXLgM/VQEntmhZMeReAjkbkOsAvu/D933cNGXjoZ0Obt3ko2yItawk8ftjoxFEq6cpQDcLQBZYiz5wicrtInv0ovweU0sBdUJxvBIUQh3/VayfSJHcoCTQIMDwqTMm/uilERxdKUEzLBQk7l5uRpG9gSqWx6lgFtUrK0oseMEZPn5jG+/d6mF2KOirmST/n64nI1oKBiBrsQFIT9fkm8hFWLxJwwqplgs1CbQeT4AUbJCWBpIBSKCBOAABfPHVIv7o5VE0WBFmwVJOjJFdvuzCOedKgSeVw41a2uNrxe7e8zxMlxl+8d1t3DDjoxRZfZKMEiIF45BUDKDVuUgXmIoUSkv7kl5Alcb1ZBAKr9OHF1LYv6TLT6N/11PdV2YFAuj4wB8+W8XfHh8BpxYsy+wWW+IunSTIkzfP87qeIQZyKpQfA0G58ud5HhhjuGebj5/f38JYifd6ThVQVWQqoGkhAForvuGZ7qSPvusXMknJFKDwJiKlDtCnBMjBD+Kt079Z1z2+rON/PDOKg0sVUN1EQWrOkCt3WQUcTdP69qX1CMakj+d58H0fkyUfP3urjTs2eyiboj8dTQG4oi99TQsBVKsL9DaNKbl75PeTZ+EIEArBORxzBg4jGBaXYCDIVQLk4YIkOLzMngBVWvjYiSI+88IoLjlFmJYZWfpaihfn+sncPUbtsUKo0ru48zcWevxd7O4ZY3hop4ufusnGbCUApYkSs1R2lkOzSFP8dA9AWxAKgkSRrqV5gT4rlyw4oEWsaJtxwtuKC50hHDzXwk2lk/iR+UXoekrBKBFrkiGBZFh+0v0NqgfJP/373x/GV46NwCcmCgWry7ZpGpTpXSxY13V7qnJpnTsxmxfH+9jd+76P4QLHL76njbuu8VDU+xE+F9kl6GRPQvg9rafSJo9+0uxUdK+o0fSmDlUjSLfBg6qbPVpiGF+9eDOePV9AsViE67qwW6v4ye0n8N65JZi66LNYVYNI8kcnm0MGbQgRA3iBjg/8h29N4fDyEAxDh2mGYC/m3g2J6FG59Kg3v+sZVAWcpAeIEX4QBLhnm49ffHcLk2XeJ8TUV5Egf8QaB8AF0AlM+wOf8UrqEAAAmtUS8Ioy6JOrcDHqT1p/DyBLUrOaiWV6HU60JuD7qzBNE67rYrJgY9twC7om1Nx/kuVTVPuSpek81k8+Xwg1cOQCOL6i41cfm0HNC7l8XTd62rHlLhwVkIvdvapTR2b9ZE7fdV0w30PFEvilu23ct82BRnv/x6waRBITdDMDqRUNerEeNganKYBerAvWnOzL1VU1faIu+SbDAzMmcEbsQa11IWxX9kINH6/4KGpcmWWo8v6+aqOC6hU5niHtBsbDC4DHT5bwe89NwEURlqX3NWyoYn1svXLZVlXAkY+Lu3RCd+/BpAFuv8bHv97fwdbRQOnGe2J+IgzkVSi5AKBbrR5x9x2oWXXuh/3hckOmECnlWBUvIGcDVIc7ug+XVq/FSu1VDA8NgwUMhBJMFl1YejBQR5FKyTIbRkR66pcWHVZsir9+rYovvDYGoYVcfpx/x4LP6s+LQ0NeESf2GnGcF4GPbaMMD+/28P6dDkqm6OkxUDampCL8foXp2adZ9UwFADVbsqtRsX1Ji0UGry+sSTQmHsTpVw7B0IyI+ROgADYVmyjpTG39pL8Encz5s4gfMmBZN74xJ1cN/OnBEfzDuRGYpglTas2Wu3VULj/ZmJkW62V2Lxb+kMnwnm0+PnqDjWsjqxcivdMoi+hJYoIeDCDJN8cDmHXOAUHXbqJQlH3T8v5epaAgEzeiZW3FqVNfgWmakZIQaMTHRNELmxRVDYd9/j2d/FE2jvSz0MrBOPDMuSL+z4FxvNEswzC0nlbstLItY6xb24+FmwYE4+Pk1C4IAlw/5eNDexzcd60LQ0tP61SuP6kYfAAPwEUo32wFIEZLpNXeSb8XiJUk9hTysdSoQGz/CdTO19BqtVGtVsMbRYCiCRhUXRcgUCtCn1Uneg/S8vi0UGD7BN84UcFfHB5HMyjBsvSedCytPy9O24Ig6ALCvImfMY3r+z4qZoB7d/r48F4bW0cCpXBTvVVG7q8MBYljBTFaOSHAqHcvTNT1+W4mkIITuj+kvAl8fB/OP/e1tXw5OrNikjWtz2IE0euJSIon4olcP68zuOURfPVYFX/52gR8UoBlmT2Vu2RfXVKwaZYvx/kYF8SC10mAW+d8/PBOFz+80+0r1Igcd96HC3KsXyR4AhHJN88DdNlAKBoy05o9k26cUANk073gjOPc2XMoFophjBQAFRRDJoEZpX+q5hOVEqT2GIiUFC+DEzhwqYj/e2wSgVaEKc2yVZE6sQUnCzhJy5f78+I2bt/3wRjDjjEf9293cfdWD5uHg1RED2R3GHfR/IA9iiRBGgli5IFAvdWnNYpQIL/y+Cb3zOfSoM2/D04QYGl5CcViqABBdEMLFoWuEWXhKOniiYIJFIpULw0U9jCF0avPNYDq0IiW2Z8XCzaeqp3VnxdbfBwiGGMYtgI89C4H91zrYs8US43pasZOHfcxABkk75P5ALkZJMUDaHV5bkBa+pdWzCFR5qAXp0DK87CbNjzPg2VZoX4JAR5wmBqFRkSPdpK0rmBJEWTBQzE/QRU4VfTwWJFhyBKo+b2TLtPSNrklWxUSZEWJGzof3OHg3mtd3Dzro2IKJW27HuFDAQ7zvuNJ/kBqBkn1AALpwE9mAolkvZxLXoJQiNG9EHoJnc4FgBIYphF1FYU3S9dJ98fJ3kXI3iStnJs6U6S/A0alEBe1HTg5cT9o8RUQ5vXFcrmAIxdxYiHL8V1G+zH3P1sJ8NM3t3HnZg9jJd4Xi5PxXNm0kYb0hfp8nsEW9ihHrgeA1gMCSU4oIMo+AAJUt4EaBXRcG7puhCkgIvfJOXTdAKGk+4OpAvBRoi7zKptBMppA4+98WDhVugf12Q9h5+QO/Ns978Mf/+n/wvkL9W6TRlyIib1CXn9e3OARg7wPXOfgA7scbB9jYdUux+Vn5fpCIWAV6ONCzRZyJaDU8kAgbfUgTPQye8oEOxaYhMiNoS2ghMJxHFimBdO0uvGBCw5ilBEIvSezSMb6ZFhQUXpCgf5VyrCkbcXZ0Q+CzvwQNk9vxtymOQyN/hDKZQe/+TufhW27PZMu06p3Mncf5/QUHLfM+viJvR3cMOOjaIg+Yago2/UKv4fTTwDCrPJwzzUJzUsD9bqSW84o/SaJIGqUgOIEqEZBBGCZBizTBKSKWECLYJECpIE+VfonFL2AsqSTxSMB4HjpAdSnHsbIzG7MTm/C9Ow0RsdHYFgmbrrjw3jw7u/hb775fLcen9WfJ3fxMsZw7YiPD1/fwe3zobsnKSVZLvIFn+XauVBnBSpAyDNIJLklPCUEhBoi1+QFUaP/VE9gjUArVEEphWEYMCwLumFAoxQCYS3dRxkB0XtDgEhv80Ky0JMMCwplaJFRHB3/GZjT+7FpZh4z0zOYmplCZbgCwTk8x0GlQPFjH/v3eO7lT+LM+dUuCaRy9zG4C1fcCPBTN9t4eJeN8RLvq9ohI9bzDIYPCkSvau5MQ/xJxeibF4A8D0BoPwZQCT/LExglwCiDahRWyULRtGCZZleRdB0QHKEHwFqoUZZ9hbohROUVZGU4ZdyOi3P/ApMzWzEzM4vpqWmMT4/DMA0EjCHwfbCo7j43M4Gf/Il/id/9gz9Ex3b6JmDGOb3ruuA8wC1zDL/6ngZmKkGfUDGAux/kvRDpAE9kZAMipzQMQvM9AFHV/TG4EkArAVoRlFBUK1WYBROGaYJESC+0Lh0tbEHAFqAJrx9jJKncJEWc8ArxcEkFx4c+CHfu/dgyO4/pqWlMTU1heKwKqlH40XIpjDEw3wdnDIJz3HbbXbjr9sfx2Hdf6ZlsGdbpHQS+h5kyw8/f1sH7tjqZreMiR/CqVHDdfMA6eIBePJDjAT7yG1+sf+ERdV9fnhJ0Jx5oJqCHlb9KpYJCRAJRqq0pAOeo4xq47AAKwuu69aTA0/iAJOsniIaauR0nRz+C8tzN2DY9h+npaYxNjqFULoEFDMz2EDAGFgTgEXpnjMHudNDutHDbHf8Mz71wGLWGDcajQo7vYbzg4Z7dLh7Z1w6bV5DOvwuRvT/P6gcBhusWvuQFPvobX8zhAQAIrVjnwh6OPUAfGifpjGA0vwBAyJpVhiqoDlXhOA60uPGPC3BBYfMxeLQMi9dS1whIKkJyvyAEHTKChfKdWJ36UUzPzGNuZg4TExOojlVhmDocu9Mt3nDGwhAQBGC+j45tY7VWw8rqKsBa+MitOl54tYmXzwMVPcAdW128f6eNHeMss2k0T/C5HECO8NNAZJonSmYEYSWwWA9XiMtRAGhWC8IeTnoAgYyG0OQyLwAEFygWipiZmsGJN04CQQBKKKhGQbmATWdQt3ahxC6Fy6/llH8BgEi5f0A0LGq7sDDyw9Cn9mPrzCxmpmYwNjWGQqkALjjarTZ4EHSFHkTcvOs4qDcaaLTbaNRX4C8fw/zKV3Hr6Mu4+3aCNxsaTF10efusNQKymjHzBM9zSr554SLJAfAsb6JZrYEUQGhWPfCwSaO9TGCcq6c1hXQVRYR4UxCBYqGEqZkpHDt+DJ7rglIaLoykGwAIlowdGNcOoMCWs8vBCWVwUMb5wh1YmXwY49NbMTM1g4nJCQyPDUPTNXiui4Ax8Cjexwrg+z7a7TZq9Tpq9TpajSVUV5/CtsY3UOSrEACKusC2MaYEd6k9eRlduSpAyAdt+hjA7as4giRhJNDfDZSuAMTso4Nl9o3Llih5gCB2ywEDDzwIIWCaBmamp1GpVPDmmwsAITA8A+VyGQXLQrO0B3V+Ambju6CC9TaToj8VDARFU5/DmcoD8CfvwuzMDGamZzA2PoZKtQwuRLg6pu+DBQFEXLuPUHyj1UKtXke9XoNXewPTtcex2XkaGhHgyJ9MkjdTWAwQBrKygrTOn6yikMz8pa1dEFYCe7uBMkKAWecCoJJVqxo+VHMBBAARhOxYWBYmmBifwNZrrsH5c2dhOw50wwhJZ6qBUA0L5TtRct5A2TnZn9pFf98XBlZcC284s/DmH8bUltswPzWDyalJDI1UUSiYXatnseUHAXgQdJdQrzUaqNfr6DQWYdYPYVvzCUwEb2R2EefF+6yS7HoED2Tz/FlpokghikQyBUx0A6V7gGidgB7BCylXV2QA8UcCgPsdcL8TrU5FUC5XsH37dhw9ehQnTp6Az1i0zHkBumGgQYZxauhhbBKPoUpWoAXhuQwGnMBEw9fxRmccJ1sjEON7cfPUTszPTWNqdg7FUhGUEtidThjjGQtjfhTvHc9Dq9VCvdFArdGAqB/HaONZbLKfRxHNnpVP0haNHGTm8CCZgSqvR4bwcxtCUq4t0opEiUJQugegoQdITgNXgb+4BiCzcMypgzn1Ln1qmibm5+ex5/o9uLh4Ce12q1szF4KDBwIr+la0Kz+KIX4JursExhjagYlV38CFOkODD+Fde6/DA/ffi4mywMpqE5pOwQMGz/G71i4jfLvTQaPdRq1WQ71eQ7X5AmbbT2PUPwmNCAQKqJG3iGQa8ZNm7VmMX1oKmEb+ZHIEUPcAxq+ch3IdEAP0t4Upmz5U3cIC4G4DzK51Z7gQSjA0NIR9+/ahVqvhwMGD4Dyusgloho4gYGhiGCtBGS6bhee5cBwfrmdjYnYSD9x+G/bffjvmN20C99ogR57H6vJ5FCoTawg/UgLXddFqt9FsNlFrNGA3LmGu8Tjm3JdQRLMH0wy6QsigXkFkIH3VcWlZwKCtYpmFoyQITHQDZXgArQ8Eqhg/kVgUoosJmQ+veQl+4CPgawsWzs7O4v777kelUsHRY8eixQx718lhjIELAU3XsWnTJG688UZct+c6bN483+0q1qwKprfsRv3Qi2jUlqCbpZDVCwLYto2m5PK1xjHs7nwTY+wN0KgB5XImCucJPNcLDIAJBskCks0eaV5ElQ6Caq0BPYDe3xiqUgL04oJYIYgQ8Otnu3PeBES0VCnB3KY5PPTQQ9izZw/OnDmD1dVVOK4LxgIAHIZRwOTkGLZu3Yrx8XFMTU3BMIyepg0IoDQ8hcmpKRw/cRqeGSAIOFqdTtfqneYyJprfw7z3IqpiuY/LyEL6g8wjGIgQGsDVi7y6gEIp+AC1A6WXSCwAkqEA/R6gu2ZAsg0rwQOEnkAgaJwF89xuBU3X9W5LeLVaxZ49e7B9+3a4ngffDx9gQSnpPgOnVCr1dOQkn8tDAUzPb8fShQWcu3QJHZ+g0WqhXq/DaB7DTucfMMregAm3r9CU7BEUyFeIrGXkBllIMis05AmfD1g1FMheJUReGiY7BKT0BcrNm1Sxxs/af88RrBxB4HXgem533drk0iLFUhGlcinF6gQElwQvIg4+atgIhAAxh7B11w04dfYxLFxsotXpYL79Xcx7L6DMV/vqBW9lyM6PiwG8QwZTmFsjGEDgWRlD6qSRRD9gdgiAlPoppn1xxZJtPV7BWYFXPwd3ZCrssSMAjZ4aQXo6SEJh97r4NWEL6S6J6O54QQA/ashoeQRNBjQvHsVe9gQm+Blo8PtmKmOAgua6Yv8APMFAzxJIwRFZPYR58wdUjaKhBxgwBCBuC4ubNbCW7sn5PrJCQuAjuHQQ/twNsF0b5aDcBXEg8fo3YXsY0oSdUIpAmlrl2DbqjQZeeeUVLJ8/hX3s6xjl5/qtMk+AlxH7M5nAHKHjMvoCkdIYmtY2rkoVY7kOigHqUdGupxWbp7j+vpU6BSCYB3/hGXjXfxiu3RsGhBDgIkxOe4QeK0LCEwghwIMAPmNwbDtk9ep1vPzKARw/chDvan0JVXIOnGQ2C6t1naS3wKcpRZrA1yv0LIsXA7B/68EDyfUBsxUAtKUiGeKef5IAfTTRvRO+5/AXj4LZq+jYJdi23X3+XZ6LF0nhswCe78FxHLQ7HdRWV/Hiiy/i8Kuv4Rr3KUxqpyFo+pTwtNVFgPQZtnm1gFS3n8EfiJycf1DBZ3oMkVV8ooOCwLBtSKQ1g2SkgnIZN/A78E49Brv0UbTbbZRLJRimCRFZPokRfsLyBcJUkguBgDF4ng/btmF3OlheXcGzzz6LgwcPocrfxCbjBEzKUh8WkefW15P7v+V6gMjmBAZJBTFARVCVNspyHYAI0lt95d5kSpiSCsr7hNuCc/xb0Ld/EI16HZVyGUPyDJyUWB/vD9uxQstvtdtYXl7GM99/BgcOHIQGH/P6SQyTlZ6JoUJh+UL0A8A8BckLB4OAwEEZQZF1nEgHgoOkiyJljeCuqFX/3CO/9WVbEM3jXLHOjOhdeCi5CBFPrEnjNy+ALR5Eq9VCs9mE53lrffZx23XytWeZNBftdgvLS8t4/vnncODgQQACZVHDBLkAnUp/F70bV/w++XeqttQbirVjAtH7N5PnCsXfCYT6dyVn+/AUNk+VBXCeuE5W+xjRvEd+68v2zcBbegAADTlJREFUQArQ7QpS/JDkGoJKdkr+J+1l2Mceheu6qNVq6ERVuz4lkD9HrdeO66LZamF1tYaDhw7i0OFXuz9vHBdQxUrfjJmkMJNCXNeWvJ4iX1duSLlfGd9z1TWS9z4DEyDlmN5uoP6hp7pCWqhz1hlTLfos8wA9aWGicRMk7KoNVo6DN86gQSkqlQqs6AGJyrSPcwScd6t5rWYLp069gdeOHAkXYKIU3O9gXF/tPt1MZDx4AlJb21vm/wcMB2LAjqG0drI0oiivYpjZQUQLdaCzDgXQwpVC4oZQGeHTJKSWMUC8YgddUwTWfBPuqSfArvs4VlZWUCwUUK1Wu9OvkACCzAvjvt3poFGv4djrr4MxH4ahw/MEiqINkzf6VgVTTQNPE15eupcHIFXCHkQJsuoIXOSfk1c0Avo9HxcANGN9HgDUrIuMuX8kY41gJDp6ArcF782XYMzehQaAcrEIy7JQsKw1BYhOCOJ833FgOw6WlldQb9ZhWVb0FHOCErVRJm3lTe7RyZz1jskAAr5SipDXPJrVRZTZT5ACBvuUStELkBMCohMkwfYsDSPWVg6VUXhPL590XFA/CbrwfdjWFJaXl8MFI0ZHQTWtSwjJky5d14Xnemg0G9CoFlULKSgFTOLAhN23LEwPZ69aPGodKeGgLGCe5WfxBnmhIoskyusb7Os1WK8CdB8fI5d50T9HICaGlMu6S/t9uwX65rPA2A1YFdegUCjAMAxUKpW1m8A5WNTDFy6t4qPTsaHpWs/q2eAMhtn/7KBBLHwQLNC3yNQAbWJZXUKDkENp6d+g9QOeNRMZAFGkgDkKEK4VlHyMq+pJHrGVkwRRlFynx1s6Au3c9xBsm8Li0lJXCcIaQdQUEk3Z8jwPXADtTicqIhFwHsDzfPiMg2nSymBCvTKogHpp+stt/hg030+ewzOOG0ToWYLPqx8ISZ7rCwFR7bjnsXHyjF3p4jTxONm0zwHzgfPfBRnehSbfg4sXL8I0TYyOjkKjtNsRFApfwPHcaJEGgDEPnufC81zYXINrFWAIR5qLsEYDUwmn9JBA6wR9XFyekqQJMLmiah5DOCgY7AF7acqp6AXI9wAi/Qmgyad9yPFeDhNJMjFoXQQ99bcItGEsAzBNE7qmoVwudxdMBiHQTRO+76NUKmFpaRm27cB1vbC3HyZaooIynP71AKQpaqr1AonCgrOeNDIoNTwIK5g2x19g8LkFWYpHMjKDdXmAT/3YfgJoDdVjX1MRdcqj5VTr+fLFl6ENbYGr/wiWVywUi8U1ChgClaEqRLsdLtlqhg9ichwXjmOH4JABtYKBaV39IMq0Ba3SnmnEubp4dLmZwHr7BwepNQxyvio7oIjXd6BtpZ2ngGQqsHZC8pkA8nMCKOl9LkD8qrqJPev2nX0cZvsU7HYbJ06exIlTp7C4tIxGswXX92CaBiyrgEKhCMsyAXDYdgeu62K15eFcuwJBzf6nm6iYMdH/m9bzQOm+cq+i2ph8OLbqmml/p+/+Kj4nr6v6vu+5DtJNF0RrfOrH9tOkrHX5fMmLGL4gHUv6Q5T0CzH5bD7Z7SdLsEmQRoI26IVvo0bH0fQ0LC4uo1AqYmJiApOeh4mJCVQqZZRKpXAaWaEA3w/Qbnfgug6ePFOEw3fi3ukzKJNm7o3u6wzK+JzmKVSZRdK7qZpPkzOd0q4rL8qZXAuBIueZQNEHTU7LpYW3XBBHknFXl3VJibRIIfQnnj9V2jG5k5Ro72/WJH9BUwSPARUEALTVgyhXtuK8sw21touhoSp834tSPopqtYpKpYxyuYxKpQJN0+B5LoTgIETDgcUC2sFO3Du7gFn9IuLmsjyDlq1IZDx2ri+sScdR1QMtMh6ziwQwRnKFVQknaEQBJElivaa0TEDuz5C+ZwydP//GAT1SgiDaRLwjFr4FoHD6Qr18cpFNThRDofc9FiblBqXtJ2lNGcxG+dxXsKlwE+rsBlx4sw0esGgtXgJd1zA6OoqhoUVUKkOoVofQaNSjZVs1EAKcbuj4arAdd22awB7rKHT4qQ+eTvW/iveDThghVJ0tiJTH1OfNKNJyuIJBJ6DIIDDgQNPFxWbHG0P4uBAXgA8g0BPCLwEoOx4rHzrToLe/K1zPl0hxXhUKktaUtUZvMoQI4WCT/X1M0kM4ZtyGM8suBF97Bt/U1BTGxsYxNraIubk5eJ6H5eUVaVlXgYYn8K0zU1icqeKe6guwiKv0Spc71tU0msI3DNJCvt5egzRiKfnZD4ADZzsGgBEAbVkMsQIYAEwARQBlANVDx85eOn/zHfW95OlhWfhE4cqTbr4PaZJswwOAAmljP76NfXoJx8WDqC8CFzUC0zQxMTGOdnsejAXRHAIKx+mE7eEBhxDhrKKXLpRQ89+DD84ewigugUBcMQVImz+Q+uh5cRncgkKJBskK8pSr5QIvvHqGARiKKQM5BJAoDOjRZgIwlxt254U3rSM37Jh6d4ld6j4tDBkKQHLiLsmJyeHoYJ/3N4D/KE6P/BKWloYwOTmJffv2wTTNSAl8LC8vdecDyg9kOFun+AK9Cx+d/T7mtPN9gOlKjfWQSgKX9+j6tELTIISUrKAntNv+9MT55yoAWpGxa9FGdZlISm5f/vp3/rD6kYdHP7CrvWuz/SSoYKmAL3mj857enZd6EQTY1foKni1eD9/3MT093X0Qc7wEe7PZBKUcmsbAWIAgYBACqLU8/N3yzXhkdhFF6l05oSu8WJrQUj3DOpUp7SFQg9QuCIBzdM93fuuPjn4jXvE22oSMa4uRVhQiDDAUbWUAJQIU9uy+dv99d9788TvKr1QqzsnqlbyhASkAoAEoZcnvA1pEe8+/M8e23ETe/e7bwTlHrVbD4cOv4vnnn8fCwkJ3BjLnDIzxaM1fAsuycNNE4429xWOnr5gG+J0pOMvXruUDb+NhVFZe8Pb/8X//8yeftm2HR7G/BaAZvdoAfBK5fC16LUQKUYq2QrTFboPKXAXeAs4ydWpESkCDQARciOQKLahUKtojjzxy92233fZvbrnlFkxOTqLdbmNpaQmHDh3Cyy+/gnq9jiDgCALWnYwKCBiGAcuy3BdeeOGXDx06dGbAn1XA1TnkTjYipXl+hPodhO1AnUjwTpQJMD0GA1IYYNFJdowHIgXQU5QAl6MIHuO5x7RaLRw+/OrTe/fe+MmFhQVteHgYpmmiUChi8+YtWF2t4fjx49Ey7VoXDxASLtbsOI65Y8fOT509e/Y/1ut1Z4Cf1b4KBZ9UAC7JMZZlnPq50Xs/+o7rUkxQKYAubTFfQCQK+QfuChuNeqdeX/3yhQvWj09PT2NiYgLFYhHlchnz8/Oo1+tYXFzsWn+4pq+HdrsF3/cJY8E1u3fvnnn22WefSSHv8kI8WWdmOOggV/BaQoHlYi/AElsgYwFdOpknlIAqtjzXf8Vv1uLi4mqr1f5ys9n88YsXL4YrjxYKKJVKGB0dxezsbNg+ZttgzIfrOqjXG9B1Da7rLhKCv1pdXX0NwNJlKMDlUANYx3WutFKpPEES4Pc0PuuJE2WXzqGoR1zGP/aWxpkzZ+D7/lHXdQ8tLl7aOz4+hqmpaZTLJZRKJUxOTqBer+PChTfRbNpYXV3FyMgoRkZGXn3llZc/02g0vvn6668HAIZjbBn9b67kHoO38BOp5BHZ2ygkJGtXyrqZnnMBcpnafCUHEYKf9H3/0WazvXdpaQWVyhAKhWK3TlAul9Dp2Gi1Wrj//gewsLDwtYWF8288+eSTT0fsF5fcYewaLUkZWCI+BhlKoSW8onxj2Q+AcrgSGWvqb9Legov5x9owOzvlDA+PGpVKZReldFOIAUoghKBeb+DixYtotVq49dZbA8uyPnP06JHrPv/5zz8mwsyiHAnbSGxaQphmdFwxJRMqRMfo0n3jCpfL/4nukwDWvwSShrf3IAC0V189Ujh8+PDiAw880NI07W5d14uWZUHTNNTrdQwNVVEsFp82DPPFxx77uw996UtfetL3/RqAMSnNJQNgGpKyDYpx6FsMJ//o4+2uALFlDtu2PXnkyBHzwQcfatq2c0dYEiYBIeSMEPzPjx9/fdcXvvBXtzz++OMHfd93AUxE54pIKD3pTwIpcwVoUlkWz7G4QMJOGwpwhTyAGTGT0ysrKxMrKyvX79+/f6RWq5ELFy6cPX369PhTTz11+5/92Z/5R44cORtNMClEgvEj8kNmvzxJGeJXP5EmBQkFCRRUeVIhEF3nqhr6VfAbg4i5agBoPPHEE3/veZ52ww037HvppZcahw8fPtJsNuOWoNjinUjoywAuRingakT0xGCPSYIPJEJMJdy8uH7VWf4/Jaq/HCU1AVQiTzBMKS0KIQpCCEuir01JoVlk7a1IcVqR8D0FIRIowBtS3LxIIV2u2kGukt8ot6zJKF6XULkuATsuceGye+cZFp4EdGm9pvxtkur9f6MAqt8rI3QqAUaSoFhVwh1EyMg49h01yDv0f1Hx7IP0hbwjhbwxNsbG2BgbY2NsjI2RHP8PrhRVUtQ19lQAAAAASUVORK5CYII=');
}
.renameFolder:before {
background-image:url('data:image/png;base64,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');
}
.deleteFolder:before {
background-image:url('data:image/png;base64,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');
}
.addFolder:before {
background-image:url('data:image/png;base64,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');
}
.expandFolder:before {
background-image:url('data:image/false;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAEF0lEQVRYhcWXX0sbWRTAf3c6zowxsY7/sNZURZrSgEW3UBAWUQoVn/vsU1n24+zbfgED+wX2zQcLPhT2bVmbNA+uoBLCilKDJmMyc+8+7Mw0k9wk7bbSAxfmnDn3nN89998MfGcRnYZisTgKGHeYs5bP52UXQLFY/OHevXu/2badE6KL65vJ7e1t1ff9n/L5/O8JgHK5XLYsK9doNO4sOYBt20gpr1utVjafz380AN6/fz8K5Or1Okopzs7OqNVqKKW+efM8DyllWimVg09zbfi+H1OenJxweXl5Z1UIcxkAJoBSKuEQBAGe59E+HUopbNvGMD6tz/Pzc66urrRJhBDMz89jmmZfGO3bIAioVqtUq9XYZhgGT58+ZWJiIra9ffuW09PTnsFfv37N/Pz8YABdBVzXTXQWQpDJZBK+W1tb3Nzc9Aw+PT3dFVsL0ClBEDAyMsLY2FjfzplMhkwm09dnkPSsQKVSSYxOCMHi4iLpdDq27e/vc3Jyog0shGB7e5upqanBAFLKhFFKSbPZpNlsAtBoNKjX67iuSyqViv0ymUxiTXQFN82u2FoAXQWy2SxPnjwBoFar8e7dO6SUCd/V1dW+wXWxtQCdoqOWUuJ5HvV6HQDLshJbTClFuVym1WppE9m2TS6X0wPoKtA+WqUUQRBQKpUolUoAZLNZnj17FvdptVrs7e31Hqlp8vjx468DePToEXNzcwCk0+lEP9M0efPmDUEQ9ATQTYcWQEqZAIj0+/fvMz4+Hvt19rNtW5u8l38M0DnnUQUiu5SSIAj48OEDx8fHADx8+JClpaW4j+/77O7u0n6ntIvjOOzs7OgBBk1BKpViYWEhAeo4TqKfYRgsLy/3BLBtu3cFOiUCiJ1MM7HgdCKE4Pnz5319dNJzDbRvucg2PDycuA2vr6+1d4HruliW9fkAujVwdHREpVKJbYZhsLKywuzsbGw7ODjQ3oYvXrwYWLG+AOvr64kD5eLiglKpRKPRSPiura1pE7muO/AI7gswOTmZ0B3H4fDwEKVUwjeVSiXuhnb5IoBB53V0EB0dHcWfajMzMzx48CCRcH9/v2sXGIbBxsYGQ0ND/x/AcRxc16XRaMSfaUNDQ8zMzCQge8Xp9y4C8JRSPj22pWVZvHr1qsveWeaXL1/S+U8RTZtmSuoQfplubm56SqnC135yB0GA7/uJFgSBzvcPpdRhXIFCoYCU8mchxJ9KqdUQLGoopeLnLxAphIiGLcOGEOJv4JdqtfqfXigUUkAemAWmgXFgBBgFUmFiJ9Q/F0ICNcALn+uhfgNcAv8AFaBoAmPAj8ByCDEaNjNMbLUlNjp0XeJmNNo23QP8EKIWJv8LqJih8msYOGrRyFMhRCRGCNzrb8MHPrYBECavt1Wi2d7+BZ6ExPU18NzUAAAAAElFTkSuQmCC');
}
.foldFolder:before {
background-image:url('data:image/false;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAADYklEQVRYhe2Xv48bRRTHP/PGvy7nuyMh8hnRIJEIBRAFFJx0BW2EaCkQDUX+EgSihX8C0dMADVIKChqQAAUJHYHLBSW+I168xus9vPModvaXd+1LcegoMtKzZ2fevved7/vOjG1UlYtscqHZnwD4PwBolR/e//Dj51R1+N+m1OjZ4TM/3Lr1jqsA+OCjT95+7dWXP7t65bI4dVixKMpWf+vcUs/jmCAIuPPzwafAuxUAw93BzZ2dbZnNI9QpqopYod3pnhuAWRRhxDAcDt7MxnIAiXM2mMTM5zGG4mx4NI7ODYCq0u50ieanufZKAIQoinnr5j6tVgtrLWAwZn1Qc5bDEoCvb39LEBTazwF02h2stbTabUYPj9ndHQBKHMc4hUsb5VIYnzwNugRpLeiNXg9r23UAYi0iktffOcdvhw+4e/iQl168Tq/bKa+ljCODU8yZ4qkC2qSMiS1mcy6sFUQE55QkSRgHfzEajTi6d0g4CXHOeVOcenOKuvS7mPc+NXO4xIExWLF1BqxN6+5UMUbo9/vM/g7ptAFd4Fxp1fVulREtjS9RkTLQAEDEYozkK0Rhf38vd3S+1kY1p7NWfc2KUPgsVQtYyYAgVlD1GlBlMpkxDqbsbPe5/NSmD+4/lwPngAotmBJCzdgxxu8wv/C8Yy0iNle1qnLy55if7vzC/DRJ6611q+hBaZ7TVCvq0vJKEwDrd4FTSBLHZBJy99cD7h/9TjB+hJIFA6f4ZFXLk1Usm0ttmYGqCMWiihfhFjduvMD1a8/z9NUraE55XgSaNlu9VZVijDRrQKxgRHJ/BQaDAadxnCYvjVeCl0RgGn0KnCZFsKIE4hnwAVTh/h/HfP/jAdGpFuPL5ikmK8UaH1WQVSK0VjCSQlXnmE5DTk6OObp3yHQ6rQRpauo3XxlQ3afOQOUotrbQwKXN9CBqWVC3qAbSEq/LFJeTNYAQkVUiTHdBcbILr+/t1QKsa1m+xnsg660UofhzANjc2s5XULpiVkXPT5mab8M76VHccB2j6kQss1lEr9v1F0dDstWx1/h7banyzyIBxdUAhOHkq15v470Ho4lZLBYNQc7K/ngvdLtdwvD4y3yk/IPi8y++uWbUDB8/eF2IZ/kamPf7G9+9sf9KUgNwEe3C/5g8AfAvi4r5BDE0EIsAAAAASUVORK5CYII=');
}
#folderMainDiv {
width:300px;
height:100%;
position:fixed;
top:0;
left:0;
border-right:1px solid #999;
padding-top: 10px;
background-color:rgba(255,255,255,1);
}
.folderContext {
position:fixed;
border:2px ridge #004D40;
position:fixed;
width:180px;
padding: 0px;
cursor: pointer;
color:#050505;
background: #fff;
z-Index:1001;
}
.folderContext > div {
padding:5px;
border:1px solid rgba(255,255,255,0);
border-width: 1px 0 1px 0;
}
.folderContext > div:hover {
background-color: #00695C;
color:#ffffff;
border:1px solid #26A69A;
border-width: 1px 0 1px 0;
}
.folderContext > div:first-Child:hover {
border-top:1px solid #00695C;
}
.folderContext > div:last-Child:hover {
border-bottom:1px solid #00695C;
}
.folderContext > div:before {
content: "";
color: #fff;
display:inline-block;
width: 16px;
height: 16px;
background-size: cover;
margin:0;
margin-right:5px;
}
#tempContextFolder {
display:none;
}
```
Пример использования класса можно увидеть на [Github](https://rinatusmanov.github.io/Folders/index.html).
**Кому лень ходить на Github**
В итоге получился класс, в котором работают кнопки верх, низ, влево, вправо, таб, ins, del, f2, а также естественно мышь, и контекстменю ))).
Папки с блекджеком и…
Следующим делом добавляю в строке поиск «event» на событие «input», для того чтобы результаты поиска появлялись моментально.
Пример на [Github](https://rinatusmanov.github.io/searchResult/).
**Для тех кому лень экспериментировать**До ввода теста в строку поиска
После того как пользователь начал вводить данные в поисковую строку
То же только в DIV добавлено css свойство opacity 0.5
Ну и в конце редактирую manifest.json. И даю название расширению «Notes beta 1».
**Редактирование названия**
Расширение готово к использованию.
**Фото отчет --- Как оно работает**Основное окно
Создание новой заметки
Отображение заметки при наведении мышки на нее
Поиск заметок
Код расширения на [Github](https://github.com/rinatusmanov/Notes1Beta).
**p.s.** Жду конструктивной критики.
**p.p.s.** В классе Folders не работает функция «Переместить». На реализацию логики немного не хватило времени. Также все картинки в стилях преобразованы в base64.
**p.p.p.s.** Основная задача топика — написать быстро расширение без использования фреймворков. | https://habr.com/ru/post/324862/ | null | ru | null |
# Офис как Платформа: как создавался проект Notegram для OneNote
> *Перед вами история успеха проекта [Notegram](http://notegram.me/) от первого лица — Дмитрия Конева — разработчика проекта, который создал интересный проект, расширяющий возможности приложения Office OneNote. Все статьи колонки «Офис как Платформа» вы всегда можете найти по ссылке [#officeplatform](http://habrahabr.ru/search/?q=%5B%23officeplatform%5D&target_type=posts) — Владимир Юнев.*
Хакатон LA Hacks проходил с 3 по 5 апреля, в стадионе Pauley Pavilion Университета Лос-Анжелеса. С огромной кучей участников и партнеров, это было удивительное зрелище, особенно для человека не разу не бывшего на хакатоне.
**Скрытый текст**Посмотреть на гифку с места проведения можно тут: [gfycat.com/UnhappyWholeHoverfly](https://gfycat.com/UnhappyWholeHoverfly)
Так получилось, что меня не очень заинтересовали проекты других участников, и я остался без команды. Пройдя самую важную часть любого хакатона – собрав все добро от компаний – где-то часа в 3 ночи я оказался у стенда Microsoft, на мое удивление, с еще живыми инженерами. Поговорив с ними (и вооружившись ваучерами для Microsoft Azure), мне пришла мысль сделать что-то с API от Microsoft.
### Проект
У Microsoft есть свое собственное хранилище заметок – OneNote. Очень удобное приложение, особенно для студента, ведь туда можно сохранять не только текст и картинки, но и экспортировать файлы PDF, математические формулы и записывать звук, а если у вас есть планшет типа Microsoft Surface, то еще и использовать рукописный ввод.
В OneNote мне не хватало шаблонов. Существуют дополнения для десктопной версии OneNote, но с учетом того, что я чаще всего использовал OneNote на планшете, мне хотелось избавится от привязки к платформе. Так и появилась идея для Notegram.
До этого я совсем не занимался back-end разработкой, так что пошел в обратном порядке.
### Дизайн
Я начал с логотипа. Буква N на логотипе OneNote была заменена на иконку “поделиться”.
Затем был сделан макет самого приложения. За основу был взят дизайн приложения OneNote для Windows 8.1.
Интерфейс создавался с нуля, без использования виджетов типа Bootstrap.
```
Monthly Calendar
================
An essential for those who keep track of everything.
Save
```
Каждый элемент был сделан достаточно просто, так что почти ничего не пришлось менять для мобильной версии – только нужно было добавить вот этот код:
### Работа с API
Поскольку мне дали много ваучеров для Microsoft Azure, было решено разместить проект именно там. Очень просто оказалось создать приложение на основе Node.js – можно просто использовать репозиторий Git. У Microsoft есть даже пример приложения OneNote API на Node.js, который может сохранять страницы в OneNote – как раз то, что я и хотел использовать.
[github.com/OneNoteDev/OneNoteAPISampleNodejs](https://github.com/OneNoteDev/OneNoteAPISampleNodejs)
Для начала, нужно было получить Client ID с портала [Live app management](http://go.microsoft.com/fwlink/p/?LinkId=193157) и прописать его в файл config.js. Приложение будет работать только с того URL, который прописан в портале, так что рекомендуется прописать домен приложения в файле hosts для тестирования.
В предоставленном Microsoft примере уже содержался самый главный код для авторизации пользователя и отправки примеров – а именно имеется функция, которая отправляет текст заметки, для его использования нужно было сделать несколько вещей:
На странице вошедшего пользователя были размещены кнопки для шаблонов:
```
Save
```
В файле routes/index.js уже был switch-statement обрабатывающий запросы, так что мне нужно было добавить в него мои шаблоны:
```
case 'month':
createExamples.createPageMonth(accessToken, createResultCallback);
break;
```
Затем, в файле lib/create-examples.js создавался сам запрос:
```
this.createPageMonth = function (accessToken, callback)
{
var htmlPayload = fs.readFileSync(path.normalize(__dirname + '/../templates/month.html'), 'utf-8');
createPage(accessToken, htmlPayload, callback, false);
};
```
В функцию сreatePage передавался текст заметки из файла и access token пользователя. Функция создает запрос для API:
```
function createPage(accessToken, payload, callback, multipart) {
var options = {
url: https://www.onenote.com/api/v1.0/pages,
headers: {'Authorization': 'Bearer ' + accessToken}
};
options.headers['Content-Type'] = 'text/html';
options.body = payload;
var r = request.post(options, callback);
}
```
Так, не имея особых познаний в работе с REST API и Node.js, у меня уже было почти готовое приложение. Оставалось последнее…
### Шаблоны
OneNote API имеет поддержку ограниченной части HTML для создания страниц: <https://dev.onenote.com/docs#/introduction/meta-tag-details>
Я пошел немного другим путем: в OneNote API можно так же получить страницы, так что я мог просто создать все шаблоны в OneNote.
Изначально у меня было 8 шаблонов. 4 для организации времени: календарь, еженедельник, ежедневник, список задач в стиле GTD.
4 для демонстрации возможностей Notegram: два шаблона для LA Hacks, планировщик поездок, шаблон для ведения дневника.
Уже после хакатона меня попросили добавить новый шаблон для бухгалтерии, так что на данный момент у меня уже 9 шаблонов.
После создания шаблонов, я использовал сервис [Apigee](https://apigee.com/onenote/embed/console/onenote) для того, чтобы получить код HTML. После авторизации в OneNote API, отправлялся запрос на страницу вида [https://www.onenote.com/api/v1.0/pages/[pageId]/content](https://www.onenote.com/api/v1.0/pages/%5BpageId%5D/content).
### Заключение
После бессонной ночи работы над проектом, у меня получилось рабочее приложение, получившее первое место от Microsoft. Это был удивительный опыт, и я очень благодарен сотрудникам Microsoft, которые помогали участникам с их проектами и очень рад, что их заинтересовал мой проект.
В связи с учебой, у меня было недостаточно времени для работы над проектом, но у меня есть много идей для Notegram:
* Пользовательские шаблоны
* Русская локализация
* Приложение для Windows 10
Notegram доступен прямо сейчас по адресу <http://notegram.me>
### Авторам
Друзья, если вам интересно поддержать колонку своим собственным материалом, то прошу написать мне на [vyunev@microsoft.com](mailto:vyunev@microsoft.com) для того чтобы обсудить все детали. Мы разыскиваем авторов, которые могут интересно рассказать про разработку под Office и другие темы.
### Об авторе
**Дмитрий Конев**
Студент обучается в De Anza College в Калифорнии
Я из Москвы. Не так давно переехал в Кремниевую долину, постигать мир разработчиков и технологий. Долго был пользователем сервисов Microsoft, но только не давно нашел себя в роле разработчика. В последнее время меня интересует веб-разработка, до этого я в основном работал с C++. | https://habr.com/ru/post/270213/ | null | ru | null |
# Еще раз об электронной библиотеке для PocketBook
Приветствую тебя, Хабр!
Данная статейка — всего лишь развернутый комментарий к тексту [«Электронная библиотека для PocketBook: автоматическая обработка»](http://habrahabr.ru/post/143492/) от [dsd\_corp](https://geektimes.ru/users/dsd_corp/), поскольку я, будучи бесплотным (readonly) духом не могу (пока) оставлять обычные комментарии. Впрочем, не буду обсуждать политику Хабра, а перейду к делу.
Во-первых, хочется выразить автору благодарность за его статью. Я узнал много полезного о давно используемом мной PocketBook 360° и привел помойку на нем в относительный порядок. Скрипт, как и обещал автор, оказался переносимым (у меня линукс), если не считать небольшого неудобства с кодировками.
Ниже я просто приведу свои замечания.
1. Директорию, где хранятся собственно книги, лучше поименовать так, чтобы она начиналась с точки. Само устройство следует древней юниксовой традиции «файлы с точки — для заточки» и не показывает их. То есть в скрипте следует изменить `$storagename` на, например, `'.zipstorage'`.
2. Я обнаружил, что имена создаваемых файлов записаны в кодировке cp1251 (неужели в винде до сих пор не перешли на юникод?). Это мне показалось очень неудобным, поэтому я попробовал отредактировать скрипт, чтобы получился кошерный utf8. Вначале наивно сделал
`sed -i 's/windows-1251/utf8/g' *php *.inc`
и т.д., но получилось хреново, поскольку скрипт делает довольно нетривиальные вещи, в частности, понимает, какая исходная кодировка у входных fb2-файлов и грамотно перекодирует. Кроме того, я вижу текст на PHP чуть ли не в первый раз в жизни. Поэтому я вернул всё, как было, и просто делал
`convmv -f cp1251 -t utf8 -r --notest out_dir/dest/`
каждый раз после выполнения скрипта.
3. То, что ссылки по авторам раскладываются слишком глубоко ('Буквы А-Я'/первая буква/три первые буквы/автор) мне показалось неудобным. По крайней мере, когда книг не очень много, это не оправдано. Я придумал как сделать лучше, а именно: сбалансировать дерево, ограничив количество элементов на верхних уровнях, так чтобы они помещались на одной странице (например, это 10 при моих настройках). Тогда путь будет выглядеть как 'Аве-Арц/Аксаков', то есть получится примерно как в именовании томов энциклопедии. В зависимости от количества книг могут понадобиться дополнительные уровни, коих должно быть примерно логарифм от количества авторов. Кажется, такая штука по-научному называется префиксным деревом. Я пока эту фичу не реализовал, а просто укоротил изначальную раскладку до 'первая буква/автор'.
4. Иногда (вероятно, на битых fb2-файлах) скрипт может вести себя неадекватно — зажирает всю память и начинает свопиться. Я не стал заниматься отладкой; вероятно мне проще переписать функционал на более привычном языке, чем разбираться с PHP. Правда, я не уверен, что доберусь хотя бы до этого, тем более что я перегнал почти всю свою библиотеку, и пока всё удовл.
5. Экспериментируя с тем, как работают файлы-ссылки, я не сразу понял, как именно именуются файловые системы с точки зрения устройства. А именно, в /mnt/ext2 монтируется внешняя SD-карта, а внутренняя память — в /mnt/ext1. (Когда я экспериментировал, писал сразу на внутреннюю память, и у меня не работали ссылки с '/mnt/ext2'.) Такое именование довольно контринтуитивно — ext2 вызывает однозначную ассоциацию с названием файловой системы (впрочем, на карте всё равно vfat). Поэтому, применяя скрипт, необходимо помнить, что он готовит файлы именно для первого раздела внешней карты. Иначе в конце нужно сделать как-то так:
`find out_dir/dest/Библиотека -name '*.flk' -exec sed -i 's/ext2/ext1/' '{}' \;`
Также я попробовал использовать относительные, а не абсолютные flk-ссылки, но они, похоже совсем не работают. Если кто знает что-либо по поводу относительных ссылок, пусть поделится.
6. Насчет эффективности копирования. Я не испытал особых проблем (всего-то полтора гига), но есть кое-какие соображения по оптимизации. Во-первых, кажется сомнительной идея зиповать файлы — мы имеем устройство с очень медленным процессором и сравнительно быстрым носителем. Поэтому время открывания файлов может ухудшиться из-за сжатия. Впрочем, здесь необходимы тесты. Во-вторых, для ускорения заливки на карту можно подготовить образ раздела и потом потом скопировать его на карту целиком утилитой dd. Как делать образ раздела на файле я даже почти помню — для этого нужна утилитка losetup, превращающая файл в устройство, на которое можно напустить mkfs и mount.
**UPD**
#### Как копировать образ
В результате работы каталогизатора появляется туча мелких файлов, которые потом долго копируются на файловую систему флешки. Можно попробовать ускорить этот процесс путем создания на диске (или даже на tmpfs, если влезет) копии образа раздела флешки, и потом скопировать весь образ целиком. Польза от этого неочевидна, поскольку в результате придется скопировать байтов, чем если копировать пофайлово. Кроме того, может возрасти ненужная амортизация флешки. Тем не менее, привожу рецепт, годный для любого (не слишком древнего) линукса. (Команды, начинающиеся с диеза требуют рутовских прав, остальные можно делать обычным пользователем.)
1. Во-первых, необходимо узнать точный размер нужного раздела флешки. Допустим, что устройство определилось как /dev/sdc:
`# fdisk -l /dev/sdc
...
Disk /dev/sdc: 4 GB, 4127195136 bytes
64 heads, 32 sectors/track, 3936 cylinders
Units = cylinders of 2048 * 512 = 1048576 bytes
Device Boot Start End Blocks Id System
/dev/sdc1 1 3934 4028400 83 Linux`
Здесь имеем размер раздела 4028400 блоков по 512 байт.
2. Далее, нужно создать файл на диске в точности такого же размера. Поскольку утилита dd имеет опцию bs (размер блока), то нам даже не нужно умножать 4028400 на 512. Впрочем, в данном случае для dd размер блока не играет роли, главное чтобы bs\*count было равно в точности требуемому размеру в байтах.
`$ dd if=/dev/zero of=image bs=512 count=4028400`
3. Создаем файловую систему на полученном файле:
`$ /sbin/mkdosfs image`
4. Монтируем файл-образ как устройство (для этого необходим ядерный модуль loop, который есть в ядрах всех современных дистрибутивов по умолчанию), копируем файлы, отмонтируем:
`$ mkdir mnt
# mount -o loop image mnt
# cp -r ...файлы... mnt
# umount mnt
$ rmdir mnt`
5. Теперь копируем файл-образ на место раздела (важно не ошибиться с именем устройства):
`# dd if=image of=/dev/sdc1`
Готово! Можно подмонтировать флешку и убедиться, что ее содержимое соответствует ожидаемому.
Бывает, что на устройстве есть битые блоки, тогда всё усложняется. В этом случае можно скопировать образ раздела в файл, вместо того чтобы создавать его заново (пункты 1-3):
`# dd if=/dev/sdc1 of=image conv=noerror`
По идее файловая система хранит метаинформацию о своих bad blocks, поэтому мы можем копировать данные на файл-образ, не боясь, что они попадут на BB. Впрочем, я этого не проверял и могу ошибаться.
Высший пилотаж заключается в том, чтобы хранить актуальный образ флешки на домашнем компьютере и иметь утилиту, которая экономично копирует на флешку *разницу* между новым образом и старым. | https://habr.com/ru/post/143847/ | null | ru | null |
# Кунг-фу стиля Linux: упрощение работы с awk
Утилита `awk` — это нечто вроде швейцарского ножа для обработки текстовых файлов. Но некоторые ограничения `awk` порой доставляют неудобства тем, кто этой утилитой пользуется. Я, для того чтобы упростить работу с `awk`, создал несколько функций. Но сразу хочу сказать о том, что для работы этих функций нужны возможности GNU-версии `awk`. Поэтому для того чтобы воспроизвести то, о чём я буду рассказывать, вам совершенно необходимо использовать `gawk` и ничего другого. Возможно, в вашей системе настроено сопоставление `/usr/bin/awk` с чем-то, и это «что-то» может представлять собой `gawk`. Но это может быть и `mawk`, и какая-то другая разновидность `awk`. Если вы используете дистрибутив Linux, основанный на Debian, то знайте, что команда `update-alternatives` — это ваш хороший друг. В данном материале я буду исходить из предположения о том, что его читатель использует `gawk`.
[](https://habr.com/ru/company/ruvds/blog/527244/)
После того, как вы прочитаете эту статью, вы узнаете о том, как пользоваться моей библиотекой дополнительных [функций](https://github.com/wd5gnr/awkparse) для `awk`. А именно, речь идёт о разделении строки на поля даже в условиях, когда не существует единого символа, используемого для разделения полей. Кроме того, вы сможете обращаться к полям, используя выбранные вами имена. Например, вам не придётся помнить о том, что `$2` — это поле, содержащее сведения о времени. Вместо этого можно будет просто воспользоваться конструкцией наподобие `Fields_fields[«time»]`.
**Все переводы серии**
[Кунг-фу стиля Linux: удобная работа с файлами по SSH](https://habr.com/ru/company/ruvds/blog/520752/)
[Кунг-фу стиля Linux: мониторинг дисковой подсистемы](https://habr.com/ru/company/ruvds/blog/527238/)
[Кунг-фу стиля Linux: глобальный поиск и замена строк с помощью ripgrep](https://habr.com/ru/company/ruvds/blog/527242/)
[Кунг-фу стиля Linux: упрощение работы с awk](https://habr.com/ru/company/ruvds/blog/527244/)
[Кунг-фу стиля Linux: наблюдение за файловой системой](https://habr.com/ru/company/ruvds/blog/528422/)
[Кунг-фу стиля Linux: наблюдение за файлами](https://habr.com/ru/company/ruvds/blog/528430/)
[Кунг-фу стиля Linux: удобный доступ к справке при работе с bash](https://habr.com/ru/company/ruvds/blog/528432/)
[Кунг-фу стиля Linux: великая сила make](https://habr.com/ru/company/ruvds/blog/528434/)
[Кунг-фу стиля Linux: устранение неполадок в работе incron](https://habr.com/ru/company/ruvds/blog/529828/)
[Кунг-фу стиля Linux: расшаривание терминала в браузере](https://habr.com/ru/company/ruvds/blog/529836/)
[Кунг-фу стиля Linux: синхронизация настроек](https://habr.com/ru/company/ruvds/blog/531088/)
[Кунг-фу стиля Linux: бесплатный VPN по SSH](https://habr.com/ru/company/ruvds/blog/530944/)
[Кунг-фу стиля Linux: превращение веб-приложений в полноценные программы](https://habr.com/ru/company/ruvds/blog/529838/)
[Кунг-фу стиля Linux: утилита marker и меню для командной строки](https://habr.com/ru/company/ruvds/blog/529840/)
[Кунг-фу стиля Linux: sudo и поворот двух ключей](https://habr.com/ru/company/ruvds/blog/532334/)
[Кунг-фу стиля Linux: программное управление окнами](https://habr.com/ru/company/ruvds/blog/532342/)
[Кунг-фу стиля Linux: организация работы программ после выхода из системы](https://habr.com/ru/company/ruvds/blog/533336/)
[Кунг-фу стиля Linux: регулярные выражения](https://habr.com/ru/company/ruvds/blog/533334/)
[Кунг-фу стиля Linux: запуск команд](https://habr.com/ru/company/ruvds/blog/536958/)
[Кунг-фу стиля Linux: разбираемся с последовательными портами](https://habr.com/ru/company/ruvds/blog/544512/)
[Кунг-фу стиля Linux: базы данных — это файловые системы нового уровня](https://habr.com/ru/company/ruvds/blog/568302/)
[Кунг-фу стиля Linux: о повторении кое-каких событий сетевой истории](https://habr.com/ru/company/ruvds/blog/568308/)
[Кунг-фу стиля Linux: PDF для пингвинов](https://habr.com/ru/company/ruvds/blog/567158/)
Проблема awk
------------
Утилита `awk` берёт на себя решение множества стандартных задач обработки текстовых файлов. Она читает файлы, считывая по одной записи за раз. Обычно «запись» — это одна строка. Затем `awk` разбивает строку на поля, ориентируясь на пробелы или на другие символы, используемые в качестве разделителей полей. Можно написать код, который что-то делает со считанной строкой или с отдельными полями. Эти стандартные возможности `awk` хорошо подходят для решения многих задач, особенно учитывая то, что можно настраивать разделители полей и признак конца записи. Такому формату соответствует удивительно большое количество файлов.
Правда, так устроены далеко не все файлы. Если нужно работать с данными из каких-нибудь логов или из баз данных, такие данные могут быть отформатированы с использованием самых разных подходов. Например, в некоторых полях могут присутствовать структурированные данные, при оформлении которых используются различные разделители. Это, конечно, не значит, что такие данные нельзя обработать с помощью `awk`. Так как в нашем распоряжении оказывается вся строка, с этой строкой можно сделать всё, что нужно. Но при обработке подобных строк усложняется логика программы. А главная цель использования `awk` — это упрощение работы.
Например, предположим, что у нас имеется файл с данными, полученный с некоего устройства. В его строках имеется восьмизначный серийный номер, за которым следует тег длиной в шесть символов. Потом идут два числа с плавающей точкой, разделённые неким разделителем. Шаблон записи может выглядеть так:
```
^([0-9]{8})([a-zA-Z0-9]{6})([-+.0-9]+),([-+.0-9]+)$
```
Подобные записи будет непросто разделить на поля с использованием стандартных возможностей `awk`. Поэтому для разбора подобных записей приходится писать код самостоятельно.
Если в записях файла имеются единообразно оформленные поля, но при этом неизвестно их точное количество, тогда, возможно, имеет смысл воспользоваться `FS` или `FPAT`. [Вот](https://hackaday.com/2016/07/13/gawking-hex-files/) материал, в котором идёт речь об использовании `FPAT` при обработке HEX-файлов с помощью `awk`. В рассматриваемой библиотеке применяется немного другой подход. Её можно использовать для полного разбора строки на составные части. Например, часть строки может представлять собой поле фиксированной длины, после чего могут идти поля, для оформления которых используется множество различных разделителей. С помощью других методов обрабатывать подобные данные может быть довольно-таки непросто.
Регулярные выражения
--------------------
Расскажу о функции `gawk` `match`. Эта функция, конечно, имеется и в обычном `awk`, но её возможности в `gawk` расширены, что упрощает её использование. Обычно эта функция выполняет поиск в строках с использованием регулярного выражения. Она сообщает о том, где начинается фрагмент строки, соответствующий регулярному выражению (если совпадение найдено), и о том, сколько именно символов строки соответствуют регулярному выражению.
В `gawk` этой функции можно передать дополнительный аргумент, представляющий собой массив. В него попадут некоторые сведения о результатах поиска. В частности, в нулевой элемент массива попадёт весь фрагмент строки, соответствующий регулярному выражению. Если регулярное выражение содержит, в круглых скобках, подвыражения, то они попадут в массив, пронумерованные в соответствии с порядком следования скобок. В массиве будут сведения о начале и о длине совпадений.
Например, пусть регулярное выражение выглядит так:
```
"^([0-9]+)([a-z]+)$"
```
Обрабатываемая строка выглядит так:
```
123abc
```
Массив будет содержать следующие данные:
```
array[0] - 123abc
array[1] - 123
array[2] - abc
array[0start] - 1
array[0length] - 6
array[1start] - 1
array[1length] - 3
array[2start] - 4
array[2length] - 3
```
Можно даже использовать вложенные выражения. Так, например, регулярное выражение вида `«^(([xyz])[0-9]+)([a-z]+)$»` при анализе строки `z1x` даст `array[1]=z1`, `array[2]=z` и `array[3]=x`.
Теория и практика
-----------------
В теории это — всё, что нужно. Можно писать регулярные выражения для разбора строк, а потом обращаться к отдельным элементам строки, пользуясь массивом. На практике же гораздо удобнее будет, если все подготовительные процедуры будут проведены заранее, что позволит работать с данными, используя обычные имена.
Вот пример строки, которую может понадобиться обработать:
```
11/10/2020 07:00 The Best of Bradbury, 14.95 *****
```
Здесь имеется дата в формате, принятом в США, время в 24-часовом формате, название товара, цена и рейтинг товара, который может выглядеть как последовательность из 1-5 звёздочек и, кроме того, может отсутствовать. Написание регулярного выражения, способного выделить из этой строки каждое интересующее нас поле, будет достаточно сложной, но решаемой задачей. Вот один из вариантов такого регулярного выражения:
```
"^(([01][0-9])/([0-3][0-9])/(2[01][0-9][0-9]))[[:space:]]*(([0-2][0-9]):([0-5][0-9]))[[:space:]]+([^,]+),[[:space:]]*([0-9.]+)[[:space:]]*([*]{1,5})?[[:space:]]*$"
```
Выглядит всё это, конечно, не очень, но с решением задачи справляется. Обратите внимание на то, что каждый интересующий нас элемент заключён в круглые скобки, и на то, что некоторые из таких конструкций вложены друг в друга. В результате, например, дата — это поле, но месяц, день и год — это тоже поля.
Библиотека, облегчающая работу с gawk
-------------------------------------
После того, как вы скачали файлы с [GitHub](https://github.com/wd5gnr/awkparse), вы можете поместить функции с именами вида `fields_*` в свой код. В блоке `BEGIN` нужно выполнить некоторые настройки. Затем строки обрабатывают с помощью функции `fields_process`. Вот небольшой пример использования моей библиотеки (код самих функций из библиотеки опущен):
```
BEGIN {
fields_setup("^(([01][0-9])/([0-3][0-9])/(2[01][0-9][0-9]))[[:space:]]*(([0-2][0-9]):([0-5][0-9]))[[:space:]]+([^,]+), [[:space:]]*([0-9.]+)[[:space:]]*([*]{1,5})?[[:space:]]*$")
fields_setupN(1,"date")
fields_setupN(2,"month")
fields_setupN(3,"day")
fields_setupN(4,"year")
fields_setupN(5,"time")
fields_setupN(6,"hours")
fields_setupN(7,"minutes")
fields_setupN(8,"item")
fields_setupN(9,"price")
fields_setupN(10,"star")
}
{
v=fields_process()
... тут будет ваш код...
}
```
В своём коде для обработки вышеприведённой строки вы можете воспользоваться, например, такой конструкцией:
```
cost=Fields_fields["price"] * 3
```
Как по мне, так это сильно упрощает работу. Функция `fields_process` возвращает `false` в том случае, если ей ничего не удалось найти. При этом, если нужно, можно работать с обычными awk-полями вроде `$0` или `$2`.
Об устройстве предлагаемых функций
----------------------------------
Мои функции основаны на двух механизмах. Во-первых — это gawk-расширение функции `match`. Во-вторых — это механизм ассоциативных массивов `awk`. Ранее я добавил именованные ключи к существующему массиву найденных совпадений. Поэтому к данным можно обращаться любым способом. Но я модифицировал массив, поэтому он является локальным, так как мне почти никогда не нужна эта возможность, и, таким образом, если понадобятся все данные из массива, нужно будет отфильтровать из него все дополнительные поля.
Часто имеет смысл начинать регулярное выражение с символа `^` и заканчивать символом `$` для того чтобы ориентироваться на обработку всей строки. Главное — не забывать о том, что регулярное выражение должно, как в примере, учитывать использование пробелов. Это часто бывает нужно в том случае, когда имеются поля, которые могут содержать пробелы. Но если надо, чтобы пробелы, в любом случае, играли роль символов-разделителей полей, то вам, возможно, лучше использовать стандартную схему разбора строк.
Ещё один интересный приём заключается в получении «остатка строки» — всего того, что осталось после обработки первых полей. Сделать это можно, добавив в конец регулярного выражения конструкцию `«(.*)$»`. Главное — не забудьте задать тег для этой конструкции, используя `fields_setupN`, что позже позволит обратиться к этим данным.
К моей библиотеке можно добавить простое расширение, которое превращает шаблон в массив шаблонов. Функция обработки строк может перебирать и испытывать элементы массива до тех пор, пока не найдёт совпадение с одним из них. Затем функция возвращает индекс сработавшего шаблона или `false` — в том случае, если не найдено совпадения ни с одним шаблоном. Вероятно, при таком подходе нужно будет предусмотреть использование различных наборов тегов полей для каждого из шаблонов.
Пользуетесь ли вы `gawk`? Планируете ли применять функции, предложенные автором этого материала?
**Все переводы серии**
[Кунг-фу стиля Linux: удобная работа с файлами по SSH](https://habr.com/ru/company/ruvds/blog/520752/)
[Кунг-фу стиля Linux: мониторинг дисковой подсистемы](https://habr.com/ru/company/ruvds/blog/527238/)
[Кунг-фу стиля Linux: глобальный поиск и замена строк с помощью ripgrep](https://habr.com/ru/company/ruvds/blog/527242/)
[Кунг-фу стиля Linux: упрощение работы с awk](https://habr.com/ru/company/ruvds/blog/527244/)
[Кунг-фу стиля Linux: наблюдение за файловой системой](https://habr.com/ru/company/ruvds/blog/528422/)
[Кунг-фу стиля Linux: наблюдение за файлами](https://habr.com/ru/company/ruvds/blog/528430/)
[Кунг-фу стиля Linux: удобный доступ к справке при работе с bash](https://habr.com/ru/company/ruvds/blog/528432/)
[Кунг-фу стиля Linux: великая сила make](https://habr.com/ru/company/ruvds/blog/528434/)
[Кунг-фу стиля Linux: устранение неполадок в работе incron](https://habr.com/ru/company/ruvds/blog/529828/)
[Кунг-фу стиля Linux: расшаривание терминала в браузере](https://habr.com/ru/company/ruvds/blog/529836/)
[Кунг-фу стиля Linux: синхронизация настроек](https://habr.com/ru/company/ruvds/blog/531088/)
[Кунг-фу стиля Linux: бесплатный VPN по SSH](https://habr.com/ru/company/ruvds/blog/530944/)
[Кунг-фу стиля Linux: превращение веб-приложений в полноценные программы](https://habr.com/ru/company/ruvds/blog/529838/)
[Кунг-фу стиля Linux: утилита marker и меню для командной строки](https://habr.com/ru/company/ruvds/blog/529840/)
[Кунг-фу стиля Linux: sudo и поворот двух ключей](https://habr.com/ru/company/ruvds/blog/532334/)
[Кунг-фу стиля Linux: программное управление окнами](https://habr.com/ru/company/ruvds/blog/532342/)
[Кунг-фу стиля Linux: организация работы программ после выхода из системы](https://habr.com/ru/company/ruvds/blog/533336/)
[Кунг-фу стиля Linux: регулярные выражения](https://habr.com/ru/company/ruvds/blog/533334/)
[Кунг-фу стиля Linux: запуск команд](https://habr.com/ru/company/ruvds/blog/536958/)
[Кунг-фу стиля Linux: разбираемся с последовательными портами](https://habr.com/ru/company/ruvds/blog/544512/)
[Кунг-фу стиля Linux: базы данных — это файловые системы нового уровня](https://habr.com/ru/company/ruvds/blog/568302/)
[Кунг-фу стиля Linux: о повторении кое-каких событий сетевой истории](https://habr.com/ru/company/ruvds/blog/568308/)
[Кунг-фу стиля Linux: PDF для пингвинов](https://habr.com/ru/company/ruvds/blog/567158/)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=kung-fu_stilya_linux_uproshhenie_raboty_s_awk#order)
[](http://ruvds.com/ru-rub/news/read/123?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=kung-fu_stilya_linux_uproshhenie_raboty_s_awk) | https://habr.com/ru/post/527244/ | null | ru | null |
# Возможности Java 17 и рекомендации по миграции
#### Java значительно изменилась с годами. Прочтите сравнение версий 8 и 17 и узнайте ответ на вопрос: стоит ли обновляться?
Через несколько месяцев, в марте 2022 года, Java 8 закончится поддержка Oracle Premier Support. Это не означает, что он не будет получать никаких новых обновлений, но усилия Oracle, вложенные в его поддержку, вероятно, будут значительно меньше, чем сейчас.
Это означает, что будет веская причина для перехода на новую версию, тем более, что 14 сентября 2021 года была выпущена Java 17. Это новая версия долгосрочной поддержки, с Oracle Premier Support, которая продлится до [сентября 2026 года](https://www.oracle.com/java/technologies/java-se-support-roadmap.html) (как минимум).
Что дает Java 17? Насколько трудной будет миграция? Стоит ли оно того? Я постараюсь ответить на эти вопросы в этой статье.
### Популярность Java 8: немного истории
Java 8, выпущенная в марте 2014 года, в [настоящее время используется 69% программистов](https://www.jrebel.com/blog/2021-java-technology-report) в своем основном приложении. Почему по прошествии более 7 лет это все еще самая распространенная версия? На то есть много причин.
Java 8 предоставила множество языковых функций, которые заставили разработчиков захотеть перейти с предыдущих версий: Lambdas, потоки, функциональное программирование, обширные расширения API - не говоря уже о расширениях MetaSpace или G1. Эту версию Java стоило использовать.
Java 9 появилась 3 года спустя, в сентябре 2017 года, и для типичного разработчика она практически ничего не изменила: новый HTTP-клиент, API процессов, незначительный diamond оператор и улучшения в методе try-with-resources.
Фактически, Java 9 действительно внесла одно существенное изменение - новаторский [проект Jigsaw](https://openjdk.java.net/projects/jigsaw/). Java сильно изменилась, многое изменилось - но *внутренне*.
Модульность Java дает большие возможности, позволяет решать множество технических проблем и применима ко всем, но действительно необходима только относительно небольшой группе пользователей, глубоко понимающих изменения.
Из-за изменений, внесенных в Jigsaw Project, многие библиотеки потребовали дополнительных доработок, были выпущены новые версии, некоторые из них не работали должным образом.
Миграция на Java 9 - в частности, для крупных корпоративных приложений - часто была сложной, трудоемкой и вызывала проблемы регрессии. Так зачем же это делать, если выгоды мало, а это стоит много времени и денег?
Это подводит нас к сегодняшнему дню, октябрю 2021 года. Java Development Kit 17 (JDK 17) был выпущен всего месяц назад. Не пора ли отказаться от Java 8 7-летней давности? Во-первых, давайте посмотрим, что есть в Java 17. Что это дает программисту и администратору или SRE по сравнению с Java 8?
### Java 17 против Java 8: изменения
В этой статье рассматриваются только те изменения, которые я считаю достаточно важными или интересными, чтобы упомянуть их. Это не включает все, что было изменено, улучшено, оптимизировано за все годы развития Java. Если вы хотите увидеть полный список изменений в JDK, вы должны знать, что они отслеживаются как JEP (предложения по расширению JDK). Список можно найти в [JEP-0](https://openjdk.java.net/jeps/0).
Кроме того, если вы хотите сравнить Java API между версиями, есть отличный инструмент под названием [Java Version Almanac](https://javaalmanac.io/). Было много полезных небольших дополнений к Java API, и посещение этого веб-сайта, вероятно, лучший вариант, если кто-то хочет узнать обо всех этих изменениях.
А пока давайте проанализируем изменения и новые функции в каждой итерации Java, которые наиболее важны с точки зрения большинства из нас, разработчиков Java.
#### Новое ключевое слово var
Было добавлено новое ключевое слово *var,* которое позволяет более кратко объявлять локальные переменные. Рассмотрим этот код:
```
// java 8 способ
Map> myMap = new HashMap>();
List myList = aDelegate.fetchDomainObjects();
// java 10 способ
var myMap = new HashMap>();
var myList = aDelegate.fetchDomainObjects()
```
При использовании var объявление становится намного короче и, возможно, немного более читаемым, чем раньше. Сначала необходимо принять во внимание удобочитаемость, поэтому в некоторых случаях может быть неправильно скрывать тип от программиста. Позаботьтесь о том, чтобы правильно назвать переменные.
К сожалению, с помощью ключевого слова *var* нельзя присвоить значение лямбда переменной:
```
var fun = MyObject::mySpecialFunction;
// вызывает ошибку компиляции: (method reference needs an explicit target-type)
```
Однако можно использовать *var* в лямбда-выражениях. Взгляните на пример ниже:
```
boolean isThereAneedle = stringsList.stream()
.anyMatch((@NonNull var s) -> s.equals(“needle”));
```
Используя *var* в лямбда-аргументах, мы можем добавлять аннотации к аргументам.
#### Records
Можно сказать, что Records (записи) - это ответ Java на Lombok. По крайней мере, частично. Запись - это тип, предназначенный для хранения некоторых данных. Позвольте мне процитировать фрагмент [JEP 395,](https://openjdk.java.net/jeps/395) который хорошо их описывает:
*[…] Запись автоматически получает множество стандартных членов:*
* *Private final поле для каждого компонента описания состояния;*
* *Public метод доступа для чтения для каждого компонента описания состояния с тем же именем и типом, что и компонент;*
* *Public конструктор, сигнатура которого совпадает с описанием состояния, который инициализирует каждое поле из соответствующего аргумента;*
* *Реализации equals и hashCode, которые говорят, что две записи равны, если они одного типа и содержат одно и то же состояние; а также*
* *Реализацию toString, которая включает строковое представление всех компонентов записи с их именами.*
Другими словами, это примерно эквивалент @Value Lombok. С точки зрения языка это похоже на enum. Однако вместо объявления возможных значений вы объявляете поля. Java генерирует некоторый код на основе этого объявления и может обрабатывать его более оптимизированным способом. Как и enum, он не может расширяться или расширяться другими классами, но может реализовывать интерфейс и иметь статические поля и методы. В отличие от enum, запись может быть создана с помощью ключевого слова new.
Запись может выглядеть так:
```
record BankAccount(String bankName, String accountNumber) implements HasAccountNumber {}
```
Вот и все: довольно коротко. Коротко - это хорошо!
Любые автоматически сгенерированные методы могут быть объявлены программистом вручную. Также можно объявить набор конструкторов. Более того, в конструкторах все поля, которые *явно не* присвоены, неявно назначаются соответствующим параметрам конструктора. Это означает, что присвоение можно полностью пропустить в конструкторе!
```
record BankAccount(String bankName, String accountNumber) implements HasAccountNumber {
public BankAccount { // <-- это конструктор! нет () !
if (accountNumber == null || accountNumber.length() != 26) {
throw new ValidationException(“Account number invalid”);
}
// здесь нет необходимости в присвоении!
}
}
```
Для получения всех подробностей, таких как формальная грамматика, примечания по использованию и реализации, обязательно обратитесь к [JEP 359](https://openjdk.java.net/jeps/359). Вы также можете посмотреть StackOverflow на самые популярные [вопросы о Java Records](https://stackoverflow.com/questions/tagged/java-record?tab=Votes).
#### Расширенные Switch выражения
*Switch* присутствует на многих языках, но с годами он становился все менее и менее полезным из-за имеющихся у него ограничений. Остальные части Java выросли, *switch -* нет. В настоящее время case ветви *Switch* могут быть сгруппированы намного проще и более читаемым образом (обратите внимание, что нет никакого break!), а само *Switch* выражение фактически возвращает результат.
```
DayOfWeek dayOfWeek = LocalDate.now().getDayOfWeek();
boolean freeDay = switch (dayOfWeek) {
case MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY -> false;
case SATURDAY, SUNDAY -> true;
};
```
Еще большего можно достичь с помощью нового ключевого слова *yield,* которое позволяет возвращать значение из блока кода. Это фактически *return,* который работает внутри case блока и устанавливает значение как результат выполения *switch*. Он также может принимать выражение вместо одного значения. Давайте посмотрим на пример:
```
DayOfWeek dayOfWeek = LocalDate.now().getDayOfWeek();
boolean freeDay = switch (dayOfWeek) {
case MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY -> {
System.out.println("Work work work");
yield false;
}
case SATURDAY, SUNDAY -> {
System.out.println("Yey, a free day!");
yield true;
}
};
```
#### Сопоставление с образцом Instanceof
На мой взгляд, *instanceof* не является революционным изменением, но решает одну из вызывающий наибольшее раздражение проблем языка Java. Вам когда-нибудь приходилось использовать такой синтаксис?
```
if (obj instanceof MyObject) {
MyObject myObject = (MyObject) obj;
// … дальнейшая логика
}
```
Теперь вам не придется это писать. Теперь Java может создать локальную переменную внутри *if*, например:
```
if (obj instanceof MyObject myObject) {
// … та же логика
}
```
Всего лишь одна строка удалена, но это была совершенно ненужная строка с точки зрения потока кода. Более того, объявленную переменную можно использовать в том же *условии if*, например:
```
if (obj instanceof MyObject myObject && myObject.isValid()) {
// … та же логика
}
```
#### Sealed классы
Это сложно объяснить. Начнем с этого: раздражало ли вас когда-нибудь предупреждение «no default» в *switch*? Вы рассмотрели все варианты, которые поддерживал домен, но, тем не менее, получали предупреждение. Sealed (запечатанные) классы позволяют избавиться от такого предупреждения при проверке типа *instanceof*.
Если у вас есть такая иерархия:
```
public abstract sealed class Animal
permits Dog, Cat {
}
public final class Dog extends Animal {
}
public final class Cat extends Animal {
}
You will now be able to do this:
if (animal instanceof Dog d) {
return d.woof();
}
else if (animal instanceof Cat c) {
return c.meow();
}
```
. . . вы не получите предупреждения. Что ж, позвольте мне перефразировать это: если вы получите предупреждение с аналогичной последовательностью, это предупреждение будет *осмысленным*! Больше информации всегда хорошо.
У меня смешанные чувства по поводу этого изменения. Введение циклической ссылки не кажется хорошей практикой. Если бы я использовал это в своем производственном коде, я бы сделал все возможное, чтобы спрятать это где-нибудь глубоко и никогда не показывать внешнему миру. Я имею в виду, что я бы никогда не раскрыл его через API, не то чтобы мне было бы стыдно использовать его в допустимой ситуации.
#### TextBlocks
Объявление длинных строк не часто происходит в программировании на Java, но когда это происходит, это утомительно и сбивает с толку. В Java 13 это было исправлено и в более поздних выпусках улучшено. Многострочный текстовый блок теперь можно объявить следующим образом:
```
String myWallOfText = ”””
______ _ _
| ___ \ | | (_)
| |_/ / __ ___| |_ _ _ _ ___
| __/ '__/ _ \ __| | | | / __|
| | | | | __/ |_| | |_| \__ \
\_| |_| \___|\__|_|\__,_|___/
”””
```
Нет необходимости в экранировании кавычек или новых строк. Можно избежать символа новой строки и оставить строку однострочной, например:
```
String myPoem = ”””
Roses are red, violets are blue - \
Pretius makes the best software, that is always true
”””
```
эквивалентно:
```
String myPoem = ”Roses are red, violets are blue - Pretius makes the best software, that still is true”.
```
Текстовые блоки можно использовать для сохранения в коде разумно читаемого шаблона JSON или XML. Внешние файлы по-прежнему, вероятно, лучше, но все же хороший вариант сделать это на чистой Java, если это необходимо.
#### Улучшенные NullPointerExceptions
Однажды в моем приложении была такая цепочка вызовов, и я думаю, она вам тоже может показаться знакомой:
```
company.getOwner().getAddress().getCity();
```
Я получил NPE, который точно сказал мне, в какой строке был обнаружен null. Да, это была эта строка. Без отладчика я не мог бы сказать, какой объект был null, или, скорее, какая операция вызова на самом деле вызвала проблему. Теперь сообщение будет конкретным, и в нем будет сказано, что JVM «не может вызвать Person.getAddress()».
Фактически, это скорее изменение JVM, чем изменение Java, поскольку анализ байт-кода для построения подробного сообщения выполняется во время выполнения JVM; но это очень нравится программистам.
#### Новый HttpClient
Есть много библиотек, которые делают то же самое, но хорошо иметь правильный HTTP-клиент в самой Java. Вы можете найти хорошее введение в новые API на сайте [Baeldung](https://www.baeldung.com/java-9-http-client).
#### Новый метод Optional.orElseThrow()
Для Optional метод *Get()* используется для получения значения в соответствии со значением Optional. Если значение отсутствует, этот метод вызывает исключение, как показано в приведенном ниже коде:
```
MyObject myObject = myList.stream()
.filter(MyObject::someBoolean)
.filter((b) -> false)
.findFirst()
.get();
```
В Java 10 появился новый метод в Optional, называемый *orElseThrow()*. Что он делает? Точно то же! Однако рассмотрите эту возможность с позици изменения удобочитаемости для программиста.
```
MyObject myObject = myList.stream()
.filter(MyObject::someBoolean)
.filter((b) -> false)
.findFirst()
.orElseThrow();
```
Теперь программист точно знает, что произойдет, если объект не будет найден. Фактически, рекомендуется использовать этот метод вместо простого (хотя и повсеместного) *get()*.
#### Другие небольшие, но приятные изменения API
Разговор не дорого стоит. Вот код, в котором Вы можете увидеть новые вещи в строках 3, 7, 8, 9, 10, 14, 18 и 19.
```
// инвертировав предикат, будет еще короче со статическим импортом
collection.stream()
.filter(Predicate.not(MyObject::isEmpty))
.collect(Collectors.toList());
// String тоже получила кое-что новое
“\nPretius\n rules\n all!”.repeat(10).lines().
.filter(Predictions.not(String::isBlank))
.map(String::strip)
.map(s -> s.indent(2))
.collect(Collectors.toList());
// нет необходимости передавать экземпляр массива в качестве аргумента
String[] myArray= aList.toArray(String[]::new);
// читать и писать файлы быстро!
// не забудьте отловить все возможные исключения
Path path = Files.writeString(myFile, "Pretius Rules All !");
String fileContent = Files.readString(path);
// .toList() в stream()
String[] arr={"a", "b", "c"};
var list = Arrays.stream(arr).toList();
```
#### Проект Jigsaw
Project [Jigsaw из](https://openjdk.java.net/projects/jigsaw/) JDK 9 значительно изменил внутреннее устройство JVM. Он изменил как [JLS, так](https://cr.openjdk.java.net/~mr/jigsaw/spec/java-se-9-jls-diffs.pdf) и [JVMS](https://cr.openjdk.java.net/~mr/jigsaw/spec/java-se-9-jvms-diffs.pdf), добавил несколько JEP (список доступен по ссылке выше на Project Jigsaw) и, что наиболее важно, внес некоторые критические изменения, несовместимые с предыдущими версиями Java.
[Модули Java 9](https://www.jrebel.com/blog/java-9-modules-cheat-sheet) были представлены как дополнительный, самый высокий уровень организации jar и классов. По этой теме много вводного контента, например, этот на сайте [Baeldung](https://www.baeldung.com/project-jigsaw-java-modularity) или эти слайды от [Юичи Сакурабы](https://www.slideshare.net/skrb/introduction-of-project-jigsaw).
Выигрыш был значительным, хотя и не видимым невооруженным глазом. Так называемого [JAR-ада](https://en.wikipedia.org/wiki/Java_Classloader#JAR_hell) больше нет (ты сталкивался с этим? Я да… и это был действительно ад), хотя [ад модулей](https://nipafx.dev/will-there-be-module-hell/) теперь тоже возможен.
С точки зрения типичного программиста, эти изменения теперь почти незаметны. Каким-то образом могут быть затронуты только самые большие и самые сложные проекты. Новые версии практически всех часто используемых библиотек придерживаются новых правил и учитывают их внутри компании.
#### Сборщики мусора
Начиная с Java 9, G1 является сборщиком мусора по умолчанию. Он сокращает время задержки по сравнению с параллельным сборщиком мусора, хотя в целом может иметь меньшую пропускную способность. Он претерпел некоторые изменения с тех пор, как он был установлен по умолчанию, включая возможность возвращать неиспользуемую выделенную память в ОС ([JEP 346](https://openjdk.java.net/jeps/346)).
Сборщик мусора ZGC был представлен в Java 11 и достиг состояния продукта в Java 15 ([JEP 377](https://openjdk.java.net/jeps/377)). Его цель - еще больше сократить паузы. Начиная с Java 13, он также способен возвращать в ОС неиспользованную выделенную память ([JEP 351](https://openjdk.java.net/jeps/351)).
Сборщик мусора Shenandoah был представлен в JDK 14 и достиг состояния продукта в Java 15 ([JEP 379](https://openjdk.java.net/jeps/379)). Он направлен на то, чтобы время паузы было небольшим и не зависело от размера кучи.
Я рекомендую прочитать отличную серию статей [Марко Топольника, в](https://jet-start.sh/blog/2020/06/09/jdk-gc-benchmarks-part1) которой сравниваются GC.
Обратите внимание, что в Java 8 у вас было гораздо меньше вариантов, и если вы не меняли свой GC вручную, вы все равно использовали Parallel GC. Простое переключение на Java 17 может привести к тому, что ваше приложение будет работать быстрее и иметь более консистентное время выполнения методов. Переход на недоступные в то время ZGC или Shenandoah может дать еще лучшие результаты.
Наконец, появился новый сборщик мусора No-Op Garbage Collector ([JEP 318](https://openjdk.java.net/jeps/318)), хотя это экспериментальная функция. Этот сборщик мусора фактически не выполняет никакой работы, что позволяет вам точно измерить использование памяти вашим приложением. Это полезно, если вы хотите, чтобы нагрузка операций с памятью была как можно ниже.
Если вы хотите узнать больше о доступных вариантах, я рекомендую прочитать отличную серию статей [Марко Топольника, в](https://jet-start.sh/blog/2020/06/09/jdk-gc-benchmarks-part1) которой сравниваются GC.
#### Осведомленность о контейнерах
Возможно вы не знали, что было время, когда Java не подозревала, что работает в контейнере. Она не учитывала ограничения памяти контейнера и вместо этого считывала размер доступной системной памяти. Итак, когда у вас был компьютер с 16 ГБ ОЗУ, максимальный объем памяти вашего контейнера был установлен на 1 ГБ и на нем работало приложение Java, тогда приложение часто отказывало, поскольку оно пыталось выделить больше памяти, чем было доступно в контейнере. Хорошая [статья Карлоса Санчеса](https://blog.csanchez.org/2017/05/31/running-a-jvm-in-a-container-without-getting-killed/) объясняет это более подробно.
Эти проблемы остались в прошлом. Начиная с Java 10, [интеграция](https://www.docker.com/blog/improved-docker-container-integration-with-java-10/) с [контейнерами](https://www.docker.com/blog/improved-docker-container-integration-with-java-10/) включена по умолчанию. Однако для вас это может быть незаметным улучшением, поскольку такое же изменение было внесено в обновление Java 8 131, хотя для этого потребовалось включить экспериментальные параметры и использовать *-XX: + UseCGroupMemoryLimitForHeap*.
PS: Рекомендуется указывать максимальный объем памяти для Java с *помощью параметра -Xmx*. В таких случаях проблема не возникает.
#### CDS архивы
Чтобы ускорить запуск JVM, архивы CDS претерпели некоторые изменения за время, прошедшее с момента выпуска Java 8. Начиная с JDK 12, создание архивов CDS в процессе сборки включено по умолчанию ([JEP 341](https://openjdk.java.net/jeps/341)). Усовершенствование в JDK 13 ([JEP 350](https://openjdk.java.net/jeps/350)) позволило обновлять архивы после каждого запуска приложения.
В отличной [статье Николая Парлога](https://nipafx.dev/java-application-class-data-sharing/) показано, как использовать эту функцию для [сокращения](https://nipafx.dev/java-application-class-data-sharing/) времени запуска вашего приложения.
#### Java Flight Recorder и Java Mission Control
Java Flight Recorder ([JEP 328](https://openjdk.java.net/jeps/328)) позволяет отслеживать и профилировать работающее Java-приложение при низких затратах на производительность (целевой 1%). [Java Mission Control](https://wiki.openjdk.java.net/display/jmc/Main) позволяет принимать и визуализировать данные JFR. См. [Руководство Baeldung,](https://www.baeldung.com/java-flight-recorder-monitoring) чтобы получить общее представление о том, как его использовать и что от него можно получить.
### Стоит ли переходить с Java 8 на Java 17?
Коротко говоря, да, вам следует. Если у вас есть большое корпоративное приложение с высокой нагрузкой, и вы по-прежнему используете Java 8, вы обязательно увидите лучшую производительность, более быстрое время запуска и меньший объем памяти после миграции. Программисты, работающие над этим приложением, тоже должны быть счастливы, поскольку в сам язык внесено множество улучшений.
Стоимость этого, однако, трудно оценить и сильно варьируется в зависимости от используемых серверов приложений, библиотек и сложности самого приложения (или, скорее, количества низкоуровневых функций, которые оно использует/повторно реализует).
Если ваши приложения представляют собой микросервисы, вполне вероятно, что все, что вам нужно сделать, это изменить базовый образ докера на 17-alpine, версию кода в Maven на 17, и все будет работать нормально. Некоторые [обновления фреймворков или библиотек](https://www.endpoint.com/blog/2020/06/why-upgrading-software-libraries-is-imperative/) могут пригодиться (но вы все равно делаете их периодически, верно?).
К настоящему времени все популярные серверы и фреймворки имеют поддержку Java 9's Jigsaw Project. Это производственный уровень, он был тщательно протестирован и исправлен на протяжении многих лет. Многие продукты предлагают руководства по миграции или, по крайней мере, подробные примечания к выпуску для версии, совместимой с Java 9. См. [Красивую статью OSGI](https://blog.osgi.org/2018/02/osgi-r7-highlights-java-9-support.html) или некоторые [примечания к выпуску Wildfly 15, в которых](https://www.wildfly.org/news/2018/12/13/WildFly15-Final-Released/) упоминается поддержка модулей.
Если вы используете Spring Boot в качестве фреймворка, есть несколько статей с советами по миграции, например, [эта](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-with-Java-9-and-above) в вики по Spring Boot, [эта](https://www.baeldung.com/java-9-migration-issue) на Baeldung и еще [одна](https://dzone.com/articles/migrating-your-project-to-jigsaw-step-by-step) на DZone. Еще есть [интересный пример от infoq](https://www.infoq.com/articles/Java-Jigsaw-Migration-Guide/). Перенос Spring Boot 1 в Spring Boot 2 - это отдельная тема, ее тоже стоит рассмотреть. Есть [учебник на](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-2.0-Migration-Guide) самой [Spring Boot](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-2.0-Migration-Guide) и [статья о Baeldung,](https://www.baeldung.com/new-spring-boot-2) посвященная этой теме.
Если в вашем приложении не было настраиваемых загрузчиков классов, вы не сильно полагались на Unsafe, не часто использовали sun.misc или sun.security, у вас, скорее всего, все будет в порядке. Обратитесь к [этой статье JDEP](https://wiki.openjdk.java.net/display/JDK8/Java+Dependency+Analysis+Tool) об инструменте анализа зависимостей Java, чтобы [узнать](https://wiki.openjdk.java.net/display/JDK8/Java+Dependency+Analysis+Tool) о некоторых изменениях, которые вам, возможно, придется внести.
Некоторые вещи были удалены из Java, начиная с версии 8, включая Nashorn JS Engine, API и инструменты Pack200, порты Solaris/Sparc, компиляторы AOT и JIT, модули Java EE и Corba. Некоторые вещи все еще остаются, но не рекомендуется удалять, например, Applet API или Security Manager. Поскольку для их удаления есть веские причины, вам в любом случае следует пересмотреть их использование в вашем приложении.
Я спросил наших технических руководителей проектов в Pretius об их опыте миграции с Java 8 на Java 9+. Было несколько примеров, и ни один из них не был проблематичным. Здесь библиотека не работала и ее нужно было обновить; там требовалась некоторая дополнительная библиотека или конфигурация, но в целом это не был неудачный опыт.
### Заключение
Java 17 LTS уже выпущена и будет поддерживаться долгие годы. С другой стороны, поддержка Java 8 закончится всего через несколько месяцев. Это, безусловно, веская причина подумать о переходе на новейшую версию Java. В этой статье я рассмотрел наиболее важные изменения языка и JVM между версиями 8 и 17 (включая некоторую информацию о процессе миграции с Java 8 на Java 9+), чтобы было легче понять различия между ними, а также оценить риски и выгоды миграции.
Если вы принимаете решения в своей компании, задайте себе следующий вопрос: наступит ли когда-нибудь «хорошее время», чтобы оставить Java 8 позади? Всегда нужно будет потратить определенное количество денег, всегда придется потратить какое-то время, и всегда будет существовать риск того, что потребуется выполнить некоторую дополнительную работу. Если никогда не бывает «хорошего времени», то это конкретное окно - несколько месяцев между выпуском Java 17 и окончанием Java 8 Premier Support - вероятно, лучшее, что когда-либо было. | https://habr.com/ru/post/591159/ | null | ru | null |
# Mikrotik VRF+NAT — Управляем с одного хоста устройствами с одинаковыми IP-адресами
Недавно знакомый попросил помощи с настройкой микротика. Просьба была не совсем простая. Идея в том, что нужно было одновременно управлять с одного хоста четырьмя устройствами с неуправляемым TCP/IP стеком. На всех этих устройствах были одинаковые настройки IP, причем просто IP-адрес и маска, ни шлюз, ни DNS не указаны. Странная, но, как оказалось, весьма реальная ситуация. Не будем вдаваться в подробности причин невозможности перенастройки адресации на этих устройствах, а просто примем этот факт за аксиому. Задача поставлена так, как есть, и ее нужно решить.
Итак, исходные данные:
1. Четыре устройства с одинаковыми настройками IP — 192.168.1.1/24; GW и DNS не указаны; изменить эти настройки невозможно.
2. ПК, с которого необходимо одновременно иметь доступ ко всем четырем устройствам, допустим на WEB-интерфейс.
3. Простенький MikroTik RB750GL на 5 портов.
MikroTik RB750GL с настройками по умолчанию использует 1 порт для подключения к Интернету (NAT, FW), а остальные порты для подключения к локальной сети с настроенным DHCP — как обычный домашний роутер или роутер Small Business серии. Нам нужно задействовать все 5 портов, поэтому для начала полностью чистим конфиг и избавляемся от NAT, FW и DHCP.
Итак, кофиг очистили, собираем схему:
Теперь к делу…
Первая и основная проблема, которая встает перед нами — это использование одинаковых IP-адресов или IP-адресов из одной подсети на разных интерфейсах маршрутизатора для обеспечения сетевой доступности целевых устройств. Как трактуют основы сетевого взаимодействия с одной таблицей маршрутизации такое сделать невозможно. Значит надо сделать несколько таблиц маршрутизации, и в этом нам поможет Virtual Routing and Forwarding (VRF). Не будем сильно погружаться в VRF — нам достаточно просто поместить разные интерфейсы в разные таблицы маршрутизации:
> /ip route vrf
>
> add interfaces=ether1 routing-mark=DEV1
>
> add interfaces=ether2 routing-mark=DEV2
>
> add interfaces=ether3 routing-mark=DEV3
>
> add interfaces=ether4 routing-mark=DEV4
Отлично. Теперь настроим IP-адресацию согласно схеме:
IP-адрес 192.168.2.1 будет использоваться для доступа к менеджменту самого MikroTik'а:
> /ip address
>
> add address=192.168.2.1/24 interface=ether5 network=192.168.2.0
>
> add address=192.168.1.2/24 interface=ether1 network=192.168.1.0
>
> add address=192.168.1.2/24 interface=ether2 network=192.168.1.0
>
> add address=192.168.1.2/24 interface=ether3 network=192.168.1.0
>
> add address=192.168.1.2/24 interface=ether4 network=192.168.1.0
Вспомним, что на самих устройствах, которыми нужно управлять, также отсутствует возможность настройки шлюза по умолчанию. Еще нам нужно как-то разделять эти устройства для доступа с MGMT PC. Естественно NAT. Для каждого устройства выделим IP из подсети 192.168.2.0/24 и настроим на интерфейсе ether5:
> /ip address
>
> add address=192.168.2.11/24 interface=ether5 network=192.168.2.0
>
> add address=192.168.2.12/24 interface=ether5 network=192.168.2.0
>
> add address=192.168.2.13/24 interface=ether5 network=192.168.2.0
>
> add address=192.168.2.14/24 interface=ether5 network=192.168.2.0
Сам NAT пока не трогаем и вспоминаем, что наши пакеты должны «бегать» между разными таблицами маршрутизации. Для этого нужно ставить маршрутные метки согласно новым IP-адресам, которые в дальнейшем будем NAT'ировать. Согласно документации NetFilter таблица Mangle, которая отвечает за маркировку трафика, отрабатывает раньше таблицы NAT. Опираясь на этот факт делаем следующее:
> /ip firewall mangle
>
> add action=mark-routing chain=prerouting dst-address=192.168.2.11 new-routing-mark=DEV1
>
> add action=mark-routing chain=prerouting dst-address=192.168.2.12 new-routing-mark=DEV2
>
> add action=mark-routing chain=prerouting dst-address=192.168.2.13 new-routing-mark=DEV3
>
> add action=mark-routing chain=prerouting dst-address=192.168.2.14 new-routing-mark=DEV4
На основе данных правил пакеты, поступающие на интерфейс ether5 от хоста управления, согласно IP-адресу назначения будут перекладываться в нужную таблицу маршрутизации, на нужный порт к целевому устройству.
Обратные пакеты от устройств необходимо возвращать в основную таблицу маршрутизации на интерфейс ether5, куда подключен наш хост управления. Для этого добавляем в Mangle еще одно правило:
> /ip firewall mangle
>
> add action=mark-routing chain=prerouting dst-address=192.168.2.2 new-routing-mark=main
На основе данного правила все пакеты с адресом назначения 192.168.2.2 будут перекладываться в основную таблицу маршрутизации «main», в которой и находится интерфейс хоста управления.
Осталось подумать о NAT. Для каждого устройства у нас будет по два правила:
> /ip firewall nat
>
> add action=dst-nat chain=dstnat dst-address=192.168.2.11 in-interface=ether5 to-addresses=192.168.1.1
>
> add action=src-nat chain=srcnat out-interface=ether1 to-addresses=192.168.1.2
>
> add action=dst-nat chain=dstnat dst-address=192.168.2.12 in-interface=ether5 to-addresses=192.168.1.1
>
> add action=src-nat chain=srcnat out-interface=ether2 to-addresses=192.168.1.2
>
> add action=dst-nat chain=dstnat dst-address=192.168.2.13 in-interface=ether5 to-addresses=192.168.1.1
>
> add action=src-nat chain=srcnat out-interface=ether3 to-addresses=192.168.1.2
>
> add action=dst-nat chain=dstnat dst-address=192.168.2.14 in-interface=ether5 to-addresses=192.168.1.1
>
> add action=src-nat chain=srcnat out-interface=ether4 to-addresses=192.168.1.2
Таким образом с помощью NAT'а и VRF мы представили для управляющего хоста устройства с одинаковыми IP-адресами, как устройства с разными IP-адресами, а с помощью NAT'а на интерфейсах, которые смотрят в сторону этих устройств, позволили им работать без шлюза по умолчанию.
В итоге, для управления целевыми устройствами (например, через web-интерфейс) на управляющем хосте необходимо набрать в браузере:
`DEV1 - 192.168.2.11`
`DEV2 - 192.168.2.12`
`DEV3 - 192.168.2.13`
`DEV4 - 192.168.2.14` | https://habr.com/ru/post/262091/ | null | ru | null |
# Учим HostBinding работать с Observable
Как и многие другие Angular-разработчики, я мирился с одним ограничением. Если мы хотим использовать `Observable` в шаблоне, мы можем взять знакомый всем `async` пайп:
Но его нельзя применить к `@HostBinding`. Давным-давно это было возможно по ошибке, но это [быстро исправили](https://github.com/angular/angular/issues/12671#issuecomment-258168242):
```
@Directive({
selector: 'button[my-button]'
host: {
'[disabled]': '(isLoading$ | async)'
}
})
export class MyButtonDirective {
```
Все потому, что хост байндинг относится к родительскому view и в нем этот пайп может быть не подключен. Это довольно [желанная фича.](https://github.com/angular/angular/issues/19483) Давайте посмотрим, как мы можем ее реализовать, пока нет официального решения.
Как работает асинхронный байндинг?
----------------------------------
Байндинг работает с обычными данными. Когда у нас есть `Observable` — на этом этапе необходимо покинуть реактивный мир. Нам нужно подписаться на поток, запускать проверку изменения по каждому значению и отписаться, когда поток больше не нужен. Примерно это за нас и делает `async` пайп. И это то, что ложится на наши плечи, когда мы хотим забайндить какие-то реактивные данные на хост.
### Зачем это может понадобиться?
Мы часто работаем с RxJS в Angular. Большинство наших сервисов построены на Observable-модели. Вот пара примеров, где возможность завязываться на реактивные данные в `@HostBinding` была бы полезна:
* **Перевод атрибутов на другой язык**. Если мы хотим сделать динамическое переключение языка в приложении — мы будем использовать `Observable`. При этом обновлять ARIA-атрибуты, `title` или `alt` для изображений довольно непросто.
* **Изменение класса или стилей**. Observable-сервис может управлять размером или трансформацией через изменение стилей хоста. Или, например, мы можем использовать [реактивный IntersectionObserver](https://github.com/ng-web-apis/intersection-observer) для применения класса к sticky-шапке в таблице:
* **Изменение полей и атрибутов.** Иногда мы хотим завязаться на [BreakpointObserver](https://material.angular.io/cdk/layout/api#BreakpointObserver) для обновления `placeholder` или на сервис загрузки данных для выставления `disable` на кнопке.
* **Произвольные строковые данные, хранимые в data-атрибутах.** В моей практике для них тоже иногда используются Observable-сервисы.
В [Taiga UI](https://taiga-ui.dev/) — библиотеке, над которой я работаю, — есть несколько инструментов, чтобы сделать этот процесс максимально декларативным:
```
import {TuiDestroyService, watch} from '@taiga-ui/cdk';
import {Language, TUI_LANGUAGE} from '@taiga-ui/i18n';
import {Observable} from 'rxjs';
import {map, takeUntil} from 'rxjs/operators';
@Component({
selector: 'my-comp',
template: '',
providers: [TuiDestroyService],
})
export class MyComponent {
@HostBinding('attr.aria-label')
label = '';
constructor(
@Inject(TUI_LANGUAGE) language$: Observable,
@Inject(TuiDestroyService) destroy$: Observable,
@Inject(ChangeDetectorRef) changeDetectorRef: ChangeDetectorRef,
) {
language$.pipe(
map(getTranslation('label')),
watch(changeDetectorRef),
takeUntil(destroy$),
).subscribe();
}
}
```
Как видите, тут довольно много кода просто чтобы реализовать байндинг одного значения. Как было бы здорово, если бы можно было просто написать:
```
@HostBinding('attr.aria-label')
readonly label$ = this.translations.get$('label');
```
Это потребует серьезных доработок со стороны команды Angular. Но мы можем использовать хитрый трюк в рамках публичного API, чтобы заставить это работать!
Event-плагины спешат на помощь!
-------------------------------
Мы не можем добавить свою логику к байндингу на хост. Но мы можем сделать это для `@HostListener`! Я уже писал статью на эту тему. [Прочитайте ее](https://habr.com/ru/company/tinkoff/blog/492766/), если хотите узнать, как добавить декларативные `preventDefault`/`stopPropagation` и оптимизировать циклы проверки изменений. Если кратко — Angular позволяет добавлять свои сервисы для обработки событий. Подходящий сервис выбирается с помощью имени события. Давайте перепишем код следующим образом:
```
@HostBinding('$.aria-label.attr')
@HostListener('$.aria-label.attr')
readonly label$ = this.translations.get$('label');
```
Выглядит странно — пытаться решить задачу `@HostBinding` через `@HostListener` но читайте дальше и вы всё увидите.
> *Мы будем использовать* `$` *в качестве индикатора в имени события. Модификатор* `.attr` *добавим в конец, а не в начало. Иначе* [*регулярное выражение в Angular*](https://github.com/angular/angular/blob/master/packages/compiler/src/render3/view/compiler.ts#L37-L39) *решит, что мы байндим строковый атрибут.*
>
>
У плагинов для обработки событий есть доступ к элементу, имени события и функции-обработчику. Последний аргумент для нас бесполезен, так как это обертка, созданная компилятором. Так что нам нужно как-то передать наш `Observable` через элемент. Вот тут-то нам и пригодится `@HostBinding`. Мы положим `Observable` в поле с тем же именем, и тогда у нас будет доступ к нему внутри плагина:
```
addEventListener(element: HTMLElement, event: string): Function {
element[event] = EMPTY;
const method = this.getMethod(element, event);
const sub = this.manager
.getZone()
.onStable.pipe(
take(1),
switchMap(() => element[event]),
)
.subscribe(method);
return () => sub.unsubscribe();
}
```
Компилятор Angular
------------------
Посмотрим на этот код повнимательнее. Первая строка может вас смутить. Хоть мы и можем назначать произвольные поля на элементы, [Angular попытается их провалидировать](https://github.com/angular/angular/blob/348d3656662a65bd3521446679de993d5a0733f0/packages/core/src/render3/instructions/shared.ts#L1075-L1092):
Возможно, вы видели такое раньшеПлагины хороши тем, что подписка на события происходит раньше разрешения байндингов. Благодаря первой строке Angular считает, что у элемента присутствует это свойство. Дальше нам нужно убедиться, что `Observable` уже на месте — ведь на момент подписки его еще нет. Хорошо, что у нас есть доступ до `NgZone` и мы можем дождаться ее стабилизации, прежде чем запросить свойство элемента.
> `NgZone` *испускает* `onStable` *когда не осталось больше микро- и макрозадач в очереди. Для нас это означает, что Angular завершил цикл проверки изменений и все байндинги обновлены.*
>
>
А отписку за нас сделает сам Angular — достаточно вернуть функцию, прерывающую стрим.
Этого хватит, чтобы код заработал [в JIT, AOT](https://angular.io/guide/aot-compiler#choosing-a-compiler) же более щепетилен. Мы добавили несуществующее поле во время выполнения, но AOT желает знать про него на этапе компиляции. До тех пор, пока [эта задача](https://github.com/angular/angular/issues/12045) не будет закрыта, мы не можем создавать свои списки разрешенных полей. Поэтому нам придется добавить `NO_ERRORS_SCHEMA` в модуль с подобным байндингом. Это может звучать страшно, но все, что эта схема делает, — перестает проверять, есть ли поле у элемента при байндинге. Кроме того, если у вас WebStorm, вы продолжите видеть предупреждение:
Это сообщение не мешает сборкеТакже AOT требует реализации Callable-интерфейса для использования `@HostListener`. Мы можем имитировать его с помощью простой функции, сохранив оригинальный тип:
```
function asCallable(a: T): T & Function {
return a as any;
}
```
Итоговая запись:
```
@HostBinding('$.aria-label.attr')
@HostListener('$.aria-label.attr')
readonly label$ = asCallable(this.translations.get$('label'));
```
Решение получше?
----------------
Другой вариант — вовсе отказаться от `@HostBinding` ведь нам надо назначить его лишь один раз. Если ваш стрим приходит из DI, что происходит довольно часто, можно создать `FactoryProvider`. В него можно передать `ElementRef` и назначить поле в нем:
```
export const TOKEN = new InjectionToken>("");
export const PROVIDER = {
provide: TOKEN,
deps: [ElementRef, IntersectionObserverService],
useFactory: factory,
}
export function factory(
{ nativeElement }: ElementRef,
entries$: Observable
): Observable {
return nativeElement["$.class.stuck"] = entries$.pipe(map(isIntersecting));
}
```
Либо можно просто назначить этот стрим на поле элемента прямо в конструкторе:
```
constructor({nativeElement}: ElementRef) {
nativeElement['$.aria-label.attr'] = this.label$;
}
```
Теперь достаточно будет оставить только `@HostListener`. Его даже можно написать прямо в декораторе класса:
```
@Directive({
selector: "table[sticky]",
providers: [
IntersectionObserverService,
PROVIDER,
],
host: {
"($.class.stuck)": "stuck$"
}
})
export class StickyDirective {
constructor(@Inject(TOKEN) readonly stuck$: Observable) {}
}
```
Приведенный выше пример можно увидеть вживую на StackBlitz. В нем `IntersectionObserver` используется для задания тени на sticky-шапке таблицы:
angular-async-hostbinding - StackBlitz[stackblitz.com](https://stackblitz.com/edit/angular-async-hostbinding?file=src/app/sticky.directive.ts)Обновление полей
----------------
В коде вы видели вызов `getMethod`. Байндинг в Angular работает не только на атрибутах и полях, но и на классах и стилях. Нам тоже нужно реализовать такую возможность. Для этого разберем имя нашего псевдособытия, чтобы понять, что же делать со значениями из потока:
```
private getMethod(element: HTMLElement, event: string): Function {
const [, key, value, unit = ''] = event.split('.');
if (event.endsWith('.attr')) {
return v => v === null
? element.removeAttribute(key)
: element.setAttribute(key, String(v));
}
if (key === 'class') {
return v => element.classList.toggle(value, !!v);
}
if (key === 'style') {
return v => element.style.setProperty(value, `${v}${unit}`);
}
return v => (element[key] = v);
}
```
Никакой мудреной логики. На этом все, осталось только зарегистрировать плагин в глобальных провайдерах:
```
{
provide: EVENT_MANAGER_PLUGINS,
useClass: BindEventPlugin,
multi: true,
}
```
Это небольшое дополнение способно существенно упростить ваш код. Нам больше не надо беспокоиться о подписке. Описанный плагин доступен в новой версии 2.1.1 нашей библиотеки [@tinkoff/ng-event-plugins](https://github.com/TinkoffCreditSystems/ng-event-plugins), а также в [@taiga-ui/cdk](https://github.com/TinkoffCreditSystems/taiga-ui). Поиграться с кодом можно на StackBlitz. Надеюсь, этот материал будет для вас полезным! | https://habr.com/ru/post/542984/ | null | ru | null |
# История о V8, React и падении производительности. Часть 1
В материале, первую часть перевода которого мы публикуем сегодня, речь пойдёт о том, как JavaScript-движок V8 выбирает оптимальные способы представления различных JS-значений в памяти, и о том, как это влияет на внутренние механизмы V8, касающиеся работы с так называемыми [формами объектов](https://habr.com/ru/company/ruvds/blog/422321/) (Shape). Всё это поможет нам разобраться с сутью недавней [проблемы, касающейся производительности React](https://github.com/facebook/react/issues/14365).
[](https://habr.com/ru/company/ruvds/blog/467247/)
Типы данных в JavaScript
------------------------
Каждое JavaScript-значение может иметь только один из ныне существующих восьми типов данных: `Number`, `String`, `Symbol`, `BigInt`, `Boolean`, `Undefined`, `Null` и `Object`.
*Типы данных в JavaScript*
Тип значения можно выяснить с помощью оператора `typeof`, но тут имеется одно важное исключение:
```
typeof 42;
// 'number'
typeof 'foo';
// 'string'
typeof Symbol('bar');
// 'symbol'
typeof 42n;
// 'bigint'
typeof true;
// 'boolean'
typeof undefined;
// 'undefined'
typeof null;
// 'object' - вот то исключение, о котором идёт речь
typeof { x: 42 };
// 'object'
```
Как видите, команда `typeof null` возвращает `'object'`, а не `'null'`, несмотря на то, что значение `null` имеет собственный тип — `Null`. Для того чтобы понять причину подобного поведения `typeof`, примем во внимание то, что множество всех JavaScript-типов может быть разделено на две группы:
* Объекты (то есть — тип `Object`).
* Примитивные значения (то есть — любые необъектные значения).
В свете этого знания оказывается, что `null` означает «отсутствие объектного значения», в то время как `undefined` — это «отсутствие значения».
*Примитивные значения, объекты, null и undefined*
Следуя этим размышлениям в духе Java, Брендан Эйх спроектировал JavaScript так, чтобы оператор `typeof` возвращал бы `'object'` для значений тех типов, которые расположены на предыдущем рисунке справа. Сюда попадают все объектные значения и `null`. Именно поэтому истинным является выражение `typeof null === 'object'` несмотря на то, что в спецификации языка имеется отдельный тип `Null`.
*Выражение typeof v === 'object' истинно*
Представление значений
----------------------
JavaScript-движки должны иметь возможность представления любых JavaScript-значений в памяти. Однако важно отметить то, что типы значений в JavaScript отделены от того, как JS-движки представляют их в памяти.
Например, значение 42 в JavaScript имеет тип `number`.
```
typeof 42;
// 'number'
```
Существует несколько способов представления в памяти целых чисел наподобие 42:
| | |
| --- | --- |
| Представление | Биты |
| 8 бит, с дополнением до двух | 0010 1010 |
| 32 бита, с дополнением до двух | 0000 0000 0000 0000 0000 0000 0010 1010 |
| Упакованное двоично-десятичное число (binary-coded decimal, BCD) | 0100 0010 |
| 32 бита, число с плавающей точкой IEEE-754 | 0100 0010 0010 1000 0000 0000 0000 0000 |
| 64 бита, число с плавающей точкой IEEE-754 | 0100 0000 0100 0101 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 |
В соответствии со стандартом ECMAScript числа — это 64-битные значения с плавающей точкой, известные как числа с плавающей точкой двойной точности (Float64). Однако это не означает того, что JavaScript-движки всегда хранят числа в представлении Float64. Это было бы очень и очень неэффективно! Движки могут использовать другие внутренние представления чисел — до тех пор, пока поведение значений в точности соответствует тому, как ведут себя Float64-числа.
Большинство чисел в реальных JS-приложениях, как оказалось, являются действительными [индексами](https://tc39.es/ecma262/#array-index) ECMAScript-массивов. То есть — целыми числами в диапазоне от 0 до 232-2.
```
array[0]; // Самый маленький из возможных индексов массива.
array[42];
array[2**32-2]; // Самый большой из возможных индексов массива.
```
JavaScript-движки могут выбирать оптимальный формат для представления подобных значений в памяти. Делается это для того чтобы оптимизировать код, который работает с элементами массивов, используя индексы. Процессору, выполняющему операции обращения к памяти, нужно, чтобы индексы массива были бы доступны в виде чисел, хранящихся в представлении с [дополнением до двух](https://en.wikipedia.org/wiki/Two%27s_complement). Если вместо этого представлять индексы массивов в виде Float64-значений — это будет означать пустую трату системных ресурсов, так как движку тогда понадобилось бы преобразовывать Float64-числа в формат с дополнением до двух и обратно всякий раз, когда кто-то обращается к элементу массива.
Представление 32-битных чисел с дополнением до двух полезно не только для оптимизации работы с массивами. В целом можно отметить, что процессор выполняет целочисленные операции гораздо быстрее, чем операции, в которых используются значения с плавающей точкой. Именно поэтому в следующем примере первый цикл без проблем оказывается в два раза быстрее в сравнении со вторым циклом.
```
for (let i = 0; i < 1000; ++i) {
// быстро
}
for (let i = 0.1; i < 1000.1; ++i) {
// медленно
}
```
То же самое применимо и к вычислениям с использованием математических операторов.
Например, производительность оператора взятия остатка от деления из следующего фрагмента кода зависит от того, какие числа участвуют в вычислениях.
```
const remainder = value % divisor;
// Быстро - если `value` и `divisor` представлены целыми числами,
// медленно в других случаях.
```
Если оба операнда представлены целыми числами, то процессор может вычислить результат весьма эффективно. В V8 есть дополнительная оптимизация для тех случаев, когда операнд `divisor` представлен числом, являющимся степенью двойки. Для значений, представленных в виде чисел с плавающей точкой, вычисления оказываются гораздо более сложными и занимают намного больше времени.
Так как целочисленные операции обычно выполняются гораздо быстрее операций над значениями с плавающей точкой, может показаться, что движки могут просто всегда хранить все целые числа и все результаты целочисленных операций в формате с дополнением до двух. К несчастью, такой подход означал бы нарушение спецификации ECMAScript. Как уже было сказано, в стандарте предусмотрено представление чисел в формате Float64, а некоторые операции с целыми числами могут приводить к появлению результатов в виде чисел с плавающей точкой. Важно, чтобы в подобных ситуациях JS-движки выдавали бы корректные результаты.
```
// Во Float64 имеется безопасный 53-битный целочисленный диапазон.
// Выход за пределы этого диапазона ведёт к потере точности.
2**53 === 2**53+1;
// true
// Float64 поддерживает отрицательные нули, в результате -1 * 0 должно дать -0, но
// в формате с дополнением до двух нет способа представления отрицательного нуля.
-1*0 === -0;
// true
// Float64 поддерживает значение Infinity, получить которое можно,
// разделив некое число на ноль.
1/0 === Infinity;
// true
-1/0 === -Infinity;
// true
// Float64 поддерживает и значения NaN.
0/0 === NaN;
```
Даже хотя в предыдущем примере все числа, находящиеся в левой части выражений, являются целыми, все числа в правой части выражения являются значениями с плавающей точкой. Именно поэтому ни одна из предыдущих операций не может быть выполнена корректно с использованием 32-битного формата с дополнением до двух. JavaScript-движкам приходится уделять особое внимание тому, чтобы при выполнении целочисленных операций получались бы правильные (хотя и способные выглядеть необычно — как в предыдущем примере) Float64-результаты.
В случае с маленькими целыми числами, укладывающимися в диапазон 31-битного представления целых чисел со знаком, V8 использует особое представление, называемое `Smi`. Всё, что не является значением `Smi`, представляется в виде значения `HeapObject`, которое является адресом некоей сущности в памяти. Для чисел, не попадающих в диапазон `Smi`, у нас имеется особый вид `HeapObject` — так называемый `HeapNumber`.
```
-Infinity // HeapNumber
-(2**30)-1 // HeapNumber
-(2**30) // Smi
-42 // Smi
-0 // HeapNumber
0 // Smi
4.2 // HeapNumber
42 // Smi
2**30-1 // Smi
2**30 // HeapNumber
Infinity // HeapNumber
NaN // HeapNumber
```
Как видно из предыдущего примера, некоторые JS-числа представляются в виде `Smi`, а некоторые — в виде `HeapNumber`. Движок V8 оптимизирован в плане обработки `Smi`-чисел. Дело в том, что маленькие целые числа весьма часто встречаются в реальных JS-программах. При работе со `Smi`-значениями не нужно выделять память под отдельные сущности. Их использование, кроме того, позволяет выполнять быстрые операции с целыми числами.
Сравнение Smi, HeapNumber и MutableHeapNumber
---------------------------------------------
Поговорим о том, как выглядит внутреннее устройство этих механизмов. Предположим, у нас имеется следующий объект:
```
const o = {
x: 42, // Smi
y: 4.2, // HeapNumber
};
```
Значение 42 свойства объекта `x` кодируется в виде `Smi`. Это значит, что оно может быть сохранено внутри самого объекта. Для хранения значения 4.2, с другой стороны, потребуется создание отдельной сущности. В объекте же будет ссылка на эту сущность.
*Хранение различных значений*
Предположим, что мы выполняем следующий фрагмент JavaScript-кода:
```
o.x += 10;
// o.x теперь равняется 52
o.y += 1;
// o.y теперь равняется 5.2
```
В данном случае значение свойства `x` может быть обновлено в месте его хранения. Дело в том, что новое значение `x` равно 52, а это число укладывается в диапазон `Smi`.
*Новое значение свойства x сохраняется там же, где хранилось предыдущее значение*
Однако новое значение `y`, 5.2, не укладывается в диапазон `Smi`, и оно, кроме того, отличается от предыдущего значения y — 4.2. В результате V8 приходится выделять память под новую сущность `HeapNumber` и ссылаться из объекта уже на неё.
*Новая сущность HeapNumber для хранения нового значения y*
Сущности `HeapNumber` являются иммутабельными. Это позволяет реализовать некоторые оптимизации. Предположим, мы хотим присвоить свойству объекта `x` значение свойства `y`:
```
o.x = o.y;
// o.x теперь равно 5.2
```
При выполнении данной операции мы можем просто сослаться на ту же сущность `HeapNumber`, а не выделять дополнительную память для хранения одного и того же значения.
Один из недостатков иммутабельности сущностей `HeapNuber` заключается в том, что частое обновление полей, значения в которых выходят за пределы диапазона `Smi`, оказывается медленным. Это продемонстрировано в следующем примере:
```
// Создание экземпляра `HeapNumber`.
const o = { x: 0.1 };
for (let i = 0; i < 5; ++i) {
// Создание дополнительного экземпляра `HeapNumber`.
o.x += 1;
}
```
При обработке первой строки создаётся экземпляр `HeapNumber`, начальным значением которого является 0.1. В теле цикла это значение меняется на 1.1, 2.1, 3.1, 4.1, и наконец — на 5.1. В результате в процессе выполнения этого кода создаётся 6 экземпляров `HeapNumber`, пять из которых будут подвергнуты операции сборки мусора после завершения работы цикла.
*Сущности HeapNumber*
Для того чтобы избежать этой проблемы в V8 имеется оптимизация, представляющая собой механизм обновления числовых полей, значения которых не укладываются в диапазон `Smi`, в тех же местах, где они уже хранятся. Если числовое поле хранит значения, для хранения которых сущность `Smi` не подходит, то V8, в форме объекта, помечает это поле как `Double` и выделяет память под сущность `MutableHeapNumber`, которая хранит реальное значение, представленное в формате Float64.
*Использование сущностей MutableHeapNumber*
В результате после того, как значение поля меняется, V8 больше не нужно выделять память под новую сущность `HeapNumber`. Вместо этого достаточно записать новое значение в уже имеющуюся сущность `MutableHeapNumber`.
*Запись нового значения в MutableHeapNumber*
Однако и у этого подхода есть свои недостатки. А именно, так как значения `MutableHeapNumber` могут меняться — важно обеспечивать такую работу системы, при которой эти значения будут вести себя так, как это предусмотрено в спецификации языка.
*Недостатки MutableHeapNumber*
Например, если присвоить значение `o.x` некоей другой переменной `y`, то нужно, чтобы значение `y` не изменялось бы при последующем изменении `o.x`. Это было бы нарушением спецификации JavaScript! В результате, когда осуществляется доступ к `o.x`, число, прежде чем оно будет присвоено `y`, должно быть переупаковано в обычное значение `HeapNumber`.
В случае с числами с плавающей точкой V8 выполняет вышеописанные операции упаковки с использованием своих внутренних механизмов. Но в случае с маленькими целыми числами использование `MutableHeapNumber` было бы пустой тратой времени из-за того, что `Smi` — это более эффективный способ представления таких чисел.
```
const object = { x: 1 };
// "Упаковка" свойства `x` объекта не выполняется
object.x += 1;
// обновление значения `x` внутри объекта
```
Для того чтобы избежать неэффективного использования системных ресурсов всё, что нам нужно сделать для работы с маленькими целыми числами, заключается в том, чтобы отмечать соответствующие им поля в формах объектов как `Smi`. В результате значения этих полей, до тех пор, пока они соответствуют диапазону `Smi`, можно обновлять прямо внутри объектов.
*Работа с целыми числами, значения которых укладываются в диапазон Smi*
Продолжение следует…
**Уважаемые читатели!** Сталкивались ли вы с проблемами производительности JavaScript-кода, вызванными особенностями JS-движков?
[](https://ruvds.com/vps_start/) | https://habr.com/ru/post/467247/ | null | ru | null |
# Буфера для буферов или пишем виртуальный буфер обмена на C# не в 30 строк кода
Так случилось, что в такую мрачную погоду, обложив себя таблетками и препаратами от простуды я решил от нечего делать поделиться с хабра-сообществом инструментом, который я сделал для себя и уже почти что месяц им успешно пользуюсь. Речь идет о windows-программе, которая перехватывает копирование текста в буфер обмена и позволяет вставить из раннее скопированного текста любой фрагмент.
#### С чего всё началось
Как любому программисту, мне постоянно приходится работать с кодом. Помимо написания кода на C#, мне постоянно приходится писать sql-запросы. Причем достаточно сложные запросы: запросы с подзапросами, с вложенными запросами, с кучей LEFT JOIN и RIGHT JOIN-ов. Производя декомпозицию таких запросов на отдельные его части легко запутаться что к чему и зачем/для чего всё это писалось.
**Типичный пример одного sql-запроса (даже не пытайтесь понять что он делает)**
```
SELECT IFNULL(SUM(t_step3.half_step3 - IFNULL(t_step1.bonus, 0) - IFNULL(t_step2.bonus, 0)), 0) AS 'bonus'
FROM (
SELECT t_orders2cat.order_id AS 'id',
(t_o.balance_rub - SUM(t_orders2cat.dprice_rub - t_orders2cat.delivery_cost_rub) - IFNULL(t_gurkin.half_step3, 0) - IFNULL(t_o2p.cost_expenses_rub, 0)) *
(
IF(base_on_tender = 0, IFNULL(t_category_percent.percent, 1),
IF(base_on_tender = 1,
IFNULL(t_category_percent.percent, 1) - 0.1,
IFNULL(t_category_percent.percent, 1) - 0.5)
) -
IF(t_orders.tech_helper_id != 0, t_users.tech_bonus_percent, 0)
) / 100 AS 'half_step3'
FROM t_orders2cat,
t_orders LEFT JOIN t_category_percent ON t_orders.category_percent_id = t_category_percent.id
LEFT JOIN t_users ON t_orders.tech_helper_id = t_users.id
LEFT JOIN (SELECT order_id, SUM(cost_expenses_rub) AS 'cost_expenses_rub'
FROM t_orders2pnr
GROUP BY t_orders2pnr.order_id
HAVING SUM(cost_expenses_rub) > 0) AS t_o2p ON t_orders.id = t_o2p.order_id
LEFT JOIN (
SELECT t_orders.id AS 'order_id',
SUM(deg_discount(deg_convert_money( t_orders.rate_eur,
t_orders.rate_usd,
t_orders.rate_jpy,
t_orders2cat.price,
t_orders2cat.currency_id,
t_orders.currency_id),
t_orders2cat.discount) * t_orders2cat.count -
t_orders2cat.dprice_rub -
t_orders2cat.delivery_cost_rub -
IFNULL(t_orders2pnr.cost_expenses_rub, 0)
) * t_p.balance_rub / t_orders.balance AS 'half_step3'
FROM t_orders LEFT JOIN t_orders2pnr ON t_orders.id = t_orders2pnr.order_id,
t_orders2cat,
t_cat,
t_vendors,
(
SELECT order_id,
SUM(summa_rub) AS 'balance_rub'
FROM t_payments
GROUP BY order_id
) AS t_p,
(
SELECT t_o.id,
GREATEST(IFNULL(t_o.date_shipment, t_o.date_pnr_finish), IFNULL(t_o.date_pnr_finish, t_o.date_shipment), MAX(t_payments.date_payment)) AS 'date_closed',
SUM(t_payments.summa_rub) AS 'balance_rub'
FROM t_payments,
(
SELECT t_orders.id,
COUNT(t_orders2cat.id) AS 'orders2cat_count',
MAX(t_orders2cat.date_from) AS 'date_shipment',
MAX(t_orders2cat.status_id) AS 'orders2cat_status',
COUNT(t_orders2pnr.id) AS 'pnr_count',
MAX(t_orders2pnr.date) AS 'date_pnr_finish',
MAX(t_orders2pnr.status_id) AS 'pnr_status'
FROM t_orders LEFT JOIN t_orders2cat ON t_orders.id = t_orders2cat.order_id
LEFT JOIN t_orders2pnr ON t_orders.id = t_orders2pnr.order_id
WHERE t_orders.user_id = in_user_id AND
t_orders.items_finished >= t_orders.items_count AND t_orders.summa - t_orders.balance < 2
GROUP BY t_orders.id
) AS t_o
WHERE t_payments.order_id = t_o.id
GROUP BY t_payments.order_id
HAVING EXTRACT(YEAR_MONTH FROM date_closed) = EXTRACT(YEAR_MONTH FROM in_date)
) AS t_o
WHERE t_orders.id = t_o.id AND
t_orders.id = t_p.order_id AND
t_orders.id = t_orders2cat.order_id AND
t_orders2cat.cat_id = t_cat.id AND
t_orders.user_id = in_user_id AND
t_cat.vendor_id = t_vendors.id AND
t_vendors.user_id = 158
GROUP BY t_orders.id
) AS t_gurkin ON t_orders.id = t_gurkin.order_id,
(
SELECT t_o.id,
GREATEST(IFNULL(t_o.date_shipment, t_o.date_pnr_finish), IFNULL(t_o.date_pnr_finish, t_o.date_shipment), MAX(t_payments.date_payment)) AS 'date_closed',
SUM(t_payments.summa_rub) AS 'balance_rub'
FROM t_payments,
(
SELECT t_orders.id,
COUNT(t_orders2cat.id) AS 'orders2cat_count',
MAX(t_orders2cat.date_from) AS 'date_shipment',
MAX(t_orders2cat.status_id) AS 'orders2cat_status',
COUNT(t_orders2pnr.id) AS 'pnr_count',
MAX(t_orders2pnr.date) AS 'date_pnr_finish',
MAX(t_orders2pnr.status_id) AS 'pnr_status'
FROM t_orders LEFT JOIN t_orders2cat ON t_orders.id = t_orders2cat.order_id
LEFT JOIN t_orders2pnr ON t_orders.id = t_orders2pnr.order_id
WHERE t_orders.user_id = in_user_id AND
t_orders.items_finished >= t_orders.items_count AND t_orders.summa - t_orders.balance < 2
GROUP BY t_orders.id
) AS t_o
WHERE t_payments.order_id = t_o.id
GROUP BY t_payments.order_id
HAVING EXTRACT(YEAR_MONTH FROM date_closed) = EXTRACT(YEAR_MONTH FROM in_date)
) AS t_o
WHERE t_orders2cat.order_id = t_o.id AND
t_orders2cat.order_id = t_orders.id
GROUP BY t_orders2cat.order_id
) AS t_step3
LEFT JOIN
(
SELECT t_orders.id,
t_o.average_curs * (t_orders.summa - IFNULL(t_gurkin.step1, 0)) *
(
IF(base_on_tender = 0, IFNULL(t_category_percent.percent, 1),
IF(base_on_tender = 1,
IFNULL(t_category_percent.percent, 1) - 0.1,
IFNULL(t_category_percent.percent, 1) - 0.5
)
) -
IF(t_orders.tech_helper_id != 0, t_users.tech_bonus_percent, 0)
) /
100 * 0.3 AS 'bonus'
FROM t_orders LEFT JOIN t_category_percent ON t_orders.category_percent_id = t_category_percent.id
LEFT JOIN t_users ON t_orders.tech_helper_id = t_users.id
LEFT JOIN (
SELECT t_orders.id AS 'order_id',
SUM(deg_discount(deg_convert_money( t_orders.rate_eur,
t_orders.rate_usd,
t_orders.rate_jpy,
t_orders2cat.price,
t_orders2cat.currency_id,
t_orders.currency_id),
t_orders2cat.discount) * t_orders2cat.count) * t_o.payment_rub / t_o.payment_currency AS 'step1'
FROM t_orders,
t_orders2cat,
t_cat,
t_vendors,
(
SELECT t_orders.id,
SUM(t_payments.summa_rub) AS 'payment_rub',
SUM(deg_convert_money(t_rates.eur, t_rates.usd, t_rates.jpy, t_payments.summa_rub, 1, t_orders.currency_id)) AS 'payment_currency',
t_orders.summa
FROM t_orders,
t_payments,
t_rates
WHERE t_orders.id = t_payments.order_id AND
t_payments.date_rates = t_rates.date AND
EXTRACT(YEAR_MONTH FROM t_orders.date_firstpay) = EXTRACT(YEAR_MONTH FROM t_payments.date_payment)
GROUP BY t_payments.order_id
HAVING payment_currency / t_orders.summa >= 0.3
) AS t_o
WHERE t_orders.id = t_orders2cat.order_id AND
t_orders2cat.order_id = t_o.id AND
t_orders.user_id = in_user_id AND
t_orders2cat.cat_id = t_cat.id AND
t_vendors.user_id = 158 AND
t_cat.vendor_id = t_vendors.id
GROUP BY t_o.id
) AS t_gurkin ON t_orders.id = t_gurkin.order_id,
(
SELECT t_orders.id,
SUM(t_payments.summa_rub) / SUM(deg_convert_money(t_rates.eur, t_rates.usd, t_rates.jpy, t_payments.summa_rub, 1, t_orders.currency_id)) AS 'average_curs'
FROM t_payments,
t_rates,
t_orders,
(
SELECT t_payments.order_id,
MIN(t_payments.date_payment) AS 'date_payment'
FROM t_payments
WHERE 0.3 <= (
SELECT SUM(deg_convert_money(t_rates.eur, t_rates.usd, t_rates.jpy, t_p.summa_rub, 1, t_o.currency_id)) / t_o.summa AS 'summa_cur'
FROM t_payments AS t_p,
t_orders AS t_o,
t_rates
WHERE t_p.order_id = t_o.id AND
t_p.date_rates = t_rates.date AND
t_p.date_payment <= t_payments.date_payment AND
t_o.id = t_payments.order_id
)
GROUP BY t_payments.order_id
) AS t_o
WHERE t_payments.order_id = t_o.order_id AND
t_payments.order_id = t_orders.id AND
t_payments.date_rates = t_rates.date AND
EXTRACT(YEAR_MONTH FROM t_payments.date_payment) <= EXTRACT(YEAR_MONTH FROM t_o.date_payment) AND
t_orders.user_id = in_user_id
GROUP BY t_orders.id
) AS t_o
WHERE t_orders.id = t_o.id AND
t_orders.user_id = in_user_id
) AS t_step1
ON t_step3.id = t_step1.id
LEFT JOIN
(
SELECT t_orders.id,
SUM(t_payments.summa_rub) / SUM(deg_convert_money(t_rates.eur, t_rates.usd, t_rates.jpy, t_payments.summa_rub, 1, t_orders.currency_id)) * (t_orders.summa - IFNULL(t_gurkin.step2, 0)) *
(
IF(base_on_tender = 0, IFNULL(t_category_percent.percent, 1),
IF(base_on_tender = 1,
IFNULL(t_category_percent.percent, 1) - 0.1,
IFNULL(t_category_percent.percent, 1) - 0.5
)
) -
IF(t_orders.tech_helper_id != 0, t_users.tech_bonus_percent, 0)
) / 100 * 0.3 AS 'bonus'
FROM t_payments,
t_rates,
t_orders LEFT JOIN t_category_percent ON t_orders.category_percent_id = t_category_percent.id
LEFT JOIN t_users ON t_orders.tech_helper_id = t_users.id
LEFT JOIN (
SELECT t_orders.id AS 'order_id',
SUM(deg_discount(deg_convert_money( t_orders.rate_eur,
t_orders.rate_usd,
t_orders.rate_jpy,
t_orders2cat.price,
t_orders2cat.currency_id,
t_orders.currency_id),
t_orders2cat.discount) * t_orders2cat.count) * t_o.payment_rub / t_o.payment_currency AS 'step2'
FROM t_orders,
t_orders2cat,
t_cat,
t_vendors,
(
SELECT t_orders.id,
SUM(t_payments.summa_rub) AS 'payment_rub',
SUM(deg_convert_money(t_rates.eur, t_rates.usd, t_rates.jpy, t_payments.summa_rub, 1, t_orders.currency_id)) AS 'payment_currency'
FROM t_payments,
t_rates,
t_orders,
(
SELECT t_o.id,
GREATEST(date_exit, date_payment) AS 'date_payment_bonus'
FROM (
SELECT t_o.id AS 'id',
MAX(t_containers.date_port_exit) AS 'date_exit'
FROM t_orders2cat,
t_invoices2orders2cat,
t_containers2invoices,
t_containers,
(
SELECT t_orders.id
FROM t_orders,
t_orders2cat
WHERE t_orders.id = t_orders2cat.order_id AND
t_orders.user_id = in_user_id AND
4 <= ALL (SELECT t_o2c.status_id FROM t_orders2cat AS t_o2c WHERE t_o2c.order_id = t_orders.id)
GROUP BY t_orders.id
) AS t_o
WHERE t_orders2cat.id = t_invoices2orders2cat.order2cat_id AND
t_invoices2orders2cat.invoice_id = t_containers2invoices.invoice_id AND
t_containers2invoices.container_id = t_containers.id AND
t_orders2cat.order_id = t_o.id
GROUP BY t_o.id
) AS t_o,
(
SELECT t_payments.order_id,
MIN(t_payments.date_payment) AS 'date_payment'
FROM t_payments
WHERE 0.8 <= (
SELECT SUM(deg_convert_money(t_rates.eur, t_rates.usd, t_rates.jpy, t_p.summa_rub, 1, t_o.currency_id)) / t_o.summa AS 'summa_cur'
FROM t_payments AS t_p,
t_orders AS t_o,
t_rates
WHERE t_p.order_id = t_o.id AND
t_o.user_id = in_user_id AND
t_p.date_rates = t_rates.date AND
t_p.date_payment <= t_payments.date_payment AND
t_o.id = t_payments.order_id
)
GROUP BY t_payments.order_id
) t_p
WHERE t_o.id = t_p.order_id
) AS t_o
WHERE t_payments.order_id = t_o.id AND
t_payments.date_rates = t_rates.date AND
t_payments.order_id = t_orders.id AND
EXTRACT(YEAR_MONTH FROM t_payments.date_payment) <= EXTRACT(YEAR_MONTH FROM t_o.date_payment_bonus)
GROUP BY t_orders.id
) AS t_o
WHERE t_orders.id = t_orders2cat.order_id AND
t_orders2cat.order_id = t_o.id AND
t_orders2cat.cat_id = t_cat.id AND
t_orders.user_id = in_user_id AND
t_vendors.user_id = 158 AND
t_cat.vendor_id = t_vendors.id
GROUP BY t_o.id
) AS t_gurkin ON t_orders.id = t_gurkin.order_id,
(
SELECT t_o.id,
GREATEST(date_exit, date_payment) AS 'date_payment_bonus'
FROM (
SELECT t_o.id AS 'id',
MAX(t_containers.date_port_exit) AS 'date_exit'
FROM t_orders2cat,
t_invoices2orders2cat,
t_containers2invoices,
t_containers,
(
SELECT t_orders.id
FROM t_orders,
t_orders2cat
WHERE t_orders.id = t_orders2cat.order_id AND
t_orders.user_id = in_user_id AND
4 <= ALL (SELECT t_o2c.status_id FROM t_orders2cat AS t_o2c WHERE t_o2c.order_id = t_orders.id) AND
t_orders.user_id = in_user_id
GROUP BY t_orders.id
) AS t_o
WHERE t_orders2cat.id = t_invoices2orders2cat.order2cat_id AND
t_invoices2orders2cat.invoice_id = t_containers2invoices.invoice_id AND
t_containers2invoices.container_id = t_containers.id AND
t_orders2cat.order_id = t_o.id
GROUP BY t_o.id
) AS t_o,
(
SELECT t_payments.order_id,
MIN(t_payments.date_payment) AS 'date_payment'
FROM t_payments
WHERE 0.8 <= (
SELECT SUM(deg_convert_money(t_rates.eur, t_rates.usd, t_rates.jpy, t_p.summa_rub, 1, t_o.currency_id)) / t_o.summa AS 'summa_cur'
FROM t_payments AS t_p,
t_orders AS t_o,
t_rates
WHERE t_p.order_id = t_o.id AND
t_o.user_id = in_user_id AND
t_p.date_rates = t_rates.date AND
t_p.date_payment <= t_payments.date_payment AND
t_o.id = t_payments.order_id
)
GROUP BY t_payments.order_id
) t_p
WHERE t_o.id = t_p.order_id
) AS t_o
WHERE t_o.id = t_payments.order_id AND
t_orders.id = t_o.id AND
t_orders.user_id = in_user_id AND
t_payments.date_rates = t_rates.date AND
EXTRACT(YEAR_MONTH FROM t_payments.date_payment) <= EXTRACT(YEAR_MONTH FROM t_o.date_payment_bonus)
GROUP BY t_orders.id
) AS t_step2
ON t_step3.id = t_step2.id;
```
Почитав статью [Пишем виртуальный буфер обмена на C#](http://habrahabr.ru/post/208314/), решил попробовать в действии то, что предложил нам [yanzlatov](http://habrahabr.ru/users/yanzlatov/), но его вариант для меня был неприемлем: во многом неудобство к быстрому доступу скопированных в буфер буферов, глючность…
##### Требования
Сформулировав для себя четкие требования того, что мне необходимо, было принято решение заново написать велосипед.
* Так как я работаю на ноуте (Win7x64), на домашнем компьютере (Win8.1x64) и на рабочем компьютере (Win8x64), то разрабатываемое приложение должно работать на трех осях Windows 7x64, 8x64, 8.1x64 с установленным .Net Framework версии 4 и выше.
* Приложение должно втихаря загружаться в момент загрузки ОС
* При копировании текста в буфер обмена приложение должно сохранять этот текст в памяти
* При вставки текста (например вызовом клавиш ctrl + v или соответствующим пунктом меню) должен вставляться последний отправленный в буфер текст
* При нажатии **ctrl + alt + v** должно появиться окно с возможностью выбора буфера
* История буферов должна сохраняться даже после перезагрузки
* Крайне необходима полноценная поддержка горячих клавиш
* Так как количество сохраненных элементов может быть огромным необходим удобный поиск по всем элементам
#### Код
Исходник проекта вы можете скачать [здесь](https://github.com/kin9pin/ClipboardToClipboard). Exe-файл можно забрать [здесь](https://www.dropbox.com/s/t0bbw7yasn5e1fp/ClipboardToClipboard.exe).
Я не буду заострять внимание на всём коде. Остановлюсь на некоторых моментах.
В самом начале запуска делается при помощи мьютекса проверка на то, чтобы не был запущен еще один экземпляр приложения:
```
static void Main()
{
bool createdNew;
Mutex mutex = new Mutex(true, "MY_UNIQUE_MUTEX_ClipboardToClipboard", out createdNew);
if (!createdNew)
{
MessageBox.Show("В памяти компьютера уже загружена один экземпляр данного приложения", Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Warning);
Process.GetCurrentProcess().Kill();
}
...
...
...
mutex.ReleaseMutex();
}
```
Сам процесс перехвата нажатия комбинации ctrl + alt + v
```
public static EventCtrlAltVHandler EventPressCtrlAltV;
private static Keys lastKey = Keys.FinalMode;
private static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
if ((nCode >= 0) && (wParam == (IntPtr)WM_KEYDOWN))
{
Keys key = (Keys)Marshal.ReadInt32(lParam);
if (lastKey == Keys.LMenu && key == Keys.V)
EventPressCtrlAltV();
lastKey = key;
}
return CallNextHookEx(_hookID, nCode, wParam, lParam);
}
```
В MainForm.cs имеется функция, которая имитирует нажатие ctrl + {*клавиша*}. В моем случае это было ctrl + v на выбранном из списка элементе
```
private static void SendCtrlhotKey(char key)
{
keybd_event(VK_CONTROL, 0, 0, 0);
keybd_event((byte)key, 0, 0, 0);
keybd_event((byte)key, 0, KEYEVENTF_KEYUP, 0);
keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
}
```
В принципе там ничего такого особенного нету. История хранится в xml-файле, настройки — прям в свойствах приложения… Кому интересно постарайтесь сами посмотреть, разобраться. Если будут вопросы, могу на них ответить.
#### Как на практике это всё выглядит и работает
Тут всё очень просто. Запускаем exe-шник. Выделяете фрагмент текста, жмакаете ctrl + c и в системном трее появляется уведомление:
Казалось бы, что эта фича бесполезна, но за ней скрывается более крутая фича — если на всплывающей подсказке кликнуть мышью, то откроется окно с возможностью добавления комментария:
Что делать с этим комментарием я расскажу попозже.
Теперь предположим, что нам понадобилось вставить текст, который фиг знает когда был скопирован в буфер обмена. Нет ничего проще — жмём ctrl + alt + v:
Мы тут же можем, перемещаясь по списку клавишами вверх или вниз, выбрать нужный нам текст. При этом, при перемещении в списке по элементам, появляется всплывающая подсказка, которая может быть удобна в том случае, если текст — многострочный. Кстати говоря, вот тут и отображается комментарий, который вы могли указать раннее:
Согласитесь, очень удобная фича при редактировании индуского кода)
Итак, вы выбрали нужный в списке элемент. Теперь просто нажимаете Enter и текст вставится в ту позицию вашего редактора, где установлен курсор.
В этом главном окне вы можете как поэлементно удалить выделенный фрагмент при помощи клавиши Del, так и полностью очистить весь буфер буферов; вы можете выделенному элементу задать комментарий при помощи комбинации ctrl + R.
Нажимая escape, окно прячется в трей.
Отдельного внимая заслуживает поиск. Если вам надо что-то найти в среди буферов, то можно быстро переключиться на поиск: ctrl + alt + v -> ctrl + f. В этом случае фокус устанавливается в строке поиска.
Вводим несколько ключевых букв, нажимает Enter -> теперь фокус будет на списке, по которому можно будет опять же перемещаться клавишами вверх или вниз. Если в строке поиска фокус и имеется текст, то при нажатии escape текстовое поле очищается. Повторное нажатие escape скрывает окно.
В настройках ничего особенного. Как-то реализовал уровень прозрачности, думал, что это будет полезная фича. На деле оказалось, что толку от нее мало. Оставил ее, но для себя прозрачность оставил 100%:
#### Заключение
Надеюсь, что мой инструмент будет вам полезен. Весь исходный код представлен как есть. Вы можете его изменять по усмотрению, можете добавить к нему по вкусу соль/перец, котят и т. д. без всяких у меня разрешений. Я не патентный тролль) | https://habr.com/ru/post/211653/ | null | ru | null |
# Немного про py2exe
Есть такое приложение. Называется py2exe. Оно позволяет упаковать, сконвертировать программу на python в exe файл (ну, точнее, exe и еще кучку других). Зачем оно все надо? Ну, далеко не у всех пользователей windows установлен интерпретатор python с нужными библиотеками. А вот упакованная программа в идеале должна запуститься на любой windows-машине.
#### Установка
К сожалению, py2exe не поддерживает третью версию питона.
Скачать py2exe можно на [SourceForge](http://sourceforge.net/projects/py2exe/files/ "скачать").
Если у вас стоит python (а он у вас наверняка стоит), проблем с установкой возникнуть не должно. Ставится в директорию python.
#### Конвертация
Теперь начинается самое интересное. В директории, где лежит Ваша программа на python, надо создать файл setup.py со следующим содержанием
> `Copy Source | Copy HTML1. from **distutils**.core import setup
> 2. import py2exe
> 3.
> 4. setup(
> 5. windows=[{"script":"main.py"}],
> 6. options={"py2exe": {"includes":["sip"]}}
> 7. )`
Где main.py имя Вашего скрипта.
Далее запускаем упаковку командой:
> setup.py py2exe
Да-да, именно так.
Смотрим, что у нас получилось. Две папки.
build — служебная, можно сразу снести.
dist — собственно, в ней и лежит наша программа.
Как было сказанно выше, это не один файлик:
* main.exe — программа
* pythonXX.dll — интерпретатор python'a
* library.zip — архив со скомпилированными исходниками (всего, кроме собственно программы, как я понимаю)
* .pyd — модули python, которые импортирует программа
* .dll — библиотеки, оказавшиеся необходимыми
* и еще файлы по мелочи, ниже будет сказано еще
Неужели все так просто? Неправда;)
#### Сложности
Скорее всего возникнут какие-то проблемы.
Например, пути к файлам. Не следует использовать относительные пути. Они ведут неведомо куда. Лучше использовать абсолютные.
Как его узнать? в интернете есть решение, функция module\_path.
> `Copy Source | Copy HTML1. import os, sys
> 2.
> 3. def module\_path():
> 4. if **hasattr**(sys, "frozen"):
> 5. return **os**.path.dirname(
> 6. **unicode**(**sys**.executable, **sys**.getfilesystemencoding( ))
> 7. )
> 8. return **os**.path.dirname(**unicode**(\_\_file\_\_, **sys**.getfilesystemencoding( )))`
Или приложение наотрез откажется запускаться (возможно, не у Вас, а у кого-то еще). Из-за отсутствие библиотек [Visual Studio](http://www.microsoft.com/downloads/details.aspx?FamilyID=9b2da534-3e03-4391-8a4d-074b9f2bc1bf&displaylang=en).
В качестве решения проблемы можно установить их на компьютер (но это же не наш метод) или кинуть dll и файл манифеста в папку с программой.
msvcr90.dll и Microsoft.VC90.CRT.manifest (не знаю как это лицензируется и выкладывать не буду)
Где их взять? Для меня самым простым было переустановить python (все остальное осталось на месте) в режиме «только для меня». И искомые файлы оказались в папке с python.
Целью топика не являлось раскрыть всех особенностей py2exe. [Здесь](http://www.py2exe.org/index.cgi/Tutorial) находится туториал, а [тут](http://www.py2exe.org/index.cgi/GeneralTipsAndTricks) некоторые советы и трюки.
#### Размер
В силу некоторых особенностей, приложение может получиться ужасающего размера. Но с этим можно и нужно бороться. Идеи подсказал [kAIST](https://habrahabr.ru/users/kaist/) (ну, кроме upx’а =р)
1. Самое действенное. Сжать библиотеки [upx’ом](http://upx.sourceforge.net/#download "сайт проекта"). Консольное приложение. Работает элементарно. На вход передается файл, оно его сжимает. Для моей [игры реверси](http://habrahabr.ru/blogs/python/87009/) размер уменьшился в ~3 раза.
2. Удалить unicodedata.pyd, bz2.pyd, select.pyd, w9xpopen.exe. Веса немного, но, как минимум, в проекте станет меньше файлов
3. Если в setup.py указать опцию optimize:2, то модули будут компилироваться в .pyo (python optimized code), а не в .pyc (python compiler script). Это не дает большого эффекта, но кто знает, может Вам повезет)
4. И наконец, можно подчистить library.zip от неиспользованных модулей и кодировок. Только аккуратно.
#### Вывод
Ну вот, кажется, и все. Мы добились, чего хотели. Да, приложение получилось солидного размера (это вам не C++, например), зато на нашем любимом Python:) | https://habr.com/ru/post/87224/ | null | ru | null |
# openSUSE 11.2 вышла в свет
Новая openSUSE принесла множество приятных изменений как пользователям KDE и Gnome так и тем пользователям, кто предпочитает более аскетичное окружение.
Подробности того что ждет вас в новой версии можно узнать под катом
Консервативных пользователей GNome порадует новая тема оформления в зеленых тонах, новый Gnome и обновленный фронтенд для NetworkManager'а, в котором теперь можно запретить выполнять обновление системы на мобильных соединениях
Пользователи KDE будут рады увидеть новый KDE 4.3. В новой openSUSE KDEшников порадует интеграция Firefox в KDE, которая включает в себя тему оформления, файловый диалог и уведомления, а также интеграция OpenOffice.org с KDE4.
LiveCD также претерпели изменения: на диск с гномом и с кде теперь по умолчанию включен Gimp и множество других программ, а также дополнительные локализации, среди которых есть и русская. Также по многочисленны пожеланиям на LiveCD теперь включен пакет pptp и соответствующий плагин для NetworkManager'а.
Кроме того, начиная с этого релиза все LiveCD являются гибридными, а это значит, что их можно не только нарезать на компакт диск, но и записать на флешку командой
`dd if=openSUSE-LiveCD.iso of=/dev/sdf bs=4M`
где **/dev/sdf** это ваша флешка.
Администраторов порадуют изменения в zypper, который теперь умеет разные стратегии обновления системы, по умолчанию установлена стратегия скачивания всех пакетов, а затем их установки.
Также для администраторов стоит напомнить что sshd теперь не стартует по умолчанию после установки, вы должны включить его запуск самостоятельно в YaST > System > System Services (Runlevel)
В Samba теперь по умолчанию как passdb используется tdbsam вместо smbpasswd, который использовался в предыдущих релизах. Подробные инструкции по конвертированию базы и переходу на новый формат можно найти в Release Notes
Сокет The MySQL перемещен в /var/run/mysql.
Из SaX2 убраны диалоги для конфигурации клавиатуры и мыши, используйте возможности своего DE для их настройки или отредактируйте настройки hal
Система управления пакетами также претерпела оптимизацию, rpm обновлен до версии 4.7 и теперь все пакеты локализации и kernel-source имеют архитектуру noarch, что позволило сэкономить место на DVD и в репозитариях.
Те пользователи, кто будет устанавливать 11.2 с DVD непременно заметят что у них установилось kernel-desktop ядро, вместо обычного -default. Это ядро специально оптимизировано для повышенной отзывчивости для использования на десктопе. В этом ядре выключена оптимизация по размеру включен FULL\_PREEMTION и установлен параметр HZ=1000. Для пользователей установивших openSUSE с LiveCD -desktop ядро доступно в репозитариях.
Одна из изюминок дистрибутива — YaST также подвергся изменениям. Во-первых YaST обрел своего маскота — трубкозуба Ясти, во-вторых Qt версия YaST теперь полностью написана на Qt4 и превосходно вписывается в окружение KDE4 и в-третьих в дистрибутиве поставляется экспериментальная поддержка web-интерфейса для YaST
Значительно улучшен модуль YaST для разметки дисков, теперь во время установки можно настроить шифрование дисков, а также выбрать экспериментальные файловые системы, такие как btrfs.
[Выбрать наиболее удобный способ и скачать](http://software.opensuse.org/112/ru)
Перед обновлением и установкой не забудьте прочитать [Release Notes](http://download.opensuse.org/distribution/11.2/repo/oss/docu/RELEASE-NOTES.en.html)
**And don't forget — Have a lot of fun!**
**UPD:** для наиболее быстрйо закачки используйте aria2c, именно для этой утилиты или для любой другой качалки, поддерживающей металинки, оптимизирован download.opensuse.org | https://habr.com/ru/post/74925/ | null | ru | null |
# VDOM своими руками
Привет.
У многих frontend-разработчиков бытует мнение, что технология VDOM, которая, в частности, используется в React.js, работает как черный ящик. Так же на просторах npm есть куча библиотек, реализующих эту технологию, однако вот как по мне — так в них черт ногу сломит. Сама тема VDOM-а меня заинтересовала некоторое время назад и я начал экспериментировать наощупь, сам. В конечном итоге все кончилось тем, что я сделал свою реализацию VDOM-а и встроил в свой фрейморк для датагридов (о нём я как-нибудь напишу). Это оказалось не просто, а очень просто и в этой статье я детально объясню что к чему, зачем и почему. И как оно работает тоже расскажу. Ныряйте под кат и мы предадимся интересному опыту.
Disclamer
=========
Я не фронтенд-разработчик. Не бейте меня тапками.
Так же, не стоит писать "возьми готовый фреймворк, дубина". Я знаю о том, что есть готовые фреймворки, но мне нужна собственная реализация по ряду сугубо технических причин.
Зачем оно надо
==============
*TL;DR*: [Пример из этой статьи на jsfiddle](https://jsfiddle.net/9no687oa/), [исходники](https://github.com/reinforced/Reinforced.VdomSample)
На хабре [где-то уже была статья про VDOM](https://habrahabr.ru/post/256965/), но объяснение сути дела в ней мне не нравится. Поэтому давайте я на пальцах раскидаю. Итак, положим у вас есть веб-страничка, ага? В ней отрисован некий HTML-элемент (вероятно, довольно большой). Чтобы немного добавить контекста — скажу что этот элемент отрисован посредством натягивания шаблона на вью-модель. Ну все пользовались фреймворками, которые делают подобное, ведь так? Handlebars там, lodash-шаблоны, AngularJS в какой-то мере… И вот короче представьте что модель, на которую натягивается шаблон — поменялась. И вам надо отрисовать эти изменения внутри HTML-элемента. Возникает вопрос — а как это сделать и при этом не попасть впросак? Тут, как водится, есть несколько вариантов.
### innerHTML
Можно прогнать модель данных через шаблонизатор, получить HTML и просто сделать `element.innerHTML = ourHtmlString;`. Дешево и сердито, но для некоторых задач вполне прокатывает. Что же здесь ужасного, спросите вы?
А я вам отвечу: этот вариант плох прежде всего потому, что все дочерние элементы, расположенные внутри `element` будут беспощадно убиты браузером и заменены новыми. Следовательно? Да, следовательно вы потеряете все подписки на события (в рамках вашего элемента, конечно же), которые у вас были. Вам придется переподписывать вновь созданные элементы заново. Тут я, честно признаюсь, не в курсе как работает сборка мусора в разных js-движках, но допускаю что если ранее в своем коде вы сохранили какие-то из дочерних элементов, например, в переменные, то эти элементы будут убраны из дерева, но не уничтожены. Привет, утечка памяти, мы по тебе скучали. Ну это если предположить что браузер использует для DOM-элементов reference counting, например. Кто знает подробности — отпишите в комментариях пожалуйста.
Окромя этого — сей вариант дюже медленный, особливо когда дочерних элементов много. То есть браузер честно сотрет все, что было отрисовано внутри элемента, пересчитает и перерисует заново. Вот представьте — нарисована у вас карточка пользователя Гриши, в которой 100 разных полей. А у вас в данных изменилась только дата рождения. И что теперь — "Все фигня, Гриша, давай по-новой" ради одного несчастного куска текста? Убьем Гришу целиком, посчитаем и нарисуем заново? А вы знаете, что перерисовка интерфейса в браузере — это вообще-то долго? И если Гриша состоит из 150 элементов — то еще куда ни шло. А вот если из тысячи (вскрытие показывает у Гриши обилие мелких деталей) — то на отдельных машинах перерисовка может достигать нескольких секунд, что дюже снижает отзывчивость интерфейса.
Ну и самое печальное: через innerHTML отрисовываются не все элементы. Как пример — в IE8 [невозможно установить innerHTML](https://stackoverflow.com/questions/4729644/cant-set-innerhtml-on-tbody-in-ie) у элемента `tbody`. В Google Chrome через innerHTML плохо рендерятся заголовки таблиц (`th`). Все, что вы туда вставите через innerHTML — будет урезано до обычного текста по неведомой мне причине. Пруфлинка не будет — информация из собственного опыта. Вероятно сейчас это уже починили, но осадочек остался.
Таким образом innerHTML — как быстрый и грязный хак. Ненадежен в общем случае, имеет кучу сайд-эффектов, да и вообще — мы тут не в 9 классе школы чтобы так писать. Из плюсов — реализуется на коленке.
### Парсер HTML
Откровенно говоря, этот вариант решает только последнюю и самую печальную проблему innerHTML — крайнюю привередливость в создаваемых элементах. Но упомянуть его определенно стоит, во многом потому что он нам понадобится для реализации VDOM.
Как оно работает? Да просто работает. Парсит HTML и вызывает `document.createElement` для каждого узла с последующей установкой атрибутов. Потом делаете `element.innerHTML = ''` и проходитесь по полученным элементам, вызывая `appendChild`/`insertBefore`.
Ну… Во-первых, мы не решили проблему с убиением элементов. Во-вторых, с парсерингом HTML всё не так гладко в этом мире.
Парсить HTML — это примерно как парсить XML-документ и в парсерах для клиентской стороны чаще всего употребляется ~~в пищу~~ поточный парсер. Дада, это примерно как [StAX в Java](https://en.wikipedia.org/wiki/StAX). Доказано, что употребление поточного парсера XML полезно для здоровья. Почему? Да потому что работает быстро и пишется легко. Не стоит использовать для этой задачи классический древесный парсер как для XML. Оно тут просто не нужно.
Все в мире HTML-парсеров хорошо, кроме одного: нету их, бедняжек, встроенных в браузеры. В MDN [упоминается DOMParser](https://developer.mozilla.org/ru/docs/Web/API/DOMParser), однако он все еще экспериментален и, видимо, отдаст вам на выходе дерево. Ну вот только обходить деревья и вызывать `document.createElement` нам на стороне клиента-то и не хватало, ага. Словом, странный он. Давайте не будем его трогать. Есть [htmlparser2 — вон лежит в npm](https://www.npmjs.com/package/htmlparser2). Событийный поточный парсер, но я сам его не пользовал, ибо как идеология моего фреймворка не позволяет мне использовать сторонние зависимости. И вот есть [статья и пример кода Джона Резига](https://johnresig.com/blog/pure-javascript-html-parser/) (пожалуйста, воспринимайте его в отрыве от jQuery), где он объяснет всё на пальцах и дает код простенького парсера. Мне он не нравится тем, что работает на регулярных выражениях. Вижу сие зело трудозатраным. Однако, вполне работоспособным. Долгое время у меня (каюсь) использовался как раз код из этой статьи, переработанный под TypeScript. Однако потом я заменил его на поточный парсер на простенькой state-машине (коим я с вами сегодня и поделюсь), дабы минимизировать сравнения строк и сделать поддержку создания виртуальных элементов (что в пример Джона запиливать было несколько неудобно).
### VDOM собственной персоной
И вот мы наконец подошли к самому хитрому подходу, который решает проблемы как с производительностью, так и с привередливостью innerHTML к элементам. А именно — используя парсер HTML мы можем, внезапно, распарсить наш HTML, но вызывать для каждого элемента не `document.createElement`, а просто создание какого-либо объекта, который будет хранить имя тега и атрибуты. Этот самый объект и будет называться *виртуальным DOM-узлом*, а их совокупность — *виртуальным DOM-деревом*, или VDOM. Здесь стоит отметить, что создать тысячу объектов в JS через `var a = {};` — это быстро. Очень быстро. А вот создать тысячу реальных DOM-узлов — это медленно. Из этого обстоятельства, собсно, и проистекает прирост производительности.
Окей, создали. И что же мы будем с этим добром делать? ~~Снимать штаны и бегать~~ Штаны можно не снимать, а вот бегать придется: мы будем **сравнивать** структуру нашего VDOM-дерева с тем, что уже отрисовано, составлять из этого некое подобие diff-патча (что надо доабвить, что убрать, куда докинуть атрибутов, где поменять контент) и накатывать его на существующее DOM-дерево. Вот прям так же, как это происходит в вашем любимом git во время мерджей. Благо, задача построения diff-а в программировании довольно известная — гуглится, внезапно, по словам [нахождение наибольшей общей подпоследовательности](https://ru.wikipedia.org/wiki/%D0%9D%D0%B0%D0%B8%D0%B1%D0%BE%D0%BB%D1%8C%D1%88%D0%B0%D1%8F_%D0%BE%D0%B1%D1%89%D0%B0%D1%8F_%D0%BF%D0%BE%D0%B4%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE%D1%81%D1%82%D1%8C). Решается она динамическим программированием. Алгоритм имеет квадратичную сложность. В хороших ВУЗах решение этой задачи изучают на первых курсах, но здесь я его тезисно опишу и подскажу как адаптировать его под деревья.
**UPD:** *в комментариях меня уже закидали помидорами на предмет того, что LCS для данной задачи неоптимален — необходимо использовать LIS, но я не могу переписать статью и код так быстро. Так что просто держите в голове, что ту часть, которая занимается высчитыванием diff-а можно оптимизировать гораздо "плотнее".*
В итоге, VDOM-подход не убивает те элементы дерева, которые не изменились и не создаёт лишних элементов, что знатно экономит память и сохраняет подписки на события (если элементы не уничтожаются), одновременно заставляя ваш CPU больше заниматься сравнениями, нежели созданием HTML-элементов. А это даёт знатный прирост производительности, когда из 1000 элементов на экране изменился только один.
Приступим
=========
Мы напишем небольшое приложение, которое будет состоять из `textarea` слева, в которой вы будете вбивать и/или изменять свой HTML, а в окошке справа — видеть результат работы. Никаких дополнительных библиотек — только TypeScript и браузер. Будем, что называется, творить магию из воздуха.
Вы знаете, сначала я хотел добавить в эту статью много кода с построчным разбором оного, но памятуя свои предыдущие статьи, не решился это делать. Непосредственно код снижает читаемость и нагоняет тоску. Так что, с вашего позволения, я просто буду давать ссылки на Github и объясню как и что работает. Наш VDOM будет состоять из трёх главных компонент — парсера HTML, непосредственно компаратора и калькулятора батчей, а так же `app.ts`, который соберёт это всё добро вместе и заставит работать.
Парсер
------
Тут надо сделать оговорочку. Как я понимаю, React.js работает без парсера HTML в виду того, что его шаблоны (jsx/tsx) уже собираются в соответствующие вызовы создания нод. Это хороший ход, улучшающий быстродействие, но вы знаете… создавать свой язык шаблонизации и писать для него компилятор не входило в мои планы, когда я писал эту статью. Так что мы будем парсить голый HTML руками. Такая реализация гарантирует нам возможность встраивать нашу поделку куда угодно, ну и позволит избежать чисто педагогических курьёзов, если вы понимаете о чём я :) Итак, поехали.
### Стек
JavaScript не содержит эффективных инструментов для работы со стеками, а таковой нам понадобится. Поэтому делаем [простенький стек](https://github.com/reinforced/Reinforced.VdomSample/blob/master/Reinforced.VdomSample/Stack.ts). Без комментариев.
### Конструктор нод
Как вы знаете, с точки зрения JavaScript, HTML-документ состоит из нод. Некоторые из которых вполне себе являются HTML-элементами, такими как HTMLInputElement (тег `input`), HTMLDivElement (тег `div`). А некоторые — нет (текст, комментарий). Все доступные типы нод перечислены [вот здесь, в MDN](https://developer.mozilla.org/ru/docs/Web/API/Node/nodeType). Мы же начнем с простого — объявим интерфейс т.н. "конструктора нод". Чтобы не вхардкоживать в наш парсер HTML-я вызовы `document.createElement` и использовать один и тот же парсер что для DOM, что для VDOM. В моей реализации он выглядит [вот так](https://github.com/reinforced/Reinforced.VdomSample/blob/master/Reinforced.VdomSample/IHtmlConstructor.ts). Как видим, мы ограничиваемся тремя типами нод — HTML-элемент, текст (контент) и комментарий. Интерфейс крайне прост и предусматривает возможность создания всех трех типов нод, а для HTML-элемента ещё и установку аттрибутов. Чтобы далеко не отходить от кассы, тут же реализуем его для реальных HTML-нод. [Это очень просто. Справится даже ребёнок](https://github.com/reinforced/Reinforced.VdomSample/blob/master/Reinforced.VdomSample/DOMConstructor.ts).
Тут же мы продумаем как мы будем хранить VDOM-ноды. Что нам важно знать о ноде, помимо её типа? В случае с HTML-элементом — тег да атрибуты. В случае с комментарием и текстом — контент. Плюс ко всему прочему нам так же важен список дочерних нод. Отлично. Описываем интерфейс и `enum` для типов, после чего реализуем сам конструктор: [вот так](https://github.com/reinforced/Reinforced.VdomSample/blob/master/Reinforced.VdomSample/VDOMConstructor.ts).
### Парсер HTML
Парсер — это у нас будет такая штука, у которой есть ограниченной число **состояний**. Она ~~неспеша~~ идёт по переданному ей HTML, символ за символом и в зависимости от текущего символа меняет своё состояние. При переходе из состояния в состояние парсер будет дёргать методы конструктора нод, выполняя соответствующие действия.
Например: читает парсер символы, никого не трогает. Оп — встретил `<`, запоминает где его увидел, меняет состояние на "слушаем внимательно, сейчас будет HTML-тег". Читает дальше. Оп — встречает пробельный символ, и такой: ага! вот оно и имя тега. Вспоминает где встретил `<`, выгрызает текст оттуда до текущей позиции — вот вам и имя тега. Стало быть, надо дернуть нод-конструктор и вызвать у него `create`, передав имя тега. Дальше парсер пропускает все пробельные символы и если видит `>`, то переходит в изначальное состояние. А если видит букву алфавита — так же ловит имя атрибута, `=`, значение атрибута в кавычках, дергает нод-конструктор… Ну и так далее, пока не дойдет до конца.
Созданные теги мы будем хранить в стеке. Каждый раз, когда мы доходим до открывающего тега — кладём его в стек. При создании элемента через конструктор, указываем текущую макушку стека как родительский элемент. Тривиально. Уверен, все хоть раз, да делали нечто подобное, когда писали калькулятор на первых курсах университета.
Все состояния, а так же действия при переходах мы сложим в *state-машину*, которая технически представляет из себя огромный ~~Dictionary, чёртов C# в голове~~ hash-объект вида "состояние" -> "описание действий". Описание действий в нашем случае состоит из трёх частей:
* функция, которая выполнится на входе в состояние;
* функция, которая выполнится на выходе из состояния;
* функция, которая будет вызываться для каждого следующего считанного символа;
Я объединил эти три функции в штуку, которую назвал [IStateInfo](https://github.com/reinforced/Reinforced.VdomSample/blob/master/Reinforced.VdomSample/IStateInfo.ts). Там же я описал все возможные состояния парсера. Сделал [сам парсер](https://github.com/reinforced/Reinforced.VdomSample/blob/master/Reinforced.VdomSample/StreamHtmlParser.ts), снабдив его несколькими полезными тестер-функциями (это когда мы смотрим какой у нас символ текущий, что было n символов назад, складываются ли следующие за текущим m символов в такое-то слово, ну и иже с ними). Особливо выделяется функция `fix()`: когда мы меняем состояние парсера — она запоминает позицию текущего символа с той мыслью, чтобы сдвинувшись на несколько символов далее, мы могли выгрызть кусок текста между запомненной позицией и текущим положением. Выгрызание куска текста от запомненной позиции до текущей производится функцией `cut()`. Обычно, после вызова `cut()` — state-машина подает парсеру **сигнал** — вроде "о, смотри, открывающий тег поймали, вот его имя". Почему так сложно? Ну… я — человек экономный. Сделал парсер, который не создает лишних строк без необходимости.
Ну и, собственно, дальше я просто перечислил все возможные состояния парсера и все возможные действия — что называется, [запрограммировал state-машину](https://github.com/reinforced/Reinforced.VdomSample/blob/master/Reinforced.VdomSample/ParseMachine.ts). Там есть много нюансов, связанных с кавычками вокруг атрибутов, самозакрывающимися тегами, символами `-` и `:` в именах атрибутов. Разрешите мне опустить здесь детальное разжевывание каждого из этих кейсов — всё есть в коде, при желании вы сами это увидите.
Ещё одна особенность: теги `style` и `script` парсер вырезает и складывает отдельно, дабы пользователь парсера сам решил ~~казнить их или помиловать~~ что с ними дальше делать. Можно, например, сделать `eval` у скриптов. А вот что делать со стилями — вопрос неясный даже для меня. Единственное, что не учтено в моей реализации — это хитрая возможная структура этих тегов. Скажем, если в `script`-е у вас встречается текст в духе `return '';`, то парсер по ошибке распознает оный как закрытие тега `script`, что неприятно, однако легко чинится ~~, просто мне лень~~.
Высчитываем разницу
-------------------
Итак, на текущем этапе мы имеем годный HTML-парсер, которому можно передать кусок HTML-я и распарсить его в реальные DOM-элементы, или же в VDOM-элементы. Это просто прекрасно.
Теперь представьте, что у нас уже отрисован на экране какой-то HTML, мы хотим его незначительно поменять. Берём его, вносим коррективы, скармливаем парсеру с VDOM-конструктором. Получаем список VDOM-нод. Теперь нам надобно высчитать разницу между HTML-ем, который отрисован на экране и тем, что нам напарсил наш парсер. По сути дела надо взять parent-нод, внутри которого отрисован наш HTML, взять массив всех его детей и сравнить его с аналогичным массивом виртуальных детей, который нам создал HTML-парсер. И когда я говорю "сравнить" — я имею в виду не просто ответить на вопрос "совпадают или нет", но и сгенерировать т.н. "update batch" — список какие элементы куда надо добавить, а какие откуда удалить чтобы из старого куска дерева получить новое. После чего, полученная пачка изменений просто накатывается на уже отрисованный HTML, не уничтожая уже отрисованное и неизменённое, но умно меняя только затронутые ноды. Называется эта операция **VDOM update**. Вот как-то так. Но, обо всём по порядку.
### Кэш сравнений
Для начала надо научиться сравнивать HTML-ноды и VDOM-ноды. Делается это относительно просто:
1. Сравниваем типы. Если не совпадает — ноды разные
2. Если обе ноды текстовые или комментарии — сравниваем контент. Совпадает? Одинаковые. Не совпадает? Разные.
3. Сравниваем количество атрибутов. Не совпадает? Разные.
4. Содержательно сравниваем наличие атрибутов и их значения. Что-то не совпало? Ну вы поняли.
5. Проделываем шаги 1-4 для каждой ноды-потомка.
6. Если вы это читаете, значит ноды всё-таки совпадают.
Как можно заметить, каждый раз с нуля сравнивать ноды — это трудозатратно. Во многом из-за рекурсии на 5 шаге. Поэтому я сделал кэш-компаратор, который живет в рамках одного update-а и хранит результаты сравнений нод друг с другом. Таким образом, если тот факт, что два нода — разные уже когда-то был установлен, то он не устанавливается заново, а берется из кэша. [Много однотипного кода](https://github.com/reinforced/Reinforced.VdomSample/blob/master/Reinforced.VdomSample/CompareCache.ts).
### LCS
Это сокращение от "Longest Common Subsequence". [Этот класс](https://github.com/reinforced/Reinforced.VdomSample/blob/master/Reinforced.VdomSample/Lcs.ts) по сути представляет собой матрицу для решения LCS-задачи методом динамического программирования. Мы ему даём на вход два массива — один из реальных нод, другой — из виртуальных, так же скармливаем кэш сравнений, про который я рассказал выше. Дальше, вызываем `produceModifyBatch` и получаем массив [batch entries (описаны в самом низу)](https://github.com/reinforced/Reinforced.VdomSample/blob/master/Reinforced.VdomSample/Defs.ts), который по сути говорит что надо сделать с такой-то по счету нодой — обновить, удалить, или вставить другую (и какую именно) ноду ПЕРЕД ней.
Первым делом после вызова `produceModifyBatch`, LCS урезает одинаковые элементы с начала и с конца массивов (функция `doSkips`). Далее на оставшихся данных стоится матрица динамического программирования — [точно так, как объясняется вот в этом видео](https://www.youtube.com/watch?v=P-mMvhfJhu8). Затем оную обходят, определяя какие ноды надо **удалить**, а какие — **добавить** (тоже описано в видео). Обратите внимание, что на этом этапе мы не получаем список нод, которые надо **обновить**. Результат содержит только удаления-добавления, но! Но удаление-добавление ноды в одно и то же место (или добавление-удаление) — это и есть **обновление**. Операция `normalizeBatch` как раз и делает, что схлопывает рядом стоящее добавление-удаление в одну операцию — **обновление**, переформатируя первичный массив batch entry-ев. Полученный результат, наконец, можно вернуть счастливому пользователю.
LCS — и есть самое сложное в VDOM-е, из-за чего многим он кажется страшной магией. Как видите, сам алгоритм, что называется, tricky, но вполне себе понимаемый. Сложность его, кстати, квадратичная, но бояться нечего. Если изменений относительно мало и они где-то в середине пачки элементов — большинство отсекается на стадии `doSkips` и в результате матрица динамического программирования нечасто превышает по размерам 3x3. Конечно же, если ваши пользователи не перерисовывают 10 тысяч кнопочек, стоящих друг под другом. На практике такие случаи происходят редко. Так что имеет смысл не строить LCS-матрицу, если у вас 2 или 1 элемент, а обработать результат "руками". Гораздо чаще в реальной жизни встречается большая вложенность элементов, если на то пошло. Но, однако, недостаточная чтобы сорвать стек вызовов в JS (у нас дальше будет рекурсивная обработка). Вот так и живём. Не знаю, возможно тот же React.js пошел ещё дальше в оптимизации этого процесса — я его исходники не читал. Кто знает — отпишитесь. Все мои задачи же вписываются в означенные ограничения с огромным запасом.
### Материализатор и DOM Differ
Наконец, пишем метод update, который заменяет потомков выбранного нами parent-элемента, через LCS-сравнение, на полученный от HTML-парсера массив виртуальных нод. Тут нам, очевидно, понадобится [материализатор нод](https://github.com/reinforced/Reinforced.VdomSample/blob/master/Reinforced.VdomSample/Materializer.ts) — штукенция, которая превращает виртуальную ноду в реальную. Без комментариев.
И создать кэш сравнений заранее! ~~И животноводство!~~
Сам update: берем потомков parent-а, берем массив VDOM-нод. Создаем LCS, получаем update batch. Меланхолично проходим по нему, собираем всех, кого надо добавить в один массив, всех, кого надо удалить — в другой. Всех, кого надо обновить — сначала обновляем список аттрибутов несложной функцией `updateAttributes`, а потом рекурсивно применяем тот же самый метод update, который мы в настоящий момент и описываем (предварительно, достав массив потомков из VDOM-ноды-донора). В итоге: всех, кого надо добавить — прогоняем через материализатор, делаем `parent.insertBefore`. Всех, кого надо удалить — делаем `parent.removeChild`. Упражнение закончено. [Код вот тут](https://github.com/reinforced/Reinforced.VdomSample/blob/master/Reinforced.VdomSample/DOMDiffer.ts).
Для дебага я ещё добавил функцию `diff`, которая выводит в консоль содержимое update batch-а. Однако, на практике её вывод несколько сложен для понимания.
### Все вместе
Создаем [простенький HTML-документ с бутстраповскими стилями](https://github.com/reinforced/Reinforced.VdomSample/blob/master/Reinforced.VdomSample/index.html), создаем [app.ts](https://github.com/reinforced/Reinforced.VdomSample/blob/master/Reinforced.VdomSample/app.ts), из которого и задействуем нашу прекрасную наработку для демонстрации.
Итоги
=====
Вы прочли статью о том, как устроен VDOM. Надеюсь, после такого экскурса, у вас появится больше понимания зачем оно надо и как оно устроено, исчезнет страх перед неизвестным и вы будете немного больше ориентироваться в происходящем внутри модных JS-фреймворков. Кому-то, возможно, понравится компактный HTML-парсер — забирайте, я не возражаю.
Всем спасибо за прочтение, комментарии приветствуются. | https://habr.com/ru/post/348378/ | null | ru | null |
# Сказ об одной ошибке, так и не попавшей в релиз ядра Linux
Совсем недавно вышло исправление, устраняющее полное зависание 32-битного ядра Linux при загрузке на процессорах Intel. Здесь небольшая история о том, откуда появилась ошибка и какие проводились исследования по поиску причин её возникновения.
Начну с небольшого экскурса в процесс загрузки. Большинство из вас уже знает, что в загрузке ОС существует множество фаз, две из которых, к примеру, загрузка загрузчика (простите за тавтологию) и загрузка им ядра ОС, в нашем случае Linux. Давайте чуть копнём в сторону, что же происходит в момент после передачи управления загрузчиком ядру Linux.
Условно ядро Linux можно разделить на две части по исполнению — загрузочная и исполняемая. После получения управления ядром оно исполняет загрузочную часть, на которую приходится декомпрессия и расположение ядра в физической памяти системы. Затем происходит минимальная настройка менеджера памяти, детектирования типа процессора и его флагов и т.п. После осуществления этих шагов передаётся управление в код, где уже непосредственно начинает работать непривязанная к архитектуре часть ядра (строго говоря это не совсем так, но здесь мы подчеркиваем переход от ассемблерного кода к Си коду). Более подробно процесс описан в [[1]](http://www.ibm.com/developerworks/library/l-linuxboot/).
Теперь вспомним ещё такой факт, что в современных процессорах используется т.н. «микрокод», конфигурирующий исполнение некоторых инструкций процессора. Также он позволяет устранять некоторые недочёты железа без перевыпуска кристалла.
Естественным желанием разработчиков ядра любой ОС является возможность наложить исправления как можно раньше в процессе загрузки. Ранее, в Linux, этим вопросом занимались специальные демоны в пространстве пользователя, загружающиеся на довольно позднем этапе.
Несколько лет назад Fenghua Yu предложил ([см. [2]](https://lwn.net/Articles/530346/)) класть файл микрокода в начальный образ RAM-диска (initrd) и использовать его на ранних стадиях. Изменение сильно улучшило ситуацию, но остались всё ещё недостатки, в частности необходимость начального образа диска и невозможность держать микрокод для разных версий процессоров, так как имя файла фиксированное.
Совсем недавно Borislav Petkov решил исправить первый из них, опубликовав изменение [[3]](http://www.spinics.net/lists/linux-tip-commits/msg28000.html).
Вот тут-то и начинаются пляски. Вызов функции `load_ucode_bsp()` для 64-битных и 32-битных ядер происходит из разных по своей сути мест процесса загрузки ядра. В 64-битном окружении вызов совершается уже из Си-кода, где MMU и программный менеджер памяти проинициализированы, но в 32-битном случае он происходит сильно раньше.
Эффектом сего поведения стало вот что. Рассмотрим причинную функцию load\_builtin\_intel\_microcode(), которая исполняется на раннем этапе.
```
static bool __init load_builtin_intel_microcode(struct cpio_data *cp)
{
unsigned int eax = 0x00000001, ebx, ecx = 0, edx;
unsigned int family, model, stepping;
char name[30];
native_cpuid(&eax, &ebx, &ecx, &edx);
family = __x86_family(eax);
model = x86_model(eax);
stepping = eax & 0xf;
sprintf(name, "intel-ucode/%02x-%02x-%02x", family, model, stepping);
return get_builtin_firmware(cp, name);
}
```
Обратите внимание на вызов внутриядерной библиотечной функции `sprintf()`. Именно её вызов в независимости от параметров (при условии их корректности) рушит систему.
Что же там происходит? Мой коллега, MIka Westerberg, предположил, что причина именно в столь раннем вызове кода, когда на самом деле функции вызываются по их физическим адресам, а не виртуальным. Пока не настроено MMU и не проинициализирован менеджер памяти, виртуальные адреса не работают, поэтому для выполнения необходимо соответствие между виртуальными и физическими адресами 1-в-1, чего не наблюдается для части функционала. (Кстати, если попытаться вызвать `strcpy()`, то результат будет таким же.)
Невдалеке маячит merge window (о нём я немного рассказывал ранее в [[4]](http://habrahabr.ru/post/253421/)), и Borislav решил пока что отключить своё изменение для 32-битных ядер, выслав обновление [[5]](http://permalink.gmane.org/gmane.linux.kernel/1969480).
Мораль басни такова, что загрузка ОС — весьма тонкий процесс, требующий довольно глубоких знаний архитектуры, чтобы понимать происходящее там.
[1] [www.ibm.com/developerworks/library/l-linuxboot](http://www.ibm.com/developerworks/library/l-linuxboot/)
[2] [lwn.net/Articles/530346](https://lwn.net/Articles/530346/)
[3] [www.spinics.net/lists/linux-tip-commits/msg28000.html](http://www.spinics.net/lists/linux-tip-commits/msg28000.html)
[4] [habrahabr.ru/post/253421](http://habrahabr.ru/post/253421/)
[5] [permalink.gmane.org/gmane.linux.kernel/1969480](http://permalink.gmane.org/gmane.linux.kernel/1969480)
**UPDATE.**
Совершенно забыл дописать одно важное замечание. Множество разработчиков тестирует свой код не на реальных машинах, а в виртуальных, с помощью того же QEMU. Так вот там всё прекрасно работает.
В [комментариях](http://habrahabr.ru/post/259535/#comment_8448707) [jcmvbkbc](https://habrahabr.ru/users/jcmvbkbc/) поделился своим анализом происходящего. | https://habr.com/ru/post/259535/ | null | ru | null |
# Реализация мьютекса вне ОС на примере микроконтроллера AVR и шины TWI
Решил однажды для себя я соорудить погодную станцию. Датчики там разные, в том числе на шине I2C. И как годится, обычно вначале, сделал все на флагах ожидания. Но путь настоящего джедая иной, и было решено все повесить на прерывания. Вот тут и начался геморрой. Проблема, с которой я столкнулся это обработка нескольких подряд идущих запросов. Например датчик давления [BMP085](https://www.sparkfun.com/datasheets/Components/General/BST-BMP085-DS000-05.pdf) для дальнейшей работы с ним, требует вытянуть из его EEPROM 11 калибровочных констант:
О том как я пришел к решению и последовательность хода мыслей изложены ниже.
#### Флаги ожидания
Определим функции **get\_AC1, get\_AC2,…, get\_MD**. Каждая из них получает соответствующую константу из EEPROM датчика по шине I2C. Формат посылки из даташита:
И пример кода для функции **get\_AC1**:
**get\_AC1**
```
int get_AC1(void)
{
union {
unsigned int Word;
unsigned char Byte[2];
} AC1; // Определяем AC1
// ----------------------------------------
TWCR = (1<
```
А вот ее осциллограмма:
Использование союза union для AC1 связано с разностью порядка байт. Для TWI это big-endian, для AVR — little-endian. Функция **get\_AC2** отличается лишь посылкой байта **0xAC** (смотрим в даташит) вместо **0xAA** после команды **SLA+W**. Во всем остальном функции абсолютно идентичны. Поэтому мы можем определить одну **get\_Data**, которая в качестве параметров будет принимать те самые Register address в соответствии с даташитом:
**get\_Data**
```
int get_Data(unsigned char Register_adress)
{
union {
unsigned int Word;
unsigned char Byte[2];
} Data; // Определяем Data
// ----------------------------------------
TWCR = (1<
```
а дальше просто:
```
struct {
short AC1;
short AC2;
short AC3;
unsigned short AC4;
unsigned short AC5;
unsigned short AC6;
short B1;
short B2;
short MB;
short MC;
short MD;
} BMP085_EEPROM;
...
static void get_EEPROM(void)
{
BMP085_EEPROM.AC1 = get_Data(0xAA);
BMP085_EEPROM.AC2 = get_Data(0xAC);
BMP085_EEPROM.AC3 = get_Data(0xAE);
BMP085_EEPROM.AC4 = get_Data(0xB0);
BMP085_EEPROM.AC5 = get_Data(0xB2);
BMP085_EEPROM.AC6 = get_Data(0xB4);
BMP085_EEPROM.B1 = get_Data(0xB6);
BMP085_EEPROM.B2 = get_Data(0xB8);
BMP085_EEPROM.MB = get_Data(0xBA);
BMP085_EEPROM.MC = get_Data(0xBC);
BMP085_EEPROM.MD = get_Data(0xBE);
}
```
Вот что получилось в итоге:
#### Работа на прерываниях
##### Предисловие
Как видно из рисунка выше, длительность одной операции составляет **488 мкс**, для частоты передачи шины в **100 кГц**, что составляет **3094 такта** процессора на частоте **8 МГц**. Ну это ни в какие ворота ребята. Конечно, можно повысить частоту, если целевое устройство позволяет. Например для **400 кГц** длительность составляет **128 мкс** или **1024 такта**
Ожидание поднятия флага — операция абсолютно бесполезная. За тысячи тактов процессор может сделать много полезной работы, например, выполнить операцию деления чисел с плавающей запятой. Поэтому единственным адекватным выходом из этой ситуации является использование прерывания.
##### Работа на прерываниях
Определим структуру:
```
struct {
unsigned char SLA; // Slave address
unsigned char *pW; // Откуда?
unsigned char nW; // Сколько?
unsigned char *pR; // Куда?
unsigned char nR; // Сколько?
} TWI;
```
а теперь и нашу функцию **get\_AC1**:
```
unsigned char Register_address;
...
void get_AC1(void)
{
Register_address = 0xAA; // Определяем Register address
TWI.SLA = 0x77; // Slave address нашего BMP085
TWI.pW = &Register_address; // Указатель откуда брать данные для записи
TWI.nW = 1; // Сколько байт записывать?
TWI.pR = &BMP085_EEPROM.AC1; // Указатель куда считывать?
TWI.nR = 2; // Сколько байт считывать?
TWCR = (1<
```
Пара слов об обработчике прерывания. Если **nW = n**, **nR = 0**, формат фрейма:
если **nW = 0**, **nR = m**:
и, если **nW = n**, **nR = m**:
К слову обработчик прерывания может быть каким угодно. Логику конечного автомата можно реализовать по-разному. Пример моего показан ниже:
**Обработчик прерывания**
```
ISR(TWI_vect)
{
/* -----------------------------------------------------------------------------------
Jump table which is stored in flash
------------------------------------------------------------------------------------*/
static const void * const twi_list[] PROGMEM = {&&TWI_00, &&TWI_08,
&&TWI_10, &&TWI_18,
&&TWI_20, &&TWI_28,
&&TWI_30, &&TWI_38,
&&TWI_40, &&TWI_48,
&&TWI_50, &&TWI_58,
&&TWI_60, &&TWI_68,
&&TWI_70, &&TWI_78,
&&TWI_80, &&TWI_88,
&&TWI_90, &&TWI_98,
&&TWI_A0, &&TWI_A8,
&&TWI_B0, &&TWI_B8,
&&TWI_C0, &&TWI_C8,
&&TWI_F8};
/* -----------------------------------------------------------------------------------
Jump to label, address of which is in twi_list[TWSR>>3]
------------------------------------------------------------------------------------*/
goto *(pgm_read_word(&(twi_list[TWSR>>3])));
/* -----------------------------------------------------------------------------------
Bus error handler
------------------------------------------------------------------------------------*/
TWI_00:
// STOP condition will be generated
goto STOP;
/* -----------------------------------------------------------------------------------
A START condition has been transmitted
A repeated START condition has been transmitted
nW = nR = 0: STOP condition will be generated
nW > 0, nR - don't care: SLA+W will be send
nW = 0, nR > 0: SLA+R will be send
------------------------------------------------------------------------------------*/
TWI_08:
TWI_10:
if (TWI.nW != 0)
// SLA+W will be send
TWDR = (TWI.SLA)<<1;
else if (TWI.nR != 0)
// SLA+R will be send
TWDR = (TWI.SLA)<<1 | 1<<0;
else
// STOP condition will be generated
goto STOP;
TWCR = (1< 0, nR - don't care: Data byte will be transmitted and ACK or NOT ACK will be received
nW = 0, nR > 0: Repeated START will be transmitted
nW = nR = 0: STOP condition will be generated
------------------------------------------------------------------------------------\*/
TWI\_18:
TWI\_28:
if (TWI.nW != 0)
{
// Data byte will be transmitted and ACK or NOT ACK will be received
TWDR = \*TWI.pW++;
TWCR = (1< 1: Data byte will be received and ACK will be returned
------------------------------------------------------------------------------------\*/
TWI\_40:
if (TWI.nR == 1)
// Data byte will be received and NOT ACK will be returned
TWCR = (1< 2: Data byte will be received and ACK will be returned
------------------------------------------------------------------------------------\*/
TWI\_50:
// Read data
\*TWI.pR++ = TWDR;
if (TWI.nR-- == 2)
// Data byte will be received and NOT ACK will be returned
TWCR = (1<
```
ну и результат работы:
как мы видим время выполнения увеличилось с **488 мкс** до **538 мкс**. Связано это с переходом в и возвратом из обработчика, а также вычислением адреса прыжка по lookup table. Но самое важное что вся передача ведется аппаратно. А значит после выполнения маленькой функции **get\_AC1**, которая длится всего **3,5 мкс** или **28 тактов**, мы можем смело заниматься другими делами, а не тупить в цикле ожидания.
Давайте посмотрим что будет если вызывать функции **get\_AC1**, **get\_AC2**,…, **get\_MD** по порядку:
Выполнится лишь одна, **get\_MD**, а все потому что:
последняя функция загружает в структуру данные еще до завершения SLA+W, поэтому Register\_address соответствует ей и равен **0xBE**. На самом деле это пожалуй самый безобидный сценарий. Ведь будь передача чуть быстрее Register\_address соответствовал бы функции **get\_AC5** например, а записали бы мы его и вовсе в **BMP085\_EEPROM.MD**. То есть ожидаем **AC1**, получаем **AC5**, сохранённое в **MD**. А если бы вместо **get\_AC5** была бы другая, со своим SLA, мы могли бы отослать половину адреса одного, а вторую другого и получили бы NACK, а там от логики обработчика прерывания, либо программа зациклиться, либо выкинет СТОП. Из этой ситуации есть один очевидный выход. Не запускать следующую функцию, пока не закончилась предыдущая. То есть запуская **get\_AC1** выставляем флаг в 1, а обработчик, отработав СТОП его сбросит. А **get\_AC2** не запустится, пока этот флаг не сброшен. Да, это выход, но теряется вся прелесть прерываний, которые в данном случае используются аж на 0%. Уж лучше флаговый автомат. Но есть еще одно красивое решение.
##### Аналог мьютекса
Функции **get\_AC1**,…, **get\_MD** не вызывают передачу данных непосредственно. Они вызывают другую функцию, которая кладет их в очередь и сама инициализирует начало передачи, если очередь не пуста. Перепишем нашу структуру, создав массив структур:
```
#define size 8
...
typedef struct {
unsigned char SLA; // Slave address
unsigned char *pW; // Откуда?
unsigned char nW; // Сколько?
unsigned char *pR; // Куда?
unsigned char nR; // Сколько?
} twi;
twi TWI[size];
```
Посмотрим как будет выглядеть функция **get\_AC1** теперь:
```
unsigned char buf[size];
...
void get_AC1(void)
{
volatile twi *pl; // Указатель на структуру типа twi
buf[0] = 0xAA; // Определяем Register address
pl->SLA = 0x77; // Slave address нашего BMP085
pl->pW = buf; // Указатель откуда брать данные для записи
pl->nW = 1; // Сколько байт записывать?
pl->pR = buf; // Указатель куда считывать?
pl->nR = 2; // Сколько байт считывать?
Scheduler(pl); // Вызываем планировщик очереди
}
```
Практически также, только вместо инициализации СТАРТ состояния мы вызываем функцию **Scheduler**, передавая ей в качестве параметра указатель на структуру типа **twi**, в которой содержаться все необходимые для TWI фрейма данные. Рассмотрим основные функции планировщика и некоторые изменения обработчика:
* получая указатель функция копирует все данные в структуру TWI[i], где i — текущий номер элемента массива структур, после чего он увеличивается на 1; если i вываливается за пределы размерности массива, он обнуляется; таким образом мы превращаем массив структур в кольцевой буфер;
* переменная j указывает на элемент который будет обрабатываться в обработчике прерывания, после чего она увеличивается на 1; если j вываливается за пределы размерности массива, она обнуляется;
* если i догоняет j (переполнение очереди) — запись в массив структур не возможна;
* переменная flag инициализируется 0;
* если i не равно j (очередь не пуста) и flag = 0, то flag = 1, запускаем СТАРТ состояние;
* в обработчике после отработки фрейма j увеличиваем на 1, таким образом она будет указывать на следующий фрейм;
* в обработчике после отработки фрейма и изменения j, если i не равно j, даем СТОП-СТАРТ состояние, в противном случае СТОП и flag = 0;
Не стоит брать в голову то что написано выше. Лучше посмотреть небольшую презентацию, которая прояснит некоторые моменты вышесказанного:
Функция-планировщик **Sheduler**:
```
void Scheduler(twi *pl)
{
if (tail-head !=1 && head-tail != size-1) // Если буфер не переполнен, то
{
twi *pg = &TWI[head]; // Получаем казатель на текущую ячейку
pg->SLA = pl->SLA; // Копируем SLA
pg->pW = pl->pW; // Копируем *pW
pg->nW = pl->nW; // Копируем nW
pg->pR = pl->pR; // Копируем *pR
pg->nR = pl->nR; // Копируем nR
head = (head+1)&(size-1); // Если номер элемента выходит за размерность - обнуляем
if (!flag.twi_run) // Если модуль TWI еще не запущен (флаг равен 0)
{
flag.twi_run = 1; // Устанавливаем флаг в 1
TWCR = (1<
```
Ну и сам обработчик:
**Переделанный обработчик прерывания**
```
ISR(TWI_vect)
{
twi *p = &TWI[tail];
/* -----------------------------------------------------------------------------------
Jump table which is stored in flash
------------------------------------------------------------------------------------*/
static const void * const twi_list[] PROGMEM = {&&TWI_00, &&TWI_08,
&&TWI_10, &&TWI_18,
&&TWI_20, &&TWI_28,
&&TWI_30, &&TWI_38,
&&TWI_40, &&TWI_48,
&&TWI_50, &&TWI_58,
&&TWI_60, &&TWI_68,
&&TWI_70, &&TWI_78,
&&TWI_80, &&TWI_88,
&&TWI_90, &&TWI_98,
&&TWI_A0, &&TWI_A8,
&&TWI_B0, &&TWI_B8,
&&TWI_C0, &&TWI_C8,
&&TWI_F8};
/* -----------------------------------------------------------------------------------
Jump to label, address of which is in twi_list[TWSR>>3]
------------------------------------------------------------------------------------*/
goto *(pgm_read_word(&(twi_list[TWSR>>3])));
/* -----------------------------------------------------------------------------------
Bus error handler
------------------------------------------------------------------------------------*/
TWI_00:
// STOP condition will be generated
goto STOP;
/* -----------------------------------------------------------------------------------
A START condition has been transmitted
A repeated START condition has been transmitted
nW = nR = 0: STOP condition will be generated
nW > 0, nR - don't care: SLA+W will be send
nW = 0, nR > 0: SLA+R will be send
------------------------------------------------------------------------------------*/
TWI_08:
TWI_10:
if (p->nW != 0)
// SLA+W will be send
TWDR = p->SLA<<1;
else if (p->nR != 0)
// SLA+R will be send
TWDR = p->SLA<<1 | 1<<0;
else
// STOP condition will be generated
goto STOP;
TWCR = (1< 0, nR - don't care: Data byte will be transmitted and ACK or NOT ACK will be received
nW = 0, nR > 0: Repeated START will be transmitted
nW = nR = 0: STOP condition will be generated
------------------------------------------------------------------------------------\*/
TWI\_18:
TWI\_28:
if (p->nW != 0)
{
// Data byte will be transmitted and ACK or NOT ACK will be received
TWDR = \*p->pW;
p->pW++;
TWCR = (1<nW--;
}
else if (p->nR != 0)
// Repeated START will be transmitted
TWCR = (1< 1: Data byte will be received and ACK will be returned
------------------------------------------------------------------------------------\*/
TWI\_40:
if (p->nR == 1)
// Data byte will be received and NOT ACK will be returned
TWCR = (1< 2: Data byte will be received and ACK will be returned
------------------------------------------------------------------------------------\*/
TWI\_50:
// Read data
\*p->pR = TWDR;
p->pR++;
if (p->nR-- == 2)
// Data byte will be received and NOT ACK will be returned
TWCR = (1<pR = TWDR;
TWI\_60:
TWI\_68:
TWI\_70:
TWI\_78:
TWI\_80:
TWI\_88:
TWI\_90:
TWI\_98:
TWI\_A0:
TWI\_A8:
TWI\_B0:
TWI\_B8:
TWI\_C0:
TWI\_C8:
TWI\_F8:
// STOP condition will be transmitted and TWSTO Flag will be reset
STOP:
tail = (tail+1)&(size-1); // Увеличиваем tail на 1, если выходит за пределы, то обнуляем
if (head != tail) // Если head и tail не равны, то
TWCR = (1<
```
ну и результат выполнения **get\_AC1**:
##### Послесловие
На самом деле если по аналогии **get\_AC1** сделать **get\_AC2** и запустить 2 функции подряд, то два раза выполнится только последняя. Связанно это с тем что данные для передачи мы постоянно храним в buf[0]. Чтобы этого избежать мы могли бы записать данные в buf[1] и все бы работало как нужно. Но так не делается. Правильно передавать указатель откуда брать данные и сколько, а некая сторонняя функция будет класть это в буфер для TWI и возвращать указатель откуда в нем брать данные в обработчике. В общем код к примеру:
**Код**
```
unsigned char bufTx[size];
unsigned char pos = 0;
...
void get_AC1(void)
{
volatile twi *pl; // Указатель на структуру типа twi
volatile uint8_t buf[] = {0xAA}; // Ложим Register address в buf
pl->SLA = 0x77; // Slave address нашего BMP085
pl->pW = buf; // Указатель откуда брать данные для записи
pl->nW = 1; // Сколько байт записывать?
pl->pR = buf; // Указатель куда считывать?
pl->nR = 2; // Сколько байт считывать?
Scheduler(pl); // Вызываем планировщик очереди
}
// ============================================
void get_AC2(void)
{
volatile twi *pl; // Указатель на структуру типа twi
volatile uint8_t buf[] = {0xAC}; // Ложим Register address в buf
pl->SLA = 0x77; // Slave address нашего BMP085
pl->pW = buf; // Указатель откуда брать данные для записи
pl->nW = 1; // Сколько байт записывать?
pl->pR = buf; // Указатель куда считывать?
pl->nR = 2; // Сколько байт считывать?
Scheduler(pl); // Вызываем планировщик очереди
}
// ============================================
void Scheduler(volatile twi *pl)
{
if (tail-head !=1 && head-tail != size-1) // Если буфер не переполнен, то
{
twi *pg = &TWI[head]; // Получаем казатель на текущую ячейку
pg->SLA = pl->SLA; // Копируем SLA
pg->pW = pushToBuf(pl->pW,pl->nW); // Вызываем функцию, которая копирует данные
// из buf в bufTX и возращает укзаатель
pg->nW = pl->nW; // Копируем nW
pg->pR = pl->pR; // Копируем *pR
pg->nR = pl->nR; // Копируем nR
head = (head+1)&(size-1); // Если номер элемента выходит за размерность - обнуляем
if (!flag.twi_run) // Если модуль TWI еще не запущен (флаг равен 0)
{
flag.twi_run = 1; // Устанавливаем флаг в 1
TWCR = (1<
```
смотрим на картинку:
По-доброму, по аналогии такую же функцию нужно сделать и для принимающего буфера. Ты говоришь ей сколько, а она тебе присылает куда. Также можно модифицировать структуру TWI, например, передавать не указатели, а индексы для оптимизации памяти.
Если у кого возник вопрос о том почему для обнуления используется код:
```
head = (head+1)&(size-1);
tail = (tail+1)&(size-1);
pos &= size-1;
```
я скажу так быстрее и меньше кода. Единственное условие, чтобы значение было равно 2n.
Из особенностей стоит отметить также максимальный размер **size** для TWI. Если он меньше чем максимально возможное количество подряд идущих запросов, мы непременно потеряем часть их. Поэтому важно выделить на этом акцент. **Всегда используйте значение size как минимум на 1 больше чем максимальное число одновременных запросов**.
Можно было бы еще добавить обработчик полученных данных, после отработки функции. Для нашего примера это обработка полученных AC1 и AC2, которые мы получаем в Big-endianne и должны преобразовать в Little-endiann, а потом сохранить в соответствующем месте. Для этого в структуре TWI можно было бы хранить еще указатель на функцию обработчик и придумать как вызывать ее после отработки.
Пару слов стоит сказать о процессах. Применительно к моей схеме, есть 2 датчика совещенности, давления, 1 микросхема времени и 1 микросхема памяти на шине TWI. И доступ к ним можно расценивать как атомарный, к примеру для датчика давления:
если мы потеряем передачу для uncompressed pressure, полученное значение uncompressed temperature нам ни к чему и мы должны все начать сначала, ибо можем получить не валидные данные.
Также не предусмотрен случай сбоя при передаче по TWI. Так как мы изменяем оригинал TWI[i] в обработчике мы не можем начать передачу заново. Для этого можно объявить глобальную структуру типа twi, и перед каждым стартом данные из TWI[tail] копировать в нее, а обработчик пусть портит копию. В случае же сбоя мы можем восстановить данные из оригинала.
#### Заключение
Многие спросят: «Зачем? Ведь для для хранения 16 элементов структуры понадобится 16\*(1+2+1+2+1) = 112 байт SRAM! Почему бы не использовать RTOS? Пускай мол будет структура с 1 элементом и если в нее не влазит, ставим в очередь на n мс.» Я считаю что подобное решение очень полезно использовать в операционных системах. Подумайте сколько будет длится такая передача? Если мы будет ставить в очередь, то каждая следующая передача будет через n мс, а вся закончится через n\*m мс. Да и зачем забивать очередь не нужными m инструкциями, ведь есть вероятность упустить действительно важную задачу. Да и ядро ОС разгружается, не ставя m\*(m+1)/2 задач в очередь. | https://habr.com/ru/post/193456/ | null | ru | null |
# Confluence для публичной базы знаний: меняем дизайн и настраиваем разделение по языкам
У нас есть шесть продуктов, которые используют в России и за рубежом. Это значит, что документация к ним должна быть в одном месте, но разделена по продуктам и языкам.
Раньше мы использовали MediaWiki, но со временем она устарела. От платформы мы ожидали так же хорошую вёрстку статей, гибкий поиск и внутренний редактор текстов. В качестве альтернативы выбрали Confluence.
В процессе стало ясно, что возможностей этой платформы из коробки тоже недостаточно для всех наших задач. Пришлось докупить плагин Scroll Viewport и потратить некоторое время на его настройку.
Вы можете посмотреть, [что в итоге получилось](https://docs.ispsystem.ru/), а я расскажу, как меняла дизайн, настраивала разделение по языкам, внутренний поиск и индексацию.
Меняем дизайн
-------------
Компания начала переносить документацию с движка MediaWiki на Confluence год назад. Но когда я приступила к проекту, Confluence выглядел стандартно, предыдущий разработчик добавил наш логотип и скрыл ненужные анонимному пользователю элементы. К запуску надо было привести документацию к нашему стилю. Дизайнеры подготовили макеты, а я должна была их сверстать.
Но дело в том, что сам Confluence даёт очень мало гибкости в стилях и скриптах, а возможности из коробки нетривиальны для понимания и использования, да и непривычны веб-разработчику.
Отмечу, что Confluence — это Java-приложение, а вовсе не веб-сайт с привычными бэкендом и фронтендом. В разделе Внешний вид можно добавить таблицу стилей или настроить пользовательский HTML, но этого недостаточно для полноценного редизайна. Поэтому для вёрстки мы купили плагин Scroll Viewport. Тут-то и началось самое интересное.
### Плагин Scroll Viewport
Scroll Viewport — это плагин для Confluence, который позволяет создавать темы, используя привычный редактор кода и файловый менеджер. С его помощью можно писать стили, работать с шаблонами страниц, добавлять изображения, настраивать поиск.
Темы создаются для пространств. Пространства в Confluence — это сущности контента, в которых хранится информация по одному проекту. У нас есть пространство для продуктов: ISPmanager, BILLmanager и т. д., а также для главной страницы. У пространства есть ключ, заголовок, ряд настроек и, собственно, тема.
### Редактирование темы в Scroll Viewport: разметка, стили и html
Начнём осваивать Scroll Viewport. Когда плагин установлен и включён, надо кликнуть на шестерёнку и далее — **Основные настройки** — раздел **Scroll Viewport** — **Themes**.
Выбираем, копируем или создаём тему и нажимаем **Edit**. Открывается редактор темы Scroll Viewport.
Обратите внимание, Scroll Viewport рекомендует не создавать тему с нуля, а брать за основу Scroll WebHelp Theme.
*Редактор темы Scroll Viewport: слева структура темы, сверху название файла, в основной части сами файлы*
Когда тема создана, можно приступить к её настройке. Зададим разметку и структуру страниц, добавим стили и скрипты, а потом перейдём к редактированию HTML-разметки элементов контента.
### Разметка: редактируем, добавляем классы и выводим однотипные элементы в цикле
**Структура страниц по типу**
В корне темы находятся основные шаблоны: page.vm, search.vm, error.vm, а также изображение-обложка темы thumbnail.png.
Шаблон “page.vm” задаёт структуру всех страниц темы. Здесь можно редактировать html и с помощью переменных placeholders задавать, где будет выводиться контент. Плейсхолдеры обращаются к контенту пространства или данным пользователя (заголовок материала, название пространства, имя автора), с их полным списком можно ознакомиться [в хелп-центре разработчика Scroll Viewport](https://help.k15t.com/scroll-viewport/latest/placeholders-147036524.html).
“page.vm” обращается к шаблонам, которые лежат на уровень ниже, в папке “include”, и оборачивает их в теги и блоки. В этом файле (page.vm) мы собираем страницу по кусочкам, и дополняем разметку всеми необходимыми атрибутами html-документа. Именно здесь мы указываем doctype, прописываем head и body.
**Составные элементы страницы**
В папке “include” лежат кусочки страницы. По названиям файлов можно догадаться, какой за что отвечает:
* include-htmlhead.vm содержит всё то, что мы обычно указываем в head html-документа: обращения к таблицам стилей, файлам шрифтов, некоторым скриптам, включая стандартные скрипты Confluence и Scroll Viewport;
* include-headerbar.vm задаёт структуру хедера;
* include-footer.vm задаёт структуру футера;
* include-content.vm описывает структуру блока основного контента;
* include-sidebar.vm описывает разметку бокового меню, в котором обычно располагается список всех статей пространства.
Синтаксис шаблонов Scroll Viewport прост для понимания. Операции начинаются с решётки, например “#if (условие)” или “#foreach($language in $languages.available)”, и заканчиваются с помощью “#end”, внутри — тело оператора. Всё остальное представляет собой html-теги.
### Стилизация: добавляем стили, изображения и скрипты
Внутри папки “assets” хранятся файлы js и css. Так как мы не создавали тему с нуля, там уже содержатся файлы от разработчиков Scroll Viewport.
Чтобы кастомизировать стили, лучше создать новый css-файл и подключить его в head шаблона страницы. Файлы, которые начинаются на theme, содержат в себе правила базовой темы Scroll Viewport. Их стоит редактировать в случае, когда новые стили упираются в базовые. Будьте внимательны, удаляя и добавляя правила, помните об иерархии селекторов, она может выручить.
В “assets” я также добавила папку с изображениями и папку с файлами шрифтов. Файловый менеджер работает не идеально, добавить папку в нужную директорию нельзя, поэтому пришлось схитрить. Я создала папку на своём компьютере, добавила в неё файл, а потом загрузила в нужную директорию драг-энд-дропом. Как только папка создана, с загрузкой файлов проблем нет.
При создании нового дизайна мы учитывали возможности плагина и ориентировались на уже существующие темы в Scroll Viewport, поэтому внутри assets/js я задержалась ненадолго. Внесла небольшие изменения в существующие файлы скриптов и добавила файлы нужных библиотек. Если изменения будут более значительными, со скриптами придётся разобраться детальнее.
### Редактор html-разметки контента статьи
В процессе работы со Scroll Viewport выяснилось, что верстать мы можем, да не всё. Полномочия шаблона плагина заканчиваются на переменной $page.renderContent. Как верстать элементы главной с классами и ссылками? Непонятно. Где HTML? По умолчанию его там и нет. Переменная подсказывает, что нам предстоит выполнить часть вёрстки непосредственно на странице статьи, правда, пока там можно редактировать лишь текст, но не теги.
Благо, всегда можно поискать плагины, и, какая удача, нужный нашёлся почти сразу. Это Confluence Source Editor. После его установки можно в режиме редактирования статьи прошерстить и старый добрый гипертекст. Наконец-то!
*Плагин Source Editor*
В Scroll Viewport верстаем шапку, сайдбар, футер и задаём стили. Контент верстаем с помощью Source Editor. Всего я создала две темы: для страниц статей и для главной страницы документации.
Настройки Viewport пространства: применяем тему
-----------------------------------------------
Когда тема создана, её надо связать с пространством. Для этого в настройках пространства нужно создать Viewport. Viewport — это то, что связывает пространство и тему. Только создав эту сущность, можно применить стили темы для пространства.
Войдите в пространство нужного продукта, откройте **Настройки пространства — Дополнения**. Здесь можно создать Viewport и управлять им: задавать темы, типы контента, разрешения, домен и путь.
*Форма для связи пространства с темой, создания Viewport*
### Выбрать тему
На вкладке **Themes** представлены все созданные темы и одна тема по умолчанию, которая появляется вместе с плагином Scroll Viewport. Выберите тему и примените к пространству.
Вкладка **Content** позволяет выбрать тип контента, к которому будет применяться тема. Она нам наименее интересна, так как ключ пространства подтягивается автоматически.
### Настроить адреса
На вкладке **URL** можно выбрать домен и путь, по которому будет открываться пространство, а также задать структуру адресов. Она так же понадобится, чтобы разделить документацию на два домена по языкам.
Есть два типа структуры URL:
* многоуровневая — путь отражает иерархию статей пространства и названия страниц,
* одноуровневая — все статьи доступны по адресам одинакового уровня с числовыми суффиксами
С адресами страниц есть нюанс. Для статей на разных языках Confluence по-разному формирует URL. На английском выводит в адрес название, а на русском — несвязный набор букв, символов и чисел. Scroll Viewport позволяет привести адреса к одному виду. Если выбрать многоуровневую структуру, то в адресах русских статей будет отображаться название текста транслитом.
Но нужно учесть, что при выборе многоуровневых адресов URL будет зависим от названия статьи. Изменится название — изменится и адрес статьи. Если выбрать одноуровневую структуру, адрес будет менее читаем и понятен, но перестанет зависеть от заголовка страницы.
Мы выбрали многоуровневый тип структуры и читаемые адреса, но нам придётся следить за изменением названий статей и вовремя настраивать редиректы. И идеальный вариант мы всё ещё ищем. Мы также используем краткие ссылки, которые всегда ведут на статью и не меняются, такую ссылку можно найти в разделе **Информация о странице**.
### Включить тему
Во вкладке **Permissions** можно обозначить, каким пользователям будет доступен просмотр пространства с применением Viewport.
Чтобы анонимные пользователи видели документацию только в заданном дизайне, нужно поставить две галочки:
* Restrict access to Confluence UI,
* Automatically redirect users to viewport.
*Настройки вида пространства во вкладке Permissions*
Настраиваем разделение по языкам
--------------------------------
У нас документация на английском и русском, поэтому нужно, чтобы пространства на русском открывались на домене .ru, а на английском — на .com.
В Scroll Viewport такие настройки предусмотрены, но если просто ввести отличный от основного домен во вкладке **URL** в поле **Domain Name**, два домена не заработают. Это особенность плагина Scroll Viewport.
Надо настроить Reverse proxy, чтобы запросы пользователей передавались Confluence и там разруливались на два домена — см. [инструкцию Scroll Viewport](https://help.k15t.com/scroll-viewport/latest/custom-domains-and-reverse-proxies-130126589.html) (конфигурации для Nginx и TOMCAT). После этого надо выключить режим совместного редактирования или внести [дополнительные изменения](https://confluence.atlassian.com/doc/possible-confluence-and-synchrony-configurations-958779064.html#PossibleConfluenceandSynchronyConfigurations-Withareverseproxy). Теперь можно указывать один из двух доменов в настройках Viewport.
### Темы для разных языков
Применить одну тему к пространствам на разном языке не получится, потому что тема включает в себя не только стили, но и шаблоны страниц. Это означает, что язык элементов, которые выводятся не переменными, не меняется. Например, текст-плейсхолдер в строке поиска, контакты в футере и др. Так что пришлось делать отдельные темы для пространств на русском и английском языках.
Фактически я создаю идентичные по стилям темы, но вот шаблоны для них различны, в основном по части текста. Это излишество и дублирование, да, но иного способа я пока не нашла. К тому же тема регулирует и работу поиска тоже, а это ещё один аргумент в пользу разделения по языкам.
В итоге у меня получилось четыре темы: две для главных страниц на русском и английском, и ещё по две для страниц контента для каждого языка.
Настраиваем поиск по сайту
--------------------------
Параметры поиска настраиваются в файлах из папки “include”. Внутри них мы задаём параметры поиска:
* include-quicksearch.vm отвечает за поле поиска на всех страницах контента,
* include-search.vm задаёт структуру страниц с результатами поиска.
### Где искать
По умолчанию поиск работает только по текущему пространству. Например, в пространстве ISPmanager — только по статьям об ISPmanager. Если нужен поиск по списку пространств, в настройках include-quicksearch.vm нужно указать их ключи.
```
#set($search = "/search")
#if ($stringUtils.equals(${viewport.link}, "/") == false)
#set($search = "${viewport.link}/search")
#end
## --- START --- Scroll Versions and Scroll Translations Integration -------------------------------------------
#if ($versions || $variants || $languages)
#if($versions)
#end
#if($variants)
#end
#if($languages)
#end
#end
## --- END -----------------------------------------------------------------------------------------------------
```
*Форма поиска для отдельного пространства*
```
#set($search = "/search")
#if ($stringUtils.equals(${viewport.link}, "/") == false)
#set($search = "${viewport.link}/search")
#end
## --- START --- Scroll Versions and Scroll Translations Integration -------------------------------------------
#if ($versions || $variants || $languages)
#if($versions)
#end
#if($variants)
#end
#if($languages)
#end
#end
## --- END -----------------------------------------------------------------------------------------------------
```
*Форма поиска по списку пространств*
### Как выводить результаты
Как будет выглядеть список с результатами поиска, задаёт шаблон include-search.vm. В моём случае у каждой найденной ссылки есть заголовок, описание и название пространства, к которому относится статья. Здесь же можно указать, что пользователь увидит, если поиск ничего не найдёт.
Из фрагмента шаблона ниже видно, что результаты поиска выводятся в цикле с использованием переменных-плейсхолдеров. Результатов поиска может быть довольно много, поэтому внизу страницы сделали пагинацию. Подробное руководство по шаблонам страниц поиска можно посмотреть в [документации по поиску Scroll Viewport](https://help.k15t.com/legacy/scroll-viewport/search-template-recipe-74711202.html).
```
#if ($searchResults.total > 0)
#foreach($result in $searchResults.items)
#set( $space = '' )
#if( $result.type == 'page' )
#set( $space = $result.getObject().fromConfluence.getSpace().getName() )
#end
####
[$result.displayTitle]($result.link)
$result.getDescription(280)
#if( $space )
$space
#end
#end
#else
#### Мы ничего не нашли :(
Проверьте запрос на ошибки, измените его или воспользуйтесь содержанием.
#end
#if($pager.hasPrev)
[Назад]($pager.prevLink)
#end
#foreach ($pagerPage in $pager.pages)
[$velocityCount]($pagerPage.link)
#end
#if($pager.hasNext)
[Дальше]($pager.nextLink)
#end
```
### Как выглядит страница поиска
В шаблоне “search.vm” задаётся вся структура поисковых страниц, начиная от открывающегося тега . В этом шаблоне и следует собрать вместе форму поиска и его результаты. В итоге получим страницу типа “поиск”, которая включает в себя форму поиска и найденные совпадения, разбитые на несколько страниц.
Все шаблоны первого уровня, расположенные в структуре рядом с page.vm, переопределяют структуру страницы в зависимости от ее типа. Так search.vm задаёт вёрстку страниц поиска, а error.vm — страниц ошибок.
Остаётся задать стили элементам, возможно добавить скрипты, и наша тема становится функциональной, выполняет задачи и выглядит согласно дизайну.
Настраиваем индексацию
----------------------
Чтобы настроить индексацию, нужно положить карту сайта в корневую папку. Но у нас нет корневой папки, ведь Confluence — это Java-приложение, а не сайт. Что делать?
Подсказка нашлась в [документации Scroll Viewport](https://help.k15t.com/legacy/scroll-viewport/using-a-sitemap-xml-file-112920277.html). Внутри пространства разводящих страниц, где хранится главная, надо создать новую статью, назвать её sitemap.xml и расположить на уровень ниже главной.
Расположение важно, потому что, как отмечают в документации, файл карты не будет доступен для Viewport с префиксом пути “/”. Как раз такой префикс у Viewport пространства главной страницы.
*Статья sitemap.xml в структуре пространства*
Мы помним, что в Confluence заголовок статьи и её URL связаны. Когда страница создана и уже открывается по адресу [docs.ispsystem.com/sitemap-xml](https://docs.ispsystem.com/sitemap-xml), займёмся её корректным отображением. Такой формат URL не совсем типичен, но вполне нам подойдёт.
Карта сайта должна быть без лишних тегов и стилей, ведь она создаётся для поисковиков. Чтобы заданные раньше стили не применялись к карте сайта, надо создать шаблон include-sitemap.vm и скопировать в него содержимое подготовленной карты сайта — sitemap.xml. Это будет выглядеть следующим образом:
Теперь для страницы sitemap.xml создадим отдельное условие в шаблоне page.vm, чтобы стили и структура из шаблонов применялись для всех страниц, кроме карты сайта.
Для условия понадобится идентификатор. Узнать его можно, открыв страницу, а затем нажав **Многоточие — Информация о странице**, в конце адресной строки и будет идентификатор. Теперь пишем условие:
```
#if ($page.id == 25370522)
$include.template("/include/include-sitemap.vm")
#else
/Разметка для остальных страниц/
```
После описанных манипуляций путь к карте сайта можно указать в панелях вебмастера Яндекс и Google, и начнётся индексация.
В целом вопрос индексации для меня остаётся открытым. Не до конца понятно, как индексируются страницы контента Confluence. Нужно подумать, как автоматизировать процесс.
Такие дела
----------
Вот так я настроила дизайн, локализацию, поиск и индексацию документации на Confluence. Понадобилось время и помощь техподдержки Scroll Viewport, чтобы разобраться с неочевидными вещами. Надеюсь, мой опыт будет полезен тем, кто столкнётся с похожей задачей. | https://habr.com/ru/post/438236/ | null | ru | null |
# Быстрая публикация скриншотов
Постить скриншоты довольно заморочно если всё делать руками. Но возможен и более лёгкий сценарий:
1) жму Alt+Ctrl+S
2) появляется редактор с готовым скриншотом
3) обрезаю картинку, закрываю редактор
4) картинка сама загружается; ссылка на картинку оказывается в буфере обмена
Как это сделать — для тех кто знает что такое bat-файлы и сумеет установить пару Python-модулей.
На рабочем столе создаёте ярлык на файл screenshot.bat (ниже) и настраиваете запуск в свёрнутом виде, чтобы консоль не мешалась на скриншоте. Ярлыку же нужно назначить глобальное клавиатурное сочетание навроде Ctrl+Alt+S.
Далее в «Program Files» (например) следует создать [5 файлов](http://narod.ru/disk/20323521001/screenshot4habr.zip.html), большинство из которых полезны и сами по себе (особенно clipboard.bat).
Файл **screenshot.bat** — координирует всю работу:
````
@rem takes a screenshot
@rem allows a userr to editt it
@rem upload image onto server
@rem puts the server link into clipboard
SET PNG=%TEMP%\screenshot.png
SET EDITOR="C:\Program Files\XnView\XnView.exe"
SET UPLOADER=fp.bat
c:\python26\python.exe screenshot.py %PNG%
%EDITOR% %PNG%
%UPLOADER% %PNG%
````
Файл **screenshot.py** — делает скриншот и сохраняет его в заданный файл:
````
# Takes a screenshot and saves it to a file specified.
# Requires Python Imging Library: http://www.pythonware.com/products/pil/
import sys
import ImageGrab # PIL
ImageGrab.grab().save(sys.argv[1])
````
Файл **clipboard.bat** — простая обёртка для скрипта пониже:
`python clipboard.py`
Файл **clipboard.py** — копирует текст из входного потока в буфер обмена:
````
# requires pywin32 module: http://sourceforge.net/projects/pywin32/files/
import sys
import win32clipboard
def setClipboard(text):
win32clipboard.OpenClipboard()
win32clipboard.EmptyClipboard()
win32clipboard.SetClipboardData(win32clipboard.CF_TEXT, text)
win32clipboard.CloseClipboard()
text = sys.stdin.read()
print text
setClipboard(text)
````
Файл **fp.bat** — загружает изображения на сервер — fastpic.ru в данном случае:
````
@echo off
@rem upload images to fastpic.ru
@rem requires zenden image uploader: http://code.google.com/p/image-uploader/downloads/list
@rem choose the CLI version like: zenden-image-uploader-CLI-XXX-win32.7z
@rem zenden works from its own directory only
@rem converting all filenames into the absolute form
SET FILES=
:loop_begin
if "%~1"=="" GOTO loop_end
SET FILES=%FILES% "%~f1"
shift
goto loop_begin
:loop_end
C:
cd C:\Portable\zenden-image-uploader
imgupload --server fastpic.ru %FILES% | clipboard
````
К сожалению, особенности питоньей платформы, не позволяют дать ссылку на 100% готовый архив — два модуля придётся скачать и установить руками:
— [pywin32](http://sourceforge.net/projects/pywin32/files/)
— [Python Imging Library](http://www.pythonware.com/products/pil/)
И вот такой аплоадер файлов на самые разные сервера:
— [zenden image uploader](http://code.google.com/p/image-uploader/downloads/list) (CLI-версия)
Если кто знает как поставлять модули Питона в архиве и не заморачивать людей поиском, скачкой и установкой модулей — прошу дать знать, ибо разрабатывается всё это несложно, но передать разработанное людям — проблема. Можно целую директорию с Питоном копировать, конечно…
В текущем виде решение работает только под Windows. Если переписать копирование текста в буфер обмена и найти аналог загрузчику картинок, то будет работать и в других OS. | https://habr.com/ru/post/125173/ | null | ru | null |
# Распространение приложения под iOS внутри компании (Enterprise Distribute iOS App in-house)
**(Осторожно, под катом трафик)**
Подготовка и распространение приложения IOS внутри компании весьма непростая задача, особенно когда приложение написано на Windows с использованием Visual studio, а большинство туториалов в интернете описывают исключительно MacOS с использованием Xcode. Однако после часов сражения с детищем Apple, нам удалось свершить казалось бы невозможное, а именно: ~~скрестить жирафа с носорогом~~ собрать IOS приложение на Xamarin в архив Xcode, сразу на MacOS, после получить нужные файлы для распространения, и в завершении создать ссылку, по которой будет распространяться приложение.
Да, на слух вроде не очень сложно. Однако когда дело касается разработки приложений под устройства Apple, всё становится в несколько раз непонятней и сложней. И после триумфальной, но нелёгкой победы, нам захотелось оставить свой след в истории, написав сей туториал.
**Предварительные условия:**
1. Должен быть Enterprise аккаунт Apple — $299 в год.
1 Шаг. Создание сертификата.
----------------------------
1. Сперва, на Mac, нужно создать запрос для создания сертификата. Для этого нужно открыть keychain access, например, через поиск:
2. Выбрать keychain access в левом верхнем углу экрана, в выпавшем меню выбрать “certificate assistant” --> “request a certificate from a certificate authority”, откроется соответствующие окно:
3. В появившемся окне заполняем поля “User Email Address” – свою электронную почту, и “Common Name” – имя ключа. А также выбираем пункт “Saved to disk”, чтобы сохранить файл запроса на компьютер. И нажимаем кнопку “Continue”:
4. Далее появится окошко, в котором нужно указать название файла запроса и выбор пути для сохранения файла. Вносим нужные изменения и сохраняем:
5. После успешного сохранения появится следующее окно. Нажимаем “Done”:
6. После мы можем увидеть, что создался файл запроса в месте сохранения (в данном примере на рабочем столе). Или мы можем увидеть созданный ключ в списке ключей в “keychain access”:
7. Далее нам надо создать сертификат, это мы сможем сделать на сайте [Apple для разработчиков](https://developer.apple.com/), войдя в свой аккаунт:
8. После успешного входа в аккаунт мы переходим в “Certificates, IDs & Profiles”, так же на странице сертификатов нужно убедиться, что выбрано “IOS, tvOS, watchOS”:
9. Далее на странице, в разделе “Certificates”, нужно выбрать “Production”:
10. На странице нажимаем на кнопку с изображением “+”, чтобы создать сертификат. Появится страничка, на которой надо выбрать тип создаваемого сертификата:
11. В данном примере нас интересует метод дистрибьюции In-House, поэтому типом сертификата нужно выбрать “In-House and Ad Hoc”. После нажать кнопку “Continue”:
12. После мы перейдём к следующей странице создания сертификата на которой будет описано как создать запрос на MacOS для сертификата. Мы уже создали этот запрос в предыдущих пунктах. Нажимаем кнопку “Continue”:
13. На следующем этапе вам потребуется загрузить файл запроса, который мы создали ранее на рабочем столе. После успешной загрузки нажмите “Continue”:
14. После произойдёт генерация сертификата, и на следующей странице его можно будет скачать на компьютер:
15. Скачиваем сертификат, в данном примере на рабочий стол. Так же мы можем увидеть созданный сертификат на сайте:
Как мы можем видеть, по итогу мы успешно получили сертификат. Следующим шагом будет создание ID приложения.
2 Шаг. Создание Apps ID.
------------------------
На предыдущем шаге мы успешно создали сертификат, теперь нам нужно создать Apps ID. Для этого нужно:
1. На сайте [Apple для разработчиков](https://developer.apple.com/), в своём аккаунте перейти сперва в “Certificates, IDs & Profiles”, так же на странице сертификатов нужно убедиться, что выбрано “IOS, tvOS, watchOS”:
2. Далее на странице, в разделе “Identifiers”, нужно выбрать “App IDs”:
3. На странице нажимаем на кнопку с изображением “+”, чтобы создать App ID. Появится страничка, на которой надо выбрать настройки создаваемого ID. Настройки ID индивидуальны для вашего приложения, единственное важное уточнение – в графе App ID Suffix нужно выбрать Explicit App ID:
4. После создания App ID, его можно увидеть на сайте:
По итогу двух шагов, мы успешно получили сертификат и создали App ID. Далее нам надо при помощи созданного сертификата создать Provisioning Profiles. И это приводит нас к следующему шагу “3 Шаг. Создание Provisioning Profiles”.
3 Шаг. Создание Provisioning Profiles.
--------------------------------------
На предыдущем шаге мы успешно создали сертификат, теперь нам нужно с его помощью создать Provisioning Profiles. Для этого нужно:
1. На сайте [Apple для разработчиков](https://developer.apple.com/), в своём аккаунте перейти сперва в “Certificates, IDs & Profiles”, так же на странице сертификатов нужно убедиться, что выбрано “IOS, tvOS, watchOS”:
2. Далее на странице, в разделе “Provisioning Profiles”, нужно выбрать “ Distribution”:
3. На странице нажимаем на кнопку с изображением “+”, чтобы создать Provisioning Profiles. Появится страничка, на которой надо выбрать тип создаваемого профайла:
4. В данном примере нас интересует In-House метод дестрибьюции, соответственно выбираем тип профайла “In House” и нажимаем на кнопку “Continue”:
5. На следующей странице нужно выбрать ранее созданный, на шаге 2, App ID:
6. После нажатия кнопки “Continue” мы перейдём к выбору сертификата, мы создали его на 1 шаге. Далее нажимаем на кнопку “Continue”:
7. На следующей странице нам надо заполнить поле с именем профайла и проверить данные перед генерацией профайла:
8. После профайл будет сгенерирован и его можно будет скачать:
9. Скачиваем Provisioning Profile, в данном примере на рабочий стол. Так же мы можем увидеть созданный provisioning profile на сайте, и увидеть, что он активен:
По итогу 3 шагов мы успешно создали Provisioning Profile.
4 Шаг. Создание Xcode архивов (.xcarchive) на базе своего приложения в Visual Studio на Windows и последующего создания .ipa и .plist файлов
--------------------------------------------------------------------------------------------------------------------------------------------
Предыдущие шаги выполнялись на компьютере от Apple (Mac), далее я расскажу как создавать .xcarchive в Visual Studio 2017 для Windows, сразу на Mac.
1. Для этого нам потребуется приложение Xamarin в Visual Studio, которое будет подключено к Mac:
2. В решение нужно выбрать проект IOS, нажав на него правой кнопкой мыши. В появившемся меню выбрать “Properties”. В открывшемся окне выбрать пункт “ios bundle setting”. Далее выбрать в “bundle setting” – “manual provisioning”, а ниже в графе “manual provisioning” выбрать свой сертификат и профайл который мы создали на предыдущих этапах:
3. В проекте IOS нужно выбрать файл Info.plist и убедится что “bundle identifier” совпадает с нужным App ID:
4. После откройте командную строку разработчика в Visual Studio (от имени администратора) “Developer Command Prompt for VS 2017” и либо перейдите в директорию с ios проектом, либо укажите полный адрес при создании команды. Данная команда создаст архив .xcarchive на Mac из Visual Studio. Сам по себе архив не содержит нужных нам для распространения .ipa и .plist файла поэтому после генерации архива нам потребуется создать их. Подробнее о том как создавать архив можно узнать [здесь](https://docs.microsoft.com/en-us/xamarin/ios/troubleshooting/questions/create-xcarchive).
**Команда:** `msbuild /p:Configuration=Release /p:ServerAddress=10.211.55.2 /p:ServerUser=xamUser /p:Platform=iPhone /p:ArchiveOnBuild=true /t:"Build" MyProject.csproj`
5. После успешного выполнения команды на Mac должен был создастся архив. Нам надо запустить Xcode, в нём выбрать “Windows” и в этом меню выбрать “Organazer”. Там в разделе “Archive” мы увидим созданный архив .xcarchive:
6. Теперь нам надо создать файлы .ipa и .plist, на основе созданного архива.
При помощи их мы сможем распространять своё приложение минуя AppStore, например, внутри компании. Далее нам надо нажать кнопку “Distribute App”. В появившемся меню выбрать “Enterprise” и нажать кнопку “Next”:
7. Далее нужно выбрать устройства, на которые можно распространять и обязательно выбрать “include manifest for over-the-air installation”, для того чтобы можно было скачать приложение из браузера:
8. В следующем окне нужно указать “Name” – имя приложения; “App URL” – путь к .ipa файлу;”Display Image URL” – Путь к иконке 57х57;”Full Size Image URL” – Путь к иконке 512х512.
Важно что бы сервер на котором размещены файлы .ipa и .plist, был с шифрованием, то есть обязательно https. В примере используется сервис [dropbox](https://www.dropbox.com/). При использовании сервиса dropbox **важно знать**: правильный путь к файлу по публичной ссылке должен начинаться не с “https://www.dropbox.com/”, как указано в сгенерированной ссылке, а с “https://dl.dropboxusercontent.com/”.
9. На следующем этапе нам нужно выбрать созданные сертификат и Provisioning Profile:
10. После мы увидим успешно собранное приложение, и мы должны выбрать куда сохранить папку с приложением, которое мы после будем распространять:
11. После сохранения на рабочем столе создалась папка. Содержимое папки вы можете видеть на скриншотах ниже, при генерации создаётся 4 файла .plist и обычно 1 .ipa, но в проверочном приложении это немного не так, но нас в данном случае будет интересовать файл у которого в имени только название нашего приложения. Что касается 4 файлов .plist, то далее нам понадобится файл “manifest.plist”. Для установки приложения нужен plist, в котором описаны предустановочные свойства. Подробнее узнать о Enterprise Distribution и посмотреть как выглядит manifest.plist можно [здесь](https://habr.com/company/naumen/blog/205780/):
Таким образом на данном шаге мы успешно создали .ipa и .plist файлы приложения, созданного в Visual Studio 2017, и которые мы будем использовать для In-House дестрибьюции.
5 Шаг. Распространение приложения
---------------------------------
На предыдущих шагах мы подготовили наше приложение к распространению. На данном шаге мы создадим простой html файл с ссылкой и выложим её на локальный IIS, это делается для упрощения примера, но местоположение ссылки роли не играет. Не в рамках примера ссылку
можно разместить на собственном сайте, чтобы она была доступно сотрудникам, как и файлы приложения, следует размещать на собственном сервере. Однако в этом примере, как упоминалось ранее, мы использовали сервис dropbox.
1. Сперва нам нужно разместить файлы (иконки, .ipa файл и manifest.plist) на dropbox и делаем их доступными по ссылке:
2. После создаём html файл, следующего содержания:
```
[Install iOS in-house App](itms-services://?action=download-manifest&url=https://www.yoursite.ru/dirname/manifest.plist)
```
3. Далее выкладываем этот html файл на локальный IIS (или ваш сайт), и пройдя по данной ссылке с мобильного устройства нам предложат установить приложение. После установки приложения пользователю нужно подтвердить доверие сертификату на устройстве **Settings → General → Device Management → «Enterprise Name»** тогда только пользователи смогут открыть приложение:
Итог
----
По итогам 5 шагов мы создали сертификат и Provisioning Profile, собрали Xcode архив из Visual Studio 2017, получили .ipa и .plist файлы для распространения, а так же смогли успешно установить приложение на устройстве перейдя по ссылке, тем самым минуя AppStore. | https://habr.com/ru/post/427579/ | null | ru | null |
# Готовим пиццу с помощью SVG
Перевод с английского: [How to cook Pizza with SVG?](http://y3x.ru/2012/08/how-to-cook-pizza-with-svg/)
В этой статье мы научимся готовить низкокалорийную пиццу, которая должна понравиться любителям SVG. Пицца будет состоять из svg-теста и вкуснейших топпингов.
Начнем с теста!
##### SVG-тесто
Приготовить тесто с помощью SVG гораздо проще чем сделать это с обычным тестом. Нам не нужны яйца, мука, молоко и т.д. Наше тесто будет состоять из радиального градиента:
```
```
тесту мы придадим форму круга:
Далее, во внешнем CSS мы определим stop-цвета для градиента:
```
#doughGradient .brownish-side {
stop-color: #ff9955
}
#doughGradient .dough {
stop-color: #ffeeaa
}
```
Перфекционисты спросят, почему свойство fill для круга не вынесено во внешний CSS?
```
#dough {
fill: url(#doughGradient)
}
```
Все просто, это пицца для ВСЕХ, а не только для пользователей Chromium. К сожалению, Opera и Firefox все еще не поддерживают такие циклические ссылки.
Чтобы не обижать любителей Opera отмечу, что поддержка спецификаций SVG там на пару шагов впереди остальных браузеров ну со скоростью отрисовки все хорошо.
Наше [SVG-тесто](http://y3x.ru/sandbox/svg-pizza/dough.svg) готово.
##### Топпинги
###### Салями
В Северной Америке подкопченые сосиски принято называть пепперони, а в России и Европе — салями. По сути, разница между ними минимальна и на вкус различить их довольно трудно. В данном случае нам потребуется окружность.
На этой окружности разместим характерные включения жира. Вот пример одного из них:
таких включений должно быть несколько. Если несколько включений имеют один цвет — их можно разместить последовательно внутри одного элемента path внутри параметра *d*. Обратите внимание, что следующая последовательность цифр должна начиваться только после буквы *z*.
Оформить окружность можно с помощью вот такой декларации во внешнем CSS:
```
#pepperoni .pepperoni-base {
fill: #a02c2c;
stroke-width: 2
}
```
Для оформления жировых включений можно использовать следующий шаблон:
```
#pepperoni .pepperoni-inc {
fill: #782121;
stroke: none
}
```
Все что нужно — придумать цвета для этих включений и названия для классов.
Для того чтобы оформление из этих классов подключилось необходимо сгруппировать содержимое внутри элемента *g* с идентификатором *#pepperoni*.
В результате получается [один кружок салями](http://y3x.ru/sandbox/svg-pizza/pepperoni.svg).
###### Помидор
Какая пицца без помидоров? Обычно помидор состоит из контура, на котором размещается несколько фрагметов и в каждом фрагменте разбросаны семена.
Итак, контур:
Фрагмент может быть вот таким:
Их тоже можно записать все в один path-элемент.
Семена помидора тоже можно распределить по фрагментам и записать в path.
С помощью добавления несложного CSS-кода можно придать оформление нашим помидорам, фрагментам и семенам.
```
#tomato .tomato-base {
fill: #ff333f;
stroke: none
}
#tomato .tomato-segment {
fill: #d40000;
stroke: none
}
#tomato .tomato-seed {
fill: #ffaaaa;
stroke: none
}
```
В конце томат будет выглядеть [следующим образом](http://y3x.ru/sandbox/svg-pizza/tomato.svg).
###### Оливки
Прототип оливки можно сделать с помощью следующего SVG-кода:
далее с помощью *use* можно сделать из этого прототипа зеленую и черную версии:
```
```
Серединка у оливок, если мы достали косточку — пустая. Поэтому следующий CSS-код поможет нам в оформлении прототипа:
```
#olive {
fill: none;
stroke-width: 22;
}
```
Далее можно назначить цвета зеленой и черной версиям:
```
#greenOlive {
stroke: #7db000;
}
#blackOlive {
stroke: #000;
}
```
В результате получится [пара SVG оливок](http://y3x.ru/sandbox/svg-pizza/olive.svg)
###### Грибы
В нашу пиццу стоит добавить еще и шампиньонов. Для ускорения процесса есть смысл воспользоваться векторным редактором [Inkscape, про который уже был материал](http://habrahabr.ru/post/149016/).
Контур шампиньона можно сделать следующим:
Также у шампиньонов можно нарисовать пластинки.
Группируем шампиньон:
и назначаем цвета контуру и жабрам:
```
#champignon .champignon-shape {
fill: #f6e5ae
}
#champignon .champignon-gills {
fill: #957f66
}
```
[SVG-шампиньон готов](http://y3x.ru/sandbox/svg-pizza/champignon.svg).
###### Болгарский перец
Добавим прототип болгарского перца. Его тоже легче нарисовать с помощью Inkscape.
Теперь можно использовать этот прототип для создания зеленой, красной и желтой версии перца.
```
```
Наши перецы должны быть пустыми внутри. Поэтому определим для прототипа следующий CSS:
```
#bellPepper {
fill-rule: evenodd
}
```
он говорит браузеру, что вложенные в наш контур фрагменты должны быть пустыми.
Теперь можно назначить цвета перцам:
```
#redBellPepper {
fill: #DA251D;
}
#greenBellPepper {
fill: #008000;
}
#yellowBellPepper {
fill: #ffcc00;
}
```
[Три SVG перца готовы](http://y3x.ru/sandbox/svg-pizza/bellPepper.svg).
###### Чиллийский перец
Чтобы придать нашей пицце пикантности добавим чиллийский перчик. У него изогнута форма:
и зеленый хвостик:
соберем его в группу:
и добавим цвет:
```
#chiliPepper .chili-pepper-body {
fill: #aa0000
}
#chiliPepper .chili-pepper-tail {
fill: #008000
}
```
В результате [SVG-перчик](http://y3x.ru/sandbox/svg-pizza/chiliPepper.svg) можно есть, но он очень острый.
##### Готовим пиццу
После того как все компоненты готовы — можно заняться сборкой.
Для этого нам потребуется много *use*-элементов. Например, тесто можно разместить следующим образом:
или немного сместить его с помощью параметров *x,y*.
Кусочек салями можно выложить так:
и так далее с помидорами, оливками, грибами и перцем.
Вот и все, [SVG-пицца](http://y3x.ru/sandbox/svg-pizza/pizza.svg) готова.
##### Выводы
Главная цель этой статьи — привлечь начинающих веб-разработчиков к использованию SVG. Использовать SVG гораздо проще чем HTML, а результатами можно впечатлить даже искушенных работодателей. Плюс продемонстрировать несколько полезных приемов:
1. Используйте один прототип для размещения похожих элементов. Это сэкономит ресурсы.
2. Группируйте фигуры которые относятся к одному смысловому объекту (помидор, гриб и т.д.).
3. Если компоненты с одной формой могут иметь разные цвета используйте *use* и назначайте цвета новым объектам. | https://habr.com/ru/post/150189/ | null | ru | null |
# Что нового в Perl 5.10?
На днях вышел первый кандидат Perl-а на релиз — [5.10.0 RC1](http://search.cpan.org/~rgarcia/perl-5.10.0-RC1/). А ведь прошло 5 лет с момента предыдущего релиза (5.8).
Так что же интересного нас ждет в 5.10?
Следует заметить, что Perl 5.10 имеет обратную совместимость с предыдущими версиями в отличии от грядущего Perl 6.
По-умолчанию новые возможности версии 5.10 отключены. Активируются они специальной прагмой [use feature](http://search.cpan.org/~rgarcia/perl-5.10.0-RC1/pod/perl5100delta.pod#The_feature_pragma), которая, кстати, имеет лексическую область видимости; или при помощи записи use 5.10.
**Функция [say](http://search.cpan.org/~rgarcia/perl-5.10.0-RC1/pod/perlfunc.pod#say)**
Аналог старого-доброго print, с тем лишь отличием, что say автоматически добавляет "\n" к выводимой строке:
`# привычный
print "$_\n" for @lines;
# становится лаконичнее
say for @lines;`
**Оператор [//](http://search.cpan.org/~rgarcia/perl-5.10.0-RC1/pod/perlop.pod#C-style_Logical_Defined-Or__)**
Смесь || и defined, которая называется defined-or. Известно, что следующий код не совсем корректен, поскольку не учитываются «ложные» значения "" и 0:
`$var = $_[0] || 'default';`
Корректная запись выглядит так:
`$var = $_[0];
$var = 'default' unless defined $var;
# или
$var = defined $_[0] ? $_[0] : 'default';`
Благодаря новому оператору // предыдущих два примера переписываются вот таким образом:
`$var = $_[0];
$var //= 'default';
# или
$var = $_[0] // 'default';`
**Оператор [~~](http://search.cpan.org/~rgarcia/perl-5.10.0-RC1/pod/perlsyn.pod#Smart_matching_in_detail)**
Данный оператор реализует механизм умного сопоставления или smart matching. Он является коммутативным (то есть, $a ~~ $b эквивалентно $b ~~ $a) и его поведение зависит от типов передаваемых аргументов. Например:
`say "$x существует" if $x ~~ @array; # grep $_ == $b, @$a или grep $_ == $b, @$a
say "foobar в массиве" if @x ~~ /foobar/; # grep /$b/, @$a
say "$key существует" if $key ~~ %hash # exists $a->{$b}`
Другими словами, ~~ — это «все-в-одном». Такое себе контекстно-зависимое сокращение. Полная таблица поведений доступна по ссылке из заголовка.
**[given](http://search.cpan.org/~rgarcia/perl-5.10.0-RC1/pod/perlsyn.pod#Switch_statements_____) — аналог C-конструкции switch**
Теперь эта конструкция built-in. Ее реализуют три новых слова: given, when и default. К тому же, она использует, описанное выше, умное сопоставление. Пример в студию!
`# вместо вот этого
if( $var ~~ undef ) { ... }
elsif( $var ~~ $var ) { ... }
elsif( $var ~~ @array ) { ... }
elsif( $var ~~ %hash ) { ... }
elsif( $var ~~ /regexp/ ) { ... }
else { ... }
# теперь пишем так
given( $var ) {
when( undef ) { ... }
when( $var ) { ... }
when( @array ) { ... }
when( %hash ) { ... }
when( /regexp/ ) { ... }
default { ... }
}`
Игра «Отгадай число» (:
````use feature qw( switch say );
my @guessed;
my $num = int( rand 100 ) + 1;
while( my $guess = ) {
chomp $guess;
given( $guess ) {
when( /\D/ ) { say "Число, пожалуйста" }
when( @guessed ) { say "Это вы уже называли" }
when( $num ) { say "В яблочко!"; last }
when( $_ < $num ) { say "Маловато"; continue }
when( $_ > $num ) { say "Многовато"; continue }
push @guessed, $_;
}
}
**Регулярные выражения**
* Буферам захвата теперь можно давать имена. Для этого используем синтаксис (?...). Существует возможность обращаться к именованным буферам в теле самого выражения — \k. Хеш %+ используется для доступа к содержимому захваченных буферов. Существует похожий хеш %-, отличие которого состоит в том, что он хранит не само значение, а ссылку на массив значений всех захваченных буферов с одинаковыми именами.
# name=value
$str =~ /(?\w+)=(?\w+)/;
say "The value of $\_ is $+{$\_}" foreach keys %+;
Добавлены собственнические квантификаторы (possessive quantifiers). Такие квантификаторы сопоставляют максимально-длинную подстроку и никогда ее не отпускают, то есть машина регулярных выражений не пытается сопоставить более короткую подстроку. Синтаксис схожий с «не жадными» квантификаторами, только вместо знака «?» используется «+». То есть: ?+, \*+, ++, {min,max}+.
**[state-переменные](http://search.cpan.org/~rgarcia/perl-5.10.0-RC1/pod/perlsub.pod#Persistent_variables_via_state())**
C-аналог модификатора static. Переменные объявленные со словом state имеют лексическую область видимости, но сохраняют свое значение постоянно.
`sub counter {
state $i = 0;
return $i++;
}`
**[Filetest -X](http://search.cpan.org/~rgarcia/perl-5.10.0-RC1/pod/perl5100delta.pod#Stacked_filetest_operators) операторы стали стековыми**
Теперь запись
`-x $file && -w _ && -f _`
сокращаем до
`-f -w -x $file`
**И многое другое…**
Рассмотреть здесь полностью все изменения не представляется возможным. Но если вы заинтересовались, то список новшеств можно прочитать в файле [perl5100delta.pod](http://search.cpan.org/~rgarcia/perl-5.10.0-RC1/pod/perl5100delta.pod)
При написании этой статьи были использованы следующие материалы:
+ [Perl 5.10 for People Who Aren’t Totally Insane](http://www.slideshare.net/rjbs/perl-510-for-people-who-arent-totally-insane)
+ [What’s new in Perl 5.10?](http://www.slideshare.net/acme/whats-new-in-perl-510)```` | https://habr.com/ru/post/16556/ | null | ru | null |
# Абстрактные войны: public interface IAbstraction против абстракции
> Следить за обновлениями блога можно в моём канале: [Эргономичный код](https://t.me/ergonomic_code)
>
>
Введение
--------
Почти 30 лет назад в классической книге по шаблонам проектирования Design Patterns: Elements of Reusable Object-Oriented Software, авторы сформулировали один из самых известных, но недопонятых принципов в истории программирования:
> Program to an interface, not an implementation.
>
> Программируйте в соответствии с интерфейсом, а не с реализацией.
>
> — Erich Gamma et. al, Design Patterns: Elements of Reusable Object-Oriented Software
>
>
Зачем "программировать в интерфейсы"? Для того чтобы реализацию этого интерфейса можно было менять без изменений клиентского кода.
Далее авторы объясняют как следовать этому совету:
> Don’t declare variables to be instances of particular concrete classes. Instead, commit only to an interface defined by an abstract class.
>
> Не объявляйте переменные как экземпляры конкретных классов. Вместо этого придерживайтесь интерфейса, определенного абстрактным классом.
>
> — Erich Gamma et. al, Design Patterns: Elements of Reusable Object-Oriented Software
>
>
Многие воспринимают это буквально и просто вносят в программу дополнительную сущность (интерфейс или абстрактный класс), которая дублирует список и сигнатуры методов одного конкретного класса.
Проблема в том, что использование ключевого слова abstract или interface само по себе не создаёт абстракцию и не защищает клиента от изменения реализации. Зато эти "заголовочные интерфейсы" по капельке, но каждый день подъедают человеческие, машинные и временные ресурсы.
Поэтому в [Эргономичном подходе](https://azhidkov.pro/posts/22/04/220409-ergo-approach-v10m1/#_%D1%8D%D1%80%D0%B3%D0%BE%D0%BD%D0%BE%D0%BC%D0%B8%D1%87%D0%BD%D1%8B%D0%B9_%D0%BF%D0%BE%D0%B4%D1%85%D0%BE%D0%B4_v1_0m1) я отказался от повсеместного использования интерфейсов и применения принципа инверсии зависимостей по умолчанию.
Давайте рассмотрим на примере вымышленной истории, почему использование ключевого слова interface не является ни достаточным, ни необходимым для защиты клиентского кода от смены реализации интерфейса.
А потом увидим, насколько легко превратить конкретный класс в интерфейс и добавить новую реализацию, если он описывает абстракцию.
Наконец, рассмотрим несколько эвристик, которые помогают создавать классы описывающие абстракции, а не реализации.
Эпизод первый: Скрытая угроза. Интерфейсы.
------------------------------------------
Представим, что некий молодой архитектор Артемий начинает новый проект. Так как бизнес требует от него минимизировать "time to market", он решает, что собрать на коленке прототип будет быстрее всего на базе Spring Data JPA. Но он будет "программировать в интерфейсы", чтобы быстро всё переписать на более поддерживаемую технологию, если проект стрельнет.
Артемий пишет примерно такой код:
```
package pro.azhidkov.programtointerfaces.v1
import org.springframework.data.repository.CrudRepository
import javax.persistence.Entity
// ...
@Entity
class User(
@Id var id: Long,
var login: String,
var password: String
)
@Repository
interface UsersRepo : CrudRepository
@Service
class UsersService( // тут по идее тоже должен быть интерфейс, но сократим его ради экономии места
private val usersRepo: UsersRepo
) {
@Transactional
fun updatePassword(id: Long, newPass: String) {
val user = usersRepo.findByIdOrNull(id)
user.password = newPass
}
}
```
Казалось бы, всё восхитительно - мы не завязываемся ни на какие детали реализации и в любой момент сможем сменить технологию работы с БД, да и сам тип БД.
И когда приложение перерастает штанишки прототипа, Артемий, решив перейти на Spring Data JDBC, просто меняет зависимость в скрипте сборки, делает замену по проекту "@Entity" на "@Table" и… О чудо! Всё собирается!
Однако, после поспешного релиза в прод выясняется, что ничего не работает. Точнее в режиме чтения приложение работает, а вот никакие модификации не сохраняются. После судорожного отката релиза и суток дебага, Артемий в документации к Spring Data JDBC выясняет, что она не реализует такую "небольшую деталь" как Dirty Checking и автомагически ничего не сохраняет. Тогда Артемий везде добавляет \*Repo.save() и всё, кризис преодолён.
```
package pro.azhidkov.programtointerfaces.v2
import org.springframework.data.relational.core.mapping.Table
import org.springframework.data.repository.CrudRepository
// ...
@Table
class User(
var id: Long,
var login: String,
var password: String
)
@Repository
interface UsersRepo : CrudRepository
@Service
class UsersService(
private val usersRepo: UsersRepo
) {
@Transactional
fun updatePassword(id: Long, newPass: String) {
val user = usersRepo.findByIdOrNull(id)
user.password = newPass
usersRepo.save(user)
}
}
```
Правда эта правка превратит код Артемия в [анти-паттерн с точки зрения JPA](https://vladmihalcea.com/best-spring-data-jparepository/)🤦.
Так на своём горьком опыте Артемий узнал, что одно только использование интерфейсов не гарантирует изменение реализации, без изменения клиентов.
> На самом деле в этой истории есть пара нестыковок, но они лишь подтверждают основной тезис поста.
>
> Артемий вряд ли смог бы скомпилировать и запустить проект, просто заменив аннотации. Наверняка ему пришлось бы нарезать модель на [агрегаты](https://azhidkov.pro/posts/22/04/220401-aggregates/) и что-то сделать с двунаправленными связями.
>
> Это обусловлено второй нестыковкой - пруф сейчас найти не могу, но уверен, что где-то читал, как сами пацаны из Spring Data писали, что интерфейсы репозиториев не являются абстракциями.
>
>
Когда проект ещё подрос, и возникла потребность в реактивном подходе, Артемий уже понимал, что переход на Spring Data R2DBC будет долгим и тяжёлым. Осознав, насколько кодовая база заточена на синхронную работу, вместо миграции проекта на Spring Data R2DBC, Артемий решил сам мигрировать на новый проект.
Эпизод второй: Пробуждение силы. Абстракции.
--------------------------------------------
Наученный горьким опытом, Артемий понял, что "программирование в интерфейсы" само по себе ничего не даёт с точки зрения гибкости. Зато интерфейсы занимают место на экране, диске и в голове Артемия. А также увеличивают время компиляции проекта. И усложняют навигацию по коду и его рефакторинг.
Поэтому в новом проекте Артемий решил программировать без лишних церемоний, зато с учётом всего своего опыта. На этот раз Артемий отложил выбор технологии для работы с БД и начал с тривиальных suspend-репозиториев неизменяемых сущностей на базе ассоциативных массивов:
```
package pro.azhidkov.programtointerfaces.v3
import org.springframework.stereotype.Repository
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
class User(
val id: Long,
val login: String,
val password: String
)
@Repository
class UsersRepo {
private val data = HashMap()
suspend fun findByIdOrNull(id: Long): User? = data[id]
suspend fun save(user: User) {
data[user.id] = user
}
}
@Service
class UsersService(
private val usersRepo: UsersRepo
) {
@Transactional
suspend fun updatePassword(id: Long, newPass: String) {
val user = usersRepo.findByIdOrNull(id)
val updatedUser = user.copy(password = newPass)
usersRepo.save(updatedUser)
}
}
```
Начав работать в таком стиле, Артемий каждый день радовался как ребёнок тому, что теперь не приходится постоянно возиться с чёртовыми прицепами в виде интерфейсов.
Однако, когда пришёл день Д - день выбора технологии работы с БД - Артемий по старой памяти напрягся. У нового проекта не ожидалось большого количества пользователей, поэтому Артемий снова решил использовать Spring Data JDBC. Кроме того, имеющиеся in-memory репозитории решили сохранить для использования в демо-версии продукта.
"Вот бы у нас сервисы зависели от интерфейсов репозиториев, чтобы мы могли во время исполнения выбирать реализацию" - злорадно говорили адепты карго культа "program to interface" из команды Артемия.
Однако, Артемий хорошо владел своими инструментами и знал, что класс, описывающий хорошую абстракцию, с помощью рефакторинга extract interface превращается в тот самый интерфейс лёгким движением руки.
Правда для Kotlin, в отличие от Java, у этого рефакторинга ещё нет галки "use interface where possible"🤦♂️. Но всё равно можно вытащить интерфейс, а потом без рефакторинга просто поменять местами имена интерфейса и класса:
1. С помощью рефакторинга из класса UsersRepo вытащить интерфейс IUsersRepo;
2. Без рефакторинга в файле IUsersRepo.kt заменить текст "IUsersRepo" на "UsersRepo";
3. Без рефакторинга в файле UsersRepo.kt заменить текст "UsersRepo" на "InMemUsersRepo";
4. Без рефакторинга переименовать файл UsersRepo.kt в InMemUsersRepo.kt;
5. Без рефакторинга переименовать файл IUsersRepo.kt в UsersRepo.kt.
> Тут опытный читатель может сказать "А если я программирую библиотеку или фреймворк и не могу зарефакторить код 100500 неизвестных клиентов?". На что я ему отвечу: "Вот тогда вам нужны интерфейсы сразу". Но это должны быть тщательно спроектированные интерфейсы, а клиенты этих интерфейсов должны изо всех сил стараться не завязываться на реализацию по умолчанию.
>
>
Следующая проблема. Артемий перестраховался и везде добавил suspend, который стал лишним, т.к. Spring Data JDBC работает в блокирующем режиме. Хорошо, что ломать не строить. Можно воспользоваться структурной заменой для того, чтобы найти и удалить все модификаторы suspend у методов классов заканчивающихся на "Repo":
Потом то же самое надо проделать для интерфейсов. Поэтому лучше загодя подумать об этом и сначала убрать suspend, а потом выделить интерфейс. В итоге у Артемия получился такой код:
```
package pro.azhidkov.programtointerfaces.v4
import org.springframework.stereotype.Repository
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
class User(
var id: Long,
var login: String,
var password: String
)
interface UsersRepo {
fun findByIdOrNull(id: Long): User?
fun save(user: User)
}
@Repository
class InMemUsersRepo : UsersRepo {
private val data = HashMap()
override fun findByIdOrNull(id: Long): User? = data[id]
override fun save(user: User) {
data[user.id] = user
}
}
@Service
class UsersService(
private val usersRepo: UsersRepo
) {
@Transactional
suspend fun updatePassword(id: Long, newPass: String) {
val user = usersRepo.findByIdOrNull(id)
val updatedUser = user.copy(password = newPass)
usersRepo.save(updatedUser)
}
}
```
Теперь Артемий может спокойно добавить "реализации" с помощью Spring Data JDBC и у него всё будет работать.
На этом история Артемия благополучно заканчивается. А нам ещё надо сделать орг. выводы.
Эпизод третий: Последние джедаи. Эргономичный подход к абстракции.
------------------------------------------------------------------
Именно потому что сами по себе интерфейсы ничего не гарантируют, а тщательно спроектированные классы превращаются в интерфейсы одним движением руки, в Эргономичном подходе я отказался от повсеместной инверсии зависимостей и внедрения интерфейсов.
Вместо этого я слежу за утечками абстракций в интерфейсах классов (имени класса и сигнатурах методов) и применяю функциональную архитектуру.
Отслеживания требуют два основных вида утечек - явные и неявные.
### Явные утечки
Явные утечки в свою очередь тоже бывают двух видов - в именовании и типах.
Для того чтобы класс описывал абстракцию, внезапно надо, чтобы имена самого класса, методов и параметров были максимально абстрактными. Например, в [True Story Project](https://azhidkov.pro/posts/22/06/220611-true-story-project/) за отправку фида в 2Гис по Email у меня отвечает такой класс:
```
class DGisFeedSender {
// Поля и конструктор
public void sendFeedTo2Gis(String recipient, String subject, InputStreamSource inputStreamSource) {
// ..
}
}
```
Как видно, в этом коде никак не упоминается Email, и я могу переделать его на отправку в телеграм, например, не трогая интерфейс класса или его клиентов. Или лёгким движением руки (и т.к. в этом проекте у меня Java - это будет действительное лёгкое движение) выделить интерфейс и сделать механизм отправки конфигурируемым.
Бывают ситуации, когда я предвижу смену или появление новой реализации и сразу завожу интерфейс. Например, я бы так поступил на месте Артемия во втором проекте.
В этом случае повысить качество абстракции мне помогает другое правило - я не пользуюсь префиксами/суффиксами I/Impl/Abstract/Default и им подобным. Интерфейсы я называю абстрактно, а в классы реализации добавляю что-то (прилагательное, название технологии и т.п.), характеризующее суть реализации. Так в примере Артемия у меня был бы интерфейс UsersRepo, который реализуется (в кавычках для Spring Data) интерфейсом SpringDataUsersRepo и классом InMemUsersRepo.
И если у меня появляются проблемы с выбором имени класса или интерфейса - для меня это красный флаг, указывающий на проблемы в дизайне.
Что касается типов - я слежу за тем, чтобы через параметры и результаты методов не утекали типы, использованные в реализации. Например, в [Проекте Л](https://azhidkov.pro/posts/21/03/210321-project-l-testing/) мне среди прочего надо было реализовать "подглядывающие" проксирование HTTP-запросов. Метод проксирования у меня очевидным образом получал HTTP-запрос и возвращал HTTP-ответ. И хотя я мог взять эти классы из библиотеки реализации (ktor) я их обернул в собственные типы:
```
data class HttpRequest(
val method: String,
val path: String,
val query: Map>,
val headers: Map>,
val body: String?
)
data class HttpResponse(
val status: Int,
val headers: Map>,
val bodyBytes: ByteArray
)
suspend fun ApiClient.proxy(token: String, request: HttpRequest): HttpResponse {
// ...
}
```
Это позволило мне при разборе одной из ошибок быстро попробовать подменить реализацию на Spring WebClient, чтобы попытаться её обойти (в итоге остался на ktor). Если бы я завёл для класса заголовочный интерфейс, но вытащил туда типы из ktor-а - этот фокус у меня не удался. Поэтому между генераций "лишних" интерфейсов и "лишних" типов параметров я голосую за вторые.
Тут важно не перегнуть палку. Например, Spring Data даёт много чудесной автомагии, если использовать класс Pageable. Если же вместо него использовать собственный класс, то придётся написать гору ручного кода для реализации пагинации. А миграцию своих проектов со Spring на что-то другое я считаю практически невероятной, поэтому использую Pageable в интерфейсах классов без зазрения совести.
### Неявные утечки
По моему опыту, наиболее проблемные неявные утечки связаны с одним предположением, проявляющемся в двух аспектах. Само предположение - "сервер" (реализация зависимости) находится в одном адресном пространстве/процессе с "клиентом".
С одним из аспектов этого предположения - достаточностью простого присвоения нового значения полю изменяемого объекта на клиенте для того, чтобы оно изменилось на сервере - мы уже столкнулись в истории Артемия. Ровно ту же проблему Артемий бы получил, если бы по каким-то причинам решил заменить реализацию репозиториев на работу через REST API, например.
С этим аспектом отлично борются неизменяемые структуры данных, которые вообще несут много светлого и доброго в дизайн. Поэтому я сам повсеместно и по умолчанию использую неизменяемые структуры данных, требую этого от своей команды и всячески продвигаю их в
интернете.
Ко второму аспекту Артемий тоже подошёл, но решил его избежать. Суть этого аспекта, заключается в полагании на простоту внутрипроцессного взаимодействия. Внутрипроцессное взаимодействие является моментальным (на фоне межпроцессного) и сам вызов наверняка дойдёт до адресата, а ответ наверняка вернётся. Если же адресат окажется в другом процессе (или того хуже на другой машине), то у нас тут же возникают все проблемы, свойственные распределённому программированию, которые никак не отражаются в упрощённом интерфейсе.
Для того чтобы обеспечить себе возможность безболезненного перехода с внутрипроцессного на межпроцессное взаимодействие, интерфейс надо существенно усложнить. Как минимум стоит рассмотреть вариант suspend/reactive интерфейса. В зависимости от контекста может быть смысл вытащить в интерфейс и потенциальные инфраструктурные ошибки.
Это всё довольно сильно усложняет код, поэтому к абстрагированию от местонахождения зависимости я прибегаю только в том случае, если считаю вероятность отъезда зависимости в другой процесс "достаточно высокой".
Вообще, самое лучшее практическое руководство по созданию нетекущих абстракций, которое я читал, содержится в книге [Practical API Design: Confessions of a Java Framework Architect](https://www.amazon.com/Practical-API-Design-Confessions-Framework/dp/1430209739). Это 400 страниц квинтэссенции боли и страданий от последствий ошибок, допущенных её автором (главным архитектором NetBeans) при проектировании "ядерных" абстракций IDE.
### Функциональная архитектура
Проектирование хороших абстракций решает проблему гибкости системы, однако остаётся проблема статической привязки домена к инфраструктуре. Для решения этой проблемы Эргономичный подход полагается на [функциональную архитектуру](https://www.youtube.com/watch?v=yTkzNHF6rMs) - выделение домена в чистое ядро, которое на **самом деле** не зависит ни от чего ни во время компиляции, ни во время исполнения.
В качестве иллюстрации возьму пример из [проекта хранения информации о торговле на бирже крипто-валют](https://azhidkov.pro/posts/22/04/220401-aggregates/#_%D0%B0%D0%BD%D0%B5%D0%BC%D0%B8%D1%87%D0%BD%D0%B0%D1%8F_%D0%B4%D0%BE%D0%BC%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D0%BC%D0%BE%D0%B4%D0%B5%D0%BB%D1%8C).
Там был такой пример плохой реализации (немного подправил под контекст этого поста):
```
fun updateCustomerSymbols(customerId: Long, activeSymbols: List) {
val customerSymbols = customerSymbolsRepo.fetchCustomerSymbols(customerId)
// Доменная логика суть которой не так важна в этом посте и описана в посте про агрегаты
activeSymbols.map { activeSymbol ->
val trading = customerSymbols.tradings.find { it.symbol == activeSymbol.symbol }
if (trading != null) {
trading.activeGrid = trading.grids.find { it.name == activeSymbol.gridName } ?: Grid(activeSymbol.gridName, BigDecimal(0))
} else {
val activeGrid = Grid(activeSymbol.gridName, BigDecimal(0))
customerSymbols.tradings.add(
SymbolTrading(activeSymbol.symbol, mutableListOf(activeGrid), activeGrid)
)
}
}
customerSymbolsRepo.save(customerSymbols)
}
```
Даже если customerSymbolsRepo - интерфейс, доменная логика всё равно сильно сцеплена с вводом-выводом и её сложно переиспользовать в другом контексте. Примером "другого контекста", который всегда актуален для доменной логики, являются тесты.
И хотя интерфейс существенно упрощает тестирование бизнес-логики, за счёт того, что позволяет в тестах использовать фейковый репозиторий, мы можем намного лучше.
Если вынести логику в отдельные чистые функции:
```
data class SymbolTrading private constructor(
val symbol: Symbol,
val grids: Map,
val activeGrid: GridName
) {
fun activateGrid(gridName: String): SymbolTrading =
if (gridName in grids) SymbolTrading(symbol, grids, gridName)
else SymbolTrading(symbol, grids + (gridName to Grid(gridName)), gridName)
}
data class CustomerSymbols(
val customerId: Long,
val tradings: Map
) {
fun activateSymbols(activeSymbols: List): CustomerSymbols {
val updatedTradings = activeSymbols.map {
tradings[it.symbol]?.activateGrid(it.gridName)
?: SymbolTrading.new(it.symbol, it.gridName)
}
return CustomerSymbols(customerId, tradings + updatedTradings.associateBy { it.symbol })
}
}
fun updateCustomerSymbols(customerId: Long, activeSymbols: List) {
val customerSymbols = customerSymbolsRepo.fetchCustomerSymbols(customerId)
val updatedCustomerSymbols = customerSymbols.activateSymbols(activeSymbols)
customerSymbolsRepo.save(updatedCustomerSymbols)
}
```
то тестирование бизнес-логики становится просто вызовом функции и проверкой результата. А изолированно тестировать оркестрацию (метод updateCustomerSymbols) особого смысла нет - ошибки в нём могут быть только на границах модулей, он будет исчерпывающе протестирован любым сценарным/интеграционным тестом, а любой юнит-тест с моками будет тавтологией.
Функциональная архитектура помогает расцепить только бизнес-логику и инфраструктуру, и если не предпринимать дополнительных усилий, то слой приложения останется сцепленным с инфраструктурой. Однако, я считаю, очень часто этого вполне достаточно. А решение расцепить слой приложения и инфраструктуру должно быть обоснованным требованиями конкретного приложения, а не способом реализации по умолчанию.
Заключение
----------
"Program to interface" - хороший совет, за которым скрывается огромный опыт банды четырёх. Однако, если интерпретировать его буквально, то следование ему повысит сложность и стоимость поддержки кодовой базы, ничего не дав взамен. Кроме того, этот совет наиболее актуален при разработке библиотек, фреймворков и платформ с динамической загрузкой кода (плагинами).
При разработке же прикладных программ, намного более простой и поддерживаемый код дают усилия по минимизации протечек абстракций и применение функциональной архитектуры. | https://habr.com/ru/post/675314/ | null | ru | null |
# 13 полезных приёмов по работе с массивами в JavaScript, которые могут вам пригодиться
Массивы являются одной из самых популярных структур данных в JavaScript, потому что они используются для хранения данных. Кроме этого, массивы дают много возможностей для работы с этими самыми данными. Понимая, что для тех, кто находится в начале пути изучения JavaScript, массивы являются одной из самых основных тем, в этой статье я хотел бы познакомить вас с некоторыми полезными трюками, о которых вы могли не знать. Давайте начнем.
### 1. Как в массиве оставить только уникальные значения
Это очень популярный вопрос во время интервью на позицию Javascript-разработчика. Вот быстрое и простое решение этой задачки. Для начала вам нужно получить уникальные значения массива, для этого можно использовать **`new Set()`** (*прим. перев.: структура данных Set хранит только уникальные значения*). Далее нужно преобразовать структуру данных Set в массив. Я хочу познакомить вас с двумя способами, как это можно сделать: первый – с помощью метода **`from()`**, второй – с помощью оператора spread (`"…"`).
```
const fruits = ['banana', 'apple', 'orange', 'watermelon', 'apple', 'orange', 'grape', 'apple'];
// Первый метод
const uniqueFruits = Array.from(new Set(fruits));
console.log(uniqueFruits); // вернет ['banana', 'apple', 'orange', 'watermelon', 'grape']
// Второй метод
const uniqueFruits2 = [...new Set(fruits)];
console.log(uniqueFruits2); // вернет ['banana', 'apple', 'orange', 'watermelon', 'grape']
```
Легко, правда?
### 2. Как заменить значения в массиве
Бывают такие ситуации, когда нужно заменить значения в массиве другими значениями. Для этого существует хороший метод, о котором вы, возможно, не знали – метод **`splice(start, value to remove, values to add)`**, где **`start`** – номер индекса, начиная с которого мы хотим удалить элементы массива, **`value to remove`** – число элементов, которые мы хотим удалить, а **`values to add`** – элементы, которые мы хотим вставить на место удаленных:
```
const fruits = ['banana', 'apple', 'orange', 'watermelon', 'apple', 'orange', 'grape', 'apple'];
fruits.splice(0, 2, 'potato', 'tomato');
console.log(fruits); // вернет ["potato", "tomato", "orange", "watermelon", "apple", "orange", "grape", "apple"]
```
### 3. Как трансформировать массив, не используя метод **`map()`**
Наверное, все знают метод массива **`map()`**, но есть и другое решение, которое может быть использовано для получения аналогичного эффекта и чистого кода. Для этого мы можем воспользоваться методом **`from()`**:
```
const friends = [
{ name: 'John', age: 22 },
{ name: 'Peter', age: 23 },
{ name: 'Mark', age: 24 },
{ name: 'Maria', age: 22 },
{ name: 'Monica', age: 21 },
{ name: 'Martha', age: 19 },
]
const friendsNames = Array.from(friends, ({name}) => name);
console.log(friendsNames); // вернет ['John', 'Peter', 'Mark', 'Maria', 'Monica', 'Martha']
```
### 4. Как быстро очистить массив
Например, у нас есть массив, в котором много элементов. Нам нужно его очистить (неважно для какой цели), при этом мы не хотим удалять элементы один за другим. Это очень просто сделать одной строчкой кода. Чтобы очистить массив, нам нужно установить длину массива в 0, и всё!
```
const fruits = ['banana', 'apple', 'orange', 'watermelon', 'apple', 'orange', 'grape', 'apple'];
fruits.length = 0;
console.log(fruits); // вернет []
```
### 5. Как преобразовать массив в объект
Бывает такая ситуация: у нас есть массив, но нам нужен объект (опять неважно для какой цели) с этими данными, и самый быстрый способ преобразовать массив в объект – это использовать оператор spread (**`"..."`**):
```
const fruits = ['banana', 'apple', 'orange', 'watermelon', 'apple', 'orange', 'grape', 'apple'];
const fruitsObj = { ...fruits };
console.log(fruitsObj); // вернет {0: 'banana', 1: 'apple', 2: 'orange', 3: 'watermelon', 4: 'apple', 5: 'orange', 6: 'grape', 7: 'apple'}
```
### 6. Как заполнить массив одинаковыми значениями
Бывают разные ситуации, когда мы хотим создать массив и заполнить его некоторыми значениями, или нам нужен массив с одинаковыми значениями. Метод **`fill()`** для подобных задач является отличным решением:
```
const newArray = new Array(10).fill('1');
console.log(newArray); // вернет ["1", "1", "1", "1", "1", "1", "1", "1", "1", "1"]
```
### 7. Как объединить более двух массивов
Вы знаете, как объединить массивы в один, не используя метод **`concat()`**? Существует простой способ объединить любое количество массивов в один массив одной строчкой кода. Как вы, вероятно, уже поняли, оператор spread (**`"..."`**) является довольно полезным инструментом при работе с массивами, как и в этом случае:
```
const fruits = ['apple', 'banana', 'orange'];
const meat = ['poultry', 'beef', 'fish'];
const vegetables = ['potato', 'tomato', 'cucumber'];
const food = [...fruits, ...meat, ...vegetables];
console.log(food); // вернет ["apple", "banana", "orange", "poultry", "beef", "fish", "potato", "tomato", "cucumber"]
```
### 8. Как найти пересечение двух массивов
С этой задачей вы можете столкнуться на любом JavaScript-собеседовании, потому что ее решение показывает ваши знания методов массива, а также то, как вы мыслите. Чтобы найти общие значения двух массивов, мы будем использовать один из ранее рассмотренных методов в этой статье, чтобы убедиться, что значения в массиве, который мы проверяем, не дублируются. Кроме этого, мы воспользуемся методами **`filter()`** и **`includes()`**. В результате мы получим массив с элементами, которые представлены в обоих массивах:
```
const numOne = [0, 2, 4, 6, 8, 8];
const numTwo = [1, 2, 3, 4, 5, 6];
const duplicatedValues = [...new Set(numOne)].filter(item => numTwo.includes(item));
console.log(duplicatedValues); // вернет [2, 4, 6]
```
### 9. Как удалить ложные значения из массива
Для начала, давайте определим ложные значения. В Javascript ложными значениями являются: **`false`**, **0**, **""**, **`null`**, **`NaN`** и **`undefined`**. Теперь мы можем выяснить, как удалить такие значения из нашего массива. Для достижения этой цели нам потребуется метод **`filter()`**:
```
const mixedArr = [0, 'blue', '', NaN, 9, true, undefined, 'white', false];
const trueArr = mixedArr.filter(Boolean);
console.log(trueArr); // вернет ["blue", 9, true, "white"]
```
### 10. Как получить рандомное значение массива
Иногда нам нужно выбрать рандомное значение массива. Чтобы решение было простым, коротким и быстрым, мы можем получить случайный номер индекса в соответствии с длиной массива. Посмотрите на этот пример:
```
const colors = ['blue', 'white', 'green', 'navy', 'pink', 'purple', 'orange', 'yellow', 'black', 'brown'];
const randomColor = colors[(Math.floor(Math.random() * (colors.length)))];
console.log(randomColor); // вернет рандомный цвет из массива
```
### 11. Как развернуть массив в обратную сторону
Когда нам нужно «перевернуть» наш массив, нет необходимости создавать его через сложные циклы и функции, потому что есть простой метод массива **`reverse()`**, который делает все это за нас, и одной строчкой кода мы можем «перевернуть» наш массив:
```
const colors = ['blue', 'white', 'green', 'navy', 'pink', 'purple', 'orange', 'yellow', 'black', 'brown'];
const reversedColors = colors.reverse();
console.log(reversedColors); // вернет ["brown", "black", "yellow", "orange", "purple", "pink", "navy", "green", "white", "blue"]
```
### 12. Метод **`lastIndexOf()`**
В JavaScript есть интересный метод **`lastIndexOf(elem)`**, который позволяет найти индекс последнего вхождения элемента **`elem`**. Например, если наш массив имеет дублированные значения, мы можем найти позицию последнего вхождения в него. Взгляните на следующий пример кода:
```
const nums = [1, 5, 2, 6, 3, 5, 2, 3, 6, 5, 2, 7];
const lastIndex = nums.lastIndexOf(5);
console.log(lastIndex); // вернет 9
```
### 13. Как просуммировать все значения в массиве
Еще один популярный вопрос во время собеседования на позицию JavaScript-разработчика. Сумму всех элементов можно найти одной строчкой кода, если знать метод **`reduce()`**:
```
const nums = [1, 5, 2, 6];
const sum = nums.reduce((x, y) => x + y);
console.log(sum); // вернет 14
```
### Заключение
В этой статье я познакомил вас с 13 полезными приёмами, которые помогут вам писать чистый и краткий код. Кроме этого, не забывайте, что есть много различных трюков, которые вы можете использовать в Javascript и которые стоит изучить не только для работы с массивами, но и для других структур данных. Я надеюсь, что вам понравились решения, представленные в статье, и вы будете использовать их для улучшения процесса разработки.
Приятного написания кода! | https://habr.com/ru/post/476042/ | null | ru | null |
# fc.tape — js-библиотека для простой анимации спрайтов
Хочу поделиться с хабросообществом javascript-библиотекой [fc.tape](http://source.futurecolors.ru/fc.tape/). Её назначение — управление анимацией спрайта, представляющего собой склеенные кадры.
[**Демо**](http://source.futurecolors.ru/fc.tape/)
Для использования fc.tape вам понадобятся [jQuery](http://jquery.com/) (1.6+), [jQuery UI](http://jqueryui.com/) (1.8+), компоненты Core и Widget.
Создать спрайт из отдельных файлов изображений можно утилитой convert, входящей в пакет [ImageMagick](http://www.imagemagick.org):
```
$ convert img_* -append sprite.png
```
*Внимание:
API версии 0.2 немного изменилось, [актуальная версия](http://source.futurecolors.ru/fc.tape/).*
Настройки
---------
**gradually** — включить плавность переключения кадров, по умолчанию включена.
**image** — путь к фоновой картинку со спрайтом анимации, по умолчанию — фоновое изображение элемента.
**frameCount** — количество кадров в анимации.
**frameHeight** — высота одного кадра, по умолчанию — высота элемента.
**frameChangeDuration** — продолжительность переключения между кадрами в милисекундах.
**backgroundX** — горизонтальное смещение спрайта с анимацией. Используется, если в одном изображении заключено несколько спрайтов.
**preload** — стартовать анимацию, когда загрузится файл со спрайтом, по умолчанию включена.
Эти настройки могут быть заданы при инициализации или через data-атрибуты, например:
API
---
### Low level API
**windToNext** — перемотать на следуюший кадр
```
$('#tape').tape('windToNext');
```
**windToPrev** — перемотать на предыдущий кадр
```
$('#tape').tape('windToPrev');
```
Оба метода учитывают размер анимации и при выходе за границы замыкают анимацию, то есть windToNext на последнем кадре покажет первый, а windToPrev на первом — последний.
**setPosition** — установить позицию спрайта на заданную безо всяких анимаций.
```
$('#tape').tape('setPosition', 14);
```
**setOptions** — изменение настроек на лету:
```
$('#tape').tape('setOptions', {
frameCount: 37
frameChangeDuration: 70
});
```
**getOption** — получение значения текущей настройки:
```
var height = $('#tape').tape('getOption', 'frameHeight');
```
### Medium level API
**windTo** — перемотать на заданный кадр. Целевой кадр указывается двумя способами — абсолютным и относительным всей анимации:
```
$('#tape').tape('windTo', 12);
$('#tape').tape('windTo', 0.6, true);
```
**stepInTo** — перемотать на заданный кадр, показывая по очереди все промежуточные. В зависимости от текущего кадра и целевого может крутить анимацию как вперёд, так и назад. Также поддерживает абсолютное и относительное задание номера целевого кадра:
```
$('#tape').tape('stepInTo', 36, false, function(){
console.log('Animation is finished');
});
```
### High level API
**rotate** — крутить спрайт при движении мышью с зажатой левой кнопкой. Это поведение можно использовать, например, в интернет-магазинах для демонстрации товара. По умолчани активной областью для кручения является сам элемент со спрайтом, но можно указать альтернативный. Также доступно указания направление кручения и его скорость:
```
$('#tape').tape('rotate', {
element: $('#handler'),
deltaX: 3,
direction: -1
});
```
---
Посмотреть на работу виджета можно на [demo-странице](http://source.futurecolors.ru/fc.tape/), на нашем [сайте](http://futurecolors.ru/team/) или на наших [работах](http://www.tnk-racing.ru/).
[Страница проекта на гитхабе](http://github.com/futurecolors/fc.tape/).
В дальнейших планах:
— улучшения API,
— добавление дополнительных поведений (high level API) в коробку,
— отказ от зависимостей от jQuery UI. | https://habr.com/ru/post/141745/ | null | ru | null |
# Хак синтаксиса PHP
Вы когда-нибудь задумывались о том, как расширить ядро PHP? Что нужно для того, чтобы создать новое ключевое слово или даже разработать новый синтаксис? Если у вас есть базовые знания языка C, то проблем с созданием небольших изменений возникнуть не должно. Да, я понимаю, что это может быть немного бессмысленно, но неважно — забавно ведь.
Давайте создадим альтернативный способ определения класса. Самый простой способ определения, разрешённый в PHP, выглядит следующим образом:
```
php
class ClassName {}
</code
```
Мы можем упростить синтаксис и заменить фигурные скобки на точку с запятой.
```
php
class ClassName;
</code
```
Если вы попытаетесь выполнить этот код, то он, очевидно, выдаст ошибку. Не проблема, мы можем это исправить.
На первом шаге необходимо установить программное обеспечение.
```
$ sudo apt-get install bison re2c
```
PHP написан на C, однако парсер разработан с помощью Bison. Bison — это генератор синтаксических анализаторов. Официальный сайт определяет его, как генератор парсеров общего назначения, который преобразует помеченную контекстно-свободную грамматику в детерминированный LR или обобщенный LR (GLR) анализатор, применяя таблицы LALR-парсера (Look-Ahead LR parser — прим. пер.).
Это очень мощная часть программного обеспечения, о которой можно написать целую книгу. Если захотите узнать больше, я посоветовал бы вам ознакомиться с [документацией](http://www.gnu.org/software/bison/manual/bison.html). Она не из легких, зато содержит хорошие примеры. И если вы когда-нибудь захотите создать язык программирования, то она может стать хорошей стартовой площадкой.
Теперь перейдите на <http://php.net> и скачайте самые свежие исходники PHP.
```
$ tar xvjf php-5.4.14.tar.bz2
$ cd php-5.4.14
$ ./configure
$ cd Zend
$ ls
```
Снимите шляпу, потому что перед вами ядро PHP. Код в этих файлах управляет подавляющим большинством веб-серверов. Давайте исследуем его.
По умолчанию для файлов генератора Bison используется расширение «y».
```
$ ls *.y
zend_ini_parser.y zend_language_parser.y
```
Мы не хотим возиться с синтаксисом «ini», поэтому остается только «zend\_language\_parser.y». Откройте его вашим любимым редактором.
Теперь, если поискать слово «class», то можно обнаружить следующее:
```
%token T_CLASS "class (T_CLASS)"
```
Парсер любит работать с токенами. Токен класса — это "**T\_CLASS**". Если вы поищете в тексте "**T\_CLASS**", то найдете нечто подобное:
```
class_entry_type:
T_CLASS { $$.u.op.opline_num = CG(zend_lineno); $$.EA = 0; }
| T_ABSTRACT T_CLASS { $$.u.op.opline_num = CG(zend_lineno); $$.EA = ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; }
| T_TRAIT { $$.u.op.opline_num = CG(zend_lineno); $$.EA = ZEND_ACC_TRAIT; }
| T_FINAL T_CLASS { $$.u.op.opline_num = CG(zend_lineno); $$.EA = ZEND_ACC_FINAL_CLASS; }
;
```
Перед вами четыре разных способа определения класса.
1. класс (class)
2. абстрактный класс (abstract class)
3. трейт (trait)
4. финальный (листовой, конечный) класс (final class)
В фигурных скобках вы можете видеть несколько присваиваний низкого уровня. Я могу только догадываться, зачем они нужны. Давайте не будем их трогать.
Мы на верном пути, но это не совсем то, что мы ищем. Поищите фразу «class\_entry\_type», которая объединяет те четыре определения класса. Она приведёт вас к пункту назначения. Разобраться в этом легко, но в первый раз читать сложновато.
```
unticked_class_declaration_statement:
class_entry_type T_STRING extends_from
{ zend_do_begin_class_declaration(&$1, &$2, &$3 TSRMLS_CC); }
implements_list
'{'
class_statement_list
'}' { zend_do_end_class_declaration(&$1, &$3 TSRMLS_CC); }
| interface_entry T_STRING
{ zend_do_begin_class_declaration(&$1, &$2, NULL TSRMLS_CC); }
interface_extends_list
'{'
class_statement_list
'}' { zend_do_end_class_declaration(&$1, NULL TSRMLS_CC); }
;
```
Здесь есть два объявления. Одно для класса, другое для интерфейса. Нас интересует первое. Оно начинается с "**class\_entry\_type**", которое разрешает конструкции: class | abstract class | trait | final class. Следующий элемент — это токен **T\_STRING**. В будущем на его месте будет имя класса. "**extends\_from**" — это группа. Этот элемент может быть преобразован в «extends T\_STRING» или оставаться пустым.
После этого парсер вызывает движок Zend, чтобы начать объявление класса.
```
{ zend_do_begin_class_declaration(&$1, &$2, &$3 TSRMLS_CC); }
```
Вы можете найти эту функцию в файле *zend\_compiler.c*.
```
void zend_do_begin_class_declaration(const znode *class_token, znode *class_name, const znode *parent_class_name TSRMLS_DC)
```
Первый аргумент здесь — это токен класса "**class\_entry\_type**", второй — имя класса "**T\_STRING**", а последний — родительский класс "**extends\_from**".
Ниже идёт группа «implements\_list». Уверен, что вы знаете, зачем она нужна. Верно, для определения интерфейсов. Следующие строки образуют обязательное тело класса: открывающая фигурная скобка "**{**", группа "**class\_statement\_list**" и закрывающая фигурная скобка "**}**". Наконец, парсер сообщает движку Zend, что объявление класса окончено.
```
{ zend_do_end_class_declaration(&$1, &$3 TSRMLS_CC); }
```
Нам необходимо продублировать этот код, но уже без тела класса.
```
unticked_class_declaration_statement:
class_entry_type T_STRING extends_from
{ zend_do_begin_class_declaration(&$1, &$2, &$3 TSRMLS_CC); }
';' { zend_do_end_class_declaration(&$1, &$3 TSRMLS_CC); }
| class_entry_type T_STRING extends_from
{ zend_do_begin_class_declaration(&$1, &$2, &$3 TSRMLS_CC); }
implements_list
'{'
class_statement_list
'}' { zend_do_end_class_declaration(&$1, &$3 TSRMLS_CC); }
| interface_entry T_STRING
{ zend_do_begin_class_declaration(&$1, &$2, NULL TSRMLS_CC); }
interface_extends_list
'{'
class_statement_list
'}' { zend_do_end_class_declaration(&$1, NULL TSRMLS_CC); }
;
```
Это было довольно просто, не так ли? Теперь вам остаётся лишь скомпилировать изменения.
```
$ cd ..
$ make
```
Первая компиляция всегда занимает некоторое время.
```
$ vim test.php
```
Введите код для тестирования.
```
php
class FooBar;
$a = new FooBar;
$a-bar = 10;
print_r($a);
```
А теперь протестируйте его.
```
$ sapi/cli/php test.php
FooBar Object
(
[bar] => 10
)
```
Отлично, у вас получилось!
Давайте сделаем еще кое-что. В PHP вы объявляете класс с помощью ключевого слова "**class**". Как насчет того, чтобы сделать его покороче? Думаю, "**cls**", подойдёт.
Ищем файлы лексера:
```
$ cd Zend/
$ ls *.l
zend_ini_scanner.l zend_language_scanner.l
```
Файл Bison оперировал токенами. Лексер позволяет вам решать как преобразовывать код в токены. Откройте zend\_language\_scanner.l и поищите слово "**class**".
```
"class" {
return T\_CLASS;
}
```
Продублируйте этот блок и измените class на cls.
```
"cls" {
return T\_CLASS;
}
"class" {
return T\_CLASS;
}
```
Дело сделано. Скомпилируйте код и можете использовать ключевое слово "**cls**" вместо "**class**".
Не правда ли забавно? Надеюсь, вам было приятно также, как и мне. Интересуйтесь, исследуйте. И если вам это действительно понравилось, то стоит подумать о том, чтобы исправить некоторые ошибки на <https://bugs.php.net/>. | https://habr.com/ru/post/179441/ | null | ru | null |
# OpenShift virtualization: контейнеры, KVM и виртуальные машины
OpenShift virtualization (апстрим проект – Kubernetes: KubeVirt, см. [здесь](https://www.openshift.com/blog/re-imagining-virtualization-with-kubernetes-and-kubevirt) и [здесь](https://www.openshift.com/blog/re-imagining-virtualization-with-kubernetes-and-kubevirt-part-ii)), в девичестве Container-native Virtualization, был представлен, как функционал платформы OpenShift, который предназначен для развертывания и управления виртуальными машинами (ВМ), как базовыми сущностями Kubernetes. Такого рода задача является технически сложной, по причине фундаментальных различий технологий. Для того, чтобы добиться поставленной цели, были использованы всем знакомые технологии на базе Red Hat Enterprise Linux и KVM, которые с нами не один год и доказали свою эффективность.
В этой статье мы рассмотрим технические аспекты OpenShift virtualization, которые делают возможным сосуществование ВМ и контейнеров в рамках одной платформы, которая управляет ими, как единым целым.
### Вычислительные задачи
Контейнеры задействуют механизмы Linux-ядра, такие как namespaces и cgroups, для изоляции процессов и управления ресурсами. Обычно под процессами понимаются приложения Python, Java или исполняемые файлы, но на самом деле это могут быть любые процессы, тот же bash, Emacs или vim.
А что такое виртуальная машина? С точки зрения гипервизора – это тоже процесс. Но только не процесс приложения, а KVM-процесс, отвечающий за выполнение конкретной ВМ.
Контейнерный образ содержит в себе все инструменты, библиотеки и файлы, необходимые для виртуальной машины KVM. Если проинспектировать pod работающей ВМ, то мы увидим там хелперы и процессы qemu-kvm. Кроме того, у нас есть доступ к KVM-инструментам для управления виртуальными машинами, таким как qemu-img, qemu-nbd и virsh.
Поскольку виртуальная машина – это pod, она автоматом наследует всю функциональность pod’а в Kubernetes. К ВМ-pod’ам точно так же, как и обычным pod’ам, применяются схемы и критерии планировщика вроде taints, tolerations, affinity и anti-affinity. Также вы получаете преимущества в виде высокой доступности и т.д. Однако есть одно важное отличие: обычные pod’ыне мигрируют с хоста на хост в привычном нам смысле. Если узел отключается, то pod на нем прерывается и переназначается на другой узел в кластере. А в случае виртуальной машины мы ожидаем увидеть живую миграцию.
Для устранения этого пробела был создан custom resource definition (CDR), описывающий механизм живой миграции, который отвечает за инициализацию, мониторинг и управление живыми миграциями ВМ между рабочими узлами.
```
apiVersion: kubevirt.io/v1alpha3
kind: VirtualMachineInstanceMigration
metadata:
name: migration-job
spec:
vmiName: fedora
```
При деактивации узла для тех его виртуальных машин, у которых в качестве eviction strategy задано Live Migration, автоматически создаются задачи миграции. Таким образом можно контролировать поведение виртуальных машин, при перемещении между нодами кластера. Вы можете как настроить Live Migration, так и управлять ВМ, как и всеми остальными подами.
### Сеть
Любая Kubernetes-система обеспечивает связь между узлами и pod’ами с помощью программных SDN-сетей. OpenShift не исключение и начиная с 3-й версии по умолчанию использует для этого OpenShiftSDN. Кроме того, в OpenShift 4 появился еще одна новая функция под названием Multus, которая позволяет сделать доступным несколько сетей и подключать к ним pod одновременно.
С помощью Multus администратор может задать дополнительные сети CNI, которые потом будут развертываются и настраиваются на кластере специальным оператором Cluster Network Operator. После чего pod’ы подключаются к одной или нескольким из этих сетей, обычно к стандартному OpenShiftSDN и дополнительному интерфейсу. Устройства SR-IOV, стандартные Linux Bridge, устройства MACVLAN и IPVLAN – все это тоже можно использовать, если это нужно вашей ВМ. На рисунке ниже показано, как задать Multus CNI для bridge сети на интерфейсе eth1:
```
apiVersion: operator.openshift.io/v1
kind: Network
metadata:
name: cluster
spec:
additionalNetworks:
- name: multus1
rawCNIConfig: '{ "cniVersion": "0.3.1", "type": "bridge", "master": "eth1", "ipam":
{ "type": "static", "addresses": [ { "address": "191.168.1.1/24" } ] } }'
type: Raw
```
Применительно к OpenShift virtualization это означает, что ВМ можно подключить к внешней сети напрямую, минуя SDN. Это важно для виртуальных машин, перенесенных на OpenShift из Red Hat Virtualization или VMware vSphere, так как при наличии доступа на второй уровень OSI не будет смены сетевых настроек. Это также означает, что ВМ может иметь сетевой адрес, обращения к которому минуют SDN. Таким образом, мы можем эффективно использовать специализированные сетевые адаптеры, или подключаться по сети к СХД напрямую…
Подробнее узнать о том, как создавать и подключать виртуальные машины OpenShift virtualization к сети можно [здесь](https://docs.openshift.com/container-platform/4.3/cnv/cnv_virtual_machines/cnv_vm_networking/cnv-attaching-vm-multiple-networks.html). Кроме того, [nmstate operator](https://github.com/openshift/kubernetes-nmstate), развертываемый в составе OpenShift virtualization, предлагает еще один хорошо знакомый вам способ создания и управления сетевыми конфигурациями на физических узлах, которые используются под гипервизорами.
### Хранение
Подключение и управление дисками виртуальных машин в рамках OpenShift virtualization выполняется с использованием таких Kubernetes-концепций как StorageClasses, PersistentVolumeClaims (PVC) и PersistentVolume (PV), а также стандартных для среды Kubernetes протоколов хранения. Таким образом, администраторы Kubernetes и отвечающие за приложения команды получают единый и привычный механизм управления как для контейнеров, так и для виртуальных машин. А для многих администраторов сред виртуализации эта концепция может показаться знакомой, поскольку в ней используются тот же принцип разделения файлов конфигурации ВМ и дисков, который применяется в OpenStack и на многих других облачных платформах.
Однако нельзя просто каждый раз создавать новый диск для ВМ, так как при миграции с гипервизора в OpenShift, нам необходимо сохранить данные. Да даже когда мы разворачиваем новую ВМ, это всегда быстрее сделать из шаблона, чем создать с нуля. Таким образом нам необходим функционал импорта имеющихся дисков.
Для упрощения этой задачи OpenShift virtualization разворачивает проект Containerized Data Importer (CDI), который сводит импорт дисковых образов дисков из нескольких источников к созданию записи в PVC.
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: "fedora-disk0"
labels:
app: containerized-data-importer
annotations:
cdi.kubevirt.io/storage.import.endpoint: "http://10.0.0.1/images/Fedora-Cloud-Base-31-1.9.x86_64.qcow2"
spec:
storageClassName: ocs-gold
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 20Gi
```
Именно эта запись и активирует CDI, запуская последовательность действий, показанных на рисунке ниже:
После того, как CDI отработает, PVC будет содержать диск виртуальной машины готовый к использованию и приведённый в стандартный для OpenShift формат…
При работе с OpenShift virtualization также пригодится OpenShift Container Storage (OCS), решение Red Hat на основе файловой системы Ceph, реализующее функционал постоянного хранилища для контейнеров. В дополнение к стандартным PVC-методам доступа – RWO (блочный) и RWX (файловый) – OCS предоставляет RWX для устройств raw block, что очень полезно при организации совместного блочного доступа для приложений с высокими требованиями к производительности. Кроме того, OCS поддерживает новый стандарт запроса группы объектов Object Bucket Claim, позволяющий приложениям напрямую использовать объектное хранилище данных.
### Виртуальные машины в контейнерах
Если вам интересно проверить, как это работает, то знайте, что OpenShift virtualization уже доступна в варианте Tech Preview в составе OpenShift 3.11 и выше. Владельцы действующей подписки на OpenShift могут воспользоваться OpenShift virtualization совершенно бесплатно и без каких-либо дополнительных телодвижений. На момент выхода этого поста актуальными являются OpenShift 4.4 и OpenShift virtualization 2.3, если вы используете предыдущие версии, то для получения последних функций стоит обновиться. Полностью поддерживаемая версия OpenShift virtualization должна выйти во второй половине 2020 года.
Для получения дополнительной информации обратитесь к [документации по OpenShift](https://docs.openshift.com/container-platform/latest/) за инструкциями по установке, включая [раздел по настройке Multus](https://docs.openshift.com/container-platform/4.3/cnv/cnv_virtual_machines/cnv_vm_networking/cnv-attaching-vm-multiple-networks.html), где приводятся сведения о настройке внешних сетей. | https://habr.com/ru/post/506200/ | null | ru | null |
# Основы работы с Shader Graph в Unity
Шейдер — это небольшая программа, содержащая инструкции для GPU. Она описывает способ вычисления экранного цвета для определённого материала.
Хотя у Unity есть Standard Shader, иногда требуется реализовать эффект, на который не способен стандартный шейдер.
Раньше для этого необходимо было знание особого языка шейдеров, такого как Cg или HLSL, а подходы в них немного отличаются от обычного создания скриптов геймплея. Для многих людей написание шейдеров — это непопулярная сторона разработки игр, потому что требуется освоение дополнительной кривой обучения.
В Unity появился **Shader Graph**, позволяющий упростить написание шейдеров почти без кода. Лучше всего то, что Shader Graph позволяет работать с визуальным интерактивным интерфейсом.
В этом туториале вы создадите свой первый шейдер для Unity!
Приступаем к работе
-------------------
В этом туториале используется Unity версии 2019.1 или более новая. Скачать новую версию Unity можно [здесь](https://unity3d.com/get-unity/update).
> *Примечание*: хотя этот туториал предназначен для новичков в Shader Graph, в нём предполагается, что вы знаете основы разработки в Unity и освоили интерфейс движка. Если вы новичок в разработке на Unity, то изучите отличный туториал [Getting Started In Unity](https://www.raywenderlich.com/5589-unity-tutorial-part-1-getting-started).
Скачайте материалы туториала по [ссылке](https://koenig-media.raywenderlich.com/uploads/2019/06/IntroToShaderGraph-2.zip). Затем распакуйте содержимое и откройте **Intro to Shader Graph Starter** в Unity.
Папка **RW** в окне Project упорядочена следующим образом:
* **Fonts**: шрифты, используемые в сцене.
* **Materials**: материалы для сцены.
* **Models**: 3D-меши для игровых фигур и фона.
* **PostFX**: эффекты постобработки для рендеринга сцены.
* **Prefabs**: различные заранее созданные компоненты.
* **Scenes**: игровая сцена.
* **Scripts**: скрипты с игровой логикой.
* **Shaders**: графы шейдеров, созданные для этого туториала.
* **Sprites**: спрайт, используемый как часть инструкций.
* **Textures**: текстурные карты для игровых фигур и фона.
Теперь загрузите сцену **TangramPuzzle** из папки **Scenes**.
Это простая игра под названием **«танграм»**, появившаяся в 19 веке в Китае. Задача игрока — переместить семь плоских геометрических фигур, составив из них стилизованные пиктограммы или силуэты.
Запустите режим **Play** в редакторе и протестируйте демо игры.
Вы можете нажимать на фигуры и перетаскивать их. Используйте клавиши направлений для поворота фигур. Поворачивайте и сдвигайте фигуры так, чтобы они не накладывались друг на друга.
Сможете разобраться, как переместить семь фигур, чтобы составить такие паттерны?
Итак, с *технической* точки зрения игра работает, но она не даёт никакой визуальной обратной связи о выбранной фигуре.
Что если мы сможем заставить фигуру светиться, когда на неё наводят мышь? Это позволит улучшить интерфейс пользователя.
И это отличный шанс продемонстрировать возможности Shader Graph!
Проверяем параметры конвейера для Shader Graph
----------------------------------------------
Shader Graph работает только с относительно новым **Scriptable Render Pipeline**, то есть с *High-Definition Render Pipeline* или с *Lightweight Render Pipeline*.
При создании нового проекта для работы с Shader Graph выберите правильный шаблон.
Пример проекта уже сконфигурирован для работы с **Lightweight Render Pipeline**. Сначала подтвердите в PackageManager, что у вас установлены пакеты **Lightweight RP** и **ShaderGraph**, выбрав **Window ► PackageManager**.
Затем выберите одну из доступных версий и при необходимости нажмите кнопку **Update to**. Обычно наилучшим выбором является последняя *verified*-версия.
Обновив пакеты, внимательно проверьте правильность параметров конвейера в **Edit ► Project Settings**.
Во вкладке **Graphics** параметр **Scriptable Render Pipeline Settings** должен иметь значение **LWRP-HighQuality**. Благодаря этому проект будет использовать наивысший параметр по умолчанию для Lightweight Render Pipeline.
Убедившись, что используется один из ассетов **Scriptable Render Pipeline**, закройте это окно.
Создание PBR Graph
------------------
При рендеринге 3D-меша на экран всегда вместе работают материал и шейдер. Поэтому прежде чем приступать к созданию шейдера, нам нужен материал.
Сначала нажмите кнопку **Create** в окне Project, чтобы сгенерировать новый материал в папке **RW/Materials**. Выберите **Create ► Material**, а затем переименуйте его в **Glow\_Mat**.
Затем в папке **RW/Shaders** создайте **PBR Graph**, выбрав **Create ► Shader ► PBR Graph**. Это граф шейдера, поддерживающий *физически точный рендеринг*, или PBR.
Назовите его **HighlightShaderGraph**.
Материал Glow\_Mat пока использует стандартный для **LightweightRenderPipeline** шейдер под названием **LightweightRenderPipeline/Lit**.
Смените его на только что созданный новый граф шейдера. Выбрав **Glow\_Mat**, нажмите на раскрывающееся меню **Shader** в верхней части инспектора и выберите **Shader Graphs ► HighlightShaderGraph**.
Материал Glow\_Mat приобретёт немного более светлый оттенок серого, но в остальном останется довольно тусклым. Не волнуйтесь, скоро мы это исправим.
Теперь дважды щёлкните на ассет **HighlightShaderGraph** или нажмите на **Open Shader Editor** в инспекторе. При этом откроется окно **Shader Graph**.
Ознакомьтесь с основными частями этого интерфейса:
* **Основное рабочее пространство** — это тёмно-серая область, в которой будут храниться операции графа. Можно нажать на рабочем пространстве правой клавишей мыши, чтобы открыть контекстное меню.
* Нод (**node**) — это единичный элемент графа. Каждый нод имеет вход, выход или операцию, в зависимости от его портов. Ноды соединяются друг с другом при помощи **рёбер**.
* **Master node** — это последний выходной нод графа. В этом примере мы используем вариант для физически точного рендеринга, также называемый нодом PBR Master. Вы можете заметить в нём отдельные свойства, например, Albedo, Normal, Emission и Metallic, которые используются в Standard Shader.
* **Blackboard** может предоставлять доступ к определённым частям графа в инспекторе. Это позволяет пользователю настраивать параметры без непосредственного редактирования самого графа.
* **Main Preview** интерактивно отображает текущие выходные данные шейдера в виде сферы.
Соединив различные ноды, вы можете создать **граф шейдера**, который Unity компилирует и передаёт в GPU.
Создание нода Color
-------------------
Для начала давайте дадим шейдеру какой-нибудь базовый цвет. Для этого нужно соединить нод цвета с компонентом Albedo нода PBR Master. **Нажмите правой клавишей** на рабочей области, чтобы создать из контекстного меню первый нод, выбрав **Create Node ► Input ► Basic ► Color**.
Заметьте, что в меню **Create Node** есть сотни нодов! Поначалу это кажется запутанным, но вы скоро разберётесь с самыми активно используемыми.
Далее перетащите нод по рабочему пространству, взявшись за его панель заголовка. Затем оставьте его где-нибудь слева от нода **PBR Master**.
Нод **Color** позволяет задать одиночный цвет. Нажмите на поле цвета и выберите красивый красный оттенок, например **R: 128, G: 5, B: 5**.
Чтобы вывести цвет в нод **PBR Master**, перетащите порт **Out** в порт **Albedo**, который обозначает базовый цвет шейдера.
Соединив ноды ребром, вы должны увидеть, как сфера в **Main Preview** станет красной.
Отлично! В области написания шейдеров создание одноцветного шейдера — это аналог *Hello, world!*
Хотя вы может быть этого ещё и не поняли, но вы только что создали свой первый шейдер!
Работа с интерфейсом
--------------------
Хотя в графе есть всего пара нодов, сейчас самое подходящее время освоиться с интерфейсом Shader Graph.
Попробуйте перетаскивать ноды и заметьте, что рёбра между выходным портом **Color** и входным портом **PBR Master** остаются соединёнными.
Ноды могут содержать различные типы данных. Так же, как мы создали нод, содержащий единственный входной цвет, можно создать нод, обозначающий одно число; выберите **Create Node ► Input ► Basic ► Integer**. С этим нодом мы ничего не будем делать, он нужен только для иллюстрации принципа.
Соедините порт **Integer Out** с портом **Alpha** нода **PBR Master**.
Наш граф по-прежнему очень мал, но у нас уже есть достаточно нодов, чтобы проверить действие горячих клавиш. Выберите пару нодов и нажмите следующие клавиши:
* **F**: выделить рамкой выбранные ноды.
* **A**: выделить рамкой весь граф.
Также можно использовать кнопки в верхней части окна, чтобы переключать отображение **Main Preview** и **Blackboard**. Кнопка **Show in Project** помогает найти текущий граф шейдера в окне Project.
Разобравшись с управлением графом, подчистим его. Нам нужны только ноды **Color** и **PBR Master**.
Нажмите правой клавишей мыши на соединение между нодами **Integer** и **Master**, а затем выберите **Delete**. Это позволит отделить нод от графа.
Аналогичным образом можно удалить нод **Integer** целиком. Нажмите правой клавишей мыши на ноде и выберите **Delete**.
Завершив работу, нажмите на кнопку **Save Asset** в левом верхнем углу интерфейса. Unity сохранит все изменения, а затем скомпилирует и активирует шейдер. Этот шаг нужно делать каждый раз, когда вы хотите увидеть последние изменения в редакторе.
Теперь вернитесь в окно и выберите материал **Glow\_Mat**.
Так как шейдер распространяется на материал, сфера в окне предварительного просмотра инспектора должна стать красной.
Теперь перетащите материал **Glow\_Mat** на фигуры танграма в окне **Scene**.
Как и ожидалось, материал с шейдером окрасили меш в красивый однородный красный цвет.
Добавляем эффект свечения
-------------------------
Если вы хотите, чтобы материал Glow\_Mat имел более загадочное свечение, то нужно снова отредактировать граф шейдера.
Сейчас выходные данные **Color** передаются на вход **Albedo** нода **PBR Master**.
Можно также перетащить ещё одно ребро из **Out** к **Emission**. Теперь тот же цвет используется дважды: и в качестве базового цвета, и в качестве цвета излучения.
Выходные порты могут иметь несколько рёбер, а входные — только одно.
Теперь переключим раскрывающееся меню **Mode** нода **Color** в режим **HDR**. Так мы включим *расширенный динамический* диапазон цветов.
Теперь изменим поле цвета. В **HDR Mode** появилась дополнительная опция **Intensity**. Нажмите пару раз на **+1** в нижней палитре или перетащите ползунок примерно на **2.5**. Теперь сохраните изменения и вернитесь в редакторе.
В редакторе фигура начнёт светиться ярко-оранжевым цветом. Постобработка в сцене уже включена и она усиливает цвет расширенного динамического диапазона.
Теперь выберите в иерархии game object **PostProcessing**. Свечение возникает благодаря эффекту **Bloom**.
Откройте параметры **Bloom** и настройте **Intensity** (силу свечения) и **Threshold** (порог начала свечения). В примере показаны значения **3** и **2**.
Ого, вот это сияние!
Создание скрипта подсветки
--------------------------
Мы не хотим, чтобы фигура светилась постоянно. Нам нужно, чтобы свечение включалось только в зависимости от позиции мыши.
Когда курсор мыши находится над фигурой, мы должны включить материал Glow\_Mat. В остальных случаях фигура должна отображаться со стандартным материалом Wood\_Mat.
Сначала создадим в **RW/Scripts** новый скрипт на **C#** и назовём его **Highlighter**. Он поможет нам переключаться между двумя материалами во время выполнения программы. Замените все строки в скрипте следующим кодом:
```
using UnityEngine;
// 1
[RequireComponent(typeof(MeshRenderer))]
[RequireComponent(typeof(Collider))]
public class Highlighter : MonoBehaviour
{
// 2
// reference to MeshRenderer component
private MeshRenderer meshRenderer;
[SerializeField]
private Material originalMaterial;
[SerializeField]
private Material highlightedMaterial;
void Start()
{
// 3
// cache a reference to the MeshRenderer
meshRenderer = GetComponent();
// 4
// use non-highlighted material by default
EnableHighlight(false);
}
// toggle betweeen the original and highlighted materials
public void EnableHighlight(bool onOff)
{
// 5
if (meshRenderer != null && originalMaterial != null &&
highlightedMaterial != null)
{
// 6
meshRenderer.material = onOff ? highlightedMaterial : originalMaterial;
}
}
}
```
Давайте разберём этот скрипт:
1. Скрипт может быть применён только к объекту, содержащему компоненты `MeshRenderer` и `Collider`. Это контролируется добавлением атрибутов `[RequireComponent]` в начало скрипта.
2. Это ссылки на `MeshRenderer`, `originalMaterial` и `highlightedMaterial`. Материалы помечены атрибутом `[SerializeField]`, что позволяет назначать их из инспектора.
3. В методе `Start` мы автоматически заполняем `MeshRenderer` при помощи `GetComponent`.
4. Вызывается `EnableHighlight(false)`. Это гарантирует, что по умолчанию будет отображаться неподсвеченный материал. Ниже находится публичный метод `EnableHighlight`, переключающий материал рендерера. Он получает булев параметр `onOff`, определяющий состояние подсветки.
5. Предотвращаем все ошибки NullReference
6. Для экономии пространства используем тернарный оператор.
Добавляем события мыши
----------------------
Так как этот скрипт применяется к фигурам, у которых есть `MeshCollider`, мы можем воспользоваться встроенными методами `OnMouseOver` и `OnMouseExit`. Добавим после метода `EnableHighlight` следующий код:
```
private void OnMouseOver()
{
EnableHighlight(true);
}
private void OnMouseExit()
{
EnableHighlight(false);
}
```
Когда мышь находится над фигурой, он будет вызывать `EnableHighlight(true)`. Аналогично, когда мышь покидает Collider, он будет вызывать `EnableHighlight(false)`.
Вот и всё! Сохраните скрипт.
Подсветка фигуры
----------------
Если в предыдущих разделах туториала вы применили Glow\_Mat к любой из фигур, то в редакторе нужно вернуть всем игровым фигурам материал Wood\_Mat. Теперь для включения свечения мы будем использовать **Highlighter** во время выполнения программы.
Сначала выберем семь объектов внутри transform **Tangram**, представляющих собой отдельные фигуры. Затем добавим им всем одновременно скрипт `Highlighter`.
Затем перетащим в поле **Original Material** материал **Wood\_Mat**, а в поле **Highlighted Material** — материал **Glow\_Mat**. Теперь запустим режим **Play** и проверим результат нашей работы.
Неплохо! При наведении курсора мыши на фигуру танграма она начинает светиться ярко-красным цветом. Если убрать от неё курсор, она возвращается к исходному состоянию.
В самой игре ничего не изменилось, но эффект подсветки добавил визуальной интересности и позволяет игроку сосредоточить внимание.
Использование нодов текстур
---------------------------
В данный момент наш простой шейдер имеет сплошной яркий красный цвет. Мы изменим шейдер таким образом, чтобы он не терял своей исходной деревянной текстуры. Для этого мы сделаем так, чтобы подсветка отображалась как светящийся край *вокруг* поверхности.
Для начала изменим **HighlightShaderGraph**, дважды щёлкнув на него или выбрав
в редакторе **Open Shader Editor**.
Удалим нод **Color**, **щёлкнув на нём правой клавишей мыши** и выбрав **Delete**. Мы будем создавать всё с нуля.
Вместо одного цвета мы подставим текстуру, воспользовавшись нодом **Sample Texture 2D**.
Создайте нод, или из контекстного меню, **нажав правой клавишей мыши** и выбрав **Create Node**, или с помощью горячей клавиши (пробела). Выберите **Input ► Texture ► Sample Texture 2D**.
Нод **Sample Texture 2D** считывает информацию цвета из ассета текстуры и выводит его RGB-значения.
Выберите текстуру из входного порта **Texture**. Нажмите на точку рядом с пустым полем, чтобы открыть файловый браузер.
Выберите ассет текстуры **WoodAlbedo**.
Соедините выходной порт **RGBA** нода **Sample Texture 2D**с портом **PBR Master Albedo**.
Вуаля! Теперь на поверхности сферы предварительного просмотра отображается текстура дерева.
Если добавить карту нормалей, то можно создать детали на поверхности. Для начала создадим ещё один нод **Sample Texture 2D**, выбрав **Create Node ► Input ► Texture ► Sample Texture 2D**.
Выберите во входном порте Texture текстуру **WoodNormal**.
Измените в раскрывающемся меню **Type** тип с **Default** на **Normal**.
Выведите значения **RGBA** в порт **Normal** нода **PBR Master**.
Сфера **Main Preview** теперь должна выглядеть более шероховатой. Карта нормалей имитирует небольшие неровности и углубления на поверхности. Это позволяет имитировать внешний вид дерева.
> *Примечание*: тип данных каждого порта указан в скобках рядом с портом. **(T2)** означает, что порт совместим с двухмерной текстурой, а **(4)** означает, что порт использует **Vector4**. В зависимости от контекста Shader Graph может игнорировать лишние значения с плавающей запятой.
Добавление эффекта Френеля
--------------------------
Теперь, когда сплошной красный цвет сменился на базовую текстуру и карту нормалей, давайте добавим эффект подсветки при помощи другого способа.
Вместо равномерного свечения всего объекта мы ограничим свечение только его краями. Это можно реализовать при помощи **эффекта Френеля**.
Создайте новый нод, нажав **правую клавишу мыши** или пробел, а затем выберите **Create Node ► Math ► Vector ► Fresnel Effect**.
Этот новый нод демонстрирует сферу с белым сияющим кольцом по диаметру. Можно настроить ширину этого гало при помощи входного порта **Power**. Щёлкните и перетащите метку **X** в левую часть поля или введите нужные числа.
Чем больше значения, тем тоньше становится гало, а маленькие значения делают его очень широким. Чтобы создать тонкое свечение по краю, можно использовать значение **4**.
Чтобы передать это гало материалу, мы соединим выход **Fresnel Effect** со входом **Emission** нода **PBR Master**.
Теперь в **MainPreview** отображается деревянная сфера с ярко-белым гало, полученным благодаря **Fresnel Effect**.
> *Примечание*: эффект Френеля назван в честь французского физика Огюстена Жана Френеля. Он заметил, что свет делает поверхности очеь яркими и похожими на зеркало, когда наблюдатель приближается к *углу скольжения*.
Можете поэкспериментировать с кухонным столом. Мы используем Unity-версию этого явления, чтобы придать геометрии сияние.
Умножение на Color
------------------
Добавить цвета светящемуся контуру можно при помощи простых вычислений с цветами.
Создайте новый нод цвета, который будет обозначать цвет светящегося кольца. Нажмите **правую клавишу мыши** или пробел, чтобы открыть контекстное меню, а затем выберите **Create node ► Input ► Basic ► Color**. Переключите цветовой режим в **HDR**.
Выберите цвет, который будет обозначать цвет подсветки. Например, выберем красивый яркий зелёный: **R:5, G:255, B:5**.
Увеличим **Intensity** до **3.5**.
Мы не можем соединить новый цвет к эффекту Френеля. потому что он не имеет входа для цвета. Поэтому нам нужно будет скомбинировать выход эффекта с выходом нода цвета. Это можно сделать при помощи нода **Multiply**.
Создадим нод **Multiply**, нажав **правую клавишу мыши**, а затем выберем **Create node ► Math ► Basic ► Multiply**.
Удалим ребро между **Fresnel Effect** и **PBR Master**. Соединим выход **Fresnel Effect** со входом **A** нода **Multiply**.
Соединим **Out** нода **Color** со входом **B** нода **Multiply**.
Затем соединим **Out** нода **Multiply** с портом **Emission** нода **PBR Master**. Вуаля! Теперь мы видим, как ярко-зелёный HDR-цвет окружает сферу **Main Preview**.
Помните, что можно использовать **Fresnel Effect Power** для увеличения или уменьшения гало. Если уменьшить значение до 1.5, то получится широкое зелёное сияние.
Для нашего примера игры хорошо подойдёт значение от **4** до **5**, но вы можете поэкспериментировать со своими значениями.
Сохраните граф шейдера и вернитесь в редактор. Вы сразу увидите свой **HighlightShaderGraph** в действии.
Запустите режим **Play**.
При наведении курсора мыши на фигуру она сохраняет свою текстуру дерева. Однако теперь вокруг её краёв появилось яркое зелёное свечение. Формально в игре ничего не изменилось, только подсветка стала более слабой.
Добавляем свойства Blackboard
-----------------------------
Если вы хотите изменить внешний вид эффекта свечения, то нужно вернуться в окно редактора Shader Graph и внести эти изменения. Например, при помощи **Fresnel Effect Power** расширить или сузить полосу гало.
Это не очень удобно, если мы захотим тестировать различные изменения. К счастью, у Shader Graph есть концепция свойств (*Properties*).
Можно сделать часть графа публично видимой в инспекторе, что позволит вносить небольшие изменения интерактивно. Это делается при помощи интерфейса **Blackboard**.
Вернитесь к Shader Graph и включите отображение **Blackboard**. Если она скрыта, то нажмите кнопку **Blackboard** в правом верхнем углу.
### Добавление свойств Base Texture и Normal Map
Теперь мы откроем и базовую текстуру, и карту нормалей, чтобы к ним можно было получить доступ через инспектор.
Нажмите на значок **+** в правом верхнем углу **Blackboard**. Выберите в раскрывающемся списке **Texture 2D**. Элемент должен появиться на **Blackboard**. Переименуйте его в **BaseTexture**.
Убедитесь, что поставлен флажок **exposed**. Если вы раскроете свойство, то оно станет публичным и доступным в инспекторе.
Чтобы добавить свойство к графу, просто перетащите его за метку в рабочее пространство. Оставьте его где-нибудь слева от нода **Sample Texture 2D**.
Соедините порт **BaseTexture** со входным портом **Texture** нода **SampleTexture 2D**, который подключен к Albedo. Так мы заменим предыдущее заданное значение.
Повторите тот же процесс для **Normal Map**. Нажмите на значок **+** и создайте новую **Texture 2D**. Переименуйте её в **Normal Map**.
Перетащите свойство в рабочее пространство и присоедините его к **Sample Texture 2D** для карты нормалей.
Нажмите **Save Asset** и вернитесь в основное окно редактора.
Выберите материал **Glow\_Mat** и обратите внимание на два новых поля в инспекторе: **Base Texture** и **Normal Map**.
Так как для них пока не заданы текстуры, в окне предпросмотра отображается зелёная подсветка поверх серой сферы.
Выберите для **BaseTexture** и **NormalMap** текстуры **WoodAlbedo** и **WoodNormal**.
Теперь под светящимися краями будут правильно отображаться текстуры дерева.
Публичные свойства позволяют пользователю вводить данные непосредственно в шейдер без необходимости редактирования графа шейдера. Поэкспериментируйте самостоятельно с выбором различных базовых текстур и карт нормалей.
### Добавляем свойства Glow Size и Glow Color
Теперь мы раскроем в Blackboard и другие типы свойств. Например, будет полезно позволить изменять значение Fresnel Effect Power.
Нажмите на значок **+** в **Blackboard** и создайте свойство **Vector1**. Оно обозначает единичный параметр типа float.
Переименуйте его в **GlowSize**.
Можно ограничивать диапазон значений, вводимых для этого свойства, преобразовав его в **ползунок**. Переключите **Mode** на **Slider**, а затем укажите для **Min** значение **0.05**, а для **Max** — значение **6**, чтобы задать диапазон. Значению **Default** присвойте **5**.
Перетащите свойство **GlowSize** в рабочее пространство. Соедините выходной порт со входом **Fresnel Effect Power**.
Теперь позволим пользователю задавать и цвет свечения. Вместо создания свойства в Blackboard мы преобразуем уже существующий в графе нод.
Выберите нод **Color**, затем нажмите **правой клавишей мыши** и выберите **Convert to Property**.
Нод **Color** преобразуется в свойство цвета в **Blackboard**, которое больше нельзя будет изменять напрямую в графе. Переименуйте свойство в **GlowColor**.
Нажмите **Save Asset** и вернитесь в основное окно редактора.
Выберите в окне Project материал **Glow\_Mat**. Вы должны увидеть что в инспекторе стали доступны ползунок **GlowSize** и поле **GlowColor**.
Измените значения материала на свой вкус. Запустите режим *Play*, чтобы протестировать свою работу.
Теперь у вас есть настраиваемая подсветка, которую можно как угодно изменять!
Куда двигаться дальше
---------------------
Поздравляю! Теперь вы можете создавать собственные шейдеры с помощью Shader Graph!
Применив собственные творческие способности, вы сами удивитесь, что у вас получится. Хотите создать крутой фантастический лазерный луч или силовое поле? Адаптируйте результат нашей работы в нужный вам шейдер.
Хотя нодов в буквальном смысле существует сотни, этот туториал должен был помочь вам в освоении Shader Graph. | https://habr.com/ru/post/479302/ | null | ru | null |
# Elixir как цель развития для python async
В книге «Python. К вершинам мастерства» Лучано Рамальо описывает одну историю. В 2000 году Лучано проходил курсы, и однажды в аудиторию заглянул Гвидо ван Россум. Раз подвернулся такой случай, все стали задавать ему вопросы. На вопрос о том, какие функции Python заимствовал из других языков, Гвидо ответил: «Все, что есть хорошего в Python, украдено из других языков».
Это действительно так. Python давно живет в контексте других языков программирования и впитывает концепции из окружения: asyncio позаимствован, благодаря Lisp появились лямбда-выражения, а Tornado скопировали с libevent. Но если у кого и стоит заимствовать идеи, так это у Erlang. Он создан 30 лет назад, и все концепции в Python, которые сейчас реализуются или только намечаются, в Erlang давно работают: многоядерность, сообщения как основа коммуникации, вызовы методов и интроспекция внутри живой системы на продакшн. Эти идеи в том или в ином виде находят своё проявление в системах вроде [Seastar.io](http://seastar.io/).
Если не брать во внимание Data Science, в котором Python сейчас вне конкуренции, то все остальное уже реализовано в Erlang: работа с сетью, обработка HTTP и веб-сокетов, работа с базами данных. Поэтому Python-разработчикам важно понимать, куда будет двигаться язык: по дороге, которую уже прошли 30 лет назад.
Чтобы разобраться в истории развития других языков и понять, куда двигается прогресс, мы пригласили на [Moscow Python Conf++](https://conf.python.ru/moscow/2020) **Максима Лапшина** ([erlyvideo](https://habr.com/ru/users/erlyvideo/)) — автора проекта Erlyvideo.ru.
Под катом текстовая версия этого доклада, а именно: в каком направлении вынуждена развиваться система, которая продолжает мигрировать от простого линейного кода к libevent и дальше, что общего и в чем отличия между Elixir и Python. Отдельное внимание уделим тому, как на разных языках программирования и платформах управлять сокетами, потоками исполнения и данными.
У Erlyvideo.ru есть система видеонаблюдения, в которой управление доступом к камерам написано на Python. Это классическая задача для этого языка. Есть пользователи и камеры, видео с которых они могут смотреть: кто-то видит одни камеры, кто-то другие — обычный сайт.
Python был выбран, потому что на нём удобно писать такой сервис: есть фреймворки, ORM, программисты, в конце концов. Разрабатываемый софт пакуется и продается пользователям. Erlyvideo.ru та компания, которая продает софт, а не только дает сервис.
Какие проблемы с Python хочется решить.
**Почему такие проблемы с многоядерностью?** Мы запускали Flussonic на стоядерных компьютерах еще до того, как это делал Intel. Но у Python с этим сложности: почему он до сих пор не использует все 80 ядер наших серверов для работы?
**Как не страдать от незакрытых сокетов?** Мониторить количество открытых сокетов это большая проблема. Когда оно достигает предела, закрывать и не допускать утечек тоже.
**Есть ли решение у забытых глобальных переменных?** Утечка глобальных переменных — это ад для любого языка со сборкой мусора, как то Java или C#.
**Как использовать железо, не сжирая впустую ресурсы?** Как обойтись без запуска 40 джанговских воркеров и 64 Гбайт RAM, если мы хотим использовать серверы эффективно, а не выбрасывать сотни тысяч долларов в месяц на ненужное железо?
### Зачем нужна многоядерность
**Чтобы все ядра использовались полностью,** требуется гораздо больше воркеров, чем ядер. Например, на 40 ядер процессора нужно от 100 воркеров: один воркер пошел к базе данных, другой занят чем-то еще.
**Один воркер может потреблять 300-400 Мбайт**. Это мы еще пишем на Python, а не на Ruby on Rails, который может потреблять в несколько раз больше и 40 Гбайт RAM легко и непринужденно вылетят впустую. Это не сильно дорого, но зачем покупать память там, где можно не покупать.
**Многоядерность помогает шарить общие данные и снижать расход памяти**, удобно и безопасно запускать много независимых друг от друга процессов. Это гораздо проще программировать, но дороже по памяти.
### Управление сокетами
По веб-сокету опрашиваем runtime-данные видеокамер с бэкенда. Софт на Python подсоединяется к Flussonic и опрашивает данные состояния видеокамер: работают или нет, есть ли новые события.
С другой стороны подключается клиент, и по веб-сокету мы отдаем эти данные в браузер. Мы хотим передавать данные клиента в реальном времени: камера включилась и выключилась, котик поел, поспал, подрал диван, нажали на кнопочку и котика прогнали.
Но, например, произошла какая-то проблема: база данных не ответила на запрос, весь код упал, осталось два открытых сокета. Запустили reload, что-то сделали, опять эта проблема — остались два сокета. Неправильно обработали ошибку БД и повисло два открытых соединения. Через какое-то время это приводит к утечкам сокетов.
### Забытые глобальные переменные
Сделали глобальный dict для списка подключенных по веб-сокету браузеров. Человек логинится на сайт, мы открываем для него веб-сокет. Потом веб-сокет с его идентификатором помещаем в какой-то глобальный dict, и, так уж получается, что возникает какая-то ошибка.
Например, записали в dict ссылку на подключение, чтобы рассылать данные. **Сработало исключение, забыли удалить ссылку и данные повисли**. Так через какое-то время начинает не хватать уже и 64 Гбайт, и хочется удвоить память на сервере. Это не решение, потому что все равно данные будут утекать.
> Мы всегда совершаем ошибки — мы люди и не можем за всем уследить.
Вопрос в том, что какие-то ошибки происходят, даже те, которые мы не ожидали увидеть.
Исторический экскурс
--------------------
Чтобы подойти к основной теме, углубимся в историю. Все, о чем мы сейчас говорим о Python, Go и Erlang, — весь этот путь другие люди прошли лет 30 назад. Мы в Python проходим путь и набиваем шишки, которые уже пройдены десятилетия назад. Путь повторяется просто удивительным образом.
### DOS
Сначала обратимся к DOS, он ближе всего. До него были совершенно другие вещи и не все живы, кто помнит компьютеры до DOS.
**Программа на DOS занимала компьютер (почти) монопольно**. Пока запущена, например, игра, ничего другое не выполняется. В интернет не пойдешь — его еще нет, и даже никуда не дозвонишься. Это было грустно, но воспоминания об этом теплые, потому что связаны с молодостью.
### Кооперативная многозадачность
Поскольку с DOS было совсем больно, появлялись новые вызовы, компьютеры становились мощнее. **Десятилетия назад разработали концепцию кооперативной многозадачности**, еще до Windows 3.11.
**Данные разделяются по процессам, и каждый процесс выполняется отдельно:** они друг от друга как-то защищены. Плохой код в одном процессе не сможет испортить код в браузере (тогда уже появлялись первые браузеры).
Дальше вопрос: как между разными процессами будет распределяться вычислительное время? Тогда не то, что не было больше одного ядра, двухпроцессорная система была редкостью. Схема была такая: пока один процесс пошел, например, на диск за данными, второй процесс получает управление от ОС. Первый сможет получить управление, когда второй сам добровольно отдаст. Я сильно упрощаю ситуацию, но **процесс как-то мог добровольно разрешать снимать его с процессора**.
### Вытесняющая многозадачность
Кооперативная многозадачность приводила к следующей проблеме: процесс мог просто повиснуть, потому что плохо написан. **Если процесс надолго занял процессор, он блокирует остальные**. В этом случае компьютер зависал, и с ним нельзя было ничего сделать, например, переключить окошко.
В ответ на эту проблему придумали вытесняющую многозадачность. ОС теперь сама жестко рулит: снимает процессы с выполнения, полностью разделяет их данные, защищает память процессов друг от друга и дает каждому какое-то количество вычислительного времени. **ОС выделяет одинаковые интервалы времени каждому процессу**.
Вопрос шедулинга времени все еще не закрыт. Сегодня разработчики ОС все еще придумывают, как правильно, в каком порядке, кому и сколько давать времени на управление. Мы сегодня видим развитие этих идей.
### Потоки
Но и этого оказалось недостаточно. Процессам нужно обмениваться данными: через сеть дорого, как-то еще сложно. Поэтому была придумана **концепция потоков**.
> Потоки — это легковесные процессы, которые объединены общей памятью.
>
>
Потоки были созданы с надеждой, что все будет легко, просто и весело. Сейчас **мультипотоковое программирование считается антипаттерном**. Если бизнес-логика написана на потоках — этот код, скорее всего, надо выбросить, потому что в нем наверняка есть ошибки. Если вам кажется, что ошибок нет, значит вы просто их еще не нашли.
Мультипотоковое программирование — это чрезвычайно сложная вещь. Мало людей, которые действительно посвятили себя умению писать на тредах и у них получается что-то реально работающее.
Тем временем появились **многоядерные компьютеры**. Они принесли с собой ужасные вещи. Потребовался совершенно другой подход к данным, возникли вопросы с локальностью данных, теперь нужно понимать, с какого ядра к каким данным идешь.
Одному ядру надо данные положить сюда, другому туда, и ни в коем случае не путать эти вещи, потому что внутри компьютера возникли фактически кластеры. Внутри современного компьютера бывает кластер, когда часть памяти припаяна к одному ядру, а другая к другому. Время прохода между этими данными может отличаться на порядки.
Примеры на Python
-----------------
Рассмотрим простой пример «Сервис в помощь покупателю». Он подбирает лучшую цену товара на нескольких площадках: вбиваем название товара и ищем торговые площадки с минимальной ценой.
Это код на старом Django, Python 2. Он сегодня не очень популярен, мало кто на нем начинает проекты.
```
@api_view(['GET'])
def best_price(request):
name = request.GET['name']
price1 = http_fetch_price('market.yandex.ru', name)
price2 = http_fetch_price('ebay.com', name)
price3 = http_fetch_price('taobao.com', name)
return Response(min([price1,price2,price3]))
```
Приходит запрос, мы идем к одному бэкенду, потом к другому. В местах, где вызывается `http_fetch_price`, потоки блокируются. В этот момент весь воркер встает на поход к Яндекс.Маркету, потом к eBay, потом до таймаута на Taobao, а в конце выдает ответ. **Все это время весь воркер стоит**.
Очень сложно одновременно опрашивать несколько бэкендов. Это плохая ситуация: потребляется память, требуется запуск большого количества воркеров и мониторинг всего сервиса. Надо смотреть насколько часты такие запросы, не нужно ли еще воркеров запускать или опять есть лишние. Это как раз те самые проблемы, о которых я говорил. **Опрашивать несколько бэкендов надо по очереди**.
Что мы видим на Python? **Один процесс на задачу,** в Python до сих пор нет мультикора. Ситуация понятна: в языках такого класса сложно сделать безопасный простой мультикор, потому что он **убьет производительность**.
Если пойти к dict с разных потоков, то доступ к данным можно написать так: склеить в памяти два экземпляра Python, чтобы они пошарили данные — они их просто сломают. Например, чтобы пойти к dict и ничего не сломать, надо ставить перед ним мьютексы. Если перед каждым dict будет мьютекс, тогда система замедлится примерно в 1000 раз — будет просто неудобно. Это сложно протаскивать в мультикор.
У нас есть **только один поток исполнения** и **масштабироваться возможно только процессами**. Фактически, мы переизобрели DOS внутри процесса — скриптовый язык образца 2010 года. Внутри процесса есть штука, которая напоминает DOS: пока мы что-то делаем, все другие процессы не работают. Огромный перерасход ресурсов и медленный ответ никому не нравился.
Какое-то время назад в Python появился **реактор сокетов**, хотя сама концепция родилась давно. Появилась возможность ожидать готовности сразу нескольких сокетов.
Сначала реактор стал востребован на серверах типа nginx. В том числе благодаря правильному использованию этой технологии, он и стал популярен. Потом концепция переползла и в скриптовые языки вроде Python и Ruby.
> Идея реактора в том, что мы перешли к событийно-ориентированному программированию.
Событийно-ориентированное программирование
------------------------------------------
Один контекст выполнения производит запрос. Пока ждем ответ, выполняется другой контекст. Примечательно, что мы практически прошли тот же этап эволюции, как переход от DOS к Windows 3.11. Только люди это сделали на 20 лет раньше, а в Python и в Ruby это появилось лет 10 назад.
### Twisted
Это событийно-ориентированный сетевой фреймворк. Он появился в 2002 году и написан на Python. Я взял пример выше и переписал его на Twisted.
```
def render_GET(self, request):
price1 = deferred_fetch_price('market.yandex.ru', name)
price2 = deferred_fetch_price('ebay.com', name)
price3 = deferred_fetch_price('taobao.com', name)
dl = defer.DeferredList([price1,price2,price3])
def reply(prices):
request.write('%d'.format(min(prices)))
request.finish()
dl.addCallback(reply)
return server.NOT_DONE_YET
```
Здесь могут быть ошибки, неточности, не хватает пресловутой обработки ошибок. Но примерная схема такая: мы не делаем запрос, а просим сходить за этим запросом когда-нибудь потом, когда будет время. В строке с `defer.DeferredList` мы хотим собрать вместе ответы от нескольких запросов.
Фактически, код состоит из двух частей. В первой части то, что было до запроса, а во второй то, что после.
> Вся история событийно-ориентированного программирования пропитана болью от разрыва линейного кода на «до запроса» и «после запроса».
Это больно, потому что куски кода смешиваются: последние строчки еще выполняются в оригинальном запросе, а функция `reply` вызовется уже после.
Это непросто удержать в голове именно потому, что мы разорвали линейный код, но это нужно было сделать. Если не вдаваться в детали, то код, который переписан с Django на Twisted, **выдаст совершенно неимоверное псевдоускорение**.
### Идея Twisted
> Объект может быть активирован при готовности сокета.
Мы берем объекты, в которые собираем необходимые данные от контекста и привязываем их активацию к сокету. Теперь готовность сокетов — один из самых важных элементов управления всей системой. Объекты будут нашими контекстами.
Но при этом язык все еще отделяет само понятие контекста исполнения, в котором живут исключения. **Контекст исполнения живет отдельно от объектов и слабо связан с ними**. Здесь возникает проблема с тем, что мы стараемся собирать данные внутри объектов: без них никак, а язык это не поддерживает.
Все это приводит к классическому callback hell. За что, например, «любят» Node.js — до недавнего времени не было вообще никаких других способов, а в Python уже все-таки появилось. Беда в том, что есть **разрывы кода в точках внешнего IO**, которые приводят к callback.
Вопросов много. Можно ли «склеить» края разрыва в коде? Можно ли вернуться обратно к нормальному человеческому коду? Что делать, если логический объект работает с двумя сокетами и один из них закрывается? Как не забыть закрыть второй? Можно ли как-то использовать все ядра?
### Async IO
Хороший ответ на эти вопросы — Async IO. Это крутой шаг вперед, хотя и непростой. Async IO сложная штука, под капотом которой много болезненных нюансов.
```
async def best_price(request):
name = request.GET['name']
price1 = async_http_fetch_price('market.yandex.ru', name)
price2 = async_http_fetch_price('ebay.com', name)
price3 = async_http_fetch_price('taobao.com', name)
prices = await asyncio.wait([price1,price2,price3])
return min(prices)
```
Разрыв кода скрыт под синтаксическим сахаром `async/await`. Мы взяли, все что было раньше, но не пошли к сети в этом коде. Мы убрали `Callback(reply)`, который был в предыдущем примере и скрыли его за `await` — местом, где код будет разрезан ножницами. Он будет разделен на две части: вызывающую и callback-часть, которая обрабатывает результаты.
Это **прекрасный синтаксический сахар**. Есть методы для склейки нескольких ожиданий в одно. Это классно, но есть нюанс: **все можно сломать «классическим» сокетом**. В Python до сих пор огромное количество библиотек, которые пойдут к сокету синхронно, сделают `timer library`и все вам испортят. Как это отладить, я не знаю.
Но **asyncio никак не помогает с утечками и с мультиядерностью**. Поэтому принципиальных изменений нет, хотя и стало лучше.
У нас остались все проблемы, о которых мы говорили в начале:
* легко утекать сокетами;
* легко оставлять ссылки в глобальных переменных;
* очень кропотливая обработка ошибок;
* всё так же сложно сделать многоядерность.
### Что делать
Будет ли это все развиваться, я не знаю, но покажу реализацию в других языках и платформах.
**Изолированные контексты выполнения.** В контекстах исполнения накапливаются результаты, держатся сокеты: логические объекты, в которых мы обычно сохраняем все данные про callback’и и сокеты. Одна из концепций: взять контексты исполнения, склеить их с потоками исполнения и полностью изолировать их друг от друга.
**Смена парадигмы объектов.** Давайте соединим контекст с потоком выполнения. Существуют аналоги, это не что-то свежее. Если кто-то пытался править исходники Apache и писать к ним модули, то знает, что там есть Apache pool. Между Apache pool’s **запрещены какие-либо ссылки**. Данные от одного Apache pool — пула, связанного с запросами, находятся внутри него, и нельзя оттуда ничего выносить.
Теоретически можно, но если так делать, то либо кто-то наругает, либо патч не примут, либо ждет долгая и мучительная отладка на продакшн. После этого никто не будет так поступать и разрешать делать такие вещи другим. На данные между контекстами ссылаться уже просто так нельзя, нужна полная изоляция.
Как обмениваться активностью? Необходимы не маленькие монады, которые внутри себя закрыты и никак друг с другом не общаются. Нам надо, чтобы они общались. Один из подходов — это обмен сообщениями. Это примерно тот путь, по которому пошли в Windows, обмениваясь сообщениями между процессами. В обычной ОС нельзя дать ссылку на память другого процесса, но можно сигнализировать через сеть, как в UNIX, или через сообщения, как в Windows.
**Все ресурсы внутри процесса и контекст становятся потоком исполнения**. Мы склеили вместе:
* runtime-данные в виртуальной машине, в которых возникают исключения;
* поток исполнения, как то, что исполняется на процессоре;
* объект, в котором логически собираются все данные.
Поздравляю — мы изобрели UNIX внутри языка программирования! Эту идею придумали примерно в 1969 году. Пока что в Python его еще нет, но Python, скорее всего, к этому придет. А, возможно, и не придет — не знаю.
### Что это дает
Прежде всего, **автоматический контроль за ресурсами**. На Moscow Python Conf++ 2019 [рассказывали](https://conf.python.ru/2019/abstracts/4680), что можно на Go написать программу и обработать все ошибки. Программа будет стоять как влитая и работать месяцами. Это действительно так, но мы не обрабатываем все ошибки.
Мы — живые люди, у нас всегда есть сроки, желание сделать что-то полезное, а не обрабатывать 535-ю ошибку за сегодня. Код, который обсыпан обработкой ошибок, ни у кого никогда не вызывает теплых чувств.
Поэтому мы все пишем «happy path», а дальше на продакшн разберемся. Будем честны: только когда нужно что-то обрабатывать, тогда и начинаем обрабатывать. Defensive programming — это чуть-чуть другое, и это не коммерческая разработка.
Поэтому, **когда у нас есть автоконтроль за ошибками — это прекрасно**. Но операционные системы его придумали 50 лет назад: если какой-то процесс умирает, то все, что он открыл, закроется автоматически. Никому сегодня не надо писать код, который будет подчищать файлы за убитым процессом. Этого нет уже 50 лет ни в одной ОС, а в Python все еще надо за этим всем внимательно и аккуратно следить руками. Это странно.
**Можно вынести тяжелые вычисления в другой контекст**, а он уже может уйти на другое ядро. Мы разделили данные, нам больше не нужны мьютексы. Можно отправить данные в другой контекст, сказать: «Ты где-нибудь там выполнись, а потом сообщи мне, что ты закончил и что-то сделал».
**Реализация asyncio без слов «async/await»**. Дальше небольшая помощь от виртуальной машины, от runtime. Это то, о чем мы говорили с `async/await`: можно переделать также на сообщения, убрать `async/await` и получить это на уровне виртуальной машины.
Процессы Erlang
---------------
Erlang придумали 30 лет назад. Бородатые ребята, которые тогда были не очень бородатые, посмотрели на UNIX и перенесли все концепции в язык программирования. Они решили, что у них теперь будет своя штука, чтобы спать по ночам и спокойно ездить на рыбалку без компьютера. Тогда еще не было ноутбуков, но бородатые ребята уже догадывались, что об этом нужно думать заранее.
**Мы получили Erlang (Elixir) — активные контексты, которые выполняются сами**. Дальше мой пример на Erlang. На Elixir он выглядит примерно так же, с некоторыми вариациями.
```
best_price(Name) ->
Price1 = spawn_price_fetcher('market.yandex.ru', Name),
Price2 = spawn_price_fetcher('ebay.com', Name),
Price3 = spawn_price_fetcher('taobao.com', Name),
lists:min(wait4([Price1,Price2,Price3])).
```
Запускаем несколько fetcher'ов — это несколько отдельных новых контекстов, которые мы ждем. Дождались, собрали данные и результат вернули как минимальную цену. Все это похоже на `async/await`, только без слов «async/await».
### Особенности Elixir
Elixir находится в базе у Erlang, и все концепции языка спокойно переносятся на Elixir. Какие у него особенности?
**Запрет на кросс-процессорные ссылки.** Под словом процесс я подразумеваю уже легковесный процесс внутри виртуальной машины — контекст. Упрощенно, если перенести на Python, в Erlang запрещены ссылки на данные внутри другого объекта. Можно иметь ссылку на весь объект целиком, как на закрытую коробочку, но на данные внутри него ссылаться нельзя. Нельзя даже синтаксически получить указатель на данные, которые находятся внутри другого объекта. Можно только знать о самом объекте.
**Внутри процессов (объектов) нет мьютексов.** Это важно — лично я больше не хочу никогда в жизни пересекаться с историей отладки многотредных рейсов на продакшн. Никому этого не пожелаю.
**Процессы могут перемещаться по ядрам, это безопасно.** Нам больше не нужно обходить, как в Java, кучу других `pointer` и переписывать их при перемещении данных из одного места в другое: у нас нет общих данных и внутренних ссылок. Например, откуда возникает проблема разреженности хипа? Из-за того, что на эти данные кто-то ссылается.
Если мы переносим данные внутри кучи в другое место для уплотнения, нам нужно пройтись по всей системе. Она может занимать десятки гигабайт и обновить все указатели — это безумие.
**Полная потокобезопасность**, за счет того, что вся коммуникация идет через сообщения. На сдачу от всего этого мы получили **вытесняющий шедулинг процессов**. Он достался легко и дешево.
**Сообщения как основа коммуникации.** Внутри объектов обычные вызовы функций, а между объектами сообщения. Приход данных из сети это сообщение, ответ другого объекта — сообщение, что-то ещё снаружи тоже сообщение в одной входящей очереди. Такого нет в UNIX, потому что не прижилось.
**Вызовы методов.** У нас есть объекты, которые мы называем процессы. Через сообщения вызываются методы на процессах.
**Вызов методов — это тоже посылка сообщения.** Здорово, что теперь его можно сделать с таймаутом. Если что-то нам отвечает медленно, вызываем метод на другом объекте. Но при этом говорим, что готовы ждать не больше 60 с, потому что у меня клиент с таймаутом в 70 с. Мне нужно будет пойти и сказать ему «503» — приходи завтра, сейчас тебя не ждут.
Больше того, **ответ на вызов можно отложить**. Внутри объекта можно принять запрос на вызов метода, и сказать: «Да-да, я тебя сейчас положу, приходи через полчаса, я тебе отвечу». Можно и не говорить, а молча отложить в сторонку. Мы этим иногда пользуемся.
### Как работать с сетью?
Можно писать линейный код, callback’ами или в стиле `asyncio.gather`. Пример, как это будет выглядеть.
```
wait4([ ]) ->
[ ];
wait4(List) ->
receive
{reply, Pid, Price} -> [Price] ++ wait4(List -- [Pid])
after
60000 ->
[]
end.
```
В функции`wait4` из предыдущего примера мы перебираем список тех, от кого еще ждем ответы. Если с помощью метода `receive` получаем сообщение от того процесса — записываем в список. Если список закончился, мы возвращаем все, что было и накапливаем список. Мы попросили одновременно три объекта пригнать нам данные. Если они не справились все вместе за 60 с, и хотя бы один из них не ответил ОК, у нас будет пустой список. Но важно то, что мы сделали общий таймаут на запрос сразу к целой пачке объектов.
Кто-то может сказать: «Подумаешь, в libcurlесть все то же самое». Но здесь важно то, что с той стороны может быть не только поход по HTTP, но и поход к БД, а еще какие-то вычисления, например, подсчет какой-то оптимальной циферки для клиента.
### Обработка ошибок
**Ошибки перешли из потока в объект, которые теперь одно и то же**. Теперь сама ошибка становится привязана не к потоку, а к объекту, где это выполнялось.
Это гораздо логичнее. Обычно, когда мы рисуем на доске всякие квадратики и кружочки в надежде, что они оживут и начнут приносить нам результат и деньги, мы рисуем, как правило, объекты, а не потоки, в которых эти объекты будут выполняться. Например, на сдачу мы можем получить автоматическое **сообщение о смерти другого объекта**.
### Интроспекция или отладка в продакшн
Что может быть приятнее, чем пойти на прод и дебажить, особенно, если ошибка возникает только под нагрузкой в часы пик. В час пик мы говорим:
*— Давайте, я сейчас рестартну!*
*— Иди за дверь и там рестартни у кого-нибудь другого!*
Здесь мы можем зайти внутрь живой системы, которая запущена прямо сейчас и специально к этому не подготовлена. Для этого не требуется перезапускать её с профилировщиком, с отладчиком, пересобирать.
**Без какой-либо потери производительности в живой продакшн-системе** мы можем посмотреть список процессов: что у них внутри, как это все это работает, потрейсить их, проверить, что у них происходит. Все это бесплатно из коробки.
### Бонусы
**Код сверхнадежен.** Например, у Python есть хрупкость с `old vs async`, и она еще сохранится лет пять, не меньше. Учитывая, с какой скоростью внедрялся Python 3, не стоит надеяться, что это будет быстро.
**Читать и трейсить сообщения проще, чем отлаживать callback’и**. Это важно. Казалось бы, если у нас все равно есть callback’и для обработки сообщений, которые мы можем увидеть, то чем это лучше? Тем, что сообщения — это кусочек данных в памяти. Его можно посмотреть глазками и понять, что сюда пришло. Его можно добавить в трейсер, получить в текстовом файле список сообщений. Это удобнее, чем callback’и.
**Шикарная многоядерность**, управление памятью и **интроспекция внутри живой системы** на продакшн.
### Проблемы
Естественно, проблемы у Erlang тоже есть.
**Потеря максимальной производительности** из-за того, что больше не можем ссылаться на данные в другом процессе или объекте. Приходится их перемещать, а это не бесплатно.
**Накладные расходы на копирование данных между процессами.** Мы можем написать программу на C, которая будет запускаться на всех 80 ядрах и обрабатывать один массив данных, и будем считать, что она это делает правильно и корректно. В Erlang так нельзя: надо аккуратно распилить данные, распределить по пачке процессов, уследить за всем. Это коммуникация стоит ресурсов — тактов процессора.
**Насколько это быстро или медленно?** Мы пишем код на Erlang уже 10 лет. Единственный конкурент, который выжил за эти 10 лет, написан на Java. С ним у нас практически полный паритет по производительности: кто-то говорит, что мы хуже, кто-то, что они. Но у них Java со всеми ее заморочками, начиная с JIT.
Мы пишем программу, которая обслуживает одновременно десятки тысяч сокетов и прокачивает через себя десятки Гб данных. Внезапно выясняется, что в этом случае **правильность алгоритмов и умение все это отлаживать в продакшн оказывается важнее, чем потенциальные плюшки от Java**. В нее вложили миллиарды долларов, но это не дает Java JIT каких-то магических преимуществ.
Но если мы хотим померяться дурацкими и бессмысленным бенчмарками, вроде «посчитать числа Фибоначчи», то здесь Erlang будет, наверное, даже хуже Python или сравним.
**Накладные расходы на аллокацию сообщений.** Иногда это больно. Например, у нас в коде есть некоторые кусочки на C, и в этих местах совсем не получалось с Erlang. Но таких мест очень мало, мы почти все выпилили из того, что оказалось лишним.
Под капотом в Erlang **нет даже синтаксиса для изменения переменных**, есть только данные, которые передаются в саморекурсивную функцию. Это функция, которая вращается по кругу, делает методы `receive` и `send receive`. Это и есть процесс — эмуляция состояния объекта, которая инспектируется снаружи. Там даже **нет объектов, это просто функция, которая работает с данными**.
Зачем это всё программисту на Python
------------------------------------
**Важно понимать траекторию развития**. Я не просто так начал с исторического контекста. Хотел показать стадии разработки у системных программистов, и что мы с вами и Python находимся где-то в середине того пути развития.
Возможно, это **позволит понять дальнейшее развитие**. Вдруг кто-то из вас решит менять Python, чтобы он наконец приобрел фичи современнее, которым хотя бы 20 лет, а не 40.
Естественно, **кругозор и знание альтернатив** тоже полезны. Какие-то вещи, возможно, вы решите переписать на Elixir, посмотрев на примеры, но это в качестве дополнительного бонуса.
> Сейчас мы работаем над программой следующей [Moscow Python Conf++](https://conf.python.ru/moscow/2020). [Здесь](https://conf.python.ru/moscow/2020/abstracts) можете посмотреть, что у программного комитета в работе и какие 6 тем приняты в программу за 4 месяца до конференции. Если знаете, что нужно добавить, то а) напишите в комментариях или б) [подайте заявку](https://conf.ontico.ru/lectures/propose?conference=mpc2020) на доклад. Call for Papers открыт до 13 января, а сама конференция состоится 27 марта. | https://habr.com/ru/post/476112/ | null | ru | null |
# Sciter — встраиваемый HTML/CSS/scripting engine
Попросили вот [здесь](http://habrahabr.ru/post/153013/) про Sciter слово замолвить… Собственно вот рассказываю.
Sciter есть встраиваемый HTML/CSS/scripting engine для создания UI десктопных и мобильных приложений, классических так и [occasionally-]connected.
В принципе поддерживаются разные парадигмы приложений ограниченные лишь фантазией разработчиков. Например одной фирмой была сделана телефонная система со smart desktop phones на которых работал Sciter-based client — фактически специализированный browser загружающий UI (HTML,CSS, scripts и images) с системного контроллера станции по специализированному протоколу.
Другой пример: фирма Symantec использует sciter как UI для их consumer продуктов — [Norton Antivirus со товарищи](http://www.softpedia.com/progScreenshots/Norton-Internet-Security-Screenshot-8667.html) (since 2007).
На картинке: sciter.exe demo проект из SDK + открытое окно DOM inspector'а, живет в inspector32.dll (исходники в SDK). inspector.dll можно использовать в своем проекте для отладки UI. Естественно что inspector UI есть опять же HTML/CSS/script + толика native code.
#### Про встраиваемость
Под встраиваемостью имеются ввиду следующие базовые принципы:
1. Компактность, сейчас движок (sciter-x.dll) имеет размер 2 — 3mb
2. Dependency free, sciter это одна DLL — sciter-x.dll. Не требует ничего сверх стандартной установки Windows.
3. Универсальный и простой API. Использется т.н. plain Windows API. Ни COM ни .NET. Но Sciter можно использовать из например .NET или Delphi — любой среды понимающей plain API.
4. Открытость и расширяемость основных механизмов. В коде приложения можно написать как свои собственные типы DOM элементов и элементов ввода так и использовать свои собственные протоколы и механизмы загрузки ресурсов. К DOM tree можно обращаться как из скрипта так и из native code.
Собственно процедура встраивания тривиальна. Это либо вызов `::CreateWindow(SciterClassName(),...)`, либо mix-in sciter'а к существующему окну добавлением в функцию окна (WinProc) такого вот кода:
```
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
//SCITER integration starts
BOOL r, handled = FALSE;
// delegating message processing to SciterProcND function:
LRESULT lr = SciterProcND(hWnd,message,wParam,lParam, &handled);
if( handled )
return lr;
//SCITER integration ends
switch (message)
{
case WM_CREATE:
//SCITER integration starts
{
// window was created, attaching callback function that will receive SCN_LOAD_DATA requests, etc.
SciterSetCallback(hWnd, BasicCallback, 0 /*cbParam is not ised in this sample*/ );
// loading default document:
LPCBYTE pb = 0; UINT cb = 0;
GetResource(L"default.html",pb,cb);
SciterLoadHtml(hWnd, pb,cb, NULL );
}
//SCITER integration ends
break;
.....
}
```
Когда функция SciterProcND получит WM\_CREATE сообщение она создаст sciter instance для этого окна. После этого этот HWND можно использовать как Sciter engine handler для остальных sciter функций. SciterSetCallback(hwnd, callback), например, зарегистрирует callback функцию в которую будут приходить например все запросы на загрузку ресурсов HTML, CSS, scripts и images. Таким образом ваше приложение может как предоставить собственный загрузчик ресурсов так и пропускать запросы в Sciter и его встроенный http client.
##### Манипулирование DOM
В составе sciter SDK есть файл sciter-x-dom.h который содержит как plain API обявления функций доступа к DOM загруженного документа так и dom::element примитив для C++. Вот например как выглядит код читающий значение 'элемента ввода ````
:
dom::element root = dom::element::root_element(hwnd);
dom::element numInput = root.find_first("input#bottles-of-beer");
json::value val = numInput.get_value(); // get numeric value
```
Sciter DOM API по своей функциональности повторяет jQuery, только исполнен "нативно".
Та же самая задача но в скрипте sciter'а ( используется [tiscript](http://www.codeproject.com/Articles/33662/TIScript-language-a-gentle-extension-of-JavaScript) ):
```
var numInput = self.select("input#bottles-of-beer");
var val = numInput.value;
```
##### behaviors - расширения и компоненты
Приложение может описывать как свои собственные типы элементов и виджетов так и использовать [набор готовых](http://www.terrainformatica.com/wiki/h-smile/built-in-behaviors/start).
Native widget в коде приложения выглядит примерно так:
```
// sort of WinProc but for windowless DOM element:
class my_widget : public sciter::event_handler
{
// CTOR/DTOR called when this event_handler is attached/detached to/from DOM element
virtual void attached (HELEMENT /*he*/ ) { }
virtual void detached (HELEMENT /*he*/ ) { }
virtual bool handle_mouse (HELEMENT he, MOUSE_PARAMS& params ) { ... }
virtual bool handle_key (HELEMENT he, KEY_PARAMS& params ) { ... }
virtual bool handle_focus (HELEMENT he, FOCUS_PARAMS& params ) { ... }
virtual bool handle_timer (HELEMENT he,TIMER_PARAMS& params ) { ... }
virtual void handle_size (HELEMENT he ) { ... }
virtual bool handle_scroll (HELEMENT he, SCROLL_PARAMS& params ) { ... }
virtual bool handle_gesture (HELEMENT he, GESTURE_PARAMS& params ) { ... }
virtual bool handle_draw (HELEMENT he, DRAW_PARAMS& params ) { ... }
virtual bool handle_method_call (HELEMENT he, METHOD_PARAMS& params ) { ... }
virtual bool handle_event (HELEMENT he, BEHAVIOR_EVENT_PARAMS& params ) { ... }
// notification event: data requested by HTMLayoutRequestData just delivered
virtual bool handle_data_arrived (HELEMENT he, DATA_ARRIVED_PARAMS& params ) { ... }
virtual bool handle_scripting_call(HELEMENT he, SCRIPTING_METHOD_PARAMS& params ) { ... }
};
struct my_widget_factory: public sciter::behavior_factory
{
my_widget_factory(): behavior_factory("my-widget") {} // symbolic name for CSS
// create the instance of our widget:
virtual event_handler* create(HELEMENT he) { return new my_widget(); }
};
// in .cpp file:
my_widget_factory _my_widget_factory; // registering the factory in global list:
```
Названия методов говорят сами за себя поэтому коментировать их не буду. Прямая аналогия: event _handler это такой WinProc, но для windowless DOM элемента.
Подключение (binding) такого контроллера к DOM элементам выполняется декларативно с помощью CSS:
```
div.my-widget
{
border: 1px solid red;
behavior: my-widget; /* the name used in sciter::behavior_factory */
}
```
Т.е. как только в документе появится `...` ему назначится объявленный event handler и будет вызвана функция `my_widget::attached(thatElement);`.
Свои behaviors можно описывать также в скрипте. Там это еще проще:
```
class MyWidget : Behavior {
function attached() { this.state.visited = true; } // as an example
function detached() { this.state.visited = false; }
function onMouse(evt) {
switch(evt.type)
{
case Event.MOUSE_DOWN: ...
case Event.MOUSE_MOVE: ...
case Event.MOUSE_UP: ...
...
}
}
property value(v) {
get { return this.text; }
set { this.text = v; }
}
}
```
И в CSS:
```
div.my-widget
{
border: 1px solid red;
prototype: MyWidget; /* script class name */
}
```
После таких деклараций DOM элементу с таким behavior делается sub-classing, т.е. вот это работает:
```
var myWidget = self.select("div.my-widget");
myWidget instanceof MyWidget; // true, that DOM element is a MyWidget now.
var val = myWidget.value; // call of MyWidget.value/get.
```
#### CSS extensions
В Sciter (h-smile core если быть точным) используется CSS level 2 плюс некоторые фичи из level 3. Также я добавил [flow и flex-units](http://www.terrainformatica.com/w3/flex-layout/flex-layout.htm) без которых использование CSS для именно desktop UI-строения занятие довольно проблематичное.
Исторически HTML и CSS используют т.н. endless tape модель - документ имеет ширину ограниченную шириной окна но высота документа не известна. Поэтому в CSS level 2 нет средств сказать "сделай высоту элемента равной высоте окна". Или, скажем, layout окна Outlook. В sciter такой layout описывается как:
```
...
...
...
```
и стиль
```
body {
flow: horizontal; /* content replaced horizontally */
width: *;
height: *; /* body spans whole window */
}
body > div {
height: *; /* all children of the body have the same height and take
whole height of the body */
}
```
Фактически flow описывает [layout manager в терминах Java AWT](http://docs.oracle.com/javase/tutorial/uiswing/layout/visual.html). В CSS level 3 появился [Flexbox Module](http://www.w3.org/TR/css3-flexbox/) который делает нечто аналогичное моему flow, но как-то коряво и не полно. Например Java::BorderLayout на нем похоже не сотворить.
#### Про версии Sciter.
В настоящее время есть две версии Sciter:
1. Sciter version 1 - GDI backend, все версии Windows включая Windows CE. Active maintenance mode.
2. Sciter version 2 - Direct2D backend, Windows Vista и выше. Актуальная версия.
Обе версии используют совместимый API поэтому взаимозаменямы.
Основные отличия Sciter2:
* Парсер и DOM HTML5 compatible.
* Custom drawing механизм переработан. Sciter использует ``alike рисование (в bitmap buffer). Element.graphics() метод в Sciter1 сосздает такой буфер (для любого DOM элемента, а не только для ). В Sciter2 используется т.н. direct drawing. В скрипте описываются функции Element.onPaintContent(graphics)`, Element.onPaintBackground(graphics) которые вызываются в момент отрисовки. Фактически эквивалент WM_PAINT, WM_ERASEBACKGRND, etc. в Windows. Direct2D достаточно производителен чтобы это стало возможным.
В CSS Sciter2 в полном объеме работает [transform](http://w3schools.com/cssref/css3_pr_transform.asp) свойство. Direct2D вытягивает это дело.`
#### Ссылки
Sciter живет [здесь](http://www.terrainformatica.com/sciter/). Там же англоязычный форум про него.
Русскоязычный форум про Sciter и HTMLayout живет на [RSDN](http://rsdn.ru/?forum/htmlayout/) за что большое человеческое спасибо всей команде RSDN.
Sciter2 SDK находится по этому адресу [terrainformatica.com/sciter/sciter2-sdk.zip](http://terrainformatica.com/sciter/sciter2-sdk.zip).
Ну вот в двух словах про Sciter. Задавайте вопросы кому интересно.` | https://habr.com/ru/post/154697/ | null | ru | null |
# For professors' note: use PVS-Studio to get students familiar with code analysis tools
Our support chats and some other indirect signs showed that there are many students among our free users. Here's the reason: PVS-Studio is now more often used by professors in courses related to software development. We are very pleased with this, and we decided to write this small article to fall under notice of other teachers. We are pleased that students become acquainted with the methodology of static code analysis in general and the PVS-Studio tool in particular. Our team will try to contribute to this trend.
Development of modern software is impossible without an integrated approach for ensuring software quality and reliability. The reason is that the size of the codebase of today's applications is growing rapidly. Let numbers speak for themselves. For example, let's take operating systems:
* MS DOS 1.0: 4,000 lines of code. One person could read this code entirety, sort it out, find bugs.
* Linux 1.0.0 kernel: 176,000 lines of code. A team still might thoroughly review the code, although it would take a lot of time and effort.
* Linux 5.0 kernel: more than 26 000 000 lines of code. One just can't embrace such a boundless project.
The Linux kernel example shows that the codebase size has grown 150 times in 25 years. Now it is impossible for a programmer to review the code of the entire application in one sitting, that is to understand it, find errors, improve architectural solutions. Inner workings of modern programs might be too overwhelming for one person. At the present time there are no more specialists who can answer any question regarding the project's internals.
The inability to grasp the project is only half the trouble. As the size of a project grows, so does the error density. I would like to emphasize that **it is not just about the increase in the number of errors, but about their density!** In a coursework program, you can write 1,000 lines of code and avoid a single error. Whereas there's no way you can add 1000 lines of code in a large application and avoid a few errors. To explain we will resort again to the numbers:
**Figure 1. Typical error density in projects of different sizes. The data is taken from Steve McConnell's book «Code complete».**
So, it is impossible to write reliable programs using the same approaches as 20-30 years ago. You have to use a set of methodologies to help control the growing complexity of a software project and ensure the necessary code quality:
* Coding standards
* Code reviews
* Unit tests
* Regression testing
* Load testing
* Manual testing
* ....
* Dynamic analysis
* Static analysis
Methodologies from the top of the list are quite familiar to programmers and have long been successfully applied by almost all teams. But the last two methodologies are still much less common, although not new. Therefore, now in the course of training students, professors should pay extra attention to the study of the static and dynamic analysis tools.
I won't say anything about dynamic analysis now, although it is no less [important](https://www.viva64.com/en/b/0643/) than static.
As for static analysis, it's our thing and I invite professors to pay attention to our PVS-Studio software product.
[PVS-Studio](https://www.viva64.com/en/pvs-studio/) is a tool designed to detect errors and potential vulnerabilities in the source code of programs, written in C, C++, C# and Java. Works in 64-bit systems on Windows, Linux and macOS and can analyze code for 32-bit, 64-bit and embedded ARM platforms.
The PVS-Studio analyzer can be regarded as a fine example of a modern static code analysis tool. First, it's a great example to show the abilities of static analysis tools in detecting [errors](https://www.viva64.com/en/inspections/) and security defects ([SAST](https://www.viva64.com/en/sast/)). Second, you can demonstrate its integration into the software development cycle to enable continuous code control. In its example, you can show integration with such systems as [Jenkins](https://www.viva64.com/en/b/0668/), [TeamCity](https://www.viva64.com/en/m/0049/), [Azure DevOps](https://www.viva64.com/en/b/0670/), [SonarQube](https://www.viva64.com/en/m/0037/), [Travis CI](https://www.viva64.com/en/b/0661/) and others.
In order to start using PVS-Studio as part of the training, you don't need to do anything special.
We provide several [options](https://www.viva64.com/en/b/0614/) for free PVS-Studio licensing, including the ones for open projects. Specifically for educational purposes, in case if student's works aren't open, the best option is to add the following comment to the code:
`// This is a personal academic project. Dear PVS-Studio, please check it.
// PVS-Studio Static Code Analyzer for C, C++, C#, and Java: http://www.viva64.com`
You need to follow two steps to start using the PVS-Studio code analyzer for free:
**Step one**
If you are using PVS-Studio as a Visual Studio plugin or you are using the «C and C++ Compiler Monitoring UI» (Standalone.exe) utility, enter the following license key:
`Name: PVS-Studio Free
Key: FREE-FREE-FREE-FREE`
If you are using PVS-Studio for Linux/macOS, use the following command:
`pvs-studio-analyzer credentials PVS-Studio Free FREE-FREE-FREE-FREE`
Note. Previously, a comment was enough to activate the free license for the Linux version. Now you also need to enter this special key, because without it, some scenarios for using the analyzer turned out to be inconvenient. [Read more](https://stackoverflow.com/a/65475501/7772356).
**Step two**
You have to write two lines of comments at the beginning of each file. Make edits in all compilable files of your project. We mean files with the extensions c, cc, cpp, cs, java and others. You don't have to change h-files.
You can both add comments manually and use an auxiliary utility to do so. You can download the utility (together with the source code) here: [how-to-use-pvs-studio-free](https://github.com/viva64/how-to-use-pvs-studio-free).
You can find the details in the article: "[How to use PVS-Studio for free](https://www.viva64.com/en/b/0457/)". Ask students to check it out. In particular, we should take into account that we provide support for free users at the StackOverflow website. But do not confuse support and notifications about bugs. These are the points that the above article describes.
Thank you for your attention. In case of any questions, we are ready to provide assistance and consultations. Don't hesitate to [write](https://www.viva64.com/en/about-feedback/) to our support.
**Additional links:**
1. [Introduce Static Analysis in the Process, Don't Just Search for Bugs with It](https://habr.com/en/post/440610/)
2. [Ways to Get a Free PVS-Studio License](https://www.viva64.com/en/b/0614/)
3. [PVS-Studio Documentation](https://www.viva64.com/en/m/) | https://habr.com/ru/post/470069/ | null | en | null |
# Миграция виртуальных машин с Xen 3.2 на XenServer 6.2 в Hetzner
#### Немного предыстории
 В 2010 году для частного проекта я завел себе небольшой выделенный сервер на hezner.de. Время шло, железо совершенствовалось, дистрибутивы Linux снимались с тех. поддержки, появлялись новые задачи и возможности, а ресурсов для полного апгрейда софта на сервере катастрофически не хватало.
Так как старый сервер был виртуализован, появилась мысль взять новый сервер и смигрировать всё старое хозяйство на него, тем более, что у hetzner появился сервер EX40 по интересной цене. По сравнению со старым X3 стоимость аренды вырастала незначительно (около 8 евро, если платить без VAT), но в плане производительности это был огромный прорыв. Заняться миграцией мешало отсутствие большого кол-ва свободного времени и немного стоимость инсталляции (Setup fee) за сервер.
Пару недель назад я случайно обнаружил, что Hetzner в июле проводит акцию и отдает данные железки без Setup fee. Лень и жаба были побеждены, да и появилось немного свободного времени, чтобы осуществить сабжевый процесс.
Акция проводится только в июле, так что, кому нужно — налетай, не скупись, покупай живопись!
#### Установка XenServer
Про установку и настройку XenServer написано много, поэтому данный момент можно опустить. Подробная инструкция по установке и настройке приведена также в [Wiki у hetzner](http://wiki.hetzner.de/index.php/Citrix_XenServer/en).
Дистрибутив XenServer и файл ответов я разместил на старом сервере, со скоростью установки проблем не было.
Сразу после установки XenServer, я рекомендую добавить непривилегированного пользователя и закрыть доступ пользователю root к ssh, а также закрыть доступ к серверу для всех сетей кроме своих (если это, конечно, возможно). В дальнейшем можно на одну из виртуалок установить OpenVPN и использовать все преимущества управления через VPN. После настройки этих простейших механизмов защиты сервера можно спокойно приступать к препарации пациента.
Диски (кстати, мне достались новые) рекомендую объединить в RAID и разбить с таким учетом, чтобы оставалось ещё немного места для подключения к dom0 в качестве хранилища ISO образов, бэкапов, заливки обновлений ПО и тд.
За прошедший год, с момента релиза 6.2, вышло много обновлений, поэтому сразу после установки XenServer крайне рекомендуется обновить ПО и установить все патчи. Начинать лучше с SP1, после установки которого cписок патчей можно посмотреть через XenCenter и скачать с web по указанным ссылкам (меню Tools/Check for Updates).
Автоматическое обновление, если Вы не купили ТП, через XenCenter невозможно. Необходимо использовать CLI.
Для обновления ПО нужно скопировать все патчи в dom0, распаковать и последовательно для каждого патча выполнить следующие команды:
```
xe patch-upload file-name=/mnt/disk/ПАТЧ1.xsupdate
xe patch-pool-apply uuid=UUID_вывод_предудущей_команды
```
После установки обновлений требуется перезапустить сервисы командой:
```
xe-toolstack-restart
```
Список установленных патчей можно проверить командой:
```
xe patch-list
```
Версия XenServer 6.2 по умолчанию использует Open vSwitch, поэтому 99% статей и комментариев по настройке сетевого окружения не полностью подходят (часть про настройку сетевого интерфейса xebr0:1, хотя, наверное, можно жить с dummy интерфейсом). Обходится эта проблема достаточно просто: в XenCenter можно добавить дополнительные локальные сети и интерфейсы (необходимо выбрать сервер и открыть вкладку Networking).
После настройки дополнительной сети не забудьте настроить iptables (Firewall и NAT) для общения с внешним миром (если используются приватные сети).
#### Миграция виртуальных машин
На момент появления идеи миграции виртуальных машин, мой склероз помнил, что я виртуализовал свои серверы с использованием LVM (почти угадал :). К счастью, зайдя на машину я обнаружил, что у меня установлен Xen 3.2 (использовалась паравиртуализация), и это значительно упрощало задачу.
Для импорта виртуальных машин я воспользовался скриптом xva.py, который можно скачать [тут](http://www-archive.xenproject.org/files/xva/).
На сервере Xen 3.2 для каждой виртуальной машины, необходимо выполнить команду:
```
python xva.py -c /etc/xen/VM.cfg -n --sparse -s IP_XenServer --username=root --password="Password"
```
Виртуальная машина автоматически будет перенесена на новый сервер за несколько минут. Экспорт через файл происходил во много раз дольше (точно время не замерял, но VM с диском на 32Gb экспортировалась более часа).
Если сразу после запуска скрипт вываливается с сообщением
```
Unauthorised response from server. Exiting
```
проверьте, не намудрили ли Вы с паролем. У меня была проблема с точкой (".").
Если после успешного завершения экспорта/импорта вы получили сообщение приведенное ниже, то нужно будет ещё кое-что подкрутить на dom0 и в виртуальной машине.
```
VM Successfully streamed
With the options you supplied, you will need to SFTP/SCP the kernel/initrd to the server manually
Create the /boot/guest/208f7a74-126e-11e4-8a8c-002185153241 directory
Copy /boot/vmlinuz-2.6.26-2-xen-amd64 to /boot/guest/208f7a74-126e-11e4-8a8c-002185153241/vmlinuz
and copy /boot/initrd.img-2.6.26-2-xen-amd64 to /boot/guest/208f7a74-126e-11e4-8a8c-002185153241/initrd
Copy these to _all_ the nodes in the pool
```
А именно, скопировать файлы vmlinuz-\* и initrd-\* из dom0 Xen 3.2 на dom0 XenServer.
Так как мне нужно было перенести 3 виртуальных машины с одним ядром, то я не стал создавать для них отдельные каталоги (может быть и зря), а создал один каталог /boot/guest/lenny в который и поместил указанные файлы.
Для того, чтобы данные виртуальные машины могли грузиться, необходимо правильно настроить параметры PV-kernel, PV-ramdisk. В моем случае пришлось ещё очистить параметр PV-bootloader, который мешал работе.
Для настройки параметров виртуальных машин необходимо выполнить следующие команды:
```
xe vm-param-set uuid=UUID_VM PV-bootloader
xe vm-param-set uuid=UUID_VM PV-kernel="/boot/guest/lenny/vmlinuz"
xe vm-param-set uuid=UUID_VM PV-ramdisk="/boot/guest/lenny/initrd"
```
UUID\_VM — идентификатор виртуальной машины (можно посмотреть командой xe vm-list)
Теперь можно пытаться загрузиться. В случае неудачи не выключайте виртуальную машину, а посмотрите путь к корневому устройству, под которыми видны диски/разделы в вашей виртуальной машине (в XenCenter вкладка Storage, параметр «Device Path»). Необходимо отредактировать параметр PV-args или через CLI или XenCenter. Я установил следующие параметры:
```
root=/dev/xvda ro clocksource=jiffies
```
Пытаемся грузиться ещё раз.
После успешной загрузки ОС не забудьте поправить файл /etc/fstab (указать правильное расположение swap), а также установить XenServer Tools. Для Debian Lenny подходит пакет xe-guest-utilities\_6.2.0-1137\_amd64.deb.
Вроде бы всё. Осталось только до конца месяца забэкапить старый сервер и отдать обратно Hetzner.
Vadim Pavlov | https://habr.com/ru/post/231301/ | null | ru | null |
# Простой дополнительный контроль состояния данных memcached
 Мониторинг memcached — дело далеко не последней важности. Как на этапе тестирования, так и на этапе сопровождения уже работающего нагруженного ресурса. Средств «из коробки» для этого не так уж и много, а если вы работает с PHP, то зачастую ограничиваетесь средствами memcache (или memcached), а именно
Memcache::getStats()
`$memcache = new Memcache;
$memcache->connect('localhost',11211);
print_r($memcache->getStats());`
что возвращает типичный набор данных
`Array ( [pid] => 25722 [uptime] => 4487286 [time] => 1308323074 [version] => 1.2.2 [pointer_size] => 64 [rusage_user] => 2646.005365 [rusage_system] => 17108.873237 **[curr\_items] => 37761** [total_items] => 10764857 **[bytes] => 140070186** [curr_connections] => 5 [total_connections] => 17360659 [connection_structures] => 31 [cmd_get] => 89154830 [cmd_set] => 10764857 **[get\_hits] => 83452021 [get\_misses] => 5702809** [evictions] => 0 [bytes_read] => 3527860756618 [bytes_written] => 4234517241183 **[limit\_maxbytes] => 2147483648** [threads] => 1 )`
Вроде всё хорошо.
Мы видим, что у нас занято 133,5 Mb из 2 Gb выделенных под memcached и около 37 тыс. ключей.
Hits к misses относиться как 83/5, что тоже не внушает опасений.
Но! То что мы видим, это не есть то, что нам нужно! (Ну или по крайней мере было нужно мне). Ведь среди этих ключей есть и те, которые устарели. И, забегая чуть вперед, скажу, что их даже больше, чем «живых» значений, и обычно раз в 10 (если конечно жаба не задушила вас выделить предельно достаточное кол-во памяти). Ибо сборщик мусора убивает устаревшие (или не устаревшие) ключи по 2-м причинам:
1) Кончилась свободная память. (тут и актуальные могут улететь)
2) Данные были запрошены и оказались expired.
Выход для этого есть, и он прост до безобразия — периодически опрашивать все ключи.
PHP для этого — не лучший вариант. Хотелось чего то «ближе к телу».
Решено. Пишем на bash/sh и ставим на cron. В моем случае достаточно 1 запуска в конце основного «нагруженного» времени (у нас это около 21-30 мск).
В качестве сервера — вполне попсовый Debian Lenny.
Итак, нам нужен libmemcached, его memdump (вывод полного списка ключей) и memccat (запрос на данные по ключю), bash/sh, и пара минут…
`#!/bin/sh
cd /usr/local/src/libmemcached-0.49/clients
./memdump --servers=127.0.0.1 >/home/memdump.dat
while read i; do
memccat $i --servers=127.0.0.1 >/dev/null 2>&1
done
#-----------------------------------------
#это всё на крон, по желанию
#
#для небольшого кол-ва ключей на 1 инстанс можно обойтись и без промежуточного файла.
#для большого будет ошибка обработки too long....`
Особенно удобно видеть реальное количество «живых» сессий, которые у нас тоже лежат в мемкеше.
Остается добавить: на рабочем сервере раз в день убивает около 850-1000 Mb данных ключей (из 2Гб выделенных) и у меня почти всегда есть **реальные** данные о состоянии memcached. | https://habr.com/ru/post/122094/ | null | ru | null |
# Как IEEE-488 может сэкономить бюджет и подарить приятные чувства ностальгии?
[](https://habr.com/ru/company/ruvds/blog/649869/)
Не все старые технологии начала компьютерной эры забыты, и некоторые энтузиасты из ностальгии по тем временам реализуют с их применением практичные и экономичные решения даже сегодня. В данном случае мы немного вспомним историю появления стандарта GPIB и поговорим о проекте сборки автоматизированного измерительного стенда для калибровки цифрового потенциометра.
Несколько месяцев назад мы с коллегой обсуждали управление оборудованием, оснащённым интерфейсом GPIB. Опираясь лишь на внутреннее чутьё и беглое изучение вопроса, я сказал, что дорогостоящие и проприетарные решения можно легко заменить открытыми инструментами и Linux. Правда, в течение многих последующих недель я несколько раз чуть было не отказался от своей позиции.
Однако благодаря упорству, делению возникавших задач на части и активному поиску информации об опыте других людей мой план, в конце концов, сработал. Я не отказывался от своего изначального взгляда полностью, просто немного отступал назад и вносил необходимые корректировки.
▍ Что такое GPIB?
-----------------
*Пример схемы подключения устройств через HP-IB в 70-х. Источник: hp9845.net*
В далёкие 60-е, если измерительное оборудование и соединялось, то никаких общепринятых методов для этого не существовало. К концу того десятилетия с появлением многосекционных контроллеров ситуация несколько улучшилась. В них устанавливалось несколько интерфейсных карт, по одной для каждого прибора, формируя общий интерфейс на задней панели.
Но, хоть такой подход и работал, инженеры HP поняли, что могут существенно улучшить его концепцию, если встроить все эти платы в приборы, избавившись от громоздкой многосекционной конструкции. Отсюда и началась разработка того, что в итоге воплотилось в Hewlett-Packard Interface Bus (HP-IB).
В 1972 году в октябрьском выпуске своего журнала компания HP представила HP-IB сразу двумя статьями: «A Practical Interface System for Electronic Instruments» и «A Common Digital Interface for Programmable Instruments: The Evolution of a System».
> «Для преодоления многих проблем, связанных с соединением приборов и цифровых устройств, была разработана новая интерфейсная система. Эта система обеспечивает простоту и гибкость реализации внутрисистемных соединений. Взаимное подключение приборов для использования на лабораторном столе, а также в крупных системах, теперь становится практичным в экономическом смысле».
После этого HP представили свою разработку в международную электротехническую комиссию (IEC), которая в итоге зафиксировала их изобретение как международный стандарт. В течение нескольких последующих лет этот интерфейс превратился в то, что мы сегодня знаем как [GPIB (интерфейсную шину общего назначения) или IEEE-488](https://en.wikipedia.org/wiki/IEEE-488), официально зарегистрированную в 1975 году.
▍ Задача
--------
Зачем мне понадобилось использовать интерфейс связи 50-летней давности? Ввиду того что GPIB в течение стольких лет являлся основным интерфейсом подключения, на рынке б/у электроники можно найти множество оснащённых им устройств, которые обойдутся намного дешевле современных аналогов. Кроме того, чем больше элементов измерительного оборудования оказывается на лабораторных столах, тем меньше их попадёт в утилизацию или на свалки. Но мне все эти оправдания не нужны — мной движет наслаждение и ностальгия от работы со всем этим старым железом.
*Схема типичного цифрового потенциометра TPL0501. Источник: Digikey Article Library*
Но что вообще может подтолкнуть к подключению приборов через компьютерный интерфейс? В моём случае речь шла о проекте, в котором нужно было откалибровать сопротивление потенциометра в каждой из программируемых позиций его движка.
Это бы позволило мне создать на основе полученных данных алгоритм калибровки, в который можно было бы подставлять нужное значение сопротивления и получать соответствующее значение регистра положения движка. Я, конечно, мог сделать эти измерения и вручную, но при 256 позициях это бы сильно утомило. Если вам интересно побольше узнать о цифровых потенциометрах, то рекомендую [статью](https://www.digikey.com/en/articles/the-fundamentals-of-digital-potentiometers) из библиотеки Digikey, в которой описываются принципы работы этих устройств и способы их использования.
*Подержанный настольный мультиметр Keithley 195A, 1982 год*
Для этой цели я приобрёл подержанный цифровой мультиметр Keithley 195A 5 ½ цифр родом из начала 80-х с установленной опцией Model 1950 AC/Amps.
▍ План действий
---------------
В ходе поисков я наткнулся на [дипломную работу](http://elektronomikon.org//Bakkarbeit%20RasPi-GPIB%20Thomas%20Klima.pdf) (Немецкий) Томаса Клима по теме использования простого в сборке шилда GPIB на базе Raspberry Pi или Pi Zero для взаимодействия с измерительными приборами. Этот проект открыт и сопровождён хорошей документацией на GitHub, а вот его сайт [electronomikon](http://elektronomikon.org/).
Это простая схема, подтверждающая моё интуитивное предположение о том, что GPIB не так уж сложен, и вы наверняка могли бы реализовать эту шину с помощью микроконтроллера 8051. Я собрал всё согласно проекту и получил готовый к работе Raspberry Pi Zero-W.
*Интерфейсный модуль GPIB установлен в заднюю панель мультиметра*
*Интерфейсный модуль GPIB на базе Raspberry Pi Zero*
Что касается ПО, то шилд задействует имеющийся модуль ядра [linux-gpib](https://linux-gpib.sourceforge.io/doc_html/index.html). Казалось, что проблем здесь возникнуть не должно. Я планировал, что спустя пару часов установки [PyVisa](https://pyvisa.readthedocs.io/en/latest/) и ряда нужных приборам библиотек у меня получится автоматически записать данные с помощью скриптов Python менее, чем за день. Вот только реальность не всегда совпадает с нашими ожиданиями.
▍ Архитектура GPIB
------------------
*Боб “Mr Fancy Pants” Стерн за стойкой с оборудованием, оснащённым HP-IB, 1980 год*
Небольшой взгляд в прошлое поможет понять принцип устройства GPIB. Если вернуться в лабораторию электроники 60-х, то использование компьютера для управления повторяющимися последовательностями было скорее исключением, чем правилом. Вместо этого вы могли увидеть магнитные или бумажные ленты, магнитные карты или даже карты, на которых команды размечались карандашом. К тому же для некоторых конфигураций компьютерное управление могло не требоваться, в принципе. Например, датчик температуры мог напрямую строить графики на ленточном самописце или сохранять значения на магнитной ленте. Если вспомнить, что именно в этой среде вращались инженеры HP, то такая архитектура имеет смысл.
*Карта для программатора HP-3260A (из коллекции перфокарт профессора Джонса, Университет Айовы)*
GPIB — это гибкая шина подключения с 15 сигналами: 8-разрядной шиной данных и 7-битами линий управления. Любое подключённое к шине устройство может быть как пассивным слушателем, так и активным отправителем. Отправитель способен одновременно сообщаться с несколькими устройствами, которые в случае возникновения требующего обработки события могут вызывать прерывание.
Сами устройства соединяются при помощи кабелей и разъёмов, которые для своего времени были достаточно невелики, но в сравнении с современными USB, Ethernet и последовательными подключениями показались бы явно неудобными. 24-контактный разъём Centronics позволяет легко соединять устройства в цепочку, но сам по себе очень громоздкий — в крайнем случае GPIB-кабель можно было использовать в качестве нунчаков.
*Кабели GPIB можно даже использовать как нунчаки*
Традиционно GPIB применялся для подключения основного управляющего компьютера к цепочке или кластеру измерительных приборов, что исторически определило распространённость аппаратных средств с интерфейсом GPIB. В течение десятилетий компьютеры оснащались интерфейсными картами ISA, появившимися позднее PCI или, если это был продукт HP, имели встроенный интерфейс GPIB. Такие компьютеры были довольно дороги, но так как интерфейсная плата могла управлять всем подключённым оборудованием, то для отдельной его группы она требовалась всего одна.
*PCI-карта GPIB от National Instruments*
Лидером в мире GPIB как по части карт, так и по части сопутствующих драйверов и программных средств являлась компания National Instruments. Однако проприетарность их ПО и высокие цены отталкивали многие небольшие компании и домашние лаборатории.
*Интерфейсный модуль USB-GPIB от Keysight*
Вы определённо можете реализовать автоматическую измерительную станцию полностью с помощью GPIB в стиле 70-х. Многие такие легаси-системы до сих пор существуют. Хотя сегодня GPIB скорее пригодится для адаптирования одного или нескольких приборов под использование в имеющейся измерительной станции, собранной на базе LAN, USB, последовательного подключения или их комбинации. Это полностью переворачивает экономическую сторону вопроса, и именно поэтому люди порой ищут дешёвые GPIB-адаптеры для всего одного прибора.
▍ Без сложностей никуда
-----------------------
На борту Pi Zero-W имеется WiFi — на деле это единственное средство подключения к локальной сети, если не использовать внешние расширения. Однако к своему WiFi-роутеру мне его подключить не удалось. Очень долго я считал, что проблема на стороне оператора. У меня довольно много плат Raspberry Pi 3-й и 4-й серии, в которых WiFi работает без проблем. Когда же я начал конкретно разбираться в проблеме, то выяснил, что сетевые инструменты в Debian/Raspberry Pi OS с течением лет изменились. Есть много руководств, в которых показываются различные способы настройки, правда некоторые из них — уже устарели.
Без LAN мой лишённый прочих средств ввода/вывода Pi Zero-W функционировать не мог, поэтому я нагромоздил кучу USB-кабелей и HDMI-адаптер, чтобы хотя бы получить доступ к командной строке, и заказал пару адаптеров USB-LAN в качестве временного обходного пути для подключения к сети. Много часов пробежало за поиском и проверкой идей, когда, наконец, я нашёл пару туманных постов, в которых указывалось, что проблемы подключения Pi Zero-W наблюдались в некоторых странах — в том числе и в Южной Корее.
И проблема действительно оказалась в этом. Я временно изменил в настройках роутера страну на США, после чего Pi спокойно подключился. Оставлять это так было нельзя, поэтому я обратно переключился на Южную Корею и продолжил использовать проводное LAN-подключение для срочной работы.
Хотя у этой проблемы всё же случился счастливый конец. На [форуме Raspberry Pi](https://forums.raspberrypi.com/viewtopic.php?t=314361) один из инженеров подтвердил баг и отправил в Cypress Semiconductors запрос на его исправление. Несколько недель спустя мы получили обновлённую прошивку, которая решила проблему и, надеюсь, будет добавлена в предстоящий релиз.
▍ Роутер сходит с ума
---------------------
Сейчас у меня есть пара Pi Zero, Pi 4B и несколько адаптеров USB-LAN — всё работает. Поскольку эти адаптеры можно перемещать — сегодня использовать на одном ПК, а завтра на другом — я предусмотрительно подписал каждый и указал эти данные в файлах `/etc/hosts` и `/etc/ethers` роутера, после чего моя сеть тут же полегла. Разобраться оказалось непросто, потому что извлечь из роутера информацию при зависшей сети очень проблемно. В конце концов, я выяснил, что по ошибке перепутал в его таблице две записи для этих адаптеров, отчего OpenWRT сошла с ума.
*Интерфейсы USB-LAN получили наклейки со своими MAC-адресами*
Процесс поиска и устранения этой проблемы затянулся надолго, и с решением я, возможно, немного перестарался. Во-первых, я полностью обнулил роутер и заново установил прошивку. Я оптимизировал организацию данных об имени хоста и присваивании статических IP-адресов, а также нашёл вот [этот код](https://gist.github.com/burghardt/d97fa4196ca4cd99bb706e8cebc05231), написанный Кшиштафом Бургхардтом, который преобразует `/etc/hosts и etc/ethers` в OpenWRT-файл `/etc/config/dhcp`. Я купил второй роутер на запас, чтобы в случае повторения проблемы, можно было быстро их поменять. И последнее, я разорился на этикеточный принтер, чтобы наглядно обозначить эти USB-LAN адаптеры их MAC-адресами.
▍ Готово
--------
*Приступим к измерениям!*
Наконец-то, я готов заняться реальной работой над проектом. Не обращайте внимание на висящие сзади провода — они идут к логическому анализатору Analog Discovery 2, следящему за сигналами GPIB. Наручные часы — это симптом моей лени — я установил старый смартфон на штатив, чтобы наблюдать за измерениями в лаборатории, и во время тестирования скриптов Python мониторил процесс со своего компьютера в офисе.
Изредка видео зависало, поэтому я ориентировался на секундную стрелку, чтобы понять, всё ли работает как надо. Во второй части этой саги я подытожу проведённые измерения, поделюсь дополнительной информацией о GPIB и его ревизиях, а также покажу графики, полученные с моей автоматизированной тестовой установки.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=kak_ieee_488_mozhet_sekonomit_byudzhet_i_podarit_priyatnye_chuvstva_nostalgii) | https://habr.com/ru/post/649869/ | null | ru | null |
# 4,2 гигабайта, или как нарисовать что угодно
> В нашем мире мы можем сделать всё, что захотим. Всё что угодно.
>
>
>
> — *Боб Росс, The Joy Of Painting, сезон 29, эпизод 1*
Однажды, когда я наблюдал за ярким закатом в Сиэтле, внезапно включилось моё воображение. Потусторонний оттенок неба пробудил воспоминания о чём-то из научной фантастики. Дымчатый оранжево-сиреневый завораживал.
Я представил огромный инопланетный объект, висящий в горящем оранжевом небе над давно покинутым Сиэтлом, здания которого покрыты зарослями.
Тем же вечером я за несколько часов создал вот такое изображение:
Простите за низкое разрешение — к сожалению, у моего GPU всего 12 ГБ памяти.
Поскольку очевидно, что я талантливый художник, имеющий за плечами буквально десятки минут опыта, мне захотелось поделиться тем, как я создал данный шедевр.
### Этап 1: небо
Давайте начнём с этого огненно-оранжевого неба. Вполне подойдёт небольшой градиент.
На мой взгляд, выглядит красиво. Это соответствует оттенкам изображения, возникшего в моём мозгу.
Этап 2: земля
-------------
Теперь нам нужна земля. Мы будем создавать красивую сцену со старым городом, но мне бы хотелось начать с зелёной земли, а позже заполнить её зданиями.
Этап 3: фон
-----------
На любом изображении Сиэтла обязано присутствовать два элемента: Спейс-Нидл и гора Рейнир.
Давайте добавим эту гору.
Прекрасно.
Этап 4: передний план
---------------------
Думаю, чтобы оживить передний план, подойдут красивые тёплые цвета осени. Давайте добавим их где-то ближе к низу.
Пусть эти пятна не совсем походят на деревья. Мы всегда можем передумать и сделать их чем-нибудь другим.
> Самое важное, чему мы хотим вас научить — наслаждаться своей работой и хорошо проводить время.
>
>
>
> — *Боб Росс, The Joy Of Painting, сезон 14, эпизод 1*
Этап 5: город
-------------
Теперь давайте добавим здания, пусть их будет столько, сколько вам захочется.
Я хочу немного сместить Спейс-Нидл, чтобы она контрастировала с горой Рейнер.
Всё выглядит очень здорово.
Этап 6: первый раунд Stable Diffusion
-------------------------------------
Теперь, когда у нас есть красивый черновик рисунка, давайте пропустим его через img2img Stable Diffusion и посмотрим на результат.
Рекомендую выполнять сэмплирование с несколькими разными seed и выбирать тот результат, который понравится больше.
Наверно, лучше начать с простого. Вместо того, чтобы перегружать строку полным запросом (инопланетный корабль, огненно-оранжевое небо, покрытые зарослями здания), давайте создадим картину Сиэтла, на основе которой потом продолжим работу. Значение `ddim_steps` можно оставить низким, около 50. Мы увеличим его ближе к завершению.
```
scripts/img2img.py –n_samples 1 –n_iter 1 –prompt “Digital fantasy painting of the Seattle city skyline. Vibrant fall trees in the foreground. Space Needle visible. Mount Rainier in background. Highly detailed.” –ddim_steps 50 –seed 47004 –scale 7 –strength 0.80 –init-img step5.png
```
*«Цифровая фэнтези-картина с очертаниями города Сиэтл. На переднем плане яркие осенние деревья. Видна Спейс-Нидл. На фоне гора Рейнер. Высокая детализация».*
Мне нравится этот результат, однако я не очень рад, что Спейс-Нидл сместилась влево. Похоже, с разными seed она перемещается, поэтому пока сохраним её, а позже подберём seed с позицией получше.
> Мы не совершаем ошибок, у нас происходят счастливые случайности.
>
>
>
> — *Bob Ross, The Joy Of Painting, сезон 3, эпизод 5*
Я предпочёл в первом раунде присвоить высокое значение `strength`, чтобы Stable Diffusion на полную силу использовала своё воображение. Если оно окажется слишком диким (например, нарисует несколько копий Спейс-Нидл), то `strength` можно уменьшить.
Для этого потребуется экспериментировать; кроме того, не все seed дают идеальные результаты. По моему опыту, если попробовать около десятка seed, то один-два вам понравятся.
Этап 7: делаем картину постапокалиптической
-------------------------------------------
Теперь давайте превратим этот красивый город в руины.
Так как на предыдущем изображении чётко видны очертания Сиэтла, в следующей строке запроса можно уменьшить упор на «Seattle». Мы упомянем его, чтобы Stable Diffusion не слишком отдалилась от темы, но больший упор мы сделаем на новую часть, то есть аспект «постапокалиптичности».
```
scripts/img2img.py –n_samples 1 –n_iter 1 –prompt “Digital Matte painting. Hyper detailed. City in ruins. Post-apocalyptic, crumbling buildings. Science fiction. Seattle skyline. Golden hour, dusk. Beautiful sky at sunset. High quality digital art. Hyper realistic.” –ddim_steps 100 –seed 47200 –scale 9 –strength 0.80 –init-img inputs\step6.png
```
*«Цифровая дорисовка. Гипердетализация. Город в руинах. Постапокалиптические осыпающиеся здания. Научная фантастика. Очертания Сиэтла. Предзакатный час, сумерки. Красивое небо на закате. Высококачественный цифровой арт. Гиперреализм».*
Сразу заметно следующее:
Спейс-Нидл переместилась на своё место, примерно к линии одной трети изображения.
Гора Рейнер пропала, как и деревья с переднего плана.
Если бы мы хотели сохранить их, это можно было бы сделать. Просто дополнить строку запроса, упомянув эти элементы, и, возможно, уменьшить свойство `strength` до 0.70, чтобы ограничить творческую свободу Stable Diffusion.
Однако мне вполне нравится этот «творческий выбор» Stable Diffusion. С этой точки обзора деревья бы казались не на своём месте, а на картине слишком сильная дымка, поэтому гора Рейнер, скорее всего, не была бы видна. Кроме того, тёплый цвет деревьев стал зловещим свечением, а зелёная земля покрылась зарослями. Поэтому мне кажется, что это улучшило картину.
#### Вкратце о строках запросов
Если вы зайдёте в любое сообщество, посвящённое генерации изображений, то заметите, что во многих (в большинстве?) строках запросов упоминаются имена реальных художников.
Например, в [этом творении](https://lexica.art/prompt/99d4c030-38d4-4846-a7da-aadb5659fbe3), использующем следующую строку запроса (prompt):
```
gigantic extraterrestrial futuristic alien ship landed on the kingdom of Julius Caesar, roman historic works in brand new condition, not ruins, hyper-detailed, artstation trending, world renowned artists, historic artworks society, antique renewel, good contrast, realistic color ,cgsociety, by **greg rutkowski,gustave dore**, Deviantart
```
*«гигантский инопланетный футуристический корабль приземлился на владения Юлия Цезаря, римские исторические здания в совершенно новом состоянии, не руины, гипердетализированные, тренды artstation, знаменитые художники, общество исторических картин, восстановление антиквариата, хорошая контрастность, реалистичный цвет, **грег рутковски, гюстав доре**, Deviantart».*
Похоже, добавление имён конкретных художников **на самом деле** улучшает результат.
Однако мне неловко пользоваться этим. Законно ли это? Абсолютно. Этично ли это?… *Вероятно*, да. Но всё равно это почему-то кажется мне неправильным.
Результаты работы этой модели *настолько хороши*, что введя в поисковике «Greg Rutkowski's art», человек может найти результаты, в которые включены и настоящие работы художника, и сгенерированные искусственным интеллектом. И я не хочу вносить в это свой вклад. На самом деле, учитывая что ИИ-модель может создавать подобия работ Грега Рутковски за считанные секунды, а *реальному* Грегу, вероятно, требуется много часов работы, нетрудно представить, что вскоре при запросах его работ поисковики будут выдавать *больше* сгенерированных ИИ картин, чем реальных. Это немного меня смущает.
Когда-нибудь эта технология окажется настолько вездесущей, что люди будут *ожидать* увидеть в результатах поиска сгенерированные ИИ изображения. Но на данный момент я предпочитаю предоставить Stable Diffusion возможность творить искусство без копирования конкретного художника.
Да, возможно, это старомодно, учитывая, что эту технологию можно использовать и её будут использовать для куда более плохих вещей. Но сейчас, в августе 2022 года, я не хочу вмешивать во всё это художников.
Учитывая всё сказанное, следующий раздел может показаться лицемерным, поскольку я приказываю модели создать что-то, напоминающее корабль из «Звёздных войн». В данном случае я считаю, что «Звёздные войны» за последние сорок с лишним лет настолько укоренились в популярной культуре, что использовать их в качестве образца не грешно.
Этап 8: космический корабль
---------------------------
Вернёмся к нашему творению:
Возможно, вам захочется нарисовать космический корабль прямо на получившемся результате.
И я рекомендую вам сделать это! Получайте удовольствие и экспериментируйте.
Но насколько я понял, Stable Diffusion не очень хорошо справляется со «смешиванием» разного уровня качества. Её сбивает с толку, когда на одной картине присутствует безукоризненная Спейс-Нидл и детский рисунок космического корабля в стиле MS Paint.
Давайте продолжим работать в слоях и составлять изображение понемногу.
Вот мой потрясающий корабль:
Прошу прощения у Джорджа Лукаса.
Он послужит хорошей отправной точкой, дальше мы можем развить идею.
```
scripts/img2img.py –n_samples 1 –n_iter 1 –prompt “Digital fantasy science fiction painting of a Star Wars Imperial Class Star Destroyer. Highly detailed, white background.” –ddim_steps 50 –seed 47001 –scale 7 –strength 0.80 –init-img step7.png
```
*«Цифровая научно-фантастическая фэнтези-картина имперского Звёздного разрушителя из Звёздных войн, высокая детализация, белый фон».*
Давайте просто закинем космический корабль на изображение:
Как будто он не на своём месте. Давайте сгладим его, снова пропустив через Stable Diffusion.
Этап 9: второй раунд Stable Diffusion
-------------------------------------
Этот раунд Stable Diffusion позволит нам решить две задачи:
* Вписать корабль в изображение
* Реинтерпретировать корабль с учётом контекста изображения
Если вам очень полюбился корабль из этапа 8, то вы можете выполнить раунд с очень низкой `strength`, чтобы Stable Diffusion не слишком его изменила.
Однако лично мне захотелось установить `strength` примерно на 0.80 и я оказался доволен результатом. Модель склонна удивлять меня, выдавая что-то лучше, чем я представлял.
Давайте пропустим изображение через несколько seed и посмотрим, что получится.
В моих результатах получилось несколько изображений с отличным кораблём, несколько изображений с красивым городом, но ни одного изображения с отличным кораблём *и* красивым городом.
Красивый город, корабль не очень:
Отличный корабль, так себе город:
Так… давайте просто скомбинируем их!
> На этом холсте вы творец, поэтому решайте сами, что хотите добавить в этот мир.
>
>
>
> — *Боб Росс, The Joy Of Painting, сезон 10, эпизод 12*
Мы возьмём отличный корабль, вставим его в красивый город и выполним проход с низкой `strength`, чтобы не слишком сильно изменить тот и другой.
Вот как выглядит «скомбинированное» изображение, которое я на скорую руку создал в GIMP:
Если уж мы редактируем картину в GIMP, неплохо будет добавить прямо посередине несколько летящих вдалеке птиц.
Давайте вырежем эту часть изображения и нарисуем на ней птиц:
А затем пусть Stable Diffusion поколдует над картиной:
```
scripts/img2img.py –n_samples 1 –n_iter 1 –prompt “Digital Matte painting. Hyper detailed. Brds fly into the horizon. Golden hour, dusk. Beautiful sky at sunset. High quality digital art. Hyper realistic.” –ddim_steps 50 –seed 47407 –scale 9 –strength 0.75 –init-img step14a.png
```
*«Цифровая дорисовка. Гипердетализация. Птицы летят к горизонту. Предзакатный час, сумерки. Красивый город на закате. Высококачественный цифровой арт. Гиперреализм».*
Соединим всё вместе копипастингом:
И, наконец, последний проход с низкой `strength`, чтобы соединить всё это вместе и создать наш шедевр:
```
scripts/img2img.py –n_samples 1 –n_iter 1 –prompt “Digital Matte painting. Hyper detailed. City in ruins. Post-apocalyptic, crumbling buildings. Science fiction. Seattle skyline. Star Wars Imperial Star Destroyer hovers. Birds fly in the distance. Golden hour, dusk. Beautiful sky at sunset. High quality digital art. Hyper realistic.” –ddim_steps 100 –seed 47413 –scale 9 –strength 0.20 –init-img step14c.png
```
*«Цифровая дорисовка. Гипердетализация. Город в руинах. Постапокалиптические осыпающиеся здания. Научная фантастика. Очертания Сиэтла. Парит Звёздный разрушитель из Звёздных войн. Вдалеке летят птицы. Предзакатный час, сумерки. Красивое небо на закате. Высококачественный цифровой арт. Гиперреализм».*
Обратите внимание, что для красивого смешения достаточно задать низкую `strength` — 0.20.
Мысли в заключение
------------------
4,2 гигабайта.
***4,2 гигабайта.***
Именно столько весит модель, благодаря которой стал возможным недавний прорыв в искусственном интеллекте.
4,2 гигабайта чисел с плавающей запятой, в которых каким-то образом закодировано столь многое из известного нам.
Да, я ударился в лирику. Нет, я не провозглашаю появление сильного ИИ, который будет нами править. Я просто любуюсь красотой ситуации, пока она нова и свежа.
Потому что новой и свежей она будет недолго. Мои ощущения не сильно отличаются от тех, которые возникли у меня при отправке первого электронного письма: бабушка уже получила моё сообщение? Во *Флориде*? За считанные секунды? Это было самым волшебным, что я видел в детстве. А теперь электронная почта — самая скучная и повседневная часть моего дня.
Многие уже говорят о практическом использовании. Преступном использовании. Преуменьшении важности. Преувеличении важности. Об искажениях. О монетизации. О демократизации — на самом деле это всего лишь монетизация с более удобным для маркетинга названием.
Я не буду говорить обо всём этом. Я просто думаю об этих 4,2 ГБ. Насколько это мало по сегодняшним меркам. Такой маленький объём, в котором хранится так много.
Сколько изображений (реальных фотографий и картин) пропущено через автокодировщик, постепенно сужающий воронку информации, пока из неё не будет выделен какой-то смысл? Сколько раз нужно обучить модель устранять шум в изображении, пока она не поймёт, чем тигр отличается от леопарда? Кажется, теперь мы это знаем.
Наверно, теперь мы будем находиться на гребне этой волны, пока магия не станет такой же распространённой и скучной, как электронная почта. Так и будет. | https://habr.com/ru/post/685848/ | null | ru | null |
# Разбираемся в С, изучая ассемблер
*Перевод статьи Дэвида Альберта — [Understanding C by learning assembly](https://www.hackerschool.com/blog/7-understanding-c-by-learning-assembly).*
В прошлый раз Аллан О’Доннелл рассказывал о том, как [изучать С используя GDB](http://habrahabr.ru/post/181738/). Сегодня же я хочу показать, как использование GDB может помочь в понимании ассемблера.
Уровни абстракции — отличные инструменты для создания вещей, но иногда они могут стать преградой на пути обучения. Цель этого поста — убедить вас, что для твердого понимания C нужно также хорошо понимать ассемблерный код, который генерирует компилятор. Я сделаю это на примере дизассемблирования и разбора простой программы на С с помощью GDB, а затем мы используем GDB и приобретенные знания ассемблера для изучения того, как устроены статические локальные переменные в С.
*Примечание автора:* Весь код из этой статьи был скомпилирован на процессоре x86\_64 под Mac OS X 10.8.1 с использованием Clang 4.0 с отключенной оптимизацией (*-O0*).
#### Изучаем ассемблер с помощью GDB
Давайте начнем с дизассемблирования программы с помощью GDB и научимся читать выходные данные. Наберите следующий текст программы и сохраните его в файле *simple.c*:
```
int main(void)
{
int a = 5;
int b = a + 6;
return 0;
}
```
Теперь скомпилируйте его в отладочном режиме и с отключенной оптимизацией и запустите GDB.
```
$ CFLAGS="-g -O0" make simple
cc -g -O0 simple.c -o simple
$ gdb simple
```
Поставьте точку останова на функции *main* и продолжайте выполнение до тех пор, пока не дойдете до оператора *return*. Введите число 2 после оператора *next*, чтобы указать, что мы хотим выполнить его дважды:
```
(gdb) break main
(gdb) run
(gdb) next 2
```
Теперь используйте команду *disassemble*, чтобы вывести ассемблерные инструкции текущей функции. Также можно передавать команде *disassemble* имя функции, чтобы указать другую функцию для исследования.
```
(gdb) disassemble
Dump of assembler code for function main:
0x0000000100000f50 : push %rbp
0x0000000100000f51 : mov %rsp,%rbp
0x0000000100000f54 : mov $0x0,%eax
0x0000000100000f59 : movl $0x0,-0x4(%rbp)
0x0000000100000f60 : movl $0x5,-0x8(%rbp)
0x0000000100000f67 : mov -0x8(%rbp),%ecx
0x0000000100000f6a : add $0x6,%ecx
0x0000000100000f70 : mov %ecx,-0xc(%rbp)
0x0000000100000f73 : pop %rbp
0x0000000100000f74 : retq
End of assembler dump.
```
По умолчанию команда *disassemble* выводит инструкции в синтаксисе AT&T, который совпадает с синтаксисом, используемым ассемблером GNU. Синтаксис AT&T имеет формат: *mnemonic* *source*, *destination*. Где *mnemonic* — это понятные человеку имена инструкций. А *source* и *destination* являются операндами, которые могут быть непосредственными значениями, регистрами, адресами памяти или метками. В свою очередь, непосредственные значения — это константы, они имеют префикс *$*. Например, *$0x5* соответствует числу 5 в шестнадцатеричном представлении. Имена регистров записываются с префиксом *%*.
##### Регистры
На изучение регистров стоит потратить некоторое время. Регистры — это места хранения данных, которые находятся непосредственно на центральном процессоре. С некоторыми исключениями, размер или *ширина* регистров процессора определяет его архитектуру. Поэтому, если у вас есть 64-битный CPU, то его регистры будут иметь ширину в 64 бита. То же самое касается и 32-битных и 16-битных процессоров и т. д. Скорость доступа к регистрам очень высокая и именно из-за этого в них часто хранятся операнды арифметических и логических операций.
Семейство процессоров с архитектурой x86 имеет ряд специальных регистров и регистров общего назначения. Регистры общего назначения могут быть использованы для любых операций, и данные, хранящиеся в них, не имеют особого значения для процессора. С другой стороны, процессор в своей работе опирается на специальные регистры, и данные, которые хранятся в них, имеют определенное значение в зависимости от конкретного регистра. В нашем примере *%eax* и *%ecx* — регистры общего назначения, в то время как *%rbp* и *%rsp* — специальные регистры. Регистр *%rbp* — это указатель базы, который указывает на базу текущего стекового фрейма, а *%rsp* — указатель стека, который указывает на вершину текущего стекового фрейма. Регистр *%rbp* всегда имеет большее значение нежели *%rsp*, потому что стек всегда начинается со старшего адреса памяти и растет в сторону младших адресов. Если Вы не знакомы с понятием “стек вызовов”, то можете найти хорошее [объяснение на Википедии](http://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B5%D0%BA_%D0%B2%D1%8B%D0%B7%D0%BE%D0%B2%D0%BE%D0%B2).
Особенность процессоров семейства x86 в том, что они сохраняют полную совместимость с 16-битными процессорами 8086. В процессе перехода x86 архитектуры от 16-битной к 32-битной и в конце-концов к 64-битной, регистры были расширены и получили новые имена, чтобы сохранить совместимость с кодом, который был написан для более ранних процессоров.
Возьмем регистр общего назначения AX, который имеет ширину в 16 бит. Доступ к его старшему байту осуществляется по имени AH, а к младшему — по имени AL. Когда появился 32-битный 80386, расширенный (Extended) AX или EAX стал 32-битным регистром, в то время как AX остался 16-битным и стал младшей половиной регистра EAX. Аналогичным образом, когда появилась x86\_64, то был использован префикс “R” и EAX стал младшей половиной 64-битного регистра RAX. Ниже приведена диаграмма, основанная на статье из Википедии, чтобы проиллюстрировать вышеописанные связи:
```
|__64__|__56__|__48__|__40__|__32__|__24__|__16__|__8___|
|__________________________RAX__________________________|
|xxxxxxxxxxxxxxxxxxxxxxxxxxx|____________EAX____________|
|xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx|_____AX______|
|xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx|__AH__|__AL__|
```
##### Назад к коду
Этого уже должно быть достаточно, чтобы перейти к разбору нашей дизассемблированой программы:
```
0x0000000100000f50 : push %rbp
0x0000000100000f51 : mov %rsp,%rbp
```
Первые две инструкции называются прологом функции или преамбулой. Первым делом записываем старый указатель базы в стек, чтобы сохранить его на будущее. Потом копируем значение указателя стека в указатель базы. После этого *%rbp* указывает на базовый сегмент стекового фрейма функции *main*.
```
0x0000000100000f54 : mov $0x0,%eax
```
Эта инструкция копирует 0 в *%eax*. Соглашение о вызовах архитектуры x86 гласит, что возвращаемые функцией значения хранятся в регистре *%eax*, поэтому вышеуказанная инструкция предписывает нам вернуть 0 в конце нашей функции.
```
0x0000000100000f59 : movl $0x0,-0x4(%rbp)
```
Здесь у нас то, с чем мы раньше не встречались: *-0x4(%rbp)*. Круглые скобки дают нам понять, что это адрес памяти. В этом фрагменте *%rbp*, так называемый регистр базы, и *-0x4*, являющееся смещением. Это эквивалентно записи *%rbp + -0x4*. Поскольку стек растет вниз, то вычитание 4 из базового стекового фрейма перемещает нас к собственно текущему фрейму, где хранится локальная переменная. Это значит, что эта инструкция сохраняет 0 по адресу *%rbp — 4*. Мне потребовалось некоторое время, чтобы выяснить, для чего служит эта строчка, и как мне кажется Clang выделяет скрытую локальную переменную для неявно возвращаемого значения из функции *main*.
Вы также можете заметить, что *mnemonic* имеет суффикс *l*. Это означает, что операнд будет иметь тип ***l**ong* (32 бита для целых чисел). Другие возможные суффиксы — ***b**yte*, ***s**hort*, ***w**ord*, ***q**uad*, и ***t**en*. Если Вам попадется инструкция, не имеющая суффикса, то размер такой инструкции будет подразумеваться из размера регистра источника или регистра назначения. Например, в предыдущей строчке *%eax* имеет ширину 32 бита, поэтому инструкция *mov* на самом деле является *movl*.
```
0x0000000100000f60 : movl $0x5,-0x8(%rbp)
```
Теперь мы переходим в самую сердцевину нашей тестовой программы. Приведенная строка ассемблера — это первая строка на С в функции *main*, и она помещает число 5 в следующий доступный слот локальной переменной (*%rbp — 0x8*), на 4 байта ниже от нашей предыдущей локальной переменной. Это местоположение переменной *a*. Мы можем использовать GDB, чтобы проверить это:
```
(gdb) x &a
0x7fff5fbff768: 0x00000005
(gdb) x $rbp - 8
0x7fff5fbff768: 0x00000005
```
Заметьте, что адрес памяти один и тот же. Также Вы можете обратить внимание, что GDB устанавливает переменные для наших регистров, поэтому, как и перед всеми переменными в GDB, перед их именем стоит префикс *$*, в то время как префикс *%* используется в ассемблере от AT&T.
```
0x0000000100000f67 : mov -0x8(%rbp),%ecx
0x0000000100000f6a : add $0x6,%ecx
0x0000000100000f70 : mov %ecx,-0xc(%rbp)
```
Далее мы помещаем переменную *a* в *%ecx*, один из наших регистров общего назначения, добавляем к ней число 6 и сохраняем результат в *%rbp — 0xc*. Это вторая строчка функции *main*. Вы могли уже догадаться, что адрес *%rbp — 0xc* соответствует переменной *b*, что мы тоже можем проверить с помощью GDB:
```
(gdb) x &b
0x7fff5fbff764: 0x0000000b
(gdb) x $rbp - 0xc
0x7fff5fbff764: 0x0000000b
```
Остальное в функции *main* — это просто процесс уборки, который еще называют эпилогом.
```
0x0000000100000f73 : pop %rbp
0x0000000100000f74 : retq
```
Мы достаем старый указатель базы и помещаем его обратно в *%rbp*, а затем инструкция *retq* перебрасывает нас к адресу возвращения, который тоже хранится в стековом фрейме.
До этого момента мы использовали GDB для дизассемблирования небольшой программы на С, прошли через чтение синтаксиса ассемблера от AT&T и раскрыли тему регистров и операндов адресов памяти. Также мы использовали GDB для проверки места хранения локальных переменных по отношению к *%rbp*. Теперь используем приобретенные знания для объяснения принципов работы статических локальных переменных.
#### Разбираемся в статических локальных переменных
Статические локальные переменные — это очень классная особенность С. В двух словах, это локальные переменные, которые инициализируются один раз и сохраняют свое значение между вызовами функции, в которой были объявлены. Простой пример использования статических локальных переменных — это генератор в стиле Python. Вот один такой, который генерирует все натуральные числа вплоть до INT\_MAX.
```
/* static.c */
#include
int natural\_generator()
{
int a = 1;
static int b = -1;
b += 1;
return a + b;
}
int main()
{
printf("%d\n", natural\_generator());
printf("%d\n", natural\_generator());
printf("%d\n", natural\_generator());
return 0;
}
```
Когда вы скомпилируете и запустите эту программу, то она выведет три первых натуральных числа:
```
$ CFLAGS="-g -O0" make static
cc -g -O0 static.c -o static
$ ./static
1
2
3
```
Но как это работает? Чтобы это выяснить, перейдем в GDB и посмотрим на ассемблерный код. Я удалил адресную информацию, которую GDB добавляет в дизассемблерный вывод и теперь все помещается на экране:
```
$ gdb static
(gdb) break natural_generator
(gdb) run
(gdb) disassemble
Dump of assembler code for function natural_generator:
push %rbp
mov %rsp,%rbp
movl $0x1,-0x4(%rbp)
mov 0x177(%rip),%eax # 0x100001018
add $0x1,%eax
mov %eax,0x16c(%rip) # 0x100001018
mov -0x4(%rbp),%eax
add 0x163(%rip),%eax # 0x100001018
pop %rbp
retq
End of assembler dump.
```
Первое, что нам нужно сделать, это выяснить, на какой инструкции мы сейчас находимся. Сделать это мы можем путем изучения указателя инструкции или счетчика команды. Указатель инструкции — это регистр, который хранит адрес следующей инструкции. В архитектуре x86\_64 этот регистр называется *%rip*. Мы можем получить доступ к указателю инструкции с помощью переменной *$rip*, или, как альтернативу, можем использовать архитектурно независимую переменную *$pc*:
```
(gdb) x/i $pc
0x100000e94 : movl $0x1,-0x4(%rbp)
```
Указатель инструкции содержит указатель именно на следующую инструкцию для выполнения, что значит, что третья инструкция еще не была выполнена, но вот-вот будет.
Поскольку знать следующую инструкцию — это очень полезно, то мы заставим GDB показывать нам следующую инструкцию каждый раз, когда программа останавливается. В GDB 7.0 и выше, вы можете просто выполнить команду *set disassemble-next-line on*, которая показывает все инструкции, которые будут исполнены в следующей строке программного кода. Но я использую Mac OS X, который поставляется с версией GDB 6.3, так что мне придется пользоваться командой *display*. Эта команда аналогична *x*, за исключением того, что она показывает значение выражения после каждой остановки программы:
```
(gdb) display/i $pc
1: x/i $pc 0x100000e94 : movl $0x1,-0x4(%rbp)
```
Теперь GDB настроен так, чтобы всегда показывать следующую инструкцию перед своим выводом.
Мы уже прошли пролог функции, который рассматривали ранее, поэтому начнем сразу с третьей инструкции. Она соответствует первой строке кода, которая присваивает 1 переменной *a*. Вместо команды *next*, которая переходит к следующей строчке кода, мы будем использовать *nexti*, которая переходит к следующей ассемблерной инструкции. Теперь исследуем адрес *%rbp — 0x4*, чтобы проверить гипотезу о том, что переменная *a* хранится именно здесь:
```
(gdb) nexti
7 b += 1;
1: x/i $pc mov 0x177(%rip),%eax # 0x100001018
(gdb) x $rbp - 0x4
0x7fff5fbff78c: 0x00000001
(gdb) x &a
0x7fff5fbff78c: 0x00000001
```
И мы видим, что адреса одинаковые, как мы и ожидали. Следующая инструкция более интересная:
```
mov 0x177(%rip),%eax # 0x100001018
```
Здесь мы ожидали увидеть выполнение инструкций строки *static int b = -1;*, но это выглядит существенно иначе, нежели то, с чем мы встречались раньше. С одной стороны, нет никаких ссылок на стековый фрейм, где мы ожидали увидеть локальные переменные. Нет даже *-0x1*! В место этого, у нас есть инструкция, которая загружает что-то из адреса *0x100001018*, находящегося где-то после указателя инструкции, в регистр *%eax*. GDB дает нам полезный комментарий с результатом вычисления операнда памяти, чем подсказывает, что по этому адресу размещается *natural\_generator.b*. Давайте выполним инструкцию и разберемся, что происходит:
```
(gdb) nexti
(gdb) p $rax
$3 = 4294967295
(gdb) p/x $rax
$5 = 0xffffffff
```
Несмотря на то, что дизассемблер показывает как получателя регистр *%eax*, мы выводим *$rax*, поскольку GDB задает переменные для полной ширины регистра.
В этой ситуации, мы должны помнить, что в то время как переменные имеют типы, которые определяют знаковые они или беззнаковые, регистры таких типов не имеют, поэтому GDB выводит значение регистра *%rax* как беззнаковое. Давайте попробуем еще раз, приведя значение *%rax* к знаковому целому:
```
(gdb) p (int)$rax
$11 = -1
```
Похоже на то, что мы нашли *b*. Можем повторно убедиться в этом, используя команду *x*:
```
(gdb) x/d 0x100001018
0x100001018 : -1
(gdb) x/d &b
0x100001018 : -1
```
Так что переменная *b* не только хранится в другом участке памяти, вне стека, но и к тому же инициализируется значением -1 еще до того, как вызывается функция *natural\_generator*. На самом деле, даже если вы дизассемблируете всю программу, то не найдете никакого кода, устанавливающего *b* в -1. Все это потому, что значение переменной *b* зашито в другой секции исполняемого файла нашей программы, и оно загружается в память вместе со всем машинным кодом загрузчиком операционной системы, когда процесс запущен.
С таким подходом, вещи начинают обретать смысл. После сохранения *b* в *%eax*, мы переходим к следующей строке кода, где мы увеличиваем *b*. Это соответствует следующим инструкциям:
```
add $0x1,%eax
mov %eax,0x16c(%rip) # 0x100001018
```
Здесь мы добавляем 1 к *%eax* и записываем результат обратно в память. Давайте выполним эти инструкции и посмотрим на результат:
```
(gdb) nexti 2
(gdb) x/d &b
0x100001018 : 0
(gdb) p (int)$rax
$15 = 0
```
Следующие две инструкции отвечают за возвращение результата *a + b*:
```
mov -0x4(%rbp),%eax
add 0x163(%rip),%eax # 0x100001018
```
Здесь мы загружаем переменную *a* в *%eax*, а затем добавляем *b*. На данном этапе мы ожидаем, что в *%eax* хранится значение 1. Давайте проверим:
```
(gdb) nexti 2
(gdb) p $rax
$16 = 1
```
Регистр *%eax* используется для хранения значения, возвращаемого функцией *natural\_generator*, и мы ожидаем на эпилог, который очистит стек и приведет к возвращению:
```
pop %rbp
retq
```
Мы разобрались, как переменная *b* инициализируется. Теперь давайте посмотрим, что происходит, когда функция *natural\_generator* вызывается повторно:
```
(gdb) continue
Continuing.
1
Breakpoint 1, natural_generator () at static.c:5
5 int a = 1;
1: x/i $pc 0x100000e94 : movl $0x1,-0x4(%rbp)
(gdb) x &b
0x100001018 : 0
```
Поскольку переменная *b* не хранится на стеке с остальными переменными, она все еще 0 при повторном вызове *natural\_generator*. Не важно сколько раз будет вызываться наш генератор, переменная *b* всегда будет сохранять свое предыдущее значение. Все это потому, что она хранится вне стека и инициализируется, когда загрузчик помещает программу в память, а не по какому-то из наших машинных кодов.
#### Заключение
Мы начали с разбора ассемблерных команд и научились дизассемблировать программу с помощью GDB. В последствии, мы разобрали, как работают статические локальные переменные, чего мы не смогли бы сделать без дизассемблирования исполняемого файла.
Мы провели много времени, чередуя чтение ассемблерных инструкций и проверки наших гипотез с помощью GBD. Это может показаться скучным, но есть веская причина для следующего подхода: лучший способ изучить что-то абстрактное, это сделать его более конкретным, а один из лучших способов сделать что-то более конкретным — это использовать инструменты, которые помогут заглянуть за слои абстракции. Лучший способ изучить эти инструменты — это заставлять себя использовать их, пока это не станет для вас обыденностью.
*От переводчика: Низкоуровневое программирование — не мой профиль, поэтому если допустил какие-то неточности, буду рад узнать о них в ЛС.* | https://habr.com/ru/post/183376/ | null | ru | null |
# Сотня криптовалют, описанных не более чем четырьмя словами
В этом списке каждая из криптовалют описана всего в четырех словах. Их много, и среди них есть как исключительные и знаковые, так и откровенное мошенничество.
```
Название | Токен | Описание
----------------|-------|------------------------------------------
Bitcoin | BTC | Цифровое золото
Ethereum | ETH | Программируемые контракты и деньги
Bitcoin Cash | BCH | Клон Биткоина
Ripple | XRP | Сеть корпоративных платежей и взаиморасчетов
Litecoin | LTC | Ускоренная версия Биткоина
Dash | DASH | Клон Биткоина с акцентом на приватность
NEO | NEO | Ethereum китайского рынка
NEM | XEM | Готовые цифровые активы из коробки
Monero | XMR | Анонимные цифровые деньги
Ethereum Classic| ETC | Клон Ethereum
IOTA | MIOTA | Платежи в сфере Интернета вещей
Qtum | QTUM | Биткоин со смарт-контрактами Ethereum
OmiseGO | OMG | Банкинг, переводы и биржа
Zcash | ZEC | Анонимные цифровые деньги
BitConnect | BCC | Пирамида Мейдоффа в мире криптовалют
Lisk | LSK | Децентрализованные приложения на Javascript
Cardano | ADA | Академический подход к умным контрактам
Tether | USDT | Стоит 1 доллар
Stellar Lumens | XLM | Цифровые долговые расписки
EOS | EOS | Децентрализованные приложения на WebAssembly
Hshare | HSR | Коммутатор для разных блокчейнов
Waves | WAVES | Децентрализованная биржа и краудфандинг
```
```
Stratis | STRAT | Децентрализованные приложения на C#
Komodo | KMD | Децентрализованные ICO
Ark | ARK | Коммутатор для разных блокчейнов
Electroneum | ETN | Клон Monero
Bytecoin | BCN | Криптовалюта с акцентом на приватность
Steem | STEEM | Reddit, на котором голосуют деньгами
Ardor | ARDR | Блокчейн для размножения блокчейнов
Binance Coin | BNB | Оплата комиссий на бирже Binance
Augur | REP | Децентрализованный рынок прогнозов
Populous | PPT | Фьючерсы на торговлю счетами
Decred | DCR | Биткоин с коллективным самоуправлением
TenX | PAY | Криптовалютная кредитная карта
MaidSafeCoin | MAID | Cервис для арендодателей вычислительных мощностей
BitcoinDark | BTCD | Клон Zcoin
BitShares | BTS | Децентрализованная биржа
Golem | GNT | Пользование чужими компьютерами для вычислений
PIVX | PIVX | Подверженный инфляции клон Dash
Gas | GAS | Оплата комиссии в Neo
TRON | TRX | Встроенные в приложения покупки
Vertcoin | VTC | Клон Биткоина
MonaCoin | MONA | Японский Dogecoin
Factom | FCT | Децентрализованный учет
Basic Attention | BAT | Децентрализованная рекламная сеть
SALT | SALT | Обеспеченные криптовалютой займы
Kyber Network | KNC | Децентрализованная биржа
Dogecoin | DOGE | Меметичный клон Биткоина
DigixDAO | DGD | Токенизированное на блокчейне золото
Veritaseum | VERI | Выдуманное ПО
Walton | WTC | Блокчейн для Интернета Вещей
SingularDTV | SNGLS | Децентрализованный Netflix
Bytom | BTM | Физические активы как токены
Byteball Bytes | GBYTE | Децентрализованная БД и валюта
GameCredits | GAME | Валюта видеоигр
Metaverse ETP | ETP | Китайский Ethereum с идентификацией
GXShares | GXS | Децентрализованное китайское кредитное бюро
Syscoin | SYS | Децентрализованный маркетплейс
Siacoin | SC | Аренда места на диске
Status | SNT | Браузер децентрализованных приложений
0x | ZRX | Децентрализованная биржа
Verge | XVG | Приватный Dogecoin
Lykke | LKK | Биржа обмена цифровыми активами
Civic | CVC | Приложение для защиты идентификационной информации
Blocknet | BLOCK | Децентрализованная биржа
Metal | MTL | Цифровой кошелек с программой лояльности
Iconomi | ICN | Платформа управления цифровыми активами
Aeternity | AE | Децентрализованные приложения (прототипы)
DigiByte | DGB | Ускоренный Биткоин
Bancor | BNT | Портфель ERC20 токенов с конвертацией
Ripio Credit | RCN | Криптовалютные кредиты с поручительством
ATMChain | ATM | Рекламная сеть
Gnosis | GNO | Децентрализованный рынок прогнозов
VeChain | VEN | Логистическая система на блокчейне
Pura | PURA | Некая криптовалюта
Particl | PART | Анонимные транзакции и рынок
KuCoin Shares | KCS | Прибыль с биржевых сделок
Bitquence | BQX | Хранение и управление криптовалютными инвестициями
FunFair | FUN | Децентрализованное казино
ChainLink | LINK | Внешние данные для умных контрактов
Power Ledger | POWR | Airbnb в мире электроэнергии
Nxt | NXT | Криптовалюта и онлайн-рынок
Monaco | MCO | Криптовалютная кредитная карта
Cryptonex | CNX | Клон Zerocoin
MCAP | MCAP | Майнинговый инвестиционный фонд
Storj | STORJ | Аренда дискового пространства
ZenCash | ZEN | Клон Биткоина с акцентом на приватность
Nexus | NXS | Клон Биткоина
Neblio | NEBL | Платформа децентрализованных приложений
Zeusshield | ZSC | Децентрализованное страхование
Streamr DATAcoin| DATA | Рынок данных в реальном времени
ZCoin | XZC | Анонимные цифровые деньги
NAV Coin | NAV | Биткоин с анонимными транзакциями
AdEx | ADX | Биржа рекламы
Open Trading | OTN | Децентрализованная биржа
SmartCash | SMART | Клон Zcoin с вознаграждением
Bitdeal | BDL | Клон Биткоина
Loopring | LRC | Децентрализованная биржа
Edgeless | EDG | Децентрализованное казино
FairCoin | FAIR | Биткоин с поощрением сбережений
```
*Источник рейтинга криптовалют — coinmarketcap.com.* | https://habr.com/ru/post/408535/ | null | ru | null |
# Ленивая инициализация в C#
Отложенная инициализация или «ленивая» инициализация — это способ доступа к объекту, скрывающий за собой механизм, позволяющий отложить создание этого объекта до момента первого обращения. Необходимость ленивой инициализации может возникнуть по разным причинам: начиная от желания снизить нагрузку при старте приложения и заканчивая оптимизацией редко используемого функционала. И действительно, не все функции приложения используются всегда и, тем более, сразу, потому создание объектов, реализующих их, вполне рационально отложить до лучших времён. Я хотел бы рассмотреть варианты ленивой инициализации, доступные в языке C#.
Для демонстрации примеров я буду использовать класс Test, у которого есть свойство BlobData, возвращающее объект типа Blob, который по легенде создаётся довольно медленно, и было решено создавать его лениво.
```
class Test
{
public Blob BlobData
{
get
{
return new Blob();
}
}
}
```
#### Проверка на null
Самый простой вариант, доступный с первых версий языка, — это создание неинициализированной переменной и проверка её на null перед возвращением. Если переменная равна null, создаём объект и присваиваем этой переменной, а потом его возвращаем. При повторном обращении объект уже будет создан и мы сразу его вернём.
```
class Test
{
private Blob _blob = null;
public Blob BlobData
{
get
{
if (_blob == null)
{
_blob = new Blob();
}
return _blob;
}
}
}
```
Объект типа Blob тут создаётся при первом обращении к свойству. Либо не создаётся, если он по какой-то причине в этой сессии программе не понадобился.
#### Тернарный оператор ?:
В C# есть тернарный оператор, позволяющий проверить условие и, если оно истинно вернуть одно значение, а если ложно, — другое. Мы можем использовать его для того, чтобы немного сократить и упростить код.
```
class Test
{
private Blob _blob = null;
public Blob BlobData
{
get
{
return _blob == null
? _blob = new Blob()
: _blob;
}
}
}
```
Суть осталась той же. Если объект не инициализирован, инициализируем и возвращаем. Ежели уже инициализирован, то просто сразу возвращаем.
#### is null
Ситуации бывают разные и мы, например, можем столкнуться с такой, в которой у класса Blob перегружен оператор ==. Для этого, вероятно, нам может потребоваться сделать проверку is null вместо == null. Доступно в свежих версиях языка.
```
return _blob is null
? _blob = new Blob()
: _blob;
```
Но это так, небольшое отступление.
#### Null-coalescing оператор ??
Ещё больше упростить код нам поможет бинарный оператор ??
Суть его работы такова. Если первый операнд не равен null, то он и возвращается. Если же первый операнд равен null, возвращается второй.
```
class Test
{
private Blob _blob = null;
public Blob BlobData
{
get
{
return _blob ?? (_blob = new Blob());
}
}
}
```
Второй операнд пришлось взять в круглые скобки из-за приоритета операций.
#### Оператор ??=
В C# 8 появился null-coalescing assignment operator, выглядящий вот так ??=
Принцип его работы заключается в следующем. Если первый операнд не равен null, то он просто возвращается. Если первый операнд равен null, то ему присваивается значение второго и возвращается уже это значение.
```
class Test
{
private Blob _blob = null;
public Blob BlobData
{
get
{
return _blob ??= new Blob();
}
}
}
```
Это позволило ещё немного сократить код.
#### Потоки
Если есть вероятность, что к данному ресурсу могут обращаться сразу несколько потоков, нам стоит сделать его потокобезопасным. В противном случае может случиться такая ситуация, что, например, оба потока проверят объект на null, результат окажется false, а затем будет создано два объекта типа Blob, нагрузив систему в два раза больше, чем нам хотелось, и кроме того, один из этих объектов сохранится, а второй будет потерян.
```
class Test
{
private readonly object _lock = new object();
private Blob _blob = null;
public Blob BlobData
{
get
{
lock (_lock)
{
return _blob ?? (_blob = new Blob());
}
}
}
}
```
Оператор lock получает взаимоисключающую блокировку заданного объекта перед выполнением определенных операторов, а затем снимает блокировку. Он является эквивалентом использования метода System.Threading.Monitor.Enter(..., ...);
#### Lazy
В .NET 4.0 появился класс Lazy, позволяющий скрыть всю эту грязную работу от наших глаз. Теперь мы можем оставить только локальную переменную типа Lazy. При обращении к его свойству Value, мы получим объект класса Blob. Если объект был создан ранее, он сразу вернётся, если нет — сначала будет создан.
```
class Test
{
private readonly Lazy \_lazy = new Lazy();
public Blob BlobData
{
get
{
return \_lazy.Value;
}
}
}
```
Так как у класса Blob есть конструктор без параметров, то Lazy сможет создать его в нужный момент без лишних вопросов. Если же нам нужно выполнить какие-то дополнительные действия во время создания объекта Blob, конструктор класса Lazy может принимать ссылку на Func
```
private Lazy \_lazy = new Lazy(() => new Blob());
```
Кроме того, во втором параметре конструктора мы можем указать, нужна ли нам потокобезопасность (тот самый lock).
#### Свойство
Теперь давайте сократим запись readonly свойства, благо современный C# позволяет это делать красиво. В конечном итоге выглядеть всё это станет так:
```
class Test
{
private readonly Lazy \_lazy = new Lazy();
public Blob BlobData => \_lazy.Value;
}
```
#### LazyInitializer
Ещё есть вариант не оборачивать класс в обёртку Lazy, а вместо этого использовать функционал LazyInitializer. Этот класс имеет один статический метод EnsureInitialized с кучей перегрузок, позволяющих творить всякое, в том числе делать потокобезопасность и писать кастомный код для создания объекта, но основная суть которого заключается в следующем. Проверить, не инициализирован ли объект. Если нет, то инициализировать. Вернуть объект. С использованием данного класса, мы можем переписать наш код так:
```
class Test
{
private Blob _blob;
public Blob BlobData => LazyInitializer.EnsureInitialized(ref _blob);
}
```
На этом всё. Спасибо за внимание. | https://habr.com/ru/post/522184/ | null | ru | null |
# Слёрм DevOps. 3-ий день. ELK, ChatOps, SRE. И тайная молитва разработчика
Наступил третий и последний день первого, но не последнего Слёрма DevOps.
Мы не рассчитывали, что сможем повторить Слёрм DevOps. Но неожиданно для нас все спикеры согласились приехать на Слёрм в феврале, а фидбек показал, как именно доработать программу. Есть понимание, как сделать программу интенсива более целостной и детальной, а некоторые темы — более практичными. Так что в феврале мы собираемся провести Слёрм DevOps в Москве. Подробности будут ближе к декабрю. Анонс обязательно появится на Хабре.
6 сентября, на третий день Слёрма выступали четыре спикера.
Владимир Гурьянов, инженер/тимлид в Southbridge, выступление которого ещё на второй день Слёрма DevOps очень понравилось участникам интенсива. Владимир активный сторонник DevOps-подхода в работе, старается внедрять его повсеместно.
Павел Селиванов, признанная звезда Слёрмов, вдохновитель первого Слёрма по Kubernetes. О нём студенты писали, что «было бы здорово, если бы он вел всю программу». Павел является Certified Kubernetes Administrator. Обладает огромным практическим опытом внедрения Kubernetes — более 25 проектов в команде и индивидуально.
Эдуард Медведев, CTO в Tungsten Labs, разрабатывал и внедрял ChatOps при автоматизации дата-центров. После его выступления на Слёрме многие участники задумались о внедрении ChatOps в своих компаниях. Сейчас успешно выступает консультантом по безопасности.
Иван Круглов, Principal Developer в Booking.com, настоящая приглашённая звезда конференции. Именно ради его выступления некоторые участники записывались на Слёрм DevOps. В Booking.com занимался такими инфраструктурными проектами, как распределенная доставка и обработка сообщений, BigData и web-stack, поиск. Сейчас в списке его задач построение внутреннего облака и Service Mesh.
Мы взяли обширные интервью у Эдуарда Медведева и Ивана Круглова — по готовности опубликуем на Хабре.
Аудитория всем своим задумчивым видом демонстрировала лёгкую усталость. Два предыдущих дня интенсива заставили поработать на пределе, головы требовали отдыха и выходных. Но темы и спикеры третьего дня разогнали усталость и дрёму. Особенно Site Reliability Engineering и Иван Круглов.
Под завершение [второго дня Слёрма](https://habr.com/ru/company/southbridge/blog/466503/) было принято решение перенести мониторинг инфраструктуры c Prometheus на завтра. Интенсив оказался слишком интенсивным — не все участники выдерживали темп.
И потому третий день начался с выступления Владимира Гурьянова. Он кратко рассказал, зачем собственно нужен мониторинг. Описал и классифицировал типы мониторинга. Затронул вопрос уведомлений в мониторинге.
Очень живо зашли в аудиторию темы «Как построить здоровую систему мониторинга» и «Человекочитаемые уведомления». Владимир завершил выступление темой Health Check, на что стоит обратить внимание и как обустроить автоматизацию на основание данных от мониторинга.
Чтобы расшевелить сонных участников и активировать у них способности к обучению на максимум, следом за Владимиром Гурьяновым вниманием публики завладел Павел Селиванов с темой «Логирование приложения с ELK». Он показал участникам Слёрма наши best practices логирования и рассмотрел ELK стек.
После первого кофебрейка, насыщенного общением и печеньками, участники Слёрма заняли места в аудитории.
Выступления Гурьянова, Селиванова и алкалоид пуринового ряда кофеин сделали своё коварное дело. Кофеин добрался до аденозиновых рецепторов мозга, заместил там пуриновый нуклеозид аденозин, отвечающий за процессы торможения — чем попросту лишил участников Слёрма шанса на «полениться» и «подремать». Не все поняли, что произошло. Зато все взбодрились.
Таким образом аудитория была на сто процентов готова к дальнейшему обучению и активному поглощению знаний. И к выступлению Эдуарда Медведева.
Эдуард выступил с темой автоматизации инфраструктуры с ChatOps, рассказал об интеграции мессенджеров с пайплайнами.
Финалом третьего дня Слёрма и Слёрма DevOps в целом стало выступление Ивана Круглова, Principal Developer в Booking.com. Иван сразу же завладел вниманием аудитории, сознавшись, что у него в презентации более 140 слайдов, аккуратно тем самым намекнув, чтобы участники Слёрма не строили планов ни на саму пятницу, ни на выходные.
В интенсивном, длительном и глубоком выступлении Иван Круглов затронул тему DevOps и SRE, кто они друг другу, как соотносятся. Рассказал о «страшных терминах из мира SRE»: SLA, SLO, Error Budget и некоторых других.
Далее пошла практика и ещё больше практики — мониторинг SLI и SLO, применения Error Budget и управление прерываниями и операционной нагрузкой (apigateway, service mesh, circuit brackers). И ещё многое, многое другое.
*Тайная молитва разработчика.*
Так как тема SRE предельно обширна и рассказывать о нюансах можно хоть несколько дней, было решено, что в феврале на следующем Слёрме DevOps мы уделим ещё больше времени SRE и его практическому применению, как наиболее актуальной и востребованной технологии.
```
Sabbath, [6 сент. 2019 г., 18:25:30]:
Шикарный доклад!!
Я теперь думаю, что букинг по крутизне не уступают гуглу :)
aaa, [6 сент. 2019 г., 18:27:07]:
еще осталось UI\UX подтянуть
mr. Dmitry, [6 сент. 2019 г., 18:28:47]:
Ага, сколько докладов слышал от спецов букинга - все круто, все четко, все по уму. Но пользоваться из-за их гуя крайне сложно
```
После выступлений пришёл черёд многочисленных вопросов, как в офлайне, так и в рабочем чате Слёрм:
```
Владимир Гурьянов, [6 сент. 2019 г., 23:24:54]:
Спрашивали про мониторинг, сколько items у нас.
Не забыл, отвечаю.
Активных: 297 432
Maksim Aleksandrov, [7 сент. 2019 г., 0:11:58]:
Спасибо . Это какое количество проверок в секунду (nvps) ? И почему все таки prometheus ?
Владимир Гурьянов, [7 сент. 2019 г., 0:24:15]:
2.21K
Почему prometheus? Ну, хотя бы из-за service discovery и его удобной и гибкой настройки.
У zabbix плохо все в средах, где инстансы не долго живут и часто создаются новые.
С мониторингом docker и k8s у zabbix все тоже грустно.
Но для нас, пока + у прома не столько, что бы вкладывать время и силы в переезд с zabbix.
```
Участники Слёрма поделились впечатлениями:
```
Alexander B, [6 сент. 2019 г., 21:11:03]:
Спасибо за мероприятие, были "неровности", но для первого раза весьма достойно.
Темп в некоторых практиках напрягал, это интенсив во всех смыслах этого слова ) Чтобы уместить всё и не выкидывать во второй и третий день из докладов и практик материалы по причине нехватки времени - рассмотрите возможность четырехдневного слёрма.
Roman D, [6 сент. 2019 г., 20:49:05]:
спасибо, местами было интересно. В качестве пожелания на будущее - за пару дней до мероприятия посадите пару человек с улицы и заставьте их пройти практику по вашим инструкциям, исправите ошибки и неточности.
Никита Суворов, [6 сент. 2019 г., 20:49:30 (06.09.2019, 20:50:07)]:
Если пол пожелания, тоже есть - спикерам тренироваться перед зеркалом, слух режут эээ, уууу, ыыы между словами
```
```
Max Grechnev, [6 сент. 2019 г., 19:42:57]:
Спасибо! Курс получился отличный! Финал вообще огонь)
Smith Wesson, [6 сент. 2019 г., 19:58:11]:
Спасибо за курс! Вы лучшие!
Igor Averin, [6 сент. 2019 г., 19:58:12]:
Согласен! Было оч здорово! Спасибо организаторам!
```
После конференции мы попросили участников оставить отзывы в форме Google Docs. Результаты нас порадовали и воодушевили.
Спасибо всем, кто был с нами — в офлайне, в конференц-зале Selectel, и в онлайне. И спасибо огромное читателям Хабра. "[Слёрм окрыляет](https://habr.com/ru/company/southbridge/blog/466503/)!"(с) | https://habr.com/ru/post/466803/ | null | ru | null |
# Custom font в Unity3d
Как-то при подготовке [своего проекта](http://habrahabr.ru/post/212665/) в Unity3d у меня возникла необходимость использовать Bitmap font (он же растровый шрифт). Я очень обрадовался, когда обнаружил в Unity инструменты для создания такого шрифта. Но спустя некоторое время понял, что процедура эта отнюдь нетривиальна из-за отсутствия какой-либо документации на этот счёт.
Эта статья о том, как собрать в Unity готовый к использованию Custom Bitmap Font. Урок довольно подробный и затрагивает работу в Photoshop. Заинтересовавшихся прошу под кат.
##### Введение
Как объясняет [wiki](http://en.wikipedia.org/wiki/Computer_font#Bitmap_fonts), растровый шрифт — это фактически набор растровых изображений всех используемых символов. То есть, в первую очередь нам понадобится текстура, содержащая изображения всех нужных нам символов. В этом примере я ограничусь только цифрами и парочкой вспомогательных знаков, однако использовать такую технику можно на любое количество глифов.
##### Подготовка текстуры
Наш шрифт будет содержать 14 символов: цифры от нуля до девяти, знаки "+", "-", точка, разделяющая дробную и целую части и пробел. Так же оставим парочку резервных мест для символов, которые мы, возможно, захотим добавить в будущем. Итого 16 слотов на текстуре.
Наиболее оптимальным образом расположить эти 16 слотов на текстуре можно таким способом: использовать 4 столбца и 4 строки
Для подготовки примера я использовал Photoshop, и по ходу урока я так же буду давать некоторые пояснения к своим дейсвиям в нём. Итак, открываем редактор изображений и создаём новый документ, размером 400 на 400 пикселей. Рзамер текстуры на данном этапе особо не критичен, главное, чтобы он был не слишком маленьким. Конечный размер текстуры мы выставим уже в Unity в самом конце урока.
Для удобства работы я советую включить отображение линейки, сетки и направляющих (ruler, grid и guides). Хоткей для отображения сетки Ctrl+' для направляющих Ctrl+; для линейки Ctrl+R. Для создания направляющей просто перетащите её с линейкина документ. Настройки всех этих помощников находятся в меню Edit -> Preferences -> Units & Rulers
Далее нам предстоит заполнить текстуру содержанием в виде, собственно, символов. В качестве основы своего растрового шрифта я использовал бесплатный шрифт Unispace. Вызываем инструмент «Text» горячей клавишей Shift+T и вводим наш первый глиф. Все символы должны быть точно позиционированны по центру каждого из 16 слотов (тут нам пригодится вспомогательная сетка). После ввода первого символа (в нашем случае это ноль) жмём Enter для подтверждения ввода. Чтобы правильно позиционировать слой, нажатием клавиш Ctrl+T вызываем инструмент «Transform» и перемещаем слой в нужное место, руководствуясь вспомогательной сеткой.
Проделываем эту нехитрую операцию со всеми нужными нам символами и — вуаля!
Следующим этапом мы объединим все получившиеся слои с цифрами и знаками в один общий слой. Для этого выделим их на панели Layers и нажмём Ctrl+E. Главное случайно не зацепить слой фона, ведь тогда пропадёт вся информация о прозрачности. После этого начинается самая интересная и творческая часть работы. Настраивание эффектов слоя по вкусу. Подробно здесь я не буду её описывать, каждый решит сам, что ему нравится и сделает на свой лад. Что получилось у меня, можно увидеть на картинке ниже.
Итак, на данный момент мы имеем два слоя: наши цифры со знаками и белый слой фона. После того, как мы настроили все нужные нам эффекты, сделаем резервную копию слоя и приступим к следующему этапу: создание альфа-канала.
В альфа-канале будет храниться информация о прозрачности. Черные пиксели отвечают за полную прозрачность, белые — наоборот. Оттенки серого же создают эффект различных степеней полупрозрачности. В моём случае вокруг символов имеется мягкая черная тень, которую я хотел бы видеть плавно затухающей по мере распространения в стороны от символов. Чтобы добиться такого эффекта, мы как раз и будем использовать полутона в альфа-канале.
Свежепродублированный слой станет основной нашего альфа-канала. Для начала нам надо запечь все его эффекты, то есть растеризовать слой. Для этого я обычно создаю новый пустой слой, выделяю его и слой, с которым я сейчас работаю — и объединяю их в один (Ctrl+E).
У нас получился растеризированный слой с информацией о прозрачности. Теперь осталось только перенести эту информацию в альфа-канал. Для этого, удерживая Ctrl, щелкаем по ионке слоя в панели Layers — получая выделение по маске прозрачности, и, на панели Channels создаём новый канал, опять-таки удерживая Ctrl. Кнопка создания нового канала находится справа внизу панели возле кнопки удаление канала, с корзинкой. Получившийся канал оказался инвертированным — не беда. Комбинацией Ctrl+I восстанавливаем нормальное положение вещей.
Альфа-канал готов. Текстура, в общем-то, тоже. За исключением того, что белый слой фона мешает правильному отображению тени вокруг символов. Я раскрасил его в цвет тени.
Сохраняем текстуру в любимый формат, поддерживающий альфа-канал (я использую TGA-32bit) и переходим к следующему этапу.
##### Подготовка к созданию шрифта в Unity
Импортируем текстуру в Unity3d. Для этого в панели Project находим папку Assets и из контекстного меню вызываем Import New Asset… Находим файл с нашей текстурой. Готово.
Настройки текстуры довольно очевидны, и я не стану подробно расписывать их. Упомяну лишь, что вам необходимо выставить вменяемый размер текстуры. В нашем случае вполне подойдёт 256x256 px.
Далее в том же контекстном меню создаём новый материал и ассет шрифта (Create -> Material, Create -> Custom Font). В настройках материала выбираем только что импортированную текстуру. Также материал должен поддерживать прозрачность. Поэтому тип материала мы подбираем соответствующий: Transparent/Diffuse.
Наконец, мы подошли к самой сути урока. У нас имеется настроенный материал с красивенькой текстурой, и теперь надо как-то собрать из него готовый к использованию в Unity растровый шрифт.
##### Растровый шрифт в Unity
По непонятной причине инструмент создания растрового шрифта в Unity сделан крайне неудобно. Впридачу, никакой документации по нему в сети найти не удалось. Всё, что мы имеем, это невнятная панель с настройками:
Проковырявшись в ней битых несколько часов, мне все же удалось распознать большинство параметров, которых хватает для создания шрифта.
**Ascii Start Offset** — целое число, отвечающее за сдвиг таблицы Ascii-кода. Пример: устанавливаем значение 10, и теперь доступ к символу «A» с кодом 65 можно получить через код 75.
**Kerning** — интервал между буквами.
**Line Spacing** — расстояние между строками текста.
**Default Material** — материал с текстурой шрифта. Мы его уже создали.
**Character Rects** — массив настроек маппинга для каждого символа.
Именно Character Rects нам интересней всего.
**Size** — размер массива (количество символов в шрифте).
**Element x** — элемент массива Character Rects с настройками конкретного символа.
**Index** — Ascii-код символа с учётом Ascii Start Offset.
**UV** — координаты и размеры символа на текстуре.
**X, Y, W, H** — координаты нижнего левого угла участка текстуры с символом, а так же ширина и высота этого участка.
Здесь необходимо сделать небольшое отступление в теорию маппига, в спойлере имеется краткое наглядное пособие.
**Краткая пояснялка в маппинг**[Маппинг текстуры](http://en.wikipedia.org/wiki/Texture_mapping) — процесс нанесения текстуры на полигональные поверхности в компьютерной графике.
Текстурные координаты участка с цифрой пять будут такими: `X = 0.25, Y = 0.5, H = 025, W = 0.25`
**Vert** — координаты и размеры полигона, на который будет маппиться символ
**X, Y, W, H** — координаты нижнего левого угла полигона с символом, а так же ширина и высота этого полигона. В общем случае x и y выставляем в 0, w и h длина и ширина полигона, причем h отрицательное число. Не спрашивайте, почему, я так сам и не понял.
**Width** — что-то вроде межбуквенного интервала для конкретного символа.
**Flipped** — поворачивает текстуру на 90 градусов относительно полигона (может использоваться для вертикальных шрифтов).
Итак, основные параметры должны быть ясны. Приступим к маппингу наших циферок. Для начала взглянем на таблицу Ascii-кодов.
Как несложно заметить, каждому символу соответствует уникальный Ascii-код. Наприер, код 43 принадлежит знаку плюс. И вот теперь мы приступаем к тяжелой муторной работе по вписыванию координат в соответствующие поля. Ниже дана картинка, на которой показано, как были замапленны знаки плюс и минус.
После того, как все символы будут замапленны, можно поздравить вас с выполнением очень трудной задачи: шрифт готов и теперь его можно использовать!
Создадим в сцене проекта пустой объект. Назначим ему компонент «TextMesh» и выберем в настройках наш шрифт.
Красота!
##### Послесловие
Создание растровых шрифтов в Unity — очень непростая, но интересная работа. Хочется верить, что, пройдя этот урок, вы узнали для себя что-то новое и полезное. Отсутствие такого описания в своё время сильно тормознуло продвижение моего проекта. И я надеюсь, что этот текст поможет сэкономить кучу времени всем, кому однажды понадобится создать кастомный фонт в Unity. | https://habr.com/ru/post/212587/ | null | ru | null |
# Микросервисы. Паттерны разработки и рефакторинга с примерами на языке Java
Привет, Хабр!
Мы приступаем к переводу книги Криса Ричардсона "[Microservices Patterns. With examples in Java](https://www.manning.com/books/microservices-patterns)". До премьеры на русском языке еще с полгода, но мы хотели бы предложить вам своеобразный трейлер — немного сокращенный обзор этой книги от Бена Нейдела (Ben Nadel), прочитавшего MEAP-версию. В обзоре активно цитируется текст Kindle-версии Ричардсона.
Добро пожаловать под кат!
Я узнал о Крисе Ричардсоне, познакомившись с его интернет-ресурсом [Microservices.io](https://microservices.io/). Где, скажу честно, дается ошеломительный объем информации – которую я решил отложить на потом, поскольку к тому моменту еще не знал, как к ней подступиться, особенно, учитывая, что еще практически не имел дел с микросервисами. Мне больше нравится читать. Поэтому, узнав, что у Криса выходит авторская книга [Microservices Patterns: With Examples In Java](https://www.amazon.com/gp/product/1617294543/), я просто воодушевился. Настолько, что не мог дождаться ее выхода. Так что приобрел и прочел «раннюю версию» (MEAP) от Manning. На прошлой неделе только и делал, что штудировал эту книгу, и считаю, что это увлекательное, прагматичное и целостное исследование микросервисного подхода к разработке.
Вся книга построена в виде истории Мэри – CTO (генерального технического директора) компании Food To Go, Inc (FTGO). Компания стремится развить бизнес, запустив рефакторинг своего старого монолитного приложения и переделав его в микросервисную архитектуру. Мэри берется за этот проект, поскольку скорость разработки снизилась, а начальство все сильнее раздражается тем, что программисты под началом Мэри не в состоянии выдавать новые фичи в достаточно качественном виде.
Разумеется, основная проблема Мэри – это так называемый «монолитный ад» в терминологии Ричардсона. Притом, что монолит – это крупное и разрастающееся приложение, Ричардсон сосредотачивается на достаточно тонком аспекте миграции FTGO, так, чтобы было удобнее изложить и донести все концепции. При этом содержание книги получается невероятно удобоваримым. Большинство рассуждений об архитектуре обычно получаются либо чрезмерно упрощенными, либо переусложненными. Однако, Ричардсону удалось найти золотую середину, сконструировав такую модель предметной области, которая (почти) укладывается в голове, но при этом достаточно сложна, чтобы на ней можно было проиллюстрировать интересные межсервисные потоки задач.
С самого начала я предвкушал, что Ричардсон будет прагматичен во всех деталях. Ни один аспект в книге не подается как «серебряная пуля» или «единственное решение». Везде мы видим просчитанный выбор, совокупность четко очерченных компромиссов. Например, даже саму идею микросервисов автор подает в таком ключе: микросервисной архитектуры следует избегать всегда, кроме тех случаев, когда она абсолютно необходима:
> Еще один вызов, связанный с использованием микросервисной архитектуры – решать, в какой момент жизненного цикла приложения приступать к использованию этой архитектуры. При разработке первой версии приложения вы зачастую еще не сталкиваетесь с проблемами, которые решает такая архитектура. Более того, использование выверенной распределенной архитектуры только замедлит разработку. Такая дилемма может возникать на стартапах, где важнейший вызов обычно заключается в стремительном развитии бизнес-модели и собственного приложения. При использовании микросервисной архитектуры значительно сложнее организовать быстрые итерации. Развитие стартапа определенно должно начинаться с монолитного приложения. (Kindle-версия, адрес 416)
Ричардсон также рассматривает микросервисы в целостной перспективе, рассуждая о динамике работы команды как о совершенно самостоятельном круге проблем, который надстраивается над технологической частью. Разумеется, он рассматривает такие темы как [Закон Конвея](https://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%BA%D0%BE%D0%BD_%D0%9A%D0%BE%D0%BD%D0%B2%D0%B5%D1%8F) и «Обратный маневр Конвея», но, при этом, он затрагивает и тот факт, что программисты – эмоциональные пафосные персонажи, которым вы должны «продать» идею микросервисов:
> Переходя на микросервисную парадигму, вы вынуждены менять вашу архитектуру, вашу организацию и процессы разработки. Однако, в конечном итоге меняется рабочая среда, условия, в которых трудятся люди, а люди, как уже упоминалось – эмоциональны. Если человеческие эмоции игнорировать, то внедрение микросервисов в организации может превратиться в крутой маршрут. (Kindle-версия, адрес 718)
Описываемые автором стратегии касаются всего бизнеса целиком, затрагивают менеджеров и руководителей, которые, возможно, не решаются приступать к большому рефакторингу, отрывая на него ценные ресурсы, людей, которые могли бы активно разрабатывать новые фичи:
> Существенная польза пошагового рефакторинга в сторону микросервисоной архитектуры – в том, что такая стратегия сразу же начинает окупаться. Это совсем не та ситуация, что при «капремонте» кода, который не принесет никакой пользы до полного завершения…
>
>
>
> Еще один плюс той ситуации, в которой ценность от перехода приобретается уже на раннем этапе – мы можем привлекать для обеспечения миграции поддержку со стороны бизнеса. Такая текущая поддержка принципиальна, поскольку чем активнее рефакторинг – тем меньше времени удастся тратить на разработку фич. В некоторых организациях сложно избавиться от технического долга, поскольку предыдущие попытки могли получаться чрезмерно амбициозными и не приносили желаемой пользы. В результате бизнес с неохотой продолжает инвестиции в «наведение порядка». Пошаговая природа рефакторинга в случае микросервисов означает, что команда может демонстрировать ценные результаты очень часто. (Kindle-версия адрес 10769)
С технологической точки зрения в книге «Микросервисы. Паттерны разработки и рефакторинга» рассмотрен широкий спектр тем: от гексагональных архитектур, тестирования и непрерывной интеграции до паттернов обмена сообщениями и создания наблюдаемых систем. Такой охват подразумевает, что некоторые темы в книге освещены подробнее других. Однако, опять же, Ричардсону отлично удается все сбалансировать и дать именно столько подробностей, чтобы можно было предметно рассуждать на тему, не обескураживая при этом читателя.
На самом деле, содержимое книги организовано таким образом, что вы сами можете выбирать, в какие темы углубляться. В каждой главе перед подробным погружение в тему дается список TL;DR, в котором кратко перечисляются все «за» и «против». Таким образом, вам удается уловить наиболее важные моменты главы, не вчитываясь в каждое слово.
Честно говоря, я просто пролистнул две главы о тестировании микросервисов и одну главу о развертывании микросервисов. Уверен, у автора эти темы проработаны отлично, но мне показалось, что там попросту больше информации, чем я смогу переварить. Развертывание не является для меня актуальной повседневной задачей. За всю жизнь написал несколько тестов.
Таким образом, хотел оставить в моем незамутненном пещерном сознании достаточно места, чтобы уложить там материал из всех остальных глав: о предметно-ориентированном проектировании (DDD), межпроцессной коммуникации и синхронизации данных.
Один из разделов, оказавших на меня особенно сильное впечатление, рассказывает о том, какой сервис должен обрабатывать запросы одного специализированного типа, а именно: находить подходящие рестораны поблизости от текущего местоположения пользователя:
> Однако, бывает сложно реализовать даже такие запросы, которые локальны с точки зрения конкретного сервиса. Такое возможно по нескольким причинам. Во-первых, потому что (как описано ниже), иногда нецелессобразно реализовывать запрос в том сервисе, который владеет данными. Другая причина – иногда база данных сервиса (или модель данных) не может эффективно поддерживать запрос (Kindle-версия, адрес 5659)
> … Если в приложении FTGO информация о ресторанах хранится в [какой-то иной] базе данных, то реализация запроса `findAvailableRestaurant()` значительно усложняется. Реплика данных о ресторанах должна храниться в такой форме, которая позволяет поддерживать геопространственные запросы. Например, в приложении можно было бы использовать библиотеку геопространственного индексирования (Geospatial Indexing Library) для DynamoDB, где таблица используется как геопространственный индекс. Альтернативный вариант: приложение может хранить реплику данных о ресторанах в базе данных совершенно другого типа. Схожая ситуация возникает, когда мы используем текстовые запросы с базой данных для текстового поиска. (Kindle-версия, адрес 5675)
> … В таком случае, целесообразно (как минимум, на первый взгляд), чтобы операцию запроса реализовывал именно тот сервис, что владеет данными. Однако, кроме владения данными приходится учитывать и другие факторы.
>
>
>
> Также требуется принимать во внимание необходимость разделения обязанностей и избегать перегрузки сервисов слишком большим количеством возможностей. Например, основная обязанность команды, разрабатывающей сервис Restaurant – помочь ресторанным менеджерам обслуживать работу заведения. Эта задача совсем не того плана, что реализация критичного запроса для работы с большими объемами данных. Более того, если бы команда разработчиков отвечала за операцию `findAvailableRestaurants()`, то постоянно боялась бы внедрять такие изменения, которые могли бы помешать потребителям делать заказы. (Kindle-версия, адрес 5675)
Здесь мне немного взорвало мозг, потому что я впервые видел сервис, чья единственная функция сводилась к оптимизации данных другого сервиса для выполнения конкретной задачи. Однако, как указывает Ричардсон, это всего лишь более обобщенная абстракция той самой идеи, что лежит в основе полнотекстового поиска, например, в Apache Lucene (этот инструмент обеспечивает полнотекстовое индексирование поверх другого хранилища данных).
Подозреваю – вернее, хочу надеяться – что, увидев такое разделение обязанностей, читатель станет совершенно по-новому проводить границы между сервисами. Будет думать не только о «владении данными», но и начнет учитывать «бизнес-возможности» — то есть, фактор реальной ценности, чтобы база данных не казалась просто тем местом, где хранится состояние.
Другой аспект, подчеркиваемый при обсуждении этой темы – абсолютная важность синхронизации и репликации данных, а также асинхронного обмена сообщениями в микросервисной архитектуре. Эта тема красной нитью проходит через всю книгу Ричардсона, о чем бы они ни рассказывал: о создании микросервиса с нуля или о постепенном рефакторинге монолита в микросервисы (этой теме посвящена отдельная глава). Он совершенно четко дает понять, что синхронизация есть та системообразующая сила, действительно позволяющая воплотить многие вещи.
Я мог бы упомянуть еще массу всего интересного. Чего стоит, например, тот факт, что Ричардсон как следует рассказывает об аутентификации и авторизации в распределенной системе – думаю, эта тема пока исследована, мягко говоря, недостаточно полно. Автор объясняет предметно-ориентированное проектирование максимально доступным образом. Также он демонстрирует, что даже очень простые классы могут обладать поведением.
Вот уже более года я пытаюсь как следует разобраться в архитектуре распределенных систем и микросервисных паттернах (что особенно сложно, поскольку моя повседневная работа связана с обслуживанием монолита). Многие тексты, которые я читал по этим темам, либо чрезмерно поверхностные, либо слишком узкие и при этом углубленные. Книга «Микросервисы. Паттерны разработки и рефакторинга» действительно является золотой серединой между этими двумя крайностями. **Решительно рекомендую эту книгу всем** (bold наш), кто пытается (в том числе, пока безуспешно) перейти от монолитной архитектуры к распределенной системе. | https://habr.com/ru/post/430062/ | null | ru | null |
# Пишем простой анализатор кода на Roslyn
Привет, Хабр!
Не так давно я сходил на конференцию [CLRium](http://clrium.ru/) от [sidristij](http://habrahabr.ru/users/sidristij/), где увидел довольно простой и удобный способ для анализа исходного кода C# в MSVS 2015.
Задача взята из проекта, в котором я участвую: каждый аргумент со ссылочным типом должен иметь аттрибут NotNull или CanBeNull (которые потом [использует ReSharper](https://www.jetbrains.com/resharper/webhelp80/Code_Analysis__Annotations_in_Source_Code.html)). В реальности, конечно, в самом проекты атрибуты являются только частью проверок, однако это не мешает им быть обязательными. Уже есть тесты, которые проверяют сборку и падают, если методы или конструкторы не содержат требуемых атрибутов, однако разработчики все равно довольно часто забывают их проставить, что приводит к падениям билдов, обновлению кода и т.д. Вот если бы Visual Studio вместе с ReSharper выдавали бы предупреждения, что код не совсем хороший, то можно было бы сэкономить время и нервы…
И, на самом деле, вместе с новой студией это становится возможным! Более того, сделать свои проверки нереально просто.
[Исходный код можно посмотреть тут](https://github.com/imanushin/NullCheck).
Итак, для начала у Вас должна быть скачана [Microsoft Visual Studio 2015](https://www.visualstudio.com/en-us/downloads/visual-studio-2015-downloads-vs.aspx). Советую внимательно выбирать язык, так как я не посмотрел и скачал русскую версию, с весьма нестандартным переводом.
Далее, необходимо скачать расширение для MSVS ".NET Compiler Platform SDK Templates" ([см. детали здесь](http://joshvarty.wordpress.com/2015/04/30/learn-roslyn-now-part-10-introduction-to-analyzers), спасибо [Ordos](http://habrahabr.ru/users/ordos/))
Далее создаем проект для для нашего анализатора кода:
В результате, студия создаст три проекта: рабочий проект, тесты и специальный проект для vsix расширения. Первый проект необходим для реализации нашего анализатора + для создания Code Fix'ов, то есть подсказок в студии с предложением исправить. Есть два способа распространения пакета: через vsix расширения и через nuget. Первый позволяет установить проверки для Visual Studio на текущем компьютере, не затрагивая проекты. Второй способ позволяет проверять код во время разработки (причем, на любом компьютере, nuget пакет докачается), а также во время сборки (даже если Visual Studio не установлена), он работает и в предыдущих выпусках Visual Studio. Для создания nuget пакета достаточно просто nuspec файла и пары скриптов, однако для vsix расширения создается дополнительный проект (который здесь приведен только для примера).
Также интересен проект с тестами: мы можем тестировать и отлаживать наш анализатор без отдельного запуска Visual Studio! Мы просто создаем C# файл, загружаем его в компилятор, а он возвращает список Warning/Error!
Изначально Visual Studio создает шаблонный анализатор, который требует, чтобы все типы имели именования в UPPERCASE. И тесты заточены на него.
Чтобы поменять поведение, проделаем следующие изменения с классом наследником DiagnosticAnalyzer:
1. Изменим DiagnosticId на свой. Это ключ нашего warning'а (с типом String). Его увидит программист в списке ошибок, на него среагирует CodeFix, его будет использовать атрибут SuppressMessage. Чтобы случайно ни с кем не пересечься, лучше всего выбрать название подлиннее. Я выбрал его как <имя nuget пакета>\_<внутренний id>: NullCheckAnalyzer\_MethodContainsNulls
2. Затем лучше всего поменять все описания на свои: см. методы Title, MessageFormat, Description, Category.
3. Далее в методе Initialize поменяем аргументы функции RegisterSymbolAction: мы будем реагировать не на типы, а на методы. Кстати говоря, судя по моим изысканиям и [исходникам Roslyn](https://github.com/dotnet/roslyn/blob/master/src/Diagnostics/CodeAnalysis/Test/MetaAnalyzers/UnsupportedSymbolKindArgumentRuleTests.cs), часть значений SymbolKind вообще не поддерживается (то есть, например, на параметры мы реагировать не можем).
3. Меняем немного метод AnalyzeSymbol:
— На вход нам придет лексема для проверки
— На каждую ошибку необходимо добавить в контекст информацию о ней. То есть, для одного метода можно найти сколько угодно ошибок, причем с разными Id.
Получается следующий код:
```
[DiagnosticAnalyzer(LanguageNames.CSharp)]
public class NullCheckAnalyzer : DiagnosticAnalyzer
{
public const string ParameterIsNullId = "NullCheckAnalyzer_MethodContainsNulls";
// You can change these strings in the Resources.resx file. If you do not want your analyzer to be localize-able, you can use regular strings for Title and MessageFormat.
internal static readonly LocalizableString Title = new LocalizableResourceString(nameof(Resources.AnalyzerTitle), Resources.ResourceManager, typeof(Resources));
internal static readonly LocalizableString MessageFormat = new LocalizableResourceString(nameof(Resources.AnalyzerMessageFormat), Resources.ResourceManager, typeof(Resources));
internal static readonly LocalizableString Description = new LocalizableResourceString(nameof(Resources.AnalyzerDescription), Resources.ResourceManager, typeof(Resources));
internal const string Category = "Naming";
internal static DiagnosticDescriptor Rule = new DiagnosticDescriptor(ParameterIsNullId, Title, MessageFormat, Category, DiagnosticSeverity.Warning, isEnabledByDefault: true, description: Description);
private static readonly ImmutableArray supportedDiagnostics = ImmutableArray.Create(Rule);
public override ImmutableArray SupportedDiagnostics => supportedDiagnostics;
public override void Initialize(AnalysisContext context)
{
context.RegisterSymbolAction(AnalyzeSymbol, SymbolKind.Method);
}
private static void AnalyzeSymbol(SymbolAnalysisContext context)
{
var methodSymbol = context.Symbol as IMethodSymbol;
if (ReferenceEquals(null, methodSymbol) || methodSymbol.DeclaredAccessibility == Accessibility.Private)
{
return;
}
foreach (var parameter in ParametersGetter.GetParametersToFix(methodSymbol))
{
var type = methodSymbol.ContainingType;
// For all such symbols, produce a diagnostic.
var diagnostic = Diagnostic.Create(Rule, parameter.Locations[0], methodSymbol.Name, type.Name, parameter.Name);
context.ReportDiagnostic(diagnostic);
}
}
}
```
Все, теперь наш маленький анализатор уже заставит Visual Studio сыпать ошибками. Для проверки запустим тесты. Microsoft заботливо создала целых два: проверка того, что пустой файл корректен, и проверка того, что диагностика + исправления работают правильно. Первый завершается правильно, а второй с ошибкой, так как мы так и не сделали Code Fix.
Я попытался быстро сделать Code Fix и понял, что даже такое простое исправление уже содержит нюансы, которые не так просто решить:
— Из какого namespace добавлять NotNull атрибут? Из Resharper.\*? А если есть несколько вариантов: свои атрибуты и пакет от Resharper?
— Как дописывать using: внутри namespace, или же сверху файла? Не будет ли коллизий? Возможно, лучше зарегистрировать alias?
— Если нет ссылки на сборку с атрибутами, то её надо добавить, однако по каким правилам? Взять первую попавшуюся, или попробовать загрузить с сайта nuget? Или с корпоративного nuget репозитория?
Попробовав несколько исправлений, я понял, что:
1. Они работают. Roslyn действительно добавляет атрибуты, компилирует результат.
2. Алгоритм довольно простой: надо найти необходимый \*Syntax элемент, потом с помощью SyntaxFactory создать правильный и вызвать ReplaceNode.
3. Правильный Code Fix не настолько прост, как кажется на первый взгляд. И вместо того, чтобы предлагать проблемное решение, лучше попросить программиста сделать исправление самостоятельно.
Для того чтобы протестировать анализатор, достаточно просто установить Nuget пакет (т.е. ввести команду в Package Manager Console: Install-Package NullCheckAnalyzer). Однако, скорее всего, тот пакет, который Вы собрали, не заработает, так как изначально PowerShell скрипты содержат ошибку: в путь в dll с анализатором зачем-то добавляется подпапка «C#». Поэтому эти строчки лучше поменять так, [как сделано тут](https://github.com/imanushin/NullCheck/tree/master/NullCheck/NullCheckAnalyzer/NullCheckAnalyzer/tools). После этих действий nuget пакет готов, его можно выгружать на nuget.org, а потом добавить в проект.
И вот как оно выглядит в Microsoft Visual Studio 2015:
В итоге, на выходе мы получаем расширение:
1. Которое подключается и обновляется через Nuget
2. Проверяет код в процессе написание и компиляции (в т.ч. без MSVS)
3. Пишется настолько просто и быстро, что ревью среднего pull-request'а в компании займет больше времени
И напоследок парочка советов:
1. Как Вы видите, Microsoft отдала предпочтение неизменяемым типам. А потому большинство конструкций Code Fix можно создать заранее, а потом просто давать ссылки.
2. В процессе тестирования проверять можно легко только один файл, а потому лучше специально предусмотреть варианты с partial-классами и прочими многофайловыми конструкциями
3. Пока нет Release версии Roslyn, а потому API может незначительно поменяться. Уже сейчас [некоторые ответы на Stackoverflow содержат советы по устаревшему API.
4. [Ordos](http://habrahabr.ru/users/ordos/) подсказал [страницу в интернете с похожим описанием](https://joshvarty.wordpress.com/2015/04/30/learn-roslyn-now-part-10-introduction-to-analyzers/).](http://stackoverflow.com/questions/17154917/how-to-add-a-trailing-end-of-line-to-attribuelist-using-roslyn-ctp) | https://habr.com/ru/post/259213/ | null | ru | null |
# Электроника всем начинающим
Хабр! *Добро пожаловать снова.*
Сегодня мы сделаем одно из самых бесполезных устройств из тех, что можно собрать, но как показывает жизнь, лучше сделать что-то, чем не сделать ничего. Тем не менее, в защиту этой бесполезности можно сказать только что-то вроде: много ли интересных дел, которыми мы занимаемся являются хоть сколько бы полезными?
Мы будем делать часы, таймер и игру в одном устройстве.
Готовое устройство и печеньки.**UPD #1**
Дисклеймер
----------
**Внимание!**
Эта статья имеет много профессиональных неточностей, по мнению уважаемых экспертов по всем вопросам и по совместительству комментаторов, также не является руководством к действию, может привести к производственным травмам и нарушениям психики. Автор призывает, не использовать данное руководство для обучения и лишь демонстрирует хаотично накопленные знания и реализует их в горделивой позе больного шизофренией с бредовыми идеями величия. Никогда не верьте мне! Я украл ваши технологии!
Некоторое вступление
--------------------
Спустя много лет я решил вернуться снова к написанию статей, с новыми знаниями и силами. Знаете, интернет научил меня всему, что я знаю и даже больше, чем просто всему. Интернет стал не просто учением, в котором тяжело, но и боем, в котором легко. И я благодарен всем, кто так или иначе принял участие в моем обучении, через статьи, описание каких-то технологий, видео на YouTube и просто критику моих работ. Это герои моего времени, только благодаря им я сейчас являюсь неплохим специалистом. Ведь я не учился в этих ваших институтах и образований не получал, да и всего у меня 9 классов. Спасибо тем, кто пишет интернет.
***И еще***
В детстве, когда я только начинал гуглить какие-то схемы, я любил статьи с картинками, больше всего мне нравилось, как нагляден процесс сборки, как процесс обучения реализован через картинки. Буквы придумали не для меня и вообще не для детей, которые хотят заниматься электроникой. Поэтому я приложил грандиозное количество усилий, чтобы эта статья могла стать для кого-то первой ступенью. Я знаю, как сложно сделать первый шаг. Мое соприкосновение с контроллером случилось только в 2016 году, хотя я был знаком с ними и заочно, задолго до 2016 года.
Компоненты
----------
Приступим. Первое, что нужно для разработки любого устройства – это, подготовить все необходимые радиокомпоненты и крепеж или хотя бы основные.
Не все компоненты были куплены мой, некоторые лежали без дела, или появились прямо за часы перед разработкой этого устройства :)
1. Резисторы 150 Ом 0.25 Ватт — 12 шт.
2. Конденсаторы 50 вольт 10 микрофарад — 4 шт.
3. Тактовая кнопка 6x6мм — 3 шт.
4. Светодиод 75x3мм — 1 шт.
5. Пьезо зуммер — 1 шт.
6. Кварцевый резонатор 16 МГц — 1 шт.
7. Разъём типа гребёнка — 7 шт.
8. Джампер (перемычка) — 1 шт.
9. Четырехразрядный семисегментный индикатор (Sm56425bsr3 или аналоги) — 1 шт.
10. Сдвиговый регистр 74ch595 корпус DIP — 1 шт.
11. Панель под микросхему 74ch595 корпус DIP (16 ножек) — 1 шт.
12. Микроконтроллер ATmega328p корпус DIP — 1 шт.
13. Панель под микросхему ATmega328p корпус DIP (28 ножек) — 1 шт.
14. Монтажная плата 40x60мм — 2 шт.
15. Батарейный отсек cr2032 — 2 шт.
16. Батарейка cr2032 — 2 шт.
17. Втулка 5x8x0мм (Не точно) — 4 шт.
18. Болт 3x6мм (Не точно) — 4 шт.
19. Шайба 5мм (Не точно)— 4 шт.
20. Гайка 3мм (Не точно) — 4 шт.
21. Преобразователь USB-UART CP2102 — 1 шт.
Также, рекомендую при необходимости купить флюс, припой и паяльник.
Я намеренно не указываю марку проводов, которая вам подойдет, так как совсем не владею информацией об их параметрах. Могу посоветовать МГТФ, вполне возможно, что очень хорошо подойдут. Если вы знаете, какие провода точно оптимальны, оставьте информацию в комментариях или напишите мне в личные сообщения **@prohetamine**.
Сдвиговый регистр 74ch595
-------------------------
Наверное, многим новичкам станет не по себе от понимания принципов работы микросхемы 74ch595, вне этой статьи и пропустить этот этап я просто не хочу. Сейчас я попробую максимально доступно объяснить, как она работает и чем будет полезна в конкретном случае с моим устройством.
Проще говоря, микросхема предназначена для расширения количества цифровых выходов.
Распиновка. **Внимание!** Рисунок имеет незначительные неточности в маркировке контактов, это сделано для более простого усвоения и понимания работы.
Самые загадочные контакты управления, которые вызывают интерес:
* ***output pin \**** — контакты вывода
* ***DS — (Serial Data Input)*** контакт, который определяет состояние напряжения на контактах вывода
* ***SH — (Shift Register Clock Input)*** контакт, который записывает состояние которое определенно в DS
* ***ST — (Storage Register Clock Input)*** контакт, который открывает микросхему для записи и закрывает, устанавливая на контакты вывода нужные состояния определенные DS
Уверен, визуальный пример, поможет вам понять происходящее лучше.
Монтажная схема соединений
--------------------------
Если нет, то я оставил и [интерактивную версию](https://prohetamine.github.io/arduino-for-students/example/index.html), кнопочки работают, можно [понажимать](https://prohetamine.github.io/arduino-for-students/example/index.html).
Теперь, когда вы овладели работой с микросхемой, можно приступить к следующему пункту.
Тонкости
--------
**Внимание!**
Чтоб ничего не перепутать и ничего не испортить, в том числе настроение. Не ждем, а готовимся! Просто оставлю это здесь, для самых маленьких. Я, конечно, понимаю, что всех тонкостей в рамках и без того длинной статьи мне обозначить не удастся, и у вас все же могут возникнуть ошибки, пускай, хотя бы не самые очевидные.
Когда мы программируем контроллер, очень важно не путать rx и tx, иначе контроллер просто не прошьется.
Это странная шутка, но работает очень просто, каждый разряд имеет 8 сегментов, у каждого разряда есть минус и восемь плюсов, по сути это те же светодиоды, только в общем корпусе.
Каждая микросхема имеет ключ, то есть небольшую метку на корпусе, это признак помогает определить положение установки.
Я смотрю на эту схему каждый раз, когда вспоминаю, как припаял более 671 кнопку не в ту сторону.. Не совершай ошибку.
Плюсик: у всех новых электронных компонентов, которые имеют полярность, выглядит как хромоног.
Цветной хромоног:
Батарейный отсек, тоже имеет свою не очевидную полярность..
Монтажная схема соединений
--------------------------
Так выглядит схема нашего устройства:
**UPD #2**
По требованию комментаторов скоро тут появится принципиальная схема.
Но не спешите собирать, ведь собирать мы будем на плате, а не на коленке. Но сначала поговорим о некоторых спорных конструкциях. Также я буду апеллировать к своему детству: Я искренне не понимал зачем нужна обвязка, мне казались ненужными эти резисторы и конденсаторы, ведь блок питания может работать и на диодном мосте, а светодиод светиться и без понижающего резистора.
Пока пин кнопки состояние, которого мы читаем не притянут к плюсу или минусу он выдает случайные (101010000101010) результаты и кнопка, не может работать нормально, чтобы «Стабилизировать» состояние кнопки нам нужно притянуть наш пин через резистор к минусу или плюсу (принято к минусу). Тогда при нажатии у нас будет 1 иначе 0. На момент создания устройства и написания статьи, автор не знал, что существует pull-up резистор встроенный в саму ATmega328p. Почитать можно об этом на [официальном сайте](https://www.arduino.cc/en/Tutorial/DigitalInputPullup).
В ходе первых экспериментов, с высокочастотной перерисовкой индикатора появлялись ужасные гличи. Из общих соображений, я решил использовать конденсаторы, чтобы их сгладить и да помогло, оставляем. Как подсказал один из [комментаторов](https://habr.com/ru/post/593421/#comment_23785503), это связанно с кривым кодом, но не мешает работе устройства.
Резисторы предназначены для ограничения тока исходящего от ATmega328p, а именно 5 вольт мы ограничиваем до 3-х вольт, так как почти все светодиоды ограничены напряжением в 3 вольта и привыкли работать за еду, более высокое напряжение приведет к деградации, насколько быстрой зависит от тока, хоть у ATmega328p он не большой, примерно 20-40 миллиампер, деградацию и сгорание не будет видно сразу, но оно случится, явно намного раньше положенного.
О нем говорят все, но никто не знает зачем он. На самом деле все просто. Предельно просто. Эта микросхема умножает количество контактов, с условных трех до N. Мой максимум 265+ выводов, но возможно и больше. В этом месте мог бы возникнуть хороший вопрос, по сути ты ведь делаешь из трех контактов четыре, а остальные четыре не используешь(?) На эту тему можно конечно рассуждать, зачем и почему, правильный ответ только один — дать возможность устройству развиваться.
Монтаж компонентов
------------------
**Внимание!**
Контакты компонентов, помеченные красным и черным маркерами, имеют полярность, будьте внимательны при монтаже, придерживайтесь рисунка.
**Внимание!**
Соблюдайте порядок установки микросхем по ключам.
Устанавливаем панели.
Устанавливаем конденсаторы и кнопки.
Устанавливаем разъемы и пьезо зуммер.
Устанавливаем микросхемы и резисторы.
Устанавливаем индикатор, светодиод и резонатор.
Устанавливаем батарейные отсеки.
Прототип
--------
Теперь, когда у нас есть не просто бесполезная безделушка, но еще и не рабочая, нужно сделать её рабочей, поэтому добавим много магических проводков.
Объединенная схема
------------------
Соединим основные линии питания и необходимую обвязку первой платы.
Соединим кнопки, светодиод индикатор прошивки и пьезо зуммер.
Соединим конденсаторы и семисегментный индикатор с сдвиговым регистром 74ch595.
Соединим семисегментный индикатор с микроконтроллером.
В финале первая плата у вас получится такой:
Вторая плата, но тут все совсем просто. Соединим последовательно элементы питания.
Соединим все вместе.
Устройство
----------
Программирование
----------------
Подключаем так как на картинке, и можно начинать прошивать микроконтроллер.
Бесспорно, абсолютно, однозначно. Мой код на C++ далек от идеала, но я, как всегда, пытался. Я пишу на JS (ну, вы поняли). И тем не менее, я все равно собой доволен, хотя бы, потому что не притрагиваясь и без того к незнакомому мне языку больше года, мне как-то удалось организовать не только структуру с своими правилами, а также создать богатый функционал: часы, игру и два таймера c разными уровнями точности. Можешь сделать лучше? Есть что дополнить? [GitHub](https://github.com/prohetamine/arduino-for-students)
Основной файл проекта, к которому я подключаю все остальные файлы и библиотеку [*AsyncDelay*](https://www.arduino.cc/reference/en/libraries/asyncdelay/), с которой управлять синхронным потоком становится проще, чем обычно (имхо). Изначально, в процессе написания кода, я обозначил для себя два компонента - это actionDriver и actionContoller. где первый переводя на JavaScript - тянский (является почти как Event Loop), то есть выполняет стек задач только не событийных, а перманентных, а второй выполняет роль Setter'a.
```
// Подключаем библиотеку
#include
// Назначаем имена прерываний
AsyncDelay delayRenderRowFirst;
AsyncDelay delayRenderRowTwo;
AsyncDelay delayRenderRowThree;
AsyncDelay delayRenderRowFour;
AsyncDelay delayAnimaton;
AsyncDelay delayButtonHandle;
// Определяем пины кнопок
const int BTN\_SET\_TOP = A5
, BTN\_SET\_MIDDLE = A4
, BTN\_SET\_BOTTOM = A3;
// Определяем пины сдвигового регистра
const int DS = 11
, ST\_CP = 10
, SH\_CP = 9;
// Определяем пины семисигментного индикатора
const int A = 2
, B = 4
, C = 7
, D = 5
, E = 1
, F = 3
, G = 8
, DP = 6;
// Определяем пины светодиода и зуммера
const int BLINK = 13;
const int SIGNAL = 12;
// подключаем модули проекта
#include "viewer.h"
#include "animation.h"
#include "time.h"
#include "mtimer.h"
#include "timer.h"
#include "gameUnLocker.h"
#include "button.h"
void setup () {
// назнчаем интервалы прерываний
delayRenderRowFirst.start(1, AsyncDelay::MILLIS);
delayRenderRowTwo.start(1, AsyncDelay::MILLIS);
delayRenderRowThree.start(1, AsyncDelay::MILLIS);
delayRenderRowFour.start(1, AsyncDelay::MILLIS);
delayButtonHandle.start(1000, AsyncDelay::MILLIS);
delayAnimaton.start(500, AsyncDelay::MILLIS);
// Устанавливаем пины на выход
pinMode(A, OUTPUT);
pinMode(B, OUTPUT);
pinMode(C, OUTPUT);
pinMode(D, OUTPUT);
pinMode(E, OUTPUT);
pinMode(F, OUTPUT);
pinMode(G, OUTPUT);
pinMode(DP, OUTPUT);
pinMode(BLINK, OUTPUT);
pinMode(SIGNAL, OUTPUT);
pinMode(DS, OUTPUT);
pinMode(ST\_CP, OUTPUT);
pinMode(SH\_CP, OUTPUT);
pinMode(BTN\_SET\_TOP, INPUT);
pinMode(BTN\_SET\_MIDDLE, INPUT);
pinMode(BTN\_SET\_BOTTOM, INPUT);
// Сбрасываем все значения на пинах
digitalWrite(A, 0);
digitalWrite(B, 0);
digitalWrite(C, 0);
digitalWrite(D, 0);
digitalWrite(E, 0);
digitalWrite(F, 0);
digitalWrite(G, 0);
digitalWrite(DP, 0);
// Сбрасываем значения на сдвиговом регистре
digitalWrite(ST\_CP, 0);
for (int i = 0; i < 8; i++) {
digitalWrite(SH\_CP, 0);
digitalWrite(DS, 1);
digitalWrite(SH\_CP, 1);
}
digitalWrite(ST\_CP, 1);
}
// Активируем анимацию
boolean aminationStartActive = true;
void loop () {
// Устанавливаем драйвера в общик поток
viewDriver();
buttonDriver();
timeDriver();
mTimerDriver();
timerDriver();
gameUnLockerDriver();
animationDriver();
// Останавливаем анимацию и запускам виджет времени
if (millis() > 3000 && aminationStartActive) {
aminationStartActive = false;
timeShow = true;
}
// Запускаем анимацию
if (millis() < 1) {
animationController(false, "hey ");
}
}
```
Управление устройством
```
// Режим работы
int modeId = -1;
// Перемещение между режимами
int selectId = 0;
// Премещение между символами
int carret = 0;
/*
* Режимы работ
* 0 - время
* 1 - таймер
* 2 - минутный таймер
* 3 - игра
*/
#define MODE_NONE -1
#define MODE_TIME 0
#define MODE_TIMER 1
#define MODE_MINUTES_TIMER 2
#define MODE_GAME 3
// Состояния кнопок
int clickedFirstButton = 0;
int clickedMiddleButton = 0;
int clickedLastButton = 0;
// Управление состоянием кнопок
void buttonController (int first, int middle, int last) {
if (first != -1) {
clickedFirstButton = first;
}
if (middle != -1) {
clickedMiddleButton = middle;
}
if (last != -1) {
clickedLastButton = last;
}
}
// Прекращает работу всех виджетов
void mainOffControllers () {
timeController(false);
mTimerController(false);
timerController(false);
gameUnLockerController(false);
}
// Меню
void menuList () {
if (selectId == MODE_TIME) {
viewController(0, String('c'));
viewController(1, String(' '));
viewController(2, String(' '));
viewController(3, String(' '));
}
if (selectId == MODE_TIMER) {
viewController(0, String('t'));
viewController(1, String(' '));
viewController(2, String(' '));
viewController(3, String(' '));
}
if (selectId == MODE_MINUTES_TIMER) {
viewController(0, String('m'));
viewController(1, String('t'));
viewController(2, String(' '));
viewController(3, String(' '));
}
if (selectId == MODE_GAME) {
viewController(0, String('g'));
viewController(1, String(' '));
viewController(2, String(' '));
viewController(3, String(' '));
}
}
// Обработчик первой кнопки
void buttonFristEvent (int clickedFirst, int clickedMiddle, int clickedLast) {
if (modeId == MODE_NONE) {
selectId++;
if (selectId > 3) {
selectId = MODE_TIME;
}
mainOffControllers();
menuList();
}
if (clickedLast == 1 || clickedLast == 2 || clickedLast == 3 || clickedLast == 4) {
if (modeId == MODE_TIME) {
for (int i = 0; i < 4; i++) {
if (carret == i) {
timeTickerController(i, 1);
viewController(carret, String(timeTicker[i]));
}
}
}
if (modeId == MODE_TIMER) {
for (int i = 0; i < 4; i++) {
if (carret == i) {
timerTickerController(i, 1);
viewController(carret, String(timerTicker[i]));
}
}
}
if (modeId == MODE_MINUTES_TIMER) {
for (int i = 0; i < 4; i++) {
if (carret == i) {
mTimerTickerController(i, 1);
viewController(carret, String(mTimerTicker[i]));
}
}
}
if (modeId == MODE_GAME) {
for (int i = 0; i < 4; i++) {
if (carret == i) {
gameUnLockerPlayerController(i, 1);
viewController(carret, String(gameUnLockerData[i]));
}
}
}
}
}
// Обработчик второй кнопки
void buttonMiddleEvent (int clickedFirst, int clickedMiddle, int clickedLast) {
if (modeId == MODE_NONE) {
selectId--;
if (selectId < 0) {
selectId = MODE_MINUTES_TIMER;
}
mainOffControllers();
menuList();
}
if (clickedLast == 1 || clickedLast == 2 || clickedLast == 3 || clickedLast == 4) {
if (modeId == MODE_TIME) {
for (int i = 0; i < 4; i++) {
if (carret == i) {
timeTickerController(i, -1);
viewController(carret, String(timeTicker[i]));
}
}
}
if (modeId == MODE_TIMER) {
for (int i = 0; i < 4; i++) {
if (carret == i) {
timerTickerController(i, -1);
viewController(carret, String(timerTicker[i]));
}
}
}
if (modeId == MODE_MINUTES_TIMER) {
for (int i = 0; i < 4; i++) {
if (carret == i) {
mTimerTickerController(i, -1);
viewController(carret, String(mTimerTicker[i]));
}
}
}
if (modeId == MODE_GAME) {
for (int i = 0; i < 4; i++) {
if (carret == i) {
gameUnLockerPlayerController(i, -1);
viewController(carret, String(gameUnLockerData[i]));
}
}
}
}
}
// Обработчик третьей кнопки
void buttonLastEvent (int clickedFirst, int clickedMiddle, int clickedLast) {
if (modeId == MODE_NONE) {
modeId = selectId;
buttonController(0, 0, 0);
if (modeId == MODE_TIME) {
timeController(true);
}
if (modeId == MODE_TIMER) {
timerController(true);
}
if (modeId == MODE_MINUTES_TIMER) {
mTimerController(true);
}
if (modeId == MODE_GAME) {
gameUnLockerController(true);
}
return;
}
if (clickedLast == 1 && modeId == MODE_TIME) {
mainOffControllers();
for (int i = 0; i < 4; i++) {
viewController(i, String(timeTicker[i]));
}
viewController(carret, String('_'));
animationController(false, "edit");
return;
}
if (modeId == MODE_TIME) {
for (int i = 0; i < 4; i++) {
viewController(i, String(timeTicker[i]));
}
if (carret < 3) {
carret++;
viewController(carret, String('_'));
return;
} else {
carret = 0;
modeId = MODE_NONE;
timeController(true);
buttonController(0, 0, 0);
}
}
if (clickedLast == 1 && modeId == MODE_TIMER) {
mainOffControllers();
for (int i = 0; i < 4; i++) {
viewController(i, String(timerTicker[i]));
}
viewController(carret, String('_'));
animationController(false, "edit");
return;
}
if (modeId == MODE_TIMER) {
for (int i = 0; i < 4; i++) {
viewController(i, String(timerTicker[i]));
}
if (carret < 3) {
carret++;
viewController(carret, String('_'));
return;
} else {
carret = 0;
modeId = MODE_NONE;
timerController(true);
buttonController(0, 0, 0);
}
}
if (clickedLast == 1 && modeId == MODE_MINUTES_TIMER) {
mainOffControllers();
for (int i = 0; i < 4; i++) {
viewController(i, String(mTimerTicker[i]));
}
viewController(carret, String('_'));
animationController(false, "edit");
return;
}
if (modeId == MODE_MINUTES_TIMER) {
for (int i = 0; i < 4; i++) {
viewController(i, String(mTimerTicker[i]));
}
if (carret < 3) {
carret++;
viewController(carret, String('_'));
return;
} else {
carret = 0;
modeId = MODE_NONE;
mTimerController(true);
buttonController(0, 0, 0);
}
}
if (clickedLast == 1 && modeId == MODE_GAME) {
mainOffControllers();
for (int i = 0; i < 4; i++) {
viewController(i, String(gameUnLockerData[i]));
}
viewController(carret, String('_'));
animationController(false, "play");
return;
}
if (modeId == MODE_GAME) {
for (int i = 0; i < 4; i++) {
viewController(i, String(gameUnLockerData[i]));
}
if (carret < 3) {
carret++;
viewController(carret, String('_'));
return;
} else {
carret = 0;
modeId = MODE_NONE;
gameUnLockerController(true);
buttonController(0, 0, 0);
}
}
}
// Отслеживает состояние кнопок
boolean buttonDriverFlag = false;
// Ловит нажатия кнопок
void buttonDriver () {
if (delayButtonHandle.isExpired()) {
if (analogRead(BTN_SET_TOP) >= 128) {
if (!buttonDriverFlag) {
tone(SIGNAL, 1700, 50);
clickedFirstButton++;
buttonFristEvent(clickedFirstButton, clickedMiddleButton, clickedLastButton);
}
buttonDriverFlag = true;
return;
}
if (analogRead(BTN_SET_MIDDLE) >= 128) {
if (!buttonDriverFlag) {
tone(SIGNAL, 1700, 50);
clickedMiddleButton++;
buttonMiddleEvent(clickedFirstButton, clickedMiddleButton, clickedLastButton);
}
buttonDriverFlag = true;
return;
}
if (analogRead(BTN_SET_BOTTOM) >= 128) {
if (!buttonDriverFlag) {
tone(SIGNAL, 1700, 50);
clickedLastButton++;
buttonLastEvent(clickedFirstButton, clickedMiddleButton, clickedLastButton);
}
buttonDriverFlag = true;
return;
}
buttonDriverFlag = false;
}
}
```
Отрисовка на семисигментном индикаторе
```
/*
* A
* @@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@
* @@ @@
* @@@ @@@
* @@@ @@@
* @@@ @@@
* @@@ F @@@ B
* @@@ @@@
* @@@ @@
* @@@ @@@
* @@ G @@@
* @@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@
* @@ @@@
* @@@ @@@
* @@@ @@@
* @@ @@@
* @@@ E @@@ C
* @@@ @@@
* @@ @@@
* @@@ @@@
* @@@ D @@@
* @@@@@@@@@@@@@@@@@@ @@
* @@@@@@@@@@@@@@@@@ @@ DP
*
*
*/
// Состояние
int valueRenderRow[4][8] = {
{ 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0 }
};
// Состояние двоеточия
boolean dotShow = false;
// Отрисовывет отдельный символ
void view (int* symbol, int offset) {
digitalWrite(A, 0);
digitalWrite(B, 0);
digitalWrite(C, 0);
digitalWrite(D, 0);
digitalWrite(E, 0);
digitalWrite(F, 0);
digitalWrite(G, 0);
digitalWrite(DP, 0);
digitalWrite(ST_CP, 0);
for (int i = 0; i < 8; i++) {
digitalWrite(SH_CP, 0);
digitalWrite(DS, 1);
digitalWrite(SH_CP, 1);
}
digitalWrite(ST_CP, 1);
delayMicroseconds(1000);
for (int r = 0; r < 10; r++) {
digitalWrite(A, symbol[0]);
digitalWrite(B, symbol[1]);
digitalWrite(C, symbol[2]);
digitalWrite(D, symbol[3]);
digitalWrite(E, symbol[4]);
digitalWrite(F, symbol[5]);
digitalWrite(G, symbol[6]);
digitalWrite(DP, symbol[7]);
if (dotShow && offset == 4) {
digitalWrite(DP, 1);
} else {
digitalWrite(DP, 0);
}
digitalWrite(ST_CP, 0);
for (int i = 0; i < 8; i++) {
digitalWrite(SH_CP, 0);
digitalWrite(DS, i != offset);
digitalWrite(SH_CP, 1);
}
digitalWrite(ST_CP, 1);
}
delayMicroseconds(1000);
}
// Отрисовывет символы
void viewDriver () {
int OFFSET_0 = 6;
int OFFSET_1 = 4;
int OFFSET_2 = 3;
int OFFSET_3 = 5;
if (delayRenderRowFirst.isExpired()) {
view(valueRenderRow[0], OFFSET_0);
}
if (delayRenderRowTwo.isExpired()) {
view(valueRenderRow[1], OFFSET_1);
}
if (delayRenderRowThree.isExpired()) {
view(valueRenderRow[2], OFFSET_2);
}
if (delayRenderRowFour.isExpired()) {
view(valueRenderRow[3], OFFSET_3);
}
}
// Контроллер управляющий символами
void viewController (int offset, String symbol) {
String viewSymbol = "00000000";
if (symbol[0] == '0') { viewSymbol = "11111100"; }
if (symbol[0] == '1') { viewSymbol = "01100000"; }
if (symbol[0] == '2') { viewSymbol = "11011010"; }
if (symbol[0] == '3') { viewSymbol = "11110010"; }
if (symbol[0] == '4') { viewSymbol = "01100110"; }
if (symbol[0] == '5') { viewSymbol = "10110110"; }
if (symbol[0] == '6') { viewSymbol = "10111110"; }
if (symbol[0] == '7') { viewSymbol = "11100000"; }
if (symbol[0] == '8') { viewSymbol = "11111110"; }
if (symbol[0] == '9') { viewSymbol = "11110110"; }
if (symbol[0] == ' ') { viewSymbol = "00000000"; }
if (symbol[0] == '_') { viewSymbol = "00010000"; }
if (symbol[0] == 'a') { viewSymbol = "11101110"; }
if (symbol[0] == 'b') { viewSymbol = "00111110"; }
if (symbol[0] == 'c') { viewSymbol = "00011010"; }
if (symbol[0] == 'd') { viewSymbol = "01111010"; }
if (symbol[0] == 't') { viewSymbol = "00011110"; }
if (symbol[0] == 'e') { viewSymbol = "10011110"; }
if (symbol[0] == 'f') { viewSymbol = "10001110"; }
if (symbol[0] == 'g') { viewSymbol = "11110110"; }
if (symbol[0] == 'h') { viewSymbol = "00101110"; }
if (symbol[0] == 'i') { viewSymbol = "00001100"; }
if (symbol[0] == 'j') { viewSymbol = "01111000"; }
if (symbol[0] == 'k') { viewSymbol = "01101110"; }
if (symbol[0] == 'l') { viewSymbol = "00011100"; }
if (symbol[0] == 'm') { viewSymbol = "00101010"; }
if (symbol[0] == 'n') { viewSymbol = "00101010"; }
if (symbol[0] == 'o') { viewSymbol = "00111010"; }
if (symbol[0] == 'p') { viewSymbol = "11001110"; }
if (symbol[0] == 'q') { viewSymbol = "11100110"; }
if (symbol[0] == 'r') { viewSymbol = "11001100"; }
if (symbol[0] == 's') { viewSymbol = "10110110"; }
if (symbol[0] == 't') { viewSymbol = "00011110"; }
if (symbol[0] == 'u') { viewSymbol = "00111000"; }
if (symbol[0] == 'v') { viewSymbol = "01111100"; }
if (symbol[0] == 'w') { viewSymbol = "00111000"; }
if (symbol[0] == 'x') { viewSymbol = "01101110"; }
if (symbol[0] == 'x') { viewSymbol = "01101110"; }
if (symbol[0] == 'y') { viewSymbol = "01110110"; }
if (symbol[0] == 'z') { viewSymbol = "11011010"; }
for (int i = 0; i < 8; i++) {
valueRenderRow[offset][i] = String(viewSymbol[i]).toInt();
}
}
// Контроллер отвечающий за двоеточие
void viewControllerDot (boolean isShow) {
dotShow = isShow;
}
```
Анимации переходов
```
// Состояние переходов анимации
float animationTicker = -1;
// Звук в анимации
int animationSound = true;
// Сообщение анимации
String animationMessage = "";
// Последнее отрисовоное состояние, так как я не понял как
// работают коллбеки и есть ли они вообще, я придумал свой способ
// тут я храню то что было отрисованно в основном стейте чтобы показать его после анимации
int animationSaveValueRow[4][8] = {
{ 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0 }
};
// Сохраняем основное состояние
void animationSaveState () {
for (int y = 0; y < 4; y++) {
for (int x = 0; x < 8; x++) {
animationSaveValueRow[y][x] = valueRenderRow[y][x];
}
}
}
// Восстанавливаем состояние
void animationPushState () {
for (int y = 0; y < 4; y++) {
for (int x = 0; x < 8; x++) {
valueRenderRow[y][x] = animationSaveValueRow[y][x];
}
}
}
// Отрисовывем анимацию
void animationDriver () {
if (delayAnimaton.isExpired()) {
if (animationTicker != -1) {
animationTicker += 0.2;
}
if (animationTicker > 32 || (animationMessage.length() == 0 && animationTicker > 16)) {
animationPushState();
animationTicker = -1;
return;
}
if (animationTicker == -1) {
return;
}
viewController(0, String(' '));
viewController(1, String(' '));
viewController(2, String(' '));
viewController(3, String(' '));
if (animationSound) {
if (int(animationTicker) > 23) {
tone(SIGNAL, (100 * (int(animationTicker) + 1) + 500), 50);
} else {
if (int(animationTicker) % 23) {
tone(SIGNAL, (20 * (int(animationTicker) + 1) + 500), 50);
} else {
noTone(SIGNAL);
}
}
}
if (animationMessage.length() != 0 && int(animationTicker) > 8 && int(animationTicker) < 24) {
for (int x = 0; x < 4; x++) {
viewController(x, String(animationMessage[x]));
}
return;
} else {
if (int(animationTicker) % 8 < 4) {
viewController(int(animationTicker) % 4, String('0'));
return;
} else {
viewController(int(animationTicker) % 4, String(' '));
return;
}
}
}
}
// Контроллируем состояние анимации
void animationController (boolean isSound, String message) {
animationSaveState();
animationMessage = message;
animationSound = isSound;
animationTicker = 0;
}
```
**Виджеты**
Время
```
// Изначательное время
int timeTicker[4] = { 1,2,4,8 };
// Счетчик секунд
int timeSecond = 0;
// Последнее время внутреннего счетчика микроконтроллера
uint32_t timeDelta;
// Флаг включающий и отключающий виджет
boolean timeShow = false;
// Управление виджетом
void timeController (boolean isShow) {
timeShow = isShow;
viewControllerDot(isShow);
}
// Управление состоянием виджета
void timeTickerController (int offset, int n) {
if (offset == 0) {
timeTicker[0] += n;
if (timeTicker[0] > 2) {
timeTicker[0] = 0;
}
if (timeTicker[0] < 0) {
timeTicker[0] = 2;
}
}
if (offset == 1) {
timeTicker[1] += n;
if (timeTicker[0] < 2) {
if (timeTicker[1] < 0) {
timeTicker[1] = 9;
}
if (timeTicker[1] > 9) {
timeTicker[1] = 0;
}
} else {
if (timeTicker[1] < 0) {
timeTicker[1] = 3;
}
if (timeTicker[1] > 3) {
timeTicker[1] = 0;
}
}
}
if (offset == 2) {
timeTicker[2] += n;
if (timeTicker[2] > 5) {
timeTicker[2] = 0;
}
if (timeTicker[2] < 0) {
timeTicker[2] = 5;
}
}
if (offset == 3) {
timeTicker[3] += n;
if (timeTicker[3] > 9) {
timeTicker[3] = 0;
}
if (timeTicker[3] < 0) {
timeTicker[3] = 9;
}
}
}
// Отвечает за ход времени
void timeDriver () {
if (timeShow && millis() - timeDelta >= 1000) {
timeDelta = millis();
timeSecond++;
viewControllerDot(timeSecond % 2 == 0);
if (timeSecond > 59) {
timeSecond = 0;
timeTicker[3]++;
if (timeTicker[3] > 9) {
timeTicker[3] = 0;
timeTicker[2]++;
if (timeTicker[2] > 5) {
timeTicker[2] = 0;
timeTicker[1]++;
if ((timeTicker[0] < 2 && timeTicker[1] > 9) || (timeTicker[0] == 2 && timeTicker[1] > 3)) {
timeTicker[1] = 0;
timeTicker[0]++;
if (timeTicker[0] > 2) {
timeTicker[0] = 0;
}
}
}
}
}
viewController(0, String(timeTicker[0]));
viewController(1, String(timeTicker[1]));
viewController(2, String(timeTicker[2]));
viewController(3, String(timeTicker[3]));
}
}
```
Таймер
```
// Изначальное время
int timerTicker[4] = { 0, 0, 3, 0 };
// Счетчик секунд
int timerSecond = 59;
// Последнее время внутреннего счетчика микроконтроллера
uint32_t timerDelta;
// Флаг включающий и отключающий виджет
boolean timerShow = false;
// Управление виджетом
void timerController (boolean isShow) {
timerShow = isShow;
viewControllerDot(isShow);
}
// Управление состоянием виджета
void timerTickerController (int offset, int n) {
if (offset == 0) {
timerTicker[0] += n;
if (timerTicker[0] > 2) {
timerTicker[0] = 0;
}
if (timerTicker[0] < 0) {
timerTicker[0] = 2;
}
}
if (offset == 1) {
timerTicker[1] += n;
if (timerTicker[0] < 2) {
if (timerTicker[1] < 0) {
timerTicker[1] = 9;
}
if (timerTicker[1] > 9) {
timerTicker[1] = 0;
}
} else {
if (timerTicker[1] < 0) {
timerTicker[1] = 3;
}
if (timerTicker[1] > 3) {
timerTicker[1] = 0;
}
}
}
if (offset == 2) {
timerTicker[2] += n;
if (timerTicker[2] > 5) {
timerTicker[2] = 0;
}
if (timerTicker[2] < 0) {
timerTicker[2] = 5;
}
}
if (offset == 3) {
timerTicker[3] += n;
if (timerTicker[3] > 9) {
timerTicker[3] = 0;
}
if (timerTicker[3] < 0) {
timerTicker[3] = 9;
}
}
}
// Отвечает за обратный отсчет
void timerDriver () {
if (timerShow && millis() - timerDelta >= 1000) {
timerDelta = millis();
timerSecond--;
viewControllerDot(timerSecond % 2 == 0);
if (timerSecond < 0) {
timerSecond = 60;
timerTicker[3]--;
if (timerTicker[3] < 0) {
timerTicker[3] = 9;
timerTicker[2]--;
if (timerTicker[2] < 0) {
timerTicker[2] = 5;
timerTicker[1]--;
if (timerTicker[1] < 0) {
timerTicker[1] = 9;
timerTicker[0]--;
if (timerTicker[0] < 0) {
timerTicker[0] = 0;
}
}
}
}
}
viewController(0, String(timerTicker[0]));
viewController(1, String(timerTicker[1]));
viewController(2, String(timerTicker[2]));
viewController(3, String(timerTicker[3]));
if (
timerTicker[0] == 0 &&
timerTicker[1] == 0 &&
timerTicker[2] == 0 &&
timerTicker[3] == 0
) {
timerController(false);
viewControllerDot(false);
animationController(true, "end");
}
}
}
```
Минутный таймер
```
// Изначальное время
int mTimerTicker[4] = { 0, 0, 0, 5 };
// Последнее время внутреннего счетчика микроконтроллера
uint32_t mTimerDelta;
// Флаг включающий и отключающий виджет
boolean mTimerShow = false;
// Управление виджетом
void mTimerController (boolean isShow) {
mTimerShow = isShow;
viewControllerDot(isShow);
}
// Управление состоянием виджета
void mTimerTickerController (int offset, int n) {
if (offset == 0) {
mTimerTicker[0] += n;
if (mTimerTicker[0] > 5) {
mTimerTicker[0] = 0;
}
if (mTimerTicker[0] < 0) {
mTimerTicker[0] = 5;
}
}
if (offset == 1) {
mTimerTicker[1] += n;
if (mTimerTicker[1] > 9) {
mTimerTicker[1] = 0;
}
if (mTimerTicker[1] < 0) {
mTimerTicker[1] = 9;
}
}
if (offset == 2) {
mTimerTicker[2] += n;
if (mTimerTicker[2] > 5) {
mTimerTicker[2] = 0;
}
if (mTimerTicker[2] < 0) {
mTimerTicker[2] = 5;
}
}
if (offset == 3) {
mTimerTicker[3] += n;
if (mTimerTicker[3] > 9) {
mTimerTicker[3] = 0;
}
if (mTimerTicker[3] < 0) {
mTimerTicker[3] = 9;
}
}
}
// Отвечает за обратный отсчет
void mTimerDriver () {
if (mTimerShow && millis() - mTimerDelta >= 1000) {
mTimerDelta = millis();
mTimerTicker[3]--;
viewControllerDot(mTimerTicker[3] % 2 == 0);
if (mTimerTicker[3] < 0) {
mTimerTicker[3] = 9;
mTimerTicker[2]--;
if (mTimerTicker[2] < 0) {
mTimerTicker[2] = 5;
mTimerTicker[1]--;
if (mTimerTicker[1] < 0) {
mTimerTicker[1] = 9;
mTimerTicker[0]--;
if (mTimerTicker[0] < 0) {
mTimerTicker[0] = 5;
}
}
}
}
viewController(0, String(mTimerTicker[0]));
viewController(1, String(mTimerTicker[1]));
viewController(2, String(mTimerTicker[2]));
viewController(3, String(mTimerTicker[3]));
if (
mTimerTicker[0] == 0 &&
mTimerTicker[1] == 0 &&
mTimerTicker[2] == 0 &&
mTimerTicker[3] == 0
) {
mTimerController(false);
viewControllerDot(false);
animationController(true, "end");
}
}
}
```
Игра
```
// Изначальное состояние
int gameUnLockerData[4] = { 0,0,0,0 };
// Состояние измененное случайным образом
int gameUnLockerHiddenData[4] = {
random(0, 9),
random(0, 9),
random(0, 9),
random(0, 9)
};
// Флаг включающий и отключающий виджет
boolean gameUnLockerShow = false;
// Управление виджетом
void gameUnLockerController (boolean isShow) {
gameUnLockerShow = isShow;
}
// Управление состояние виджета
void gameUnLockerPlayerController (int offset, int n) {
if (offset == 0) {
gameUnLockerData[0] += n;
if (gameUnLockerData[0] > 9) {
gameUnLockerData[0] = 0;
}
if (gameUnLockerData[0] < 0) {
gameUnLockerData[0] = 9;
}
}
if (offset == 1) {
gameUnLockerData[1] += n;
if (gameUnLockerData[1] > 9) {
gameUnLockerData[1] = 0;
}
if (gameUnLockerData[1] < 0) {
gameUnLockerData[1] = 9;
}
}
if (offset == 2) {
gameUnLockerData[2] += n;
if (gameUnLockerData[2] > 9) {
gameUnLockerData[2] = 0;
}
if (gameUnLockerData[2] < 0) {
gameUnLockerData[2] = 9;
}
}
if (offset == 3) {
gameUnLockerData[3] += n;
if (gameUnLockerData[3] > 9) {
gameUnLockerData[3] = 0;
}
if (gameUnLockerData[3] < 0) {
gameUnLockerData[3] = 9;
}
}
}
// Обработка состояния виджета
void gameUnLockerDriver () {
if (gameUnLockerShow) {
if (
gameUnLockerData[0] == gameUnLockerHiddenData[0] &&
gameUnLockerData[1] == gameUnLockerHiddenData[1] &&
gameUnLockerData[2] == gameUnLockerHiddenData[2] &&
gameUnLockerData[3] == gameUnLockerHiddenData[3]
) {
viewController(0, String('g'));
viewController(1, String('o'));
viewController(2, String('o'));
viewController(3, String('d'));
} else {
viewController(0, String('b'));
viewController(1, String('a'));
viewController(2, String('d'));
viewController(3, String(' '));
}
}
}
```
Демонстрационная версия
-----------------------
Я искренне надеюсь, что это получился хороший материал для начинающих, пробовать себя в электронике и программировании. Полный код проекта, вы также можете найти на [GitHub](https://github.com/prohetamine/arduino-for-students).
Также, пользуясь случаем, передаю привет своему другу Каро, в гараже которого, было собранно это устройство *осенью 2019 года*. | https://habr.com/ru/post/593421/ | null | ru | null |
# GSM на столе
Разработка под веб: HTTP, HTML, CSS, JavaScript, Python… Ох. Всё одно и то же. Так хочется отвлечься на что-нибудь радикально другое. Я же обитаю в московском хакспейсе [Нейрон](http://neuronspace.ru/)! Почему бы не поспрашивать вокруг?
Например, в Нейроне сидят ребята из компании [Fairwaves](http://www.fairwaves.ru/), разрабатывающие GSM-оборудование для недорогих сотовых сетей. Весь стек — от железа до софта — доступен под open source лицензией. Да, да, включая [железо](http://umtrx.org/). Поэтому совсем не обязательно работать в Fairwaves, чтобы познакомиться с этой технологией. И результат копания можно выложить на GitHub или сделать вклад в [существующий](http://osmocom.org) [проект](http://umtrx.org/). Как минимум, будет чем похвастаться на собеседованиях.
Пара дней чтения документации, пролистывания кода, десятки навязчивых вопросов и экспериментов (спасибо Александру Чемерису и Ивану Ключникову за помощь). И вот результат — собственная GSM-сеть под контролем моего Макбука:
Тестировать сеть пришли постояльцы хакспейса:
О чём они разговаривают?
Как это работает? Вот так:
```
+----------------------------------------+
| Макбук |
| |
| +-------------------------------+ |
| | VirtualBox виртуалка | |
| | | |
| | +----------------------+ | | |
| | | Docker контейнер | | | \ | / |
| | | (Ubuntu 12.04) | | | \ | / |
| | | | | | \ | / |
| | | +-------------+ | | | +----+----+ +-------+
| | | | OpenBSC | | | | | | | |
| | | | (osmo-nitb) |<-------------------------+ базовая | | GSM |
| | | | | | | | | станция | | теле- |
| | | +-------------+ | | | | | | фон |
| | | | | | | | | |
| | +----------------------+ | | +---------+ +-------+
| | | |
| +-------------------------------+ |
| |
+----------------------------------------+
```
На компьютере работаёт VirtualBox c Ubuntu, на котором запущен [Docker](https://docker.io/) контейнер c Ubuntu 12.04 и open source контроллером базовых станций [OpenBSC](http://openbsc.osmocom.org/) (Base Station Controller, BSC). В моём случае OpenBSC работает в режиме [network-in-the box](http://openbsc.osmocom.org/trac/wiki/osmo-nitb) и включает в себя не только BSC, но и простую реализацию всех остальных компонентов, нужных для небольшой GSM-сети ([MSC, HLR, VLR, AuC](https://ru.wikipedia.org/wiki/GSM_core_network) и [SMSC](https://ru.wikipedia.org/wiki/SMS-%D1%86%D0%B5%D0%BD%D1%82%D1%80)).
К контроллеру по локальной сети подключается базовая станция Fairwaves UmSITE, на котором крутится [OsmoBTS](http://openbsc.osmocom.org/trac/wiki/OsmoBTS) — open source реализация базовой станции GSM (Base Transceiver Station, BTS):
Для запуска GSM-сети достаточно одной (!) команды:
```
docker run -v $HOME/db:/var/db -i -t -p 3002:3002 -p 3003:3003 -p 30000:30000/udp -p 30001:30001/udp -p 30002:30002/udp -p 30003:30003/udp -p 30004:30004/udp -p 30005:30005/udp -p 30006:30006/udp -p 30007:30007/udp shamrin/osmonitb start-nitb -i 10.0.0.10 -n HabraFon GSM1800 10 20
```
(Нет Докера? [Установите](https://docker.io/) его. У вас не Ubuntu и Докер не ставится? Тогда cмотрите ниже.)
`10.0.0.10` нужно заменить на сетевой адрес Docker хоста (ifconfig). А `10` и `20` на используемые номера каналов, [ARFCN](https://en.wikipedia.org/wiki/Absolute_radio-frequency_channel_number). Какие каналы указывать, спросите вы? Это сложный вопрос. На частотах GSM нельзя ничего излучать без лицензии, не зависимо от мощности. А простым смертным лицензию получить невозможно. Остаются следующие варианты:
1. Тестировать в [клетке Фарадея](https://ru.wikipedia.org/wiki/%D0%9A%D0%BB%D0%B5%D1%82%D0%BA%D0%B0_%D0%A4%D0%B0%D1%80%D0%B0%D0%B4%D0%B5%D1%8F). Если нет клетки Фарадея подходящих размеров, сымитировать ее в глухом подвале, где не ловит сотовая сеть и где нет риска помешать сотовым операторам (и они не помешают вам). В этом случае весь радиочастотный спектр в вашем распоряжении и можно указать любую пару чисел в диапазоне от 512 до 885 с разницей не меньше чем в 2-3 канала (лучше в 10 каналов). Например, 600 и 700.
2. Под присмотром квалифицированного специалиста найти пару неиспользуемых каналов и указать эти каналы при запуске. Например, с помощью телефона, умеющего сканировать эфир, такого как Sagem OT. Еще раз, под присмотром квалифицированного специалиста!
Информацию о других параметрах контейнера и команды `start-nitb` смотрите в [моём репозитарии](https://github.com/shamrin/osmonitb-docker).
**А если у меня не Ubuntu?**
Если у вас нет Ubuntu 12.04+, установите [Vagrant](http://www.vagrantup.com/) и [VirtualBox](https://www.virtualbox.org/) и запустите виртуалку Ubuntu + Docker с помощью этих команд:
```
git clone https://github.com/shamrin/osmonitb-docker
cd osmonitb-docker
vagrant up
vagrant ssh
```
**Почему Docker?**
Да, Docker использовать не обязательно. Можно и руками всё [поставить](http://openbsc.osmocom.org/trac/wiki/network_from_scratch) и [настроить](http://umtrx.org/applications/osmocom/). Но, во-первых, мне хотелось поэкспериментировать с Docker. Во-вторых, с ним можно надёжно завернуть, а потом повторить конфигурацию всей машины (debian-пакеты, вручную установленные программы, файлы конфигурации). В-третьих, список из десятков команд и манипуляций заменяется на одну — `docker run …`.
**Почему не OpenBTS?**
Кроме описанных проектов Osmocom (OpenBSC, OsmoBTS, [OsmoTRX](http://openbsc.osmocom.org/trac/wiki/OsmoTRX)) есть другая open source реализация GSM протоколов — [OpenBTS](http://openbts.org/). Возраст обоих проектов примерно одинаков, но OpenBTS более известен в интернете благодаря чуть большей дружелюбности к новичкам. Если не вникать в технические различия, то в реальных условиях Osmocom [работает лучше](https://fairwaves.ru/wp/telecom-revolution-starts-in-yaviche-mexico/):
> We started using Osmocom software at the beginning of this year and found that it works much better in real life deployments than OpenBTS. It almost never crashes, has more features, scales better and is more flexible.
>
>
**Где взять оборудование?**
Самый простой вариант для жителей Москвы — пользоваться оборудованием в [хакспейсе Нейрон](http://neuronspace.ru/) :)
Если вы живёте не в Москве или просто хотите иметь оборудование, чтобы поиграть с GSM у себя дома, есть две сравнительно недорогих альтернативы для лабораторного применения:
* Ettus Research [USRP](https://www.ettus.com/product/category/USRP-Bus-Series) разных версий
* Fairwaves [UmTRX](http://shop.fairwaves.ru/accessories-and-diy/UmTRX-transceiver-for-OpenBTS-and-Osmocom-OpenBSC)
По возможностям они приблизительно близки, но у UmTRX есть преимущества:
* все схемы платы и исходные коды софта доступны под open source лицензией
* дешевле, чем аналогичная конфигурация на USRP
* плата может работать с двумя независимыми каналами, в то время как USRP имеют только один канал
* GPS для точной подстройки опорного генератора частоты уже встроен, а не закупается отдельно, как в USRP (плавающая частота генератора приводит в GSM к [неожиданным проблемам](https://wush.net/trac/rangepublic/wiki/Clocks))
* поддержка российского производителя (и не надо платить таможне)
Если хочется немного сэкономить и не страшны проблемы с опорным генератором, то можно использовать USRP B200. У неё всего один канал, но для домашних экспериментов это не принципиально. Опорный генератор у USRP B200 не соответствует по точности стандарту GSM, но в большинстве случаях его хватает для простой работы «на столе». С USRP B200 могут возникнут проблемы при [хэндовере](https://ru.wikipedia.org/wiki/%D0%A5%D1%8D%D0%BD%D0%B4%D0%BE%D0%B2%D0%B5%D1%80) от одной вашей базовой станции к другой, но вы же не планируете строить подноценную сеть на коленке, правда?
Но я могу быть необъективным, проверяйте сами.
**Спасибо** Андрею Бахмату, Ивану Ключникову, Павлу Труханову, Александру Чемерису и другим участникам хакспейса за комментарии к черновикам этого текста. | https://habr.com/ru/post/213845/ | null | ru | null |
# Ломаем датчик утечки газа
 Ежегодно в России из-за утечки бытового газа происходят десятки взрывов. В частности, грустный рекорд был отмечен в 2008 году, когда только в январе произошло 7 [мощнейщих взрывов](http://vz.ru/information/2009/2/10/254968.html), в которых пострадали и погибли люди. О [разрушениях](http://habrastorage.org/files/4e7/589/2b1/4e75892b1b944ef3a9b3cfef4ba2983e.png) и убытках я уже и не говорю. И это только случаи, которые попали в ленту федеральных новостей. На самом деле, утечек газа значительно больше. Изношенность оборудования, неаккуратность и безответственность — главные причины подобных трагедий. Их может быть меньше, если активнее внедрять системы контроля утечек газа, реализованных на недорогих электрохимических сенсорах. Одно из таких устройств попало мне в руки. Статья посвящена анализу девайса и возможных неспортивных способов его использования. Однако, главную функцию устройство выполняет всецело, поэтому после технических издевательств оно будет дополнительно протестировано в биогазовой лаборатории, о которой можно прочесть [здесь](http://habrahabr.ru/post/226953/), и затем подарено Матушке, у которой всю жизнь на кухне газ).
Внимание! Возрастное ограничение статьи 18+
#### А у нас в квартире газ! А у вас?
На самом деле газ является одним из самых удобных в использовании вещей. Профессиональные повара предпочитают готовить именно на газовых плитах. Это быстро, удобно, экономичнее, а мясо и хорошие стейки, пожалуй, можно приготовить только на огне. Газ обогревает миллионы людей, а современное газовое оборудование является надежным и безопасным при условии, что вы внимательно следите и правильно его эксплуатируете. Даже я при своем не плохом уровне понимания техники с интересом изучал устройство газового бойлера именно с точки зрения безопасности. Да, действительно, такие девайсы надежны.
Этот простенький рисунок показывает общий принцип действия прибора, конструкция же на самом деле достаточно не простая. Что обязательно в каждом такой устройстве — контроль расхода газа и горения пламени. Для его контроля используют инфракрасные датчики, а при малейших перебоях в подаче газа автоматика надежно отключает устройство. Газовое оборудование обязано быть установлено только специалистами газовой службы и его необходимо регулярно проверять.
При всей надежности оборудования нельзя исключать вероятности утечек газа. Для контроля таких утечек в газ добавляют специальные пахучие вещества — одоранты. Их задача — создание пахучести, что необходимо для установления утечек газа главным образом в бытовом потреблении. Для придания газу необходимого уровня запаха установлены нормы внесения одорантов по этилмеркаптану не менее 16 г/100 м3 газа. Это чрезвычайно токсичные и летучие вещества с омерзительным запахом. Именно этот запах человек расценивает как утечку газа, при этом сам природный газ не имеет цвета и запаха.
#### Контролируем утечки
Утечка газа может случиться по разным причинам, но в большинстве случаев это происходит из-за халатности человека. Сбежало молоко, убавили газ на плите и он потух, часто с газом балуются маленькие дети. Могут быть скачки магистрального давления в газовой трубе из-за перемерзания газовых труб в сильные морозы, так как в них может скапливаться конденсат. Поэтому полезно иметь датчик утечки газа, который может оповестить людей об утечке, к примеру, дополнительным звуковым сигналом. Одно из таких устройств [(ссылка)](http://dadget.ru/katalog/bezopasnost/signalizator-utechki-gaza/?utm_source=habrahabr.ru&utm_medium=referral&utm_campaign=MT8055) мне попалось на изучение.
Девайс внешне сделан из хорошего пластика, нанесена шелкография, однако все надписи на английском языке. Сделано, конечно, в любимом Китае. Устройство подключается непосредственно в розетку и не требует батареек. Потребление мизерное (думаю несколько ватт), поэтому намотать много электроэнергии оно не в состоянии. Толково продуман дизайн с точки зрения газовой кюветы. Устройство имеет специальные вырезы, чтобы воздух проникал свободнее. Однако, для установки устройства лучше воспользоваться коротким удлинителем и спозиционировать его так, как сказано в инструкции — для природного магистрального газа ближе к потолку (метан легче воздуха), а если вы используете сжиженный газ или пропановые баллоны — к полу, так как этот газ тяжелее воздуха и стелется низом. При включении устройство издает короткий сигнал и начинает калиброваться. Этот процесс занимает несколько минут. В это время ничего не происходит и только мигает прочерк на цифровом индикаторе. Когда устройство откалибровалось, на экране появляется ноль. Калибровка важный момент и то, что она есть очень хорошо. Так как используется интегральный датчик, то устройство за ноль принимает уровень газового состояния в момент калибровки, что снижает вероятность ложных срабатываний. Это удобно, к примеру, на кухне, когда в любом случае при поджоге газа имеется кратковременная его утечка и откалибровать устройство лучше при всех включенных конфорках и духовке и через несколько минут включить датчик утечек газа для калибровки, чтобы устройство поняло «рабочий» уровень состава воздуха и не пикало, когда не нужно. Устройство было испытано в боевых условиях в моей биогазовой лаборатории, о которой я рассказывал в своем посте [«Биогаз из биомасс»](http://habrahabr.ru/post/226953/) и дома у Матушки, у которой газ всю жизнь. Кстати, подобные датчики очень полезны именно в старых домах, где установлено доисторическое газовое оборудование. Я, конечно, неоднократно пытался заменить плиту, но это не так просто. Мама, старая закалка, маленькая кухня. Поэтому в большинстве старых квартир стоят такие вот маленькие плиты, хотя сделаны они очень добротно. Еще при Сталине)
**Видео с испытанием устройства на кухне с газовой плитой**Устройство расположено ближе к полу, так как в этом случае в квартиру подается пропан, который при утечке стелется низом.
Газ — не игрушка. Не повторяйте таких экспериментов сами! А если не сдержались, то не забудьте проветрить помещение и выключить газ!
#### Вскрытие устройства
Конечно, я вскрыл устройство для детального его изучения. Это не составило много труда, так как в нем нет никаких защелок, всё на саморезах.
Сделано устройство трудолюбивыми китайскими девушками (юношами), спаяно вручную и даже не отмыто от канифоли. Однако, все сделано добротно и даже проверено китайским ОТК). Конечно, для меня было интересно, на каком датчике сделано устройство и как запилено по схеме. Априори я полагал, что устройство использует датчик серии MQ и не ошибся. Никаких более знакомых мне деталей (я говорю о контроллерах, конечно) я не обнаружил. В устройстве поставлены загадочные китайские микросхемы, а само устройство спроектировано с явной избыточностью. Ведь датчик серии MQ можно запустить на копеечной Attiny или ATmega за несколько микросекунд. А если завалялась ардуинка, то ещё быстрее. Подключаем сигнальный вывод датчика к любому аналоговому порту, к примеру А0, подаем питание и через минуту получаем данные):
```
int sensorValue;
void setup()
{
Serial.begin(9600); // портец то откроем
}
void loop()
{
sensorValue = analogRead(0); // че он там нам меряет то?
Serial.println(sensorValue, DEC); // давай уже цифирь на экран, не стесняйся!
delay(1000); // курим 1 сек, чтоб датчик очухался
}
```
Это даже кодом не назвать. Кстати, ардуинщики молодцы, на сайте очень добросовестно всё про эти датчики собрали. [Ссылка](http://playground.arduino.cc/Main/MQGasSensors).
Но вернемся к нашему исследуемому устройству. Скорей всего, схема спроектирована так, чтобы её использовать в различных датчиках и приборах, путем замены сенсора и перепрошивки. Нормально! Все остальное стандартно. Я, конечно, поставил бы дополнительно предохранитель в цепи блока питания, но это скорей для трусов, нежели для смелых китайских инженеров. Ещё в устройстве меня удивил сигнализатор на 85 Дб. Аккуратно подлит жидкими гвоздями у датчика газа.
Может 85 Дб там и нет, но пищит он громко и довольно противно. Таким образом, оповещение в устройстве реализовано добротно. Кстати, громкая сирена включается не сразу. Устройство сначала начинает пикать, когда показание на экране становятся более трех единиц, а если более 9 — включается громкая сирена. По типу автомобильной. Пожалуй, её могут даже услышать соседи.
Немного о датчике газа. Такой же у меня оказался в коллекции. Это датчик серии MQ фирмы Henan Hanwei Electronics. Популярный датчик из серии электрохимических датчиков, технология изготовления которых хорошо отработана. [Принцип](http://eldigi.ru/articles/datchik_utechki_gaza_na_mikrokontrollere) работы датчика обнаружения газа основан на свойстве изменения проводимости тонкопленочного слоя диоксида олова SnO2 при контакте его с определяемым газом. Чувствительность к разного рода газам достигается путем легирования различных примесей в чувствительный слой датчика. Сам чувствительный элемент датчика состоит из керамической микротубы с покрытием Al2O3 и нанесенного на неё чувствительного слоя диоксида олова. Внутри тубы проходит нагревательный элемент, который нагревает чувствительный слой до температуры, при которой он начинает реагировать на определяемый газ. При попадании газа в датчик, происходит абсорбция газа и в следствие чего сопротивление датчика падает. За пару сотен рублей можно приобрести [на выбор](http://www.ebay.com/itm/MQ-2-MQ-3-MQ-4-MQ-5-MQ-6-MQ-7-MQ-8-MQ-135-5V-DC-Smoke-LPG-Butane-Gas-Sensor-/371212878284?tfrom=131377004613&tpos=top&ttype=coupon&talgo=undefined) нужный из датчиков серии MQ.
Для работы датчика необходим нагрев. Однако, это всё миниатюрное, поэтому ощутимого нагрева сенсора вы не почувствуете. Сигнал, конечно, аналоговый. Датчики надежны и вполне долговечны, если их не использовать в агрессивных условиях. Хорошее быстродействие, короткое время восстановления. Однако, у таких датчиков не очень хорошая селективность, а также им требуется калибровка. Но это дает возможность позабавиться с ним не стандартно!
#### Не спортивное использование. 18+
Такое использование случилось благодаря дню рождения одного из сотрудников, которое мы решили слегка отметить в узком кругу. Собрались в небольшой переговорной комнате к концу рабочего дня. Компания из четырех человек выпивала коньяк. Примерно через час в помещении, где в этот момент уже было прилично выпито спиртного, начали раздаваться сигналы устройства, которое было включено в розетку. Это взбодрило присутствующих. Однако, любое приближение выпившего человека с желанием подуть на девайс мгновенно вызывало сирену и бурный смех. Таким образом, из устройства можно сделать и алкотестер. Это неудивительно. Датчики серии MQ в бОльшей или меньшей степени чувствительны к разным газам. Это хорошо иллюстрирует график чувствительности датчиков для различных газов.
Позже было выяснено, что 50 грамм крепкого спиртного (коньяка) в течение 3-4 часов вызывает сирену при выдохе в течение 5 секунд на датчик устройства.
Теперь о курении. Так как в табачном дыму уже запредельная концентрация СО, устройство мгновенно реагирует на табачный дым. Поэтому в курилке буквально через минуту включается сирена. Также был проведен эксперимент с курящими и некурящими сотрудниками. Продувка через трубочку 10 секунд.
Эталоном некурящего человека была выбрана замечательная девушка с красивым именем Люсьена, которой не удавалось выдуть более 2 единиц на устройстве. Курильщик выдувает 8-9 единиц. Буквально драконий выхлоп.
#### Выводы
Устройство рабочее. Из хорошего — отличный дизайн, надежность. Думаю, [купив](http://dadget.ru/katalog/bezopasnost/signalizator-utechki-gaza/?utm_source=habrahabr.ru&utm_medium=referral&utm_campaign=MT8055) такое устройство, можно сделать оригинальный не шаблонный подарок для того, кто использует газ на кухне или отапливает им дом. Малое потребление энергии. Очень высокая чувствительность. Сирена на всю катушку включается при концентрациях более 0,2% от взрывоопасной. Есть достаточное количество времени отреагировать на утечку газа. С другой стороны — слабая селективность. Устройство может давать ложные срабатывания. Также необходимо внимательно отнестись к месту установки. Конечно, хотелось бы иметь беспроводной протокол передачи данных с устройства, было бы куда интересней. Ну а в целом девайс, безусловно, полезный.
А вы не забыли, уходя из дома, выключить газ?
Всем хорошего дня!
P.S. — А утюг?
[](https://www.youtube.com/channel/UCGfyfadFbzXxiKyWT8heBCA) | https://habr.com/ru/post/256215/ | null | ru | null |
# Особенности метода xPDOObject::save() + транзакции
Совсем недавно Сергей Прохоров ака [proxyfabio](http://habrahabr.ru/users/proxyfabio/) написал статью [Валидация объектов + транзакции](https://modxclub.ru/topics/validacziya-obektov-tranzakczii-1837.html). Немного эта тема [обсуждалась здесь](https://modx.pro/help/6309/#comment-45051). От себя хочу добавить, что эта тема крайне важная, и на сегодня это одна из самых главных проблем в разработке крупных проектов на MODX Revolution.
*Здесь сразу попрошу не начинать ничего вроде «Если делаете крупные проекты, не надо их делать на MODX, возьмите бла-бла-бла». Мы делали крупные проекты, и не только на MODX. На MODX вполне можно делать крупные проекты, и на сегодня есть всего лишь пара слабых мест, которые мы правим на индивидуальных проектах, в остальном же MODX на 98% пригоден для разработки крупных проектов.*
Итак, одна из этих серьезных проблем связана именно с методом xPDOObject::save() (вызываемая при сохранении xPDO-объектов). Суть этой проблемы в том, что внутри него срабатывает метод сохранения связанных объектов xPDOObject::\_saveRelatedObjects() **дважды**. [Раз](https://github.com/modxcms/revolution/blob/36a662675acdb23d158f9879e16dfc979e56314c/core/xpdo/om/xpdoobject.class.php#L1353) и [два](https://github.com/modxcms/revolution/blob/36a662675acdb23d158f9879e16dfc979e56314c/core/xpdo/om/xpdoobject.class.php#L1503). Делается это для того, чтобы выставить первичные и вторичные ключи для этих связанных объектов (см. [справочный материал](https://ilyaut.ru/xpdo/xpdo-for-dummies-part-4/) от Ильи Уткина). Объясню подробней на примере. Вот код:
```
php
$user_data = array(
"username" = "test",
);
$profile_data = array();
$user = $modx->newObject('modUser', $user_data);
$user->Profile = $modx->newObject('modUserProfile', $profile_data);
$user->save();
print '
```
';
print_r($user->toArray());
print_r($user->Profile->toArray());
```
```
В целом наверняка суть этого кода понятна многим, но давайте сосредоточимся на деталях. Когда мы создали два новых объекта ($user и $user->Profile), у них еще нет айдишников, пока их не сохранили. Но сохранив только объект $user, мы на выходе получаем и сохраненный объект $user->Profile. Это как бы тоже понятно почему, Илья в своей статье все это описывает. Но вопрос, который не совсем на виду болтается — это «как xPDO „знает“ какой id у объекта $user, чтобы назначить этот id в качестве $modx->Profile->internalKey?». Для этого давайте опять-таки пробежимся по коду метода xPDO::save();
Вот у нас [первый вызов метода $user->\_saveRelatedObjects()](https://github.com/modxcms/revolution/blob/36a662675acdb23d158f9879e16dfc979e56314c/core/xpdo/om/xpdoobject.class.php#L1353). В этот момент объект $user еще не сохранен (не записан в базу), id-шника у него еще нет. $user->Profile тоже не сохранен и не имеет ни id, ни internalKey. Переходя к вызову метода $user->\_saveRelatedObjects(), мы видим, что идет [перебор связанных объектов](https://github.com/modxcms/revolution/blob/36a662675acdb23d158f9879e16dfc979e56314c/core/xpdo/om/xpdoobject.class.php#L1521) и [их сохранение](https://github.com/modxcms/revolution/blob/36a662675acdb23d158f9879e16dfc979e56314c/core/xpdo/om/xpdoobject.class.php#L1536) (метод xPDO::\_saveRelatedObject()). Здесь я еще раз уточню, что сохраняем мы объект $user, для которого объект $user->Profile является связанным. И вот здесь-то и получается, что фактически объект $user->Profile сохранится раньше, чем объект $user. Почему? Потому что в вызове $user->\_saveRelatedObject($user->Profile) будет [вызван метод $user->Profile->save()](https://github.com/modxcms/revolution/blob/36a662675acdb23d158f9879e16dfc979e56314c/core/xpdo/om/xpdoobject.class.php#L1585), а так как в текущий момент для $user->Profile нет связанных объектов, то он будет записан в базу данных. И что у нас здесь получается? $user->Profile уже сохранен и у него есть свой id, но id нет у объекта $user (потому что он еще не был сохранен). По этой причине и вторичный ключ $user->Profile->internalKey все еще пустой.
ОК, с этим разобрались, едем дальше. А дальше у нас идет сохранение уже самого объекта $user с записью его в БД и присвоением ему id. Все, запись сделана. Вот теперь у нас у обоих объектов есть эти id-шники, но все еще нет значения $user->Profile->internalKey. Вот как раз для этого и вызывается метод [$user->\_saveRelatedObjects()](https://github.com/modxcms/revolution/blob/36a662675acdb23d158f9879e16dfc979e56314c/core/xpdo/om/xpdoobject.class.php#L1585) еще раз. Теперь, когда будет сохраняться связанный объект $user->Profile, он сможет получить значение $user->id и присвоить его в качестве $user->Profile->internalKey и сохраниться.
Да, я согласен, что все это очень запутанно (а объясняю это еще запутанней), но логика во всем этом есть. И, собственно, именно по этой причине я вижу такое упорное использование MyIsam вместо innoDB. Почему? Да потому что на innoDB это просто не сможет полноценно работать. И вот как раз сейчас мы разберем имеющуюся проблему, а не сам принцип работы. Сразу скажу, что для полного понимания всего этого требуется хорошее понимание MySQL, а именно понимание транзакций, primary и foreign key и т.п.
Давайте настроим нашу базу данных еще правильней, а именно настроим первичные и вторичные ключи на уровне самой базы. Для этого выполним следующее:
**1. Переведем таблицы на движок innoDB.**[](https://habrastorage.org/files/257/fbd/83f/257fbd83f3b949c58afe730cfa7435e5.jpg)
[](https://habrastorage.org/files/9f7/978/683/9f797868368c497b8efb4dd8b934c916.jpg)
2. В таблице modx\_users поле id int(10)unsigned, а в modx\_users\_attributes поле internalKey int(10) (не unsigned). Из-за этого мы просто не сможем настроить вторичный ключ, ибо типы данных в колонках обеих таблиц обязаны полностью совпадать.
**Меняем на unsigned**[](https://habrastorage.org/files/158/3f3/46a/1583f346aff74ad29d493584e4928078.jpg)
**3 Создаем вторичный ключ**[](https://habrastorage.org/files/0c3/56e/89b/0c356e89b04c445d912740937568f018.jpg)
[](https://habrastorage.org/files/afe/b24/4af/afeb244afc84482c9cfd8fe50b0277f2.jpg)
Если при сохранении вторичного ключа вы не получили никаких ошибок, то замечательно! Но есть несколько ошибок, которые вы можете получить. Самые распространенные из них:
1. Типы данных не совпадают.
2. Для вторичной записи не существует первичной (то есть, к примеру, у вас есть запись в modx\_user\_attributes с internalKey = 5, а записи в modx\_users с id = 5 нету).
А теперь давайте посмотрим суть проблемы на примере. Для этого выполним в [консоли](http://modx.com/extras/package/console) следующий код:
```
php
$user_data = array(
"username" = "test_". rand(1,100000),
);
$profile_data = array(
"email" => "test@local.host",
);
$user = $modx->newObject('modUser', $user_data);
$user->Profile = $modx->newObject('modUserProfile', $profile_data);
$user->save();
print '
```
';
print_r($user->toArray());
print_r($user->Profile->toArray());
```
```
Сейчас мы никакой проблемы не увидели, все сохранилось без замечаний. **Примерный вывод при успешном выполнении**
```
Array
(
[id] => 59
[username] => test_65309
[password] =>
[cachepwd] =>
[class_key] => modUser
[active] => 1
[remote_key] =>
[remote_data] =>
[hash_class] => hashing.modPBKDF2
[salt] =>
[primary_group] => 0
[session_stale] =>
[sudo] =>
)
Array
(
[id] => 54
[internalKey] => 59
[fullname] =>
[email] => test@local.host
[phone] =>
[mobilephone] =>
[blocked] =>
[blockeduntil] => 0
[blockedafter] => 0
[logincount] => 0
[lastlogin] => 0
[thislogin] => 0
[failedlogincount] => 0
[sessionid] =>
[dob] => 0
[gender] => 0
[address] =>
[country] =>
[city] =>
[state] =>
[zip] =>
[fax] =>
[photo] =>
[comment] =>
[website] =>
[extended] =>
)
```
А теперь немного изменим наш код:
```
php
$user_data = array(
"username" = "test_". rand(1,100000),
);
$profile_data = array(
"email" => "test@local.host",
);
$user = $modx->newObject('modUser', $user_data);
$user->Profile = $modx->newObject('modUserProfile', $profile_data);
// Заранее установим id первичному объекту. Здесь следует указать свой какой-нибудь id, убедившись, что в БД он не занят.
$user->id = 40;
$user->save();
print '
```
';
print_r($user->toArray());
print_r($user->Profile->toArray());
```
```
Что мы теперь получим при выполнении этого кода?
1. Сообщение об SQL-ошибке
```
Array
(
[0] => 23000
[1] => 1452
[2] => Cannot add or update a child row: a foreign key constraint fails (`shopmodxbox_test2`.`modx_user_attributes`, CONSTRAINT `modx_user_attributes_ibfk_1` FOREIGN KEY (`internalKey`) REFERENCES `modx_users` (`id`))
)
```
2. Оба наши объекта все-таки сохранились и имеют корректные id и internalKey.
Почему так происходит? При сохранении вторичного объекта xPDO [проверяет имеется ли значение первичного ключа](https://github.com/modxcms/revolution/blob/36a662675acdb23d158f9879e16dfc979e56314c/core/xpdo/om/xpdoobject.class.php#L1577-L1585), и только если он есть, тогда уже устанавливает его значение в качестве вторичного ключа и сохраняет этот объект. В нашем случае мы вручную указали первичный ключ id и вторичный объект сумел получить его значение и попытался записаться в базу данных, но так как фактически первичной записи там нет, мы и получаем SQL-ошибку о невозможности записать вторичную запись без первичного объекта. Но сохранение первичного объекта на этом не прерывается. После этого первичный объект $user успешно записывается в базу, а при повторной попытке сохранения связанного объекта $user->Profile уже нормально все сохраняется, так как первичная запись имеется.
**Из всего этого вытекает два заключения.**
1. При сохранении связанных объектов невозможно отследить ошибки сохранения вторичных объектов и как-то на них среагировать. То есть никогда нельзя с уверенностью сказать, по какой причине не был сохранен вторичный объект (то ли нет пока первичного объекта, и он сможет позже записаться при повторном вызове метода xPDOObject::\_saveRelatedObjects(), то ли там какой-нибудь уникальный ключ сконфликтовал и запись в принципе не может быть записана, то ли там валидация на уровне мапы не прошла и т.д. и т.п.).
2. По этой причине невозможно использовать полноценно транзакции.
**Возможный путь решения этой проблемы.**
Мы видим решение этой проблемы в том, чтобы разграничить первый и второй вызов метода xPDOObject::\_saveRelatedObjects() по типам связанных объектов, а именно первый вызов — для первичных объектов, а второй вызов — для вторичных. В таком случае точно не будет путаницы с ключами, и если объект по какой-то причине не сохранился, то это точно будет означать ошибку и можно будет выполнять прерывание процесса сохранения (в том числе и откат транзакций). | https://habr.com/ru/post/265485/ | null | ru | null |
# Делаем многоуровневого бота для ВК с Long Poll VK API, Python, MySQL и решаем вопрос многопоточности c помощью threading
Создание ботов - довольно заезжанная тема, но все уроки, статьи и различного рода документация дают информацию только о том, как построить бота в один уровень без возможности создания древа из различных всплывающих меню (клавиатур).
А это нужно для создания:
* Сложных ботов с несколькими уровнями "глубины" (различные меню/клавиатуры)
* Ботов, созданных одновременно для групповых чатов и для лички сообщества
* Ботов, с повторяющимися ключевыми командами в различных меню, которые необходимо разделять
Можно сделать многоуровневого бота на Python сразу (без, например, библиотеки **threading** и без **базы данных**), но он будет адекватно работать только для одного пользователя в текущий момент времени, потому что одна клавиатура и текущее положение пользователя будет сохраняться в **MainThread** (основном треде) для всех.
Предварительная подготовка
--------------------------
Устанавливаем MySQL на необходимую машину:
<https://dev.mysql.com/downloads/mysql/>
Или через терминал (для Linux):
```
sudo apt install mysql-server
```
Если у Вас не установлены необходимые библиотеки - то устанавливаем их через терминал:
```
pip3 install vk_api
pip3 install pymysql
```
В базе данных нам предварительно нужно создать базу данных в MySQL с названием **vktest** с таблицей **user** и полями - **iduser** и **position.** Я создаю БД с кодировкой **utf8mb4:**
```
CREATE SCHEMA vktest DEFAULT CHARACTER SET utf8mb4 ;
CREATE TABLE `vktest`.`user` (
`iduser` INT UNSIGNED NOT NULL,
`position` TINYINT UNSIGNED NULL,
PRIMARY KEY (`iduser`));
```
Базовый алгоритм
----------------
Основная идея алгоритма в том, что основной тред будет занят *слушанием* **longpoll**, который при появлении нового сообщения будет создавать новый тред. В этот новый тред, как аргументы, будут отсылаться айди пользователя и текст сообщения и далее обрабатываться.
В новосозданном треде бот сразу берет текущее положение пользователя в БД, в зависимости от этого положения происходит обработка сообщения и после обновляется положение пользователя в БД на новое и выполняются нужные инструкции.
Для начала представим этот алгоритм для основной функции, которая и будет создавать эти треды (код составлен для сообщений в личку сообщества):
```
import vk_api
from vk_api import VkUpload
from vk_api.utils import get_random_id
from vk_api.bot_longpoll import VkBotLongPoll, VkBotEventType
import threading
import requests
import random
import pymysql
import pymysql.cursors
if __name__ == '__main__':
while True:
session = requests.Session()
vk_session = vk_api.VkApi(token="%Токен сообщества VK%")
vk = vk_session.get_api()
upload = VkUpload(vk_session)
longpoll = VkBotLongPoll(vk_session, "%ID сообщества VK%")
try:
for event in longpoll.listen():
if event.type == VkBotEventType.MESSAGE_NEW and event.from_user:
threading.Thread(target=processing_message, args=(event.obj.from_id, event.obj.text)).start()
except Exception:
pass
```
Весь код в основной функции завернут в **while True** из-за того, что раньше каждую ночь (возможно также и сейчас) примерно в 4:30 по МСК переставал отвечать VK на запросы и бот падал (видимо перезагружали серверы).
Основная идея тренировочного бота - это сделать три меню, где **Основное меню 1** будет иметь возможность попасть в **Меню 2** и в **Меню 3**, а они, в свою очередь, могли вернуться обратно в **Основное меню 1**:
В формате меню в самом ВКонтакте хочется представить это так:
У нас 3 клавиатуры, которые нужно создать в виде файлов с расширением **.json** в папке с **main.py**. Первый файл **keyboard\_main.json** будет с кодом**:**
keyboard\_main.json
```
{
"one_time": false,
"buttons": [
[{
"action": {
"type": "text",
"label": "Цитаты Дурова"
},
"color": "default"
}],
[
{
"action": {
"type": "text",
"label": "Цитаты Цукерберга"
},
"color": "default"
}]
]
}
```
Второй файл **keyboard\_durov.json** с кодом:
keyboard\_durov.json
```
{
"one_time": false,
"buttons": [
[{
"action": {
"type": "text",
"label": "Хочу ещё Дурова"
},
"color": "positive"
}],
[
{
"action": {
"type": "text",
"label": "Выйти в главное меню"
},
"color": "default"
}]
]
}
```
Третий, практически идентичный - **keyboard\_zuckerberg.json**:
keyboard\_zuckerberg.json
```
{
"one_time": false,
"buttons": [
[{
"action": {
"type": "text",
"label": "Хочу ещё Цукерберга"
},
"color": "positive"
}],
[
{
"action": {
"type": "text",
"label": "Выйти в главное меню"
},
"color": "default"
}]
]
}
```
Значение **target** у нас **processing\_message**, поэтому создаём функцию в **main.py** с именем **processing\_message** иc аргументами в виде **id юзера** и **его сообщения**:
processing\_message
```
def processing_message(id_user, message_text):
number_position = take_position(id_user)
if number_position == 0:
send_message(id_user, "keyboard_main.json", "Тебя приветствует бот!")
add_new_line(id_user)
elif number_position == 1:
if message_text == "Цитаты Дурова":
update_position(id_user, "2")
send_message(id_user, "keyboard_durov.json", durov_quote())
elif message_text == "Цитаты Цукерберга":
update_position(id_user, "3")
send_message(id_user, "keyboard_zuckerberg.json", zuckerberg_quote())
else:
send_message(id_user, "keyboard_main.json", "Непонятная команда")
elif number_position == 2:
if message_text == "Хочу ещё Дурова":
send_message(id_user, "keyboard_durov.json", durov_quote())
elif message_text == "Выйти в главное меню":
update_position(id_user, "1")
send_message(id_user, "keyboard_main.json", "Мы в главном меню")
else:
send_message(id_user, "keyboard_durov.json", "Непонятная команда")
elif number_position == 3:
if message_text == "Хочу ещё Цукерберга":
send_message(id_user, "keyboard_zuckerberg.json", zuckerberg_quote())
elif message_text == "Выйти в главное меню":
update_position(id_user, "1")
send_message(id_user, "keyboard_main.json", "Мы в главном меню")
else:
send_message(id_user, "keyboard_zuckerberg.json", "Непонятная команда")
else:
send_message(id_user, "keyboard_main.json", "Произошла какая-то ошибка")
```
Весь алгоритм этой функции построен на том, что мы сразу берем текущую позицию пользователя и в зависимости от неё обрабатываем сообщение пользователя. Если **number\_position** - это **0** (функция **take\_position(id\_user)** вернула **0**, то есть в базе данных она не нашла пользователя), то она сразу добавляет его в БД с позицией **1** через функцию **add\_new\_line(id\_user)**, перемещая таким образом его в главное меню и открывая ему клавиатуру **keyboard\_main.json**.
Если **number\_position** от **1** до **3** - то бот выполняет код в соответствующем для него ветвлении **if-elif-else.**
Функция **take\_position(id\_user)** выглядит таким образом:
```
def take_position(id_user):
connection = get_connection()
try:
with connection.cursor() as cursor:
sql = "SELECT position FROM user WHERE iduser = %s"
cursor.execute(sql, (id_user))
line = cursor.fetchone()
if line is None:
return_count = 0
else:
return_count = line["position"]
finally:
connection.close()
return return_count
```
В свою очередь **add\_new\_line(id\_user)** выглядит так:
```
def add_new_line(id_user):
connection = get_connection()
try:
with connection.cursor() as cursor:
sql = "INSERT INTO user (iduser, position) VALUES (%s, %s)"
cursor.execute(sql, (id_user, "1"))
connection.commit()
finally:
connection.close()
return
```
Когда пользователь имеет свою строку в БД - он уже может приступать к взаимодействию с ботом. И обновление его положения - это функция **update\_position(id\_user, new\_position)**, которая выглядит таким образом:
```
def update_position(id_user, new_position):
connection = get_connection()
try:
with connection.cursor() as cursor:
sql = "UPDATE user SET position = %s WHERE iduser = %s"
cursor.execute(sql, (new_position, id_user))
connection.commit()
finally:
connection.close()
return
```
Эти три функции не будут работать без основной функции для БД (которую необходимо добавить практически в самое начало, сразу после импорта библиотек) и вписать ваши данные от БД. Я изменяю только название БД и кодировку на те, которые мы создали в самом начале:
```
def get_connection():
connection = pymysql.connect(host="%name_host%",
user="%name_user%",
password="%password_user%",
db="vktest",
charset="utf8mb4",
cursorclass=pymysql.cursors.DictCursor)
return connection
```
И одна из самых важных функций - отправка сообщения пользователю. Я вывел её в отдельную функцию **send\_message**, так как это нерационально возить такую махину постоянно по всему коду:
```
def send_message(id_user, id_keyboard, message_text):
try:
vk.messages.send(
user_id=id_user,
random_id=get_random_id(),
keyboard=open(id_keyboard, 'r', encoding='UTF-8').read(),
message=message_text)
except:
print("Ошибка отправки сообщения у id" + id_user)
```
Ничего не забыли? Ах да, нам же нужны крутые цитаты Дурова и Цукерберга:
durov\_quote() и zuckerberg\_quote()
```
def durov_quote():
durov = ['Лучшее решение из возможных — самое простое. И наоборот.',
'Что такое университет? Это же раздробленная структура с удельными княжествами.',
'Коммуникация переоценена. Час одиночества продуктивнее недели разговоров.',
'Проблемы — это спрятанные решения.',
'Врать вредно для духовной целостности.']
return random.choice(durov)
def zuckerberg_quote():
zuckerberg = ['В мире, который меняется очень быстро, единственная стратегия, которая гарантированно '
'провальна — не рисковать.',
'Двигайтесь быстро и разрушайте препятствия. Если вы ничего не разрушаете, '
'Вы движетесь недостаточно быстро.',
'Вопрос не в том, что мы хотим знать о человеке. Вопрос стоит так:'
'«Что люди хотят рассказать о себе?»',
'Люди могут быть очень умными или иметь отличные профессиональные навыки, '
'но если они действительно не верят в свое дело, они не будут по-настоящему работать.',
'Вопрос, который я задаю себе почти каждый день: сделал ли я самую важную вещь, которую '
'я мог бы сделать? Если я не чувствую, что я работаю над самой важной проблемой, где я '
'могу помочь, я не буду чувствовать, что хорошо провожу свое время']
return random.choice(zuckerberg)
```
Для них мы использовали встроенные списки Python и подключили библиотеку **random**.
И весь код **main.py** (целиком) под спойлером для удобства:
main.py
```
import vk_api
from vk_api import VkUpload
from vk_api.utils import get_random_id
from vk_api.bot_longpoll import VkBotLongPoll, VkBotEventType
import threading
import random
import pymysql
import pymysql.cursors
import requests
def get_connection():
connection = pymysql.connect(host="%name_host%",
user="%name_user%",
password="%password_user%",
db="vktest",
charset="utf8mb4",
cursorclass=pymysql.cursors.DictCursor)
return connection
def send_message(id_user, id_keyboard, message_text):
try:
vk.messages.send(
user_id=id_user,
random_id=get_random_id(),
keyboard=open(id_keyboard, 'r', encoding='UTF-8').read(),
message=message_text)
except:
print("Ошибка отправки сообщения у id" + id_user)
def add_new_line(id_user):
connection = get_connection()
try:
with connection.cursor() as cursor:
sql = "INSERT INTO user (iduser, position) VALUES (%s, %s)"
cursor.execute(sql, (id_user, "1"))
connection.commit()
finally:
connection.close()
return
def take_position(id_user):
connection = get_connection()
try:
with connection.cursor() as cursor:
sql = "SELECT position FROM user WHERE iduser = %s"
cursor.execute(sql, (id_user))
line = cursor.fetchone()
if line is None:
return_count = 0
else:
return_count = line["position"]
finally:
connection.close()
return return_count
def update_position(id_user, new_position):
connection = get_connection()
try:
with connection.cursor() as cursor:
sql = "UPDATE user SET position = %s WHERE iduser = %s"
cursor.execute(sql, (new_position, id_user))
connection.commit()
finally:
connection.close()
return
def durov_quote():
durov = ['Лучшее решение из возможных — самое простое. И наоборот.',
'Что такое университет? Это же раздробленная структура с удельными княжествами.',
'Коммуникация переоценена. Час одиночества продуктивнее недели разговоров.',
'Проблемы — это спрятанные решения.',
'Врать вредно для духовной целостности.']
return random.choice(durov)
def zuckerberg_quote():
zuckerberg = ['В мире, который меняется очень быстро, единственная стратегия, которая гарантированно '
'провальна — не рисковать.',
'Двигайтесь быстро и разрушайте препятствия. Если вы ничего не разрушаете, '
'Вы движетесь недостаточно быстро.',
'Вопрос не в том, что мы хотим знать о человеке. Вопрос стоит так:'
'«Что люди хотят рассказать о себе?»',
'Люди могут быть очень умными или иметь отличные профессиональные навыки, '
'но если они действительно не верят в свое дело, они не будут по-настоящему работать.',
'Вопрос, который я задаю себе почти каждый день: сделал ли я самую важную вещь, которую '
'я мог бы сделать? Если я не чувствую, что я работаю над самой важной проблемой, где я '
'могу помочь, я не буду чувствовать, что хорошо провожу свое время']
return random.choice(zuckerberg)
def processing_message(id_user, message_text):
number_position = take_position(id_user)
if number_position == 0:
send_message(id_user, "keyboard_main.json", "Тебя приветствует бот!")
add_new_line(id_user)
elif number_position == 1:
if message_text == "Цитаты Дурова":
update_position(id_user, "2")
send_message(id_user, "keyboard_durov.json", durov_quote())
elif message_text == "Цитаты Цукерберга":
update_position(id_user, "3")
send_message(id_user, "keyboard_zuckerberg.json", zuckerberg_quote())
else:
send_message(id_user, "keyboard_main.json", "Непонятная команда")
elif number_position == 2:
if message_text == "Хочу ещё Дурова":
send_message(id_user, "keyboard_durov.json", durov_quote())
elif message_text == "Выйти в главное меню":
update_position(id_user, "1")
send_message(id_user, "keyboard_main.json", "Мы в главном меню")
else:
send_message(id_user, "keyboard_durov.json", "Непонятная команда")
elif number_position == 3:
if message_text == "Хочу ещё Цукерберга":
send_message(id_user, "keyboard_zuckerberg.json", zuckerberg_quote())
elif message_text == "Выйти в главное меню":
update_position(id_user, "1")
send_message(id_user, "keyboard_main.json", "Мы в главном меню")
else:
send_message(id_user, "keyboard_zuckerberg.json", "Непонятная команда")
else:
send_message(id_user, "keyboard_main.json", "Произошла какая-то ошибка")
if __name__ == '__main__':
while True:
session = requests.Session()
vk_session = vk_api.VkApi(token="%Токен сообщества VK%")
vk = vk_session.get_api()
upload = VkUpload(vk_session)
longpoll = VkBotLongPoll(vk_session, "%ID сообщества VK%")
try:
for event in longpoll.listen():
if event.type == VkBotEventType.MESSAGE_NEW and event.from_user:
threading.Thread(target=processing_message, args=(event.obj.from_id, event.obj.text)).start()
except Exception:
pass
```
Заключение
----------
Этой статьей я поделился с массами адекватным, как мне кажется, решением для создания многоуровневого бота. Надеюсь, это защитит многих на старте от решений в виде цикла **longpoll** в цикле **longpoll** и в ещё одном **longpoll**, из которых довольно трудно выйти. Всем удачи. | https://habr.com/ru/post/648591/ | null | ru | null |
# Liqpay: выставление счета по SMS, гордо названное POS-терминалом
Недавно хабраюзер [упоминал](http://habrahabr.ru/blogs/pay_sistem/85058/) о событии.
Не буду дублировать описание, вот [оригинал](http://privatblog.com.ua/page/468122.html).
Попробую прояснить некоторые непонятные моменты.
Итак, следует помнить, что основным идентификатором (логином) в системе Liqpay является номер мобильного телефона, а к каждому номеру привязаны 4 счета в гривне, рублях, долларах и евро.
Предлагаемая схема работает так :
*(Считаем, что продавец уже активировал свою верифицированную карту для выставления смс-счетов)*
1) Продавец выставляет счет покупателю по SMS (сумма+валюта+телефон покупателя):
`1000+USD+3805556677`
Покупатель получает сообщение:`Dlya perevoda 1000 USD na nomer 380222333444, otpravte komandu nomer karti+srok deystviya+cvv na nomer 7440`
2) Покупатель оплачивает счет с платежной карты на счет liqpay (т.е. на телефонный номер: номер карты+срок действия+cvv-код):
`5555666677778888+0314+123`
3) Обоим приходит sms о проведенной транзакции
а) покупателю: `Vi uspeshno pereveli 1000 USD na nomer 380222333444`,
б) продавцу: `Vi poluchili perevod na summu 1000 USD ot nomera 3805556677 uspeshno`.
*Заметьте, что в дебете указан номер телефона покупателя, а не номер его карты.*
О чем не написано ни в приватблоге, ни на хабре, так это о необходимости верификации карты покупателя в системе Liqpay. Т.е. покупатель должен зайти в систему, добавить свою карту, позвонить в свой банк и узнать сумму, заблокированную при добавлении карты, после чего ввести ее на сайте ликпея, чтобы завершить верификацию.
**С неверифицированных в liqpay карт нельзя оплатить sms-счет.**
Соответственно фишку нельзя назвать ни POS-терминалом для чайников (оригинальное название поста в приватблоге), ни sms-эквайрингом.
Плюсы схемы: комиссии при этой операции не взымаются. Согласно тарифам ликпея: с карты на ликпей=0, внутри системы=0. Если же будете выводить с ликпея на карту, то заплатите полбакса+полпроцента (карта Привата) или 2 бакса и один процент при выводе на другие карты.
С верифицированными картами платежи происходят за минуты.
На мой взгляд, можно было бы обойтись без верификации карты покупателя, ведь в сравнении с интернет-эквайрингом, здесь заменен только канал сообщения с банком с http на sms.
Это попытка банка ознакомить покупателя со своим сервисом?
Интересно мнение хабрапользователей.
**upd 12.10:** Дождавшись ночи, когда в чате саппорта остаются люди с мозгом, решил уточнить, зачем же эта дополнительная верификация карты, которая сводит на нет все задуманное удобство.
Смысл ответа, который я смог выцедить из них через полчаса, был такой: через интернет-эквайринг принимаются только украинские карты, а liqpay работает с картами всего мира, что требует усиленной верификации.
Второй вопрос: почему не разделите карты на украинские и другие?
В ответ что-то промямлили про законодательство в разных странах и возможные проблемы. На этом я понял, что внятный ответ не получу. | https://habr.com/ru/post/86965/ | null | ru | null |
# Meteor + JQuery-UI Sortable + Animation + Todos
Анимация и драг-н-дроп на [Метеоре](http://www.meteor.com/) пока больше мечта чем реальность. Умельцы находят пути реализовать такие вещи, но как показывает исследование — это обход основных паттернов метеор разработки
Этот пост о том, как я пытался прикрутить анимацию и сортировку к известному примеру [todos](http://www.meteor.com/examples/todos).
#### Введение
Разработчики метеора [обещают](http://www.meteor.com/blog/2013/09/13/previewing-meteors-new-rendering-engine-reactive-sortable-lists), что работают над возможностью использования [JQuery-UI Sortable](http://jqueryui.com/sortable/) или его подобия. Но я пока не нашел как это потрогать руками.
А вот с анимацией пока света не видно. Вот что [пишет](http://stackoverflow.com/questions/13214686/drag-and-drop-sortable-list-in-meteor) об этом Tom Coleman:
> I think there is a big need for such a widget, done in a meteoric way. It's on my personal radar (but so are a lot of things, including a nice way to re-order with animation).
Так случилось, что мне это было надо на вчера, поэтому я попробовал посмотреть, в чем же там трудности реализации.
#### Что получилось
Если вкратце, то пару дней исследований и экспериментов вылились в код на гитхабе: [meteor-todos-sortable-animation](https://github.com/nleush/meteor-todos-sortable-animation). Там я постарался детально описать как его использовать.
Можно посмотреть [демо](http://todos-dnd-animated.meteor.com/). Откройте одновременно два окна и наблюдайте за изменениями во втором, пока таскаете тудушки в первом. Если кто-то там уже это делает — можете пообщаться с ним в мини-чате.
В частности там работает:
1. Сортировка тудушек.
2. Сортировка листов.
3. Анимация сортировки на другом клиенте.
4. Аниамация удаления и добавления элементов.
Разработка начиналась для тудушек. После завершения за 10 минут мне удалось прикрутить то же для списка листов. Собственно ради быстрого реюза это и делалось.
#### Баги
Основной баг, от которого я не смог избавиться — невозможность перерендерить созданный через `Meteor.render` шаблон. Если данные изменились — код удаляет старый фрагмет и создает новый. Из-за это не работают `preserve` фичи.
Много проблем было с аккуратными изменениями DOM элементов. И Meteor, и Sortable работают с DOM весьма динамично, пришлось их подружить.
#### Хитрости решения
Одно из основных ноу хау решения — использование инкрементального изменения DOM вслед за последовательными сигналами об изменениях от `Meteor cursor observer`.
При этом для решения конфликтов работы с DOM между Meteor и Sortable, учитывая задержки анимации, создается очередь событий. Очередь блокирует изменения и последовательно выполняет одно изменение за другим.
Таким образом это симулирует те же последовательные изменения, что бы делал Meteor сам, но с задержками для анимации.
#### Заключение
В первую очередь следует заметить, что получился относительно быстрый способ прикрутить драг-н-дроп и анимацию к спискам.
Я рассчитываю, что это решение, хоть и является хаком, но все же максимально приближено к метеор паттерну. А это означает, что когда Meteor будет уметь делать то же сам, то переделать готовый код большого приложения с хаками на штатную схему без хаков будет несложно.
В процессе разработки я сталкивался с весьма сложно отлавливаемыми багами. Возможно поймал не все. Желающих прошу потестить. Буду рад, если решение рассмотрят более опытные разработчики, которые подскажут как его улучшить. | https://habr.com/ru/post/197296/ | null | ru | null |
# PHP и регулярные выражения: азы для новичков
*В преддверии старта нового потока по курсу [«Backend-разработчик на PHP»](https://otus.pw/vMHA/), а также смежного с ним курса [«Framework Laravel»](https://otus.pw/vS2d/), хотим поделиться статьей, которую подготовил наш внештатный автор.
**Внимание!** данная статья **не имеет отношения к программе курса** и будет полезна **только для новичков**. Для получения более углубленных знаний приглашаем вас посетить **[бесплатный двухдневный онлайн интенсив по теме: «Создание Telegram-бота для заказа кофе в заведении и оплаты онлайн»](https://otus.pw/vMHA/)**. Второй день интенсива будет проходить [тут](https://otus.pw/cl2i/).*
---
Всем привет! Всех с наступившим `[20]{2,}0` годом. Сегодня я хочу затронуть тему, которая иногда является темой для шуток от «Да зачем тебе все это учить, если есть уже есть готовые решения» до «может тебе еще и весь Perl выучить?». Однако время идет, множество программистов начинают осваивать регулярные выражения, а на Хабре нет ни одной свежей (*хоть регулярные выражения не слишком изменились за последнее время*) статьи на этой тематику. Пришло время написать ещё одну!
### Регулярные выражения в отрыве от их конкретной реализации
Регулярные выражения (обозначаемые в английском как *RegEx* или как *regex*) являются инструментальным средством, которое применяется для различных вариантов изучения и обработки текста: поиска, проверки, поиска и замены того или иного элемента, состоящего из букв или цифр (или любых других символов, в том числе специальных символов и символов пунктуации). Изначально регулярные выражения пришли в мир программирования из среды научных исследований, которые проводились в 50-е годы в области математики.
Спустя десятилетия принципы и идеи были перенесены в среду операционной системы UNIX (в частности вошли в утилиту `grep`) и были реализованы в языке программирования Perl, который на заре интернета широко использовался на бэкенде (и по сей день используется, но уже меньше) для такой задачи, как, например, валидация форм.
##### Если они вроде простые, тогда почему такие страшные на первый взгляд?
На самом деле любое выражение может быть «регулярным» и применяться для проверки или поиска каких-либо символов. Например, слова *Pavel* или *example@mail.ru* тоже могут использоваться как регулярки, только, понятное дело, в довольно узком ключе. Для проверки работы регулярных выражений в среде PHP без запуска своего сервера или хостинга вы можете воспользоваться следующим онлайн [сервисом](https://regex101.com/) (вот только на нем у меня не работала обработка русских символов). Для начала в качестве регулярного выражения мы используем просто *Pavel*.
Положим у нас есть следующий текст:
**Pavel** knows too much. **Pavel** using nginx and he’s not rambler.
Сейчас регулярные выражения нашли оба вхождения слова Pavel. Здорово, но звучит не очень полезно (разве что только вы зачем-то пытаетесь проанализировать что-то вроде количества упоминания слова **сударь** в Войне и Мире через Vim и Python, но тогда у меня к вам вопросов нет).
##### Вариативность выражения
Если ваше регулярное выражение вариативно (например, вам известна только некоторая его часть и нужно найти количество вхождений годов, начиная от 2000 и заканчивая 2099), то мы можем использовать следующее регулярное выражение: *20..*
*Текст: Молодые писатели пишут много чего. Например писатель **2002** года рождения очень отличается от **2008** и **2012***
Здесь у нас с помощью регулярного выражения найдутся все годы, но пока в этом нет никакого смысла. Скорее всего нам не нужны годы дальше 2012 (хотя молодые писатели младше 8 лет могут обидеться, но не об этом сейчас). Стоит изучить наборы символов, но об этом попозже, потому как сейчас поговорим про другую важную часть регулярных выражений: экранирование метасимволов.
Представим, что нам нужно найти количество вхождений файлов с расширением `.doc` (допустим, мы экспортируем только определенные файлы загруженные в нашу базу данных). Но ведь точка обозначает просто любой символ? Так как же быть?
Тут к нам на помощь приходит экранирование метасимволов обратным слешем `\`. Теперь выражение `\.doc` будет достаточно успешно искать любой текстовое упоминание с расширением `.doc`:
Регулярное выражение: `\.doc`
Текст: kursach**.doc** , `nepodozritelneyfail.exe`, work**.doc**, `shaprgalka.rtf doc`
Как видите, мы успешно можем найти количество файлов с расширением `.doc` в списке. Однако мы не сможем вытащить полные имена файлов с помощью данного регулярного выражения, например, в массив. Пришло время взглянуть на наборы символов.
##### Совпадение с целым набором символов
В регулярных выражениях совпадения с набором обеспечивается с помощью метасимволов — квадратных скобочек `[ ]`. Любые два символа ASII могут быть указаны в качестве начала и конца диапазона. Для простой реализации, положим, мы хотим найти все пронумерованные файлы от 0 до 9 с расширением `.jpg`.
Регулярное выражение: `[0-9]\.jpg`
Текст: **1.jpg**, **2.jpg**, **3.jpg**, photo.jpg, anime.jpg, **8.jpg**, jkl.jpg
Стоит отметить, что имя файлов из более 1 цифры наше регулярное выражение не охватит. Про множественный выбор будет чуть ниже, а пока представим, что нам вдруг понадобилось добиться обратного результата. Добавим метасимвол `^` (у которого, самое противное, в регулярных выражениях есть аж две функции). Чтобы воспользоваться им как исключением, нужно добавить его именно внутрь нашего набора:
Регулярное выражение: `[^0-9]\.jpg`
Текст: 1.jpg, 2.jpg, 3.jpg, phot**o.jpg** , anim**e.jpg** , 8.jpg, jk**l.jpg**
Но без множественного выбора это конечно неполноценные выражения.
##### Полезные таблицы
Приведем таблицу метасимволов:
| | |
| --- | --- |
| \ | экранировать метасимвол как обычный символ |
| ^ | искать определенный символ именно в начале строки (но только если исключить его из набора []) |
| $ | конец строки |
| | | альтернатива |
| () | группировка |
| \w | все буквенно и цифровые символы (многие руководства почему-то не договаривают про цифровые символы) |
| \W | тоже самое, только наоборот |
| \s | любой пробельный символ |
| \S | любой НЕ пробельный символ |
Таблица пробельных метасимволов
| | |
| --- | --- |
| [\b] | возврат на один символ |
| \f | перевод страницы |
| \n | перевод строки |
| \r | возрат каретки |
| \t | табуляция |
| \v | вертикальная табуляция |
### Множественный выбор: делаем простую валидацию
Вооружившись полученными знаниями, попробуем сделать регулярное выражение, которое находит, например, слова короче 3 букв (стандартная задача для антиспама). Если мы попробуем использовать следующее регулярное выражение — `\w{1,3}` (в котором метасимвол `\w` указывает на любой символ, а фигурные скобки обозначают количество символов от сколько до скольки, то у нас выделятся все символы подряд — нужно как-то обозначить начало и конец слов в тексте. Для этого нам потребуется метасимвол `\b`.
Регулярное выражение: `\b\w{1,3}\b:`
Текст: good word
**not**
**egg**
Неплохо! Теперь слова короче трех букв не смогут попадать в нашу базу данных. Посмотрим на валидацию почтового адреса:
Регулярное выражение: `\w+@\w+\.\w+`
Требования: в электронной почте в начале должен быть любой символ (цифры или буквы, ведь электронная почта, которая состоит только из цифр в начале, встречается довольно часто). Потом идет символ `@`, затем — сколько угодно символов, после чего экранированная точка (т.е. просто точка) и домен первого уровня.
##### Подробнее рассмотрим повторение символов
Теперь давайте поподробнее разберем, как можно в регулярных выражениях задать повторение символов. К примеру вы хотите найти любые комбинации цифр от 2-6 в тексте:
Регулярное выражение: `[2-6]+`
Текст: Here are come’s 89 different **234** digits **24** .
Давайте я приведу таблицу всех квантификаторов метасимволов:
| | |
| --- | --- |
| \* | символы повторяются 0 и до бесконечности |
| + | повторяются от 1 и до бесконечности |
| {n} | повторяются точно n раз |
| {n,} | от n и до бесконечности |
| {n1, n2} | от n1 и до n2 раз точно |
| ? | 0 или 1 символ, не больше |
В применении квантификаторов нет ничего сложного. Кроме одного нюанса: жадные и ленивые квантификаторы. Приведем таблицу:
| | |
| --- | --- |
| \* | \*? |
| + | +? |
| {n,} | {n,}? |
Ленивые квантификаторы отличаются от жадных тем, что они выхватывают минимальное, а не максимальное количество символов. Представим, что есть у нас задача найти все теги заголовков h1-h6 и их контент, а весь остальной текст не должен быть затронут (я умышленно ввел несуществующий тэг h7, чтобы не мучаться с экранированием хабровских тэгов):
Регулярное выражение: .\*?<\/h[1-7]>
Текст: **`<``h7``>` hello ``h7``>``** lorem ipsum avada kedavra **`<``h7`> buy`<``/h7``>`**
Все сработало успешно, однако только благодаря ленивому квантификатору. В случае применения жадного квантификатора у нас выделился бы весь текст между тегами (полагаю, в иллюстрации это не нуждается).
##### Границы символьных строк
Границы символьных строк мы уже использовали выше. Приведем здесь более подробную таблицу:
| | |
| --- | --- |
| \b | граница слова |
| \B | не граница слова |
| \A | начало строки |
| \Z | конец строки |
| \G | конец действия |
##### Работа с подвыражениями
Подвыражения в регулярных выражениях делаются с помощью метасимвола группировки `()`.
Приведем пример регулярного выражения, которое универсально может находить различные вариации IP — адресов.
Регулярное выражение: (((25[0-5])|(2[0-4]\d)|(1\d{2})|(\d{1,2}))\.){3}(((25[0-5]|(2[0-4]\d)|(1\d{2})|(\d{1,2}))))
Текст: **255.255.255.255** просто адрес
**191.198.174.192** wikipedia
**87.240.190.67** vk
**31.13.72.36** facebook
Здесь используется логический оператор `|` (или), который позволяет нам составить регулярное выражение, которое соответствует правилу, по которому составляются IP- адреса. В IP адресе должно быть от 1 и до 3 цифр, в котором число из трех чисел может начинаться с 1, с 2 (или тогда вторая цифра должна быть в пределах от 0 и до 4), или начинаться с 25, и тогда 3 цифра оказывается в пределах от 0 и до 5. Также между каждой комбинацией цифр должна стоять точка. Используя приведенные выше таблицы, постарайтесь сами расшифровать регулярное выражение сверху. Регулярные выражения в начале пугают своей длинной, но длинные не значит сложные.
##### Просмотр вперед
Для просмотра выражения на любую комбинацию определенных символов указывается шаблон по которому обнаруживается, но не возвращается, совпадение. По существу, просмотр вперед определяет подвыражение и поэтому он формируется соответствующим образом. Синтаксический шаблон для просмотра вперед состоит из подвыражения, перед которым стоит ?=, а после равно следует сопоставляемый текст.
Приведем конкретную задачу: есть пароль, который должен состоят не менее чем из 7 символов и должен обязательно включать как минимум одну заглавную букву и цифру. Здесь все будет несколько сложнее, потому как пользователь должен иметь возможность поставить заглавную букву как в начале, так и в середине предложения (и тоже самое должно повторяться с буквой).
Следовательно, нам потребуется просмотр выражения вперед. Кроме того, нам нужно разбить на группы знаки. И я хочу ограничить его размеры от 8 и до 22 знаков:
Регулярное выражение: `/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$/`
Текст: **Qwerty123**
**Im789098**
weakpassword
### Особенности работы регулярных выражений именно в PHP
Для изучения работы регулярных выражений в PHP, изучите функции в официальной документации PCRE (Perl Compatible Regular Expressions) которая доступна на официальном сайте. Выражение должно быть заключено в разделители, например, в прямые слеши.
Разделителем могут выступать произвольные символы, кроме буквенно-цифровых, обратного слеша '\' и нулевого байта. Если символ разделителя встречается в шаблоне, его необходимо экранировать \. В качестве разделителей доступны комбинации, пришедшие из Perl: (), {}, [].
Какие функции используются в php? В пакете PCRE предоставляются следующие функции для поддержки регулярных выражений:
* *preg\_grep()* — выполняет поиск и возвращает массив совпадений.
* *preg\_match()* — выполняет поиск первого совпадения с помощью регулярных выражений
* *preg\_match\_all()* — выполняет глобальный поиск с помощью регулярных выражений
* *preg\_quote()* — принимает шаблон и возвращает его экранированную версию
* *preg\_replace()* — выполняет операцию поиска и замены
* *preg\_replace\_callback()* — тоже выполняет операцию поиска и замены, но используют callback – функцию для любой конкретной замены
* *preg\_split()* — разбивает символьную строку на подстроки
Для организации совпадения без учета регистра букв служит модификатор `i`.
С помощью модификатора `m` можно активировать режим обработки многострочного текста.
Замещающие строки допускается вычислять в виде кода PHP. Для активизации данного режима служит модификатор *e*.
Во всех функциях `preg_replace()`, `preg_replace_callback()` и `preg_split()` поддерживается дополнительный аргумент, который вводит ограничения на максимальное количество замен или разбиений.
Обратные ссылки могут обозначаться с помощью знака $ (например $1), а в более ранних версиях вместо знака $ применяются знаки \\.
Метасимволы \E, \l, \L, \u и \U не используются (поэтому они и не были упомянуты в этой статье).
Наша статья была бы неполной без классов символов POSIX, которые также работают в PHP (и в общем вполне могут повысить читабельность ваших регулярок, но не все их спешат учить, потому как часто ломают логику выражения).
| | |
| --- | --- |
| [[:alnum:]] | Любая буква английского алфавита или цифра |
| [[:alpha:]] | Любая буква ([a-zA-Z]) |
| [[:blank:]] | Пробельный символ или символ с кодом 0 и 255 |
| [[:digit:]] | Любая цифра ([0-9]) |
| [[:lower:]] | Любая строчная буква английского алфавита ([a-z]) |
| [[:upper:]] | Любая заглавная буква английского алфавита ([A-Z]) |
| [[:punct:]] | Любой знак пунктуации |
| [[:space:]] | Любой пробельный символ |
| [[:xdigit:]] | Любая шестнадцатеричная цифра ([0-9a-fA-F]) |
Под конец приведу пример конкретной реализации регулярных выражений в PHP, используя упомянутые выше реализации. Также я добавил валидацию имени пользователя, чтобы он не смог вводить слишком короткие сочетания букв (ну, положим, это никнеймы, а не имена, имена бывают короче двух букв):
```
$pattern_name = '/\w{3,}/';
$pattern_mail = '/\w+@\w+\.\w+/';
$pattern_password = '/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$/';
if (preg_match($pattern_name, $name) &&
preg_match($pattern_mail, $mail) &&
preg_match($pattern_password, $_POST['password'])) {
# тут происходит, к примеру, регистрация нового пользователя, отправка ему письма, и внесение в базу данных
}
```
Всем спасибо за внимание! Конечно, сегодня мы затронули только часть регулярных выражений и о них можно написать ещё несколько статей. К примеру, мы не поговорили о реализации поиска повторений одинаковых слов в тексте. Но я надеюсь, что полученных знаний хватит, чтобы осмысленно написать свою первую валидацию формы и уже потом перейти к более зубодробительным вещам.
**По традиции, несколько полезных ссылок:**
[Шпаргалка](http://web.mit.edu/hackl/www/lab/turkshop/slides/regex-cheatsheet.pdf) от MIT по регулярным выражениям
Официальная часть [документации](https://www.php.net/manual/ru/pcre.pattern.php) php по регулярным выражениям.
**На этом все. До встречи на [интенсиве](https://otus.pw/vMHA/)!**
**Второй день интенсива [пройдет тут](https://otus.pw/cl2i/)** | https://habr.com/ru/post/484048/ | null | ru | null |
# Взлом биткоин биржи на Rails
В последнее время появилась масса биткоин сервисов. И то что раньше было проектом «for fun» неожиданно стало хранить десятки и даже сотни тысяч долларов. Цена биткоина выросла, но уровень безопасности биткоин сервисов остался таким же низким.
Ради портфолио мы провели бесплатный аудит [биткоин биржи с открытым кодом Peatio](http://github.com/peatio/peatio) использующей Ruby on Rails. Репорт в pdf можно [скачать тут](http://sakurity.com/peatio.pdf). Самое интересное что в результате нашлись не очередные унылые рейс кондишены или SQLi, а довольно таки любопытная цепочка багов ведущая к угону аккаунта и краже существенной части горячего кошелька.
#### Угон аккаунта
В глаза сразу бросается «Вход через Weibo» (это у китайцев популярная социалка). Если почитать [шпаргалку по безопасности OAuth](http://www.oauthsecurity.com/) становится очевидно, там где OAuth там и угон аккаунта.
**Присоединение Вейбо атакующего к аккаунту жертвы**
В [omniauth-weibo-oauth2](https://github.com/beenhero/omniauth-weibo-oauth2/pull/12) был баг фиксирующий state. state это важный параметр для защиты от CSRF, и защита от него была встроена (не сразу, конечно) в omniauth. Вот только строчка
```
session['omniauth.state'] = params[:state] if v == 'state'
```
выключала эту защиту, вставляя в session['omniauth.state'] значение из GET параметра. Теперь можно зафиксировать state=123 и использовать code выпущенный для вейбо атакующего. Пример эксплуатации:
```
require 'sinatra'
get '' do
conn = Faraday.new(:url => 'https://api.weibo.com')
new_url = conn.get do |r|
r.url "/oauth2/authorize?client_id=456519107&redirect_uri=https%3A%2F%2Fyunbi.com%2Fauth%2Fweibo%2Fcallback&response_type=code&state=123"
r.headers['Cookie'] =<![]()"
end
```
В результате мы имеем вейбо атакующего подключенным к аккаунты жертвы на бирже, и можем в него зайти напрямую.
**А если Вейбо уже подключен у жертвы?**
Второй аккаунт подключить нельзя, поэтому надо найти способ украсть code для текущего вейбо жертвы.
Вейбо не привязывает code к redirect\_uri (что само по себе грубая ошибка, но зарепортить китайцам я не смог) а значит найдя страницу сливающую код через рефереры мы достигнем цели. Поиски такой страницы как и опен редиректа не увенчались успехом, но в самом конце интересная строчка в DocumentsController спасла положение:
```
if not @doc
redirect_to(request.referer || root_path)
return
end
```
Если документ не найден то происходит редирект на request.referer, а значит следующая цепочка редиректов сольет код:
1. attacker\_page редиректит на weibo.com/authorize?...redirect\_uri=http://app/documents/not\_existing\_doc%23…
2. Weibo неправильно парсит redirect\_uri c %23 и редиректит жертву на [app/documents/not\_existing\_doc#?code=VALID\_CODE](http://app/documents/not_existing_doc#?code=VALID_CODE)
3. Peatio не может найти not\_existing\_doc и возвращает Location заголовок равный текущему request.referer который все еще attacker\_page (браузер его продолжает слать с самого начала)
4. Браузер копирует фрагмент #?code=VALID\_CODE и загружает attacker\_page#?code=VALID\_CODE. Теперь код на странице может прочитать VALID\_CODE через location.hash и загрузить настоящий [app/auth/weibo/callback?code=VALID\_CODE](http://app/auth/weibo/callback?code=VALID_CODE) чтобы зайти в аккаунт жертвы на бирже.
Итак, мы угнали аккаунт у пользователей с Вейбо и даже без. Но дальше нас останавливает двух-факторная аутенфикация.
#### Обход 2FA
Peatio из коробки заставляет всех пользователей использовать Google Authenticator и/или SMS коды для важных функций (вывод биткоинов). А значит нам так или иначе нужно найти способ обхода.
**Если у жертвы включен только Google Authenticator**
 | https://habr.com/ru/post/248887/ | null | ru | null |
# Архитектура и решения безопасности в облаке часть 1
При увеличении объёма использования облачных ресурсов возникла необходимость встраивания методологии CI/CD в процесс облачной разработки, так как в текущем варианте скорость раскатки приложений и сервисов хоть и стала быстрее, но по концепции не сильно отличалась от baremetal-инфраструктуры.
При обсуждении архитектуры решения обнаружилось несколько факторов, которые препятствовали внедрению данных методик в используемом компанией облаке (Яндекс.Облако). В статье я расскажу компромиссные методы преодоления этих препятствий.
Согласование сетевых и системных доступов в нашей компании — это отдельный процесс, который находится в зоне ответственности подразделения информационной безопасности и подразумевает использование согласованной матрицы ролей для системных и ACL (Access Control List) для сетевых доступов.
Разработчики и администраторы облачной инфраструктуры получали доступ к набору ролей, который не включал возможностей управления “[Группами Безопасности](https://cloud.yandex.ru/docs/vpc/concepts/security-groups)”
Команда информационной безопасности осуществляла переход на описание Групп безопасности при помощи Terraform. Для повышения эффективности перехода внутри команды мной было организовано обучение коллег базовым концепциям Infrastructure as Code. После обмена опытом увеличилась скорость обработки запросов на предоставление доступа в части облачной инфраструктуры.
Пример группы безопасности в Terraform
```
resource "yandex_vpc_security_group" "RESOURCE-NAME-SG-1" {
name = "SG-NAME"
description = "you comment"
network_id = "NETWORK_ID"
folder_id = "ID-folder" #указываем id фолдера, для которого предназначены SG
ingress { #входящий доступ
protocol = "TCP"
description = "sample"
v4_cidr_blocks = ["172.27.0.0/16"]
port = 22
}
egress { #исходящий доступ
protocol = "TCP"
description = "sample"
v4_cidr_blocks = ["172.27.0.0/16"]
from_port = 8080
to_port = 8099
}
egress {
protocol = "ANY"
description = "sample"
security_group_id = "SG-ID" # SG сошлется на другую SG
port = 6432
}
ingress {
protocol = "ANY"
description = "sample"
predefined_target = "self_security_group" #SG сошлется на саму себя
from_port = 1
to_port = 65535
}
ingress {
protocol = "TCP"
description = "rule1 description"
predefined_target = "loadbalancer_healthchecks" #Проверка состояния балансировщика
port = 8080
}
}
```
Пример корпоративной матрицы ролей:
| | |
| --- | --- |
| Роль | Права доступа |
| Администратор Kubernetes | viewerk8s.admin |
| Администратор виртуальныхмашин каталога(базовая роль) | viewervpc.viewercompute.adminload-balancer.privateAdminalb.editor |
| Администратор сети облака | viewervpc.adminload-balancer.admin |
| Владелец облака | cloud.owner |
| Пользователь Container Registry каталога | container-registry.images.pusher |
| Администратор Container Registry каталога | container-registry.admin |
| Пользователь хранилища каталога | storage.editor |
| Администратор хранилища каталога | storage.admin |
| Пользователь сервисных аккаунтов каталога | iam.serviceAccounts.useriam.serviceAccounts.tokenCreator |
| Администратор хранилища сертификатов каталога | certificate-manager.admin |
| Администратор мониторинга каталога | monitoring.editor |
| Пользователь мониторинга каталога | monitoring.viewer |
| Read-only Пользователь каталога | viewer for folder |
| Read-only Пользователь облака | viewer for cloud |
| Администратор баз данных каталога | mdb.admin |
| Пользователь баз данных каталога | mdb.viewer |
| Администратор Key Management Service | kms.admin |
| Пользователь Key Management Service | kms.keys.encrypterDecrypter |
| Пользователь Datalens в облаке | datalens.instances.user |
| Администратор Datalens в облаке | datalens.instances.admin |
Стандарты нашей компании предусматривали использование минимальной гранулярности доступа к группам безопасности. Штатно такой ролью в облаке являлась “vpc.securityGroups.admin” назначающая права доступа к созданию, редактированию и удалению групп безопасности. При использовании мультифолдерной модели передавать данный доступ в управление являлось риском нарушения изоляции dev и prod-сред в облаке.
Для решения этой ситуации был направлен фич-реквест в поддержку облака на создание роли с меньшей гранулярностью. Роль “vpc.securityGroups.user” позволила использовать группы безопасности без возможности их редактирования. Так появилась новая роль для корпоративной матрицы ролей — "Пользователь групп безопасности".
Одновременно с появлением данной роли в облаке появилась возможность переноса групп безопасности в другие фолдеры без отключения привязки к мультифолдерной VPC.
Про наш переход использование мультифолдерного подхода вы можете прочитать в статье [Как мы переезжали на новую сетевую маршрутизацию и Interconnect в Яндекс.Облаке.](https://habr.com/ru/company/alfastrah/blog/578632/)
Изменения в процессе при работе с группами безопасностиДля сбора логов, мониторинга и организации механизма оповещений о действиях в облаке наша команда адаптировала под себя следующие решения из библиотеки [Yandex.Cloud Security Solution Library](https://github.com/yandex-cloud/yc-solution-library-for-security).
Решение с Elastic кластером было использовано для агрегации логов и удобного поиска по событиям и передачей в SOC для построения схемы приоритезации реагирования на критические события.
[Решение](https://github.com/yandex-cloud/yc-solution-library-for-security/tree/master/auditlogs/export-auditlogs-to-ELK_main) позволяет собирать, мониторить и анализировать аудит логи в Yandex.Cloud Managed Service for Elasticsearch (ELK) из Yandex Audit Trails
Пример дашборда решения с визуализацией изменений за определенный периодСхема работы SIEM решенияРешение с [Yandex Cloud: Trails-function-detector](https://github.com/yandex-cloud/yc-solution-library-for-security/tree/master/auditlogs/trails-function-detector) позволило отслеживать и реагировать на критические действия в облаке в реальном времени. Само решения является хорошим примером реализации возможностей различных интеграций с Cloud Functions. В нашей компании оно развёрнуто с необходимыми доработками, реализованными в рамках задач мониторинга информационной безопасности.
Схема решения Yandex.Cloud Trails-function-detectorИтоги
-----
Использование новых принципов и подходов отлично сработало. Использование групп безопасности позволило совместить несовместимое и при этом дало возможность получить запас изоляции dev и prod сред.
Управляемые сервисы Yandex Cloud позволили значительно ускорить процессы разработки:
Было: команда разработки делает заявку на создание нужных ресурсов, ресурсы развёртываются подразделением инфраструктуры или членами команды срок ожидания составляет от нескольких часов до нескольких дней.
Стало: команда информационной безопасности создаёт группы безопасности с использованием Terraform для планируемой схемы инфраструктуры, а команда разработки сама создаёт нужные ресурсы в dev и prod-окружении по требованию за несколько минут, используя предварительно согласованный список доступов.
Внедрение стандартизированного подхода облегчило совместную работу, а соответствие облачной платформы [индустриальным стандартам](https://cloud.yandex.ru/security) и законодательным требованиям в рамках безопасности физической инфраструктуры и защиты данных позволили всегда быть готовыми к аудиту регуляторов.
В следующей части этого цикла статей я расскажу о дальнейших этапах внедрения облачных решений на стыке безопасности и разработки.
[Вторая часть](https://habr.com/ru/company/alfastrah/blog/705468/) статьи. | https://habr.com/ru/post/669526/ | null | ru | null |
# Как работает массив в Swift
В [прошлой статье](https://habr.com/ru/post/645723/) мы поговорили про оценку относительной производительности структуры данных или алгоритма(Big O), теперь я предлагаю взглянуть на самый популярный тип данных - **Массив** и оценить основные методы взаимодействия с ним.
Массив — это набор элементов одного типа, которые можно устанавливать и извлекать через непрерывный ряд целых чисел, так называемые индексы.
Эти индексы, которые в большинстве компьютерных языков начинаются с нуля, определяют, где в массиве происходит действие.
Например, чтобы получить первый элемент нашего массива, мы бы сделали get запрос с нулевым индексом. Чтобы положить во второй ячейку массива, мы бы указали индекс, равный единице. С помощью индексов мы контролируем то, что входит и выходит из нашего массива.
О массивах нужно знать три вещи
* Во-первых, массивы могут содержать практически все, что угодно: числа, строки, объекты и даже другие массивы.
* Во-вторых, массивы имеют фиксированный размер. Вы не видите этого в Swift, потому что в Swift, когда мы создаем множество, мы не указываем его размер. Но во многих других компьютерных языках при инициализации массива вы должны дать ему начальный размер.
* В-третьих, у массивов есть уникальная возможность случайного доступа к данным через индекс.
Связанные списки не могут этого сделать. Стеки и очереди не могу этого сделать и даже бинарные деревья поиска, а массивы могут и в этом их сила.
Теперь давайте быстро рассмотрим основные операции работы с массивом, а также взглянем на него с точки зрения относительной производительности каждой из операций, начиная с get и set.
Random AccessВозможность получать и устанавливать данные в любом месте за постоянное время — вот что делает массив таким популярным.
Независимо от того, насколько большим становится массив, если вы знаете индекс нужных вам элементов, вы можете просто добраться до него внутри и получить его за O(1) постоянное время.
Именно поэтому они есть почти в каждом компьютерном языке и почему они так популярны на интервью.
Есть еще три случая работы массивов, которые нам нужно рассмотреть, чтобы понять всю их природу. И это вставка(insert), удаление(delete), а также рост массива, и его способность изменить вместимость.
Начнем со вставки.
------------------
Когда мы вставляем элемент в массив, мы на самом деле делаем три вещи. Мы копируем, вставляем и увеличиваем размер. Допустим, мы хотим вставить символ B на место под индексом один. Когда мы передаем эту инструкцию в наш массив, нам сначала нужно скопировать ее вверх. Мы должны взять элементы в первом индексе и все, что над ними, и сдвинуть их вверх на одну ячейку. Как только мы это сделали, мы освободили место в первом индексе и можем вставить B. Затем, если мы отслеживаем, насколько велики массивы, мы также можем увеличить счетчик и изменить наш размер с трех до четырех.
ВставкаИтак заметим, что в худшем случае, там, где нам приходится перебирать, иногда почти каждый элемент в массиве, и сдвигать все вверх время операции для этого фактически является линейным или O(n).
Удаление.
---------
Удалить — это то же самое, что и вставить, только вместо копирования вверх здесь мы копируем вниз. Допустим, мы хотим удалить тот элемент B, который мы только что вставили с индексом один.
Здесь нам не нужно явно удалять B, мы можем просто взять все элементы выше индекса один - два, три, четыре и выше и просто сдвигайте их вниз и просто перезаписывайте все, что там было.
УдалениеОценка относительной производительности времени выполнения - линейная O(n), потому что в худшем случае пришлось бы сдвинуть каждый или почти элемент в массиве вниз на один, и это займет O(n) время.
Самое интересное начинается, когда наш массив просто недостаточно вместителен. Другими словами, что произойдет, если мы добавим элемент в конец нашего массива, например E, и нашему массиву, который, как мы знаем, имеет фиксированную вместительность четыре, просто некуда этот элемент положить?
В подобных ситуациях происходит *удваивание размера массива*.
Берем наш первоначальный массив, которого в данном случае будет четыре ячейки, создаем новый массив с размером восемь и затем мы копируем туда все существующие элементы. Переписываем A, B, C и D. Теперь, когда наш массив достаточно большой, мы можем добавить последний элемент E в самый конец под пятым индексом.
Рост вместимости массиваИз за изменения размера массива оценочное время O(n).
Давайте добавим E в самый конец этого массива.
Мы должны быть осторожны, потому что мы не можем просто вставить E в какую-то позицию, например, 99. Компилятор выдаст ошибку: индекс за пределами границ, потому что наш массив не достигает этого значения. Но если мы используем метод добавления(append), мы можем добавить E в конец нашего массива.
Обычное добавление элемента в массив происходит за постоянное время 0(1). Это очень, очень быстро, потому что обычно у нашего массива есть место, для нового элемента. Но в
тех редких случаях, когда нам нужно изменить вместимость массива, это будет O(n).
Рассмотрим несколько отличий массивов в Swift.
----------------------------------------------
Единственное, что отличает массивы Swift, если вы пришли из других компьютерных языков, это то, что большая часть тяжелой работы, связанной с изменением размера массива, встроена прямо в сам объект массива. Если вы хотите создать массив, который может удалять, вставлять и добавлять элементы, на таком языке, как Java, или C, вам потребуется указать размер массива. В Swift все это сделано за вас. Обычно мы не указываем размер массивов. Мы просто инициализируем их, создаем, а затем используем.
Мы можем создавать массивы определенного размера, иногда такую задачу ставят на интервью, но довольно редко, поэтому вы не увидите такой код в реальном проекте.
```
let arrayOfSpecificSize = Array(repeating: "A", count: 10)
```
Вывод:
------
1. Массив имеет фиксированный размер.
2. Рандомный доступ О(1).
3. Вставка/ удаление – О(n).
4. Массивы могут сокращаться и расти О(n).
5. Swift проделывает большую работу за нас при создании массива.
**Полезные ссылки:**
* [Apple Developer Documentation. Swift. Array](https://developer.apple.com/documentation/swift/array)
* [Статья на Хабр: "Big O нотация в Swift"](https://habr.com/ru/post/645723/)
* [Перемещение массива в памяти](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D0%BD%D0%B0%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2#%D0%9F%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%89%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%D0%B0_%D0%B2_%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D0%B8) | https://habr.com/ru/post/665536/ | null | ru | null |
# NFun — expression evaluator для .Net
[Репозиторий](https://github.com/tmteam/NFun).
[Примеры и спецификация](https://github.com/tmteam/NFun/blob/master/README.md).
### Что есть "Expression evaluator" ?
Expression evaluator позволяет вычислять указанные выражения, например:
* `12*3` это 36
* `[1,2,3].reverse()` это массив [3,2,1]
* `'Kate'.reverse()` это "etaK"
Выражения могут зависеть от входных переменных:
* `10*x + 4` зависит от значения `x`.
* `'My name is {userName}. Age is {2022-birthYear}'` зависит от значений `userName` и `birthYear`.
Nfun скрипты в обработке сигналов scada - системы SonicaСкрипт может содержать несколько таких выражений:
```
x = Vx*t
y = Vy*t
distance = sqrt(x**2 + y**2)
average = (x+y)/2
```
В общем случае, вы можете использовать Nfun везде, где раньше вы хранили, передавали или настраивали константы. В примере ниже, мы формульно задаем правила начисления бонусов
```
// ...`settings.json`...
{
"offset": "25",
"timeOffset": "3* 60 * 60 * 24 #sec",
"condition": "if (age>18) isEmpty(orders) else isEmpty(parent.orders)",
"bonus": "(min(max(order.price, 20.0), 100) + prevBonus)/ordersCount"
}
```
Вот несколько примеров использования:
* Backend: фильтры входящих запросов;
* Embeded: настройка обработки сигналов;
* Система лояльности: настройки бонусной программы;
* Робототехника: кинематическая модель. Описания траекторий;
* Low-code решения.
### Что умеет NFun
Nfun продолжает идею библиотеки [Ncalc](https://github.com/sklose/NCalc2), но для богатой системы типов
* Примитивные типы - `byte`, `u16`, `u32`, `u64`, `i16`, `i32`, `i64`, `real`, `bool`, `ip`, `char`, `text`, `any`
* Массивы, структуры, лямбда выражения и Linq.
* Арифметические, бинарные, дискретные операторы, операторы по работе с массивами
* Условный оператор `if`.
* Интерполяция строк.
* Именованные выражения и пользовательские функции.
* Строгая типизация с выведением типов.
* Встроенные функции.
* Кастомизация семантики.
Playground
----------
Установите nuget пакет `NFun`
`PM> Install-Package NFun`
Начнем с классики!
```
var a = Funny.Calc("'Hello world'");
Console.WriteLine(a);
```
Посчитаем константы
```
bool b = Funny.Calc("false and (2 > 1)"); // false of bool
double d = Funny.Calc(" 2 \* 10 + 1 "); // 21 of double
int i = Funny.Calc(" 2 \* 10 + 1 "); // 21 of int
```
Посчитаем выходные данные
```
class User { public string Age {get;set;} public string Name {get;set;} }
var inputUser = new User{ Age = 42; Name = "Ivan"; }
string userAlias =
Funny.Calc (
"if(age < 18) name else 'Mr. {name}' ",
inputUser);
```
А теперь перейдем в режим хардкора. Этот режим предоставляет доступ ко всем переменным, и к контролю исполнения на низком уровне
```
var runtime = Funny.Hardcore.Build(
"y = a-b; " +
"out = 2*y/(a+b)"
);
// Set inputs
runtime["a"].Value = 30;
runtime["b"].Value = 20;
// Run script
runtime.Run();
// Get outputs
Assert.AreEqual(0.4, runtime["out"].Value);
```
Мы можем продолжить ...#### Вычисление нескольких значений, на основании входных переменных
```
// Assume we have some С# model
/*
class SomeModel {
public SomeModel(int age, Car[] cars) {
Age = age;
Cars = cars;
}
public int Age { get; } //Used as input
public Car[] Cars { get; } //Used as input
public bool Adult { get; set; } //Used as output
public double Price { get; set; } //Used as output
}
*/
var context = new SomeModel(
age:42,
cars: new []{ new Car{ Price = 6000 }, new Car{ Price = 6200 }}
);
// then we can set the 'Adult' and 'Price' properties based on the value of the 'Age' and 'Cars' properties
Funny.CalcContext(
@"
adult = age>18
price = cars.sum(rule it.price)
",
context);
Assert.AreEqual(true, context.Adult);
Assert.AreEqual(12200, context.Price);
// So input values and output values are properties of the same object
```
#### Кастомизация
Nfun предоставляет кастомизацию синтаксиса и семантики под ваши нужды
- Запрет или разрешение if-выражений
- Decimal или Double арифметика
- Integer overflow поведения
- Запрет или разрешение пользовательских функций
- Тип по умолчанию для целочисленных констант
```
var uintResult = Funny
.WithDialect(integerOverflow: IntegerOverflow.Unchecked)
.Calc("0xFFFF\_FFFF + 1");
Assert.AreEqual((uint)0, uintResult);
//now you cannot launch script with such an expression
var builder = Funny.WithDialect(IfExpressionSetup.Deny);
Assert.Throws(
() => builder.Calc("if(2<1) true else false"));
```
#### Добавление функций и констант
```
//assume we have custom function (method or Func<...>)
Func myFunctionMin = (i1, i2) => Math.Min(i1, i2);
object a = Funny
.WithConstant("foo", 42)
.WithFunction("myMin", myFunctionMin)
// now you can use 'myMin' function and 'foo' constant in script!
.Calc("myMin(foo,123) == foo");
Assert.AreEqual(true, a);
```
Синтаксис
---------
Nfun поддерживает однострочные выражения:
```
12 * x**3 - 3
```
Многострочные именованные выражения:
```
nameStr = 'My name is: "{name}"'
ageStr = 'My age is {age}'
result = '{nameStr}. {ageStr}'
```
И пользовательские функции:
```
maxOf3(a,b,c) = max(max(a,b),c)
y = maxOf3(1,2,3) # 3
```
В зависимости от задачи, вы можете включать и отключать эти возможности.
Подробнее про синтаксис#### Операторы
```
# Arithmetic operators: + - * / % // **
y1 = 2*(x//2 + 1) / (x % 3 -1)**0.5
# Bitwise: ~ | & ^ << >>
y2 = (x | y & 0xF0FF << 2) ^ 0x1234
# Discreet: and or not > >= < <= == !=
y3 = x and false or not (y>0)
```
#### If-выражение
```
simple = if (x>0) x else if (x==0) 0 else -1
complex = if (age>18)
if (weight>100) 1
if (weight>50) 2
else 3
if (age>16) 0
else -1
```
#### Пользовательские функции и обобщенная арифметика
```
sum3(a,b,c) = a+b+c #define generic user function sum3
r:real = sum3(1,2,3)
i:int = sum3(1,2,3)
```
#### Массивы
```
# Инициализация
a:int[] = [1,2,3,4] # [1,2,3,4] type: int[]
b = ['a','b','foo']# ['a','b','foo'] type: text[]
c = [1..4] # [1,2,3,4] type: int[]
d = [1..7 step 2] # [1,3,5,7] type: int[]
# Оператор In
a = 1 in [1,2,3,4] # true
# Чтение
c = (x[5]+ x[4])/3
# Срезы
y = [0..10][1:3] #[1,2,3]
y = [0..10][7:] #[7,8,9,10]
y = [0..10][:2] #[0,1,2]
y = [0..10][1:5 step 2] #[1,3,5]
# Функции
# concat, intersect, except, unite, unique, find, max, min, avg, median, sum, count, any, sort, reverse, chunk, fold, repeat
```
#### Структуры
```
# initialization
user = {
age = 12,
name = 'Kate'
cars = [ # array of structures
{ name = 'Creta', id = 112, power = 140, price = 5000},
{ name = 'Camaro', id = 113, power = 353, price = 10000}
]
}
userName = user.name # field access
```
#### Строки
```
a = ['one', 'two', 'three'].join(', ') # "one, two, three" of String
# Interpolation:
x = 42
out = '21*2= {x}, arr = {[1,2,x]}'
#"21*2= 42, arr = [1,2,42]" of String
```
#### Linq (лямбды)
```
[1,2,3,4]
.filter(rule it>2)
.map(rule it**3)
.max() # 64
```
Семантика
---------
Nfun строго типизирован - это было основным вызовом, и ключевой особенность для гармоничной интеграции в C#, а так же защиты от ошибок. Однако, синтаксис языков со строгой типизацией всегда сложнее.
Что бы решить эту проблему я опирался на постулат:
> Все, что выглядит как правильный скрипт (в рамках синтаксиса/семантики) - должно запуститься
>
>
Или, более формализовано:
> Если код выглядит как слабо-типизированный скрипт, но при этом запускается без ошибок, значит для него можно однозначно вывести типы.
>
> Либо показать, что такой код не может быть выполнен без ошибок.
>
>
Это потребовало разработки сложной системы выведения типов, от которой и отталкивается вся семантика языка. Результатом этого является повсеместное использование Generic-ов.
В примере ниже - функции, вычисления, и даже константы - являются обобщенными типами (из списка `int32`, `uint32`, `int64`, `uint64`, `real`). Однако, пользователь не должен задумываться об этом:
```
var expr = @"
# generic function
inc(a) = a + 1
# generic calculation
out = 42.inc().inc()
";
double d = Funny.Calc(expr); // 44 of double
int i = Funny.Calc(expr); // 44 of int
```
Таким образом, удалось собрать все преимущества строгой типизации:
* Если типы выражения не сходятся - вы получаете ошибку на этапе интерпретации.
* Если типы не сходятся с ожидаемыми C# типами - вы получаете ошибку на этапе интерпретации.
* Производительность.
При этом, синтаксис остался максимально простым для неподготовленного пользователя!
Технические детали
------------------
Так как Nfun под капотом это - "почти язык программирования", то его архитектура достаточно стандартна. Не буду описывать ее здесь подробно, об этом уже есть много классных статей.
Интерпритацию кода можно разделить на несколько этапов:
1. Токенизация (лексер).
Самописный лексер разбирает входную строку на токены, учитывается возможность интерполяции строк.
2. Парсинг.
Разбор токенов в дерево AST. Используется самописный парсер. Спецификация синтаксиса опирается на спецификацию языка (и очень много тестов). Формальная грамматика не описана.
3. Выведение типов.
Кастомный, графовый алгоритм выведения типов, с поддержкой неявных преобразований между типами.
Нюансы:
* Целочисленные константы являются "обобщенными константами"
```
one() = 1 # returns T, where byte -> T -> real
y:int = one() # 1 of int
z:real = one() # 1.0 of real
```
* Тип узла может зависеть, как от предыдущего, так и от последующего кода
```
y = 1 # y:real, так как используется в знаменателе на следующей строчке
x:real = 1/y
```
* Ограничения на дженерик-переменные могут быть заданы, как сверху (наследование, тип к которому можно привести данный), так и снизу ( потомок, тип, которой может быть приведен к данному)
```
sum(a,b) = a+b
x:int = 1 + 2 # x = 3 of int
y:real = 1 + 2 # y = 3.0 of real
z:byte = 1 + 2 # error! operator '+' is defined for (uint16|int16)-> T -> real
# so it cannot return 'byte'
```
4. Сборка выражений (построение рантайма)
Из результатов решения типов и Ast-дерева собирается самописное дерево вычисляемых выражений.
5. Конвертация CLR-значений в Nfun.
6. Исполнение выражений.
7. Конвертация результатов в CLR значения.
Я сознательно не использовал Csharp-expression-tree, так как, одним из важнейших критериев была скорость "one-time-shot". То есть запуска, от момента получения строки со скриптом и до момента получения результатов выполнения.
Состояние проекта
-----------------
Проект готов к использованию в продакшене.
Используется в течении года в составе scada-системы, покрыт 6000+ тестами, к нему написана спецификация, и.. даже есть несколько звездочек на гитхабе (да-да, это call to action!). Почти успех!
Заключение
----------
Когда я начинал Nfun, я мечтал создать простой, надежный и интуитивный опенсорс-инструмент. Я хотел реализовать синтаксические идеи и поэкспериментировать с системами выведения типов, попробовать для себя что-то новое...
По итогу, Nfun стоил огромного количества сил, времени и инвестигаций. Я впервые столкнулся с подобной задачей. Теперь мне хочется, чтобы люди пользовались этим инструментом! И писали тикеты, да реквесты на гитхаб. Ну, или комментарии под этот пост ;) | https://habr.com/ru/post/698190/ | null | ru | null |
# Играем с огнем: запускаем произвольный код на девелоперском iPhone 7
Под Новый год к нам в руки попал программатор [JC PCIE-7](http://aliexpress.com/item/32964787586.html). В процессе использования выяснилось, что его функционал ограничен, однако вещица оказалась с двойным дном. Внутри этого программатора мы обнаружили плату iPhone 7 специальной отладочной версии. За новогодними приключениями в мире исследования и отладки «яблочной» продукции – добро пожаловать под кат!
Наверное, только совсем ленивые исследователи безопасности не пощупали своими руками возможности, предоставляемые checkm8 и основанном на нем checkra1n (классный обзор checkm8 [был недавно на Хабре](https://habr.com/ru/post/471668)). Конечно, мы тоже протестировали наши смартфоны и в процессе решили посмотреть, что есть полезного для исследователей на китайском рынке «железных» поделок. ~~Интересный~~ факт: если хочешь протестировать на безопасность какое-либо устройство, то на AliExpress уже есть для этого свои игрушки.
Наша игрушка пришла под самый Новый год – программатор [JC PCIE-7](http://aliexpress.com/item/32964787586.html), который легко найти на AliExpress:
Мы предполагали, что с помощью этого программатора сможем сделать бэкап флеш-памяти iPhone. Но при эксплуатации обнаружилось, что такой функции в программе просто нет! Да, программатор умеет читать и записывать конфигурацию во флеш-память и привязывать ее к телефону, но чтение произвольных блоков не поддерживается. Затем мы заметили необычные строки в консольном окне управляющей программы, похожие на журнал загрузки операционной системы:
*Кадр момента загрузки из обучающего [видео](http://youtube.com/watch?v=3KKhTDUwadU)*
Наконец, мы обратили внимание на функцию подключения программатора к компьютеру по протоколу DFU. В этом режиме программатор корректно определялся в iTunes как iPhone. Мы решили разобрать устройство и посмотреть, что же находится внутри и как происходит эмуляция режима DFU.
Внутри программатора установлены три платы:
* управляющая плата на базе STM32F103;
* плата-мультиплексор с напаянным чипом NVMe и колодкой;
* и, неожиданно, плата iPhone 7.
Оказалось, что программатор переключает мультиплексор таким образом, что сначала плата iPhone загружается с напаянной флеш-памяти, а затем к ней подключается чип NVMe, который нужно прошить. Управление выполняется по виртуальному COM-порту, причем сначала передаются команды переключения чипов NVMe, а затем плата пробрасывает отладочную консоль iPhone, имитируя [DCSD-кабель](http://theiphonewiki.com/wiki/DCSD_Cable). Внимательно просмотрев отправляемые в COM-порт команды, мы увидели строчки:
**setenv diags-path /AppleInternal/Diags/bin/diag.img4**
**diags**
Уже на этом моменте мы поняли, что плата iPhone 7 не совсем обычная (в ней, как минимум, есть папка [AppleInternal](http://theiphonewiki.com/wiki//AppleInternal)). Чтобы посмотреть, как она себя ведет в более привычном «окружении», мы переставили плату и NVMe чип в донорский телефон:
Помимо шестеренки при загрузке, в отладочной консоли мы увидели строчку BUILD\_STYLE: DEVELOPMENT:
После окончательной загрузки (с помощью упомянутых ранее команд *diags*) мы получили фиолетовый экран, а уже после нажатия клавиш громкости на экране отобразилось следующее меню:
То есть собранное нами устройство оказалось специальной версией iPhone для тестирования и разработки! К слову, [подобные телефоны](https://www.vice.com/en_us/article/gyakgw/the-prototype-dev-fused-iphones-that-hackers-use-to-research-apple-zero-days) скупаются исследователями и даже коллекционерами – вот это настоящий подарок в нашу техническую коллекцию! В полноценном девелоперском iPhone установлена специальная сборка iOS с рутовой консолью, значительно облегчающая исследование телефона и поиск уязвимостей:
В нашем случае на телефоне установлена только диагностическая утилита, основное взаимодействие с которой осуществляется через отладочную консоль:
**Лог загрузки и вывод help**
```
=======================================
::
:: iBoot for d10, Copyright 2007-2016, Apple Inc.
::
:: Local boot, Board 0x8 (d10ap)/Rev 0xd
::
:: BUILD_TAG: iBoot-3406.1.53.1.4
::
:: BUILD_STYLE: DEVELOPMENT
::
:: USB_SERIAL_NUMBER: CPID:8010 CPRV:11 CPFM:03 SCEP:01 BDID:08 ECID:000114422885E526 IBFL:3D
::
=======================================
Boot Failure Count: 0 Panic Fail Count: 0
Entering recovery mode, starting command prompt
] setenv diags-path /AppleInternal/Diags/bin/diag.img4
] diags
Unable to load image type 64696167 from flashnx_mount:432: reloading after unclean unmount, checkpoint xid 112, superblock xid 11
jumping into image at 0x810000000
pinot_quiesce()
mipi_dsim_quiesce()
Console router buffer allocated @ 0x87CB84018, size = 262144 bytes
WHO_AM_I doesn't match MPU6700's Chip ID! Expected 0x90 got 0x0
Carbon: MPU6900 is found.
Carbon: MPU6900 (south) detected
Carbon: MPU6900 (south) selected
MPU6900 not found. Expected 0x10, found 0x0
Carbon: MPU6900 (north) not detected
Phosphorous: BMP284 is found.
mcc-supported : 1
Phosphorous: BMP282 is not found on SPI 4. Expected 0x58, found 0x0
time-train: 26719 uS
Link 0 speed negotiate to 3
Link 0 width negotiate to 1
APCIE power on completed
Device 00:00:0 config space@0x610000000
Vendor:106B Device:1007 Revision:01 ClassCode:060400 Type:01
PriBus:00 SecBus:01 SubBus:01
Capability 0x01 Offset:0x40 Address:0x610000040
Capability 0x05 Offset:0x50 Address:0x610000050
Capability 0x10 Offset:0x70 Address:0x610000070
Extended Capability 0x0001 Ver:0x02 Offset:0x0100 Address:0x610000100
Extended Capability 0x0019 Ver:0x01 Offset:0x0148 Address:0x610000148
Extended Capability 0x001E Ver:0x01 Offset:0x0160 Address:0x610000160
Found device id 0x2002
Device 01:00:0 config space@0x610100000
Vendor:106B Device:2002 Revision:11 ClassCode:018002 Type:00
BAR0 MEM C0000000/00004000
BAR1 IO 00000000/00000004
Capability 0x01 Offset:0x40 Address:0x610100040
Capability 0x05 Offset:0x50 Address:0x610100050
Capability 0x10 Offset:0x70 Address:0x610100070
Extended Capability 0x0001 Ver:0x02 Offset:0x0100 Address:0x610100100
Extended Capability 0x0002 Ver:0x01 Offset:0x0148 Address:0x610100148
Extended Capability 0x0019 Ver:0x01 Offset:0x0168 Address:0x610100168
Extended Capability 0x0018 Ver:0x01 Offset:0x0178 Address:0x610100178
Extended Capability 0x001E Ver:0x01 Offset:0x0180 Address:0x610100180
APCIE Enumerate on completed
ICE BB not supported on this platform
D10 Diag (factory_d10_pvt)
BuildEng build D10Casaval24C302an (24C302an). Revision 6040f18.
Built at 2016/08/20 15:57:53
script: device -k ThermalSensor -e sochot 0 on 120
script: device -k ThermalSensor -e sochot 1 on 125
script: cbcolor
Setting Screen Color based on iPX Control Bits:
script: alias vbat=pmuadc --sel tigris --read vbat
script --cont startup.txt
script: alias bbon="meta 'baseband --on --load_firmware; baseband --wait_for_ready --ping'"
script: alias bbonbypass="meta 'baseband --on --load_firmware; baseband --wait_for_ready --ping --bypass en'"
script: alias bboff=baseband --off
script: alias getcd=bblib -e BB_GetCD()
script: alias erase_rfcal=smokey Tools/RFCalErase --run
script: alias erase_efs=smokey Tools/EFSErase --run
script: alias erase_pac=smokey Tools/RFPacErase --run
script: alias hdq_en=i2c --devwrite 1 0x75 0x1D 1
script: alias hdq_dis=i2c --devwrite 1 0x75 0x1D 0
script: alias bblib="smokeyshell -p -e 'if BBLib_cfg then print [[no init]] else require [[BBLib.14A]];BB_Init() end'"
script: alias wcs=smokey --run WCS --clean LogBehavior=ConsoleOnly
script: alias bblibcfg=bblib -e printLibCfg()
script: alias bbdebug="meta 'base --debug on;ramlog --on 10;consolerouter --add -s *.{warn,error,print},system.debug.debug -d ramlog --quiet;consoleformat --en --sink serial -o ts'"
script: alias gpsdebug="meta 'ramlog --on 10;consolerouter --add -s gps.debug.* -d ramlog'"
script: alias updateroot="meta 'usbfs --mount;cp -r usbfs:\AppleInternal nandfs:\;usbfs --unmount;smokeyshell -r'"
[00011442:2885E526] :-) help
DiagShell builtin commands:
"time" time
"echo" echo
"waitfor" waitfor
"repeat" repeat
"alias" alias [[=]]
"unalias" unalias
"true" true
"false" false
"args" args
"shopt" shopt
EDK Boot Loader commands (help for more info):
"accessory" Command to change power settings as well as identifying accessories connected to the unit
"aes" Command for AES encryption/decryption
"amux" Analog Mux selection command
"audio" General command to hande resetting/blanking/scripting of the audio subsystem
"audioparam" Audio parameter retrieval/setting utility
"audioreg" Manages register operations on audio blocks in the system
"barcode" Show S/N and ECID barcode
"baseband" Command to control/test baseband functionality
"battery" Command to display basic information about the battery
"baud" : Set UART Baud rate
"bl" BackLight Test
"blockdevice" Show information about boot devices. Bare quantities are in bytes.
"bluetooth" Command to control/test bluetooth functionality
"boardid" Get the board ID
"boardrev" Get the board revision
"bonfire" Run Bonfire
"bootcfg" Get the boot configuration
"buckcheck" Buck voltage check
"button" Test individual buttons on the unit
"buttoncnt" [--dqe] Count button presses on the unit
"camisp" camera command that can run in seperat steps.
"cat" Print the contents of a file.
"cbcolor" iPX Control Bit - Set screen color based on number of passed stations
"cbdump" iPX Control Bit - Dump the CB area from the NAND
"cberase" iPX Control Bit - Erase a control bit
"cbinit" iPX Control Bit - Initialize control bit area
"cbread" iPX Control Bit Read
"cbreadall" iPX Control Bit - read all
"cbwrite" iPX Control Bit Write
"charge" Charge controls for system
"chipid" Show ChipID
"clkmon" [signal/off]; Set Clock Test out pin to specified signal or switch it off
"consoleformat" Command to control the formatting of text display on serial output mediums like the console
"consolerouter" Main command that deals with all things console in the system
"consolesinkctrl" Manage the console sink controls
"cp" cp [-r] ...
"debug" Turns on/off global debug levels in the system
"device" Interfaces with a devices of the system.
"dfufile" Use dfu protocol to transfer file.
"directory" DirDev [\*match]; directory listing of dirdev. opt match a substring
"DisCfg#" Display CFG systemcfg
"DisOpts" Display OPTS systemcfg
"display" Command to control display
"displayid" Get the display ID
"displaytext" Display text on the unit's screen
"dt" Provide access to the device tree structure
"dumpmemmap" Dumps memory map
"dwi" backlight test using DWI
"event" Signal EFI event groups
"filelog" Log formatted console output to a file
"getnonce" iPX Control Bit - generate a salt value for control-bit write authentication
"getvol" Gets volume information/values from the various audio blocks
"gps" Command to test/control GPS functionality
"hash" compute Hash
"help" [cmd]; Help on cmd or a list of all commands if cmd is ommited
"hid" Command for the hid controllers/sensors
"i2c" generic read/write to I2C device
"key" Read buttons' status from AP side and PMU side
"legal" Outputs the copyright for any libraries used by Diags.
"loopaudio" Plays/Record full-duplex audio out/in through selected 'playable' and 'recordable' ports on an audio block
"lua" lua [options] [script [args]]
"mbt" Menu Button Test
"memcat" Read memory into file or a file into memory
"memory" Memory Utilities [--info] | [--list] | [--leak] | [--dump]
"memrw" Read/write/or/and from memory
"menu" Navigate menu items in Display
"meta" [cmd]; Execute cmd as if it was entered at the shell (useful for scripting)
"mipi" Command to interact with mipi
"mkdir" mkdir ...
"nand" Command to test nand functionality
"nandcsid" Read Nand Chip ID and detect ID mismatch
"nandppnfwver" Prints the PPN Firmware version for all populated CE's
"nandsize" Nand testing
"nanduid" Read Unique ID from each Nand die
"network" Command to control network interface
"nvram" Print or modify NVRAM variables
"pattern" [--iqc [#]|--dqe [#]|--fatp [#]|--other [#]|--fill [rgb #] --list will List available displays --pick will Pick Display name [n]:Test LCD display pattern[n]
"pcie" qucik pcie test
"physaddr" Decodes a physical address into bank/column/row/etc
"playaudio" Plays audio out through a selected 'playable' port
"pmuadc" PMU ADC Command for Calibration/Reading/Listing Channels
"pmubutton" pmu button test
"pmuevent" [all|chipid|btn|vbus|chgr|gpio|misc|temp|fault|ouv|clear]
"pmugpio" Set a PMU GPIO to a certain state
"pmureg" Print the values of all the pmu registers
"pmurw" generic read/write to PMU Registers
"pmuset" set the buck and ldo voltages value
"pmustat" [all|chipid|btn|vbus|chgr|gpio|misc|temp|fault]
"pmutemp" PMU TEMP test
"processaudio" Post-processes audio data using various audio filters registered in the system
"profile" Turns profiling on/off, dumps data, and resets profiling data.
"qrbarcode" Command for showing the QRbarcode
"quit" Quit EBL
"ramlog" Command to manage the ramlog console sink which can be used for logging text to RAM for timing sensitive issues
"recordaudio" Records audio in through a selected 'recordable' port
"reset" Resets the system
"rm" rm [-f] ...
"rmdir" rmdir ...
"routeaudio" Sets up audio routing.
"rtc" Set or get the RTC from PMU
"script" [filename]; Execute the commands in the specified file
"sensor" General command that interfaces with the various sensors in the system
"sensorreg" General command that allows for reading/writing sensor chipset registers
"sep" Manipulate the SEP
"setvol" Sets volume levels within the various audio blocks
"shutdown" Wait until the unit is unplugged then go to standby
"signal" Measure Signal Jitter, Period
"sleep" Set system to specified sleep state
"smash" Memory smasher
"smokey" EFI diag scripting sequencer
"smokeyshell" EFI diag scripting sequencer debug shell
"sn" Read/Write serial number
"soc" Command for displaying SoC info
"socgpio" Set a GPIO to a certain state
"spi" Test Spi buses
"spkid" Return 1 bit Speaker ID
"stockholm" Command to control/test stockholm functionality
"stopaudio" Stop audio out through a selected 'playable/recordable' port
"strobe" Command to control the Strobe on the System
"syscfg" [init | add | print | list | type | delete] ...; System Config
"sysinfo" Dumps system information
"system" Command to display basic information about the unit
"tag" Turns tagging of data on/off.
"temperature" Control Settings and Dump Readings from various Temperature Sensors in the System
"testCDMADDR" CDMA DDR test
"testmemory" Run data and address patterns to exercise DRAM subsystem
"testmp" boot up second core for simple tests
"thermalmonitor" Command to control/test thermal functionality
"touch" Command for the Touch subsystem
"tristar" TriStar test commands
"uartloopback" Perform a loopback test on the specified uart. Note that you will have to put the chip into loopback mode using separate commands.
"uartpassthrough" pass through uart traffic from dock uart to select uart
"uartrx" Receive and store message from uart . It will send the message back to uart when a is detected.
"uarttx" send message to the selected uart
"usbfs" Enables/Disables UsbFS (Filesystem-over-USB)
"usbp" Test USB Present
"version" Diag Version
"wait" [ms]; Wait ms milliseconds
"wakeevent" Select wake event for wakeup for PMU STANDBY or Hibernate mode
"wakeeventsmanager" Command to control wakeevents in the system
"wfi" Enable/Disable the wfi feature
"wifi" Command to control/test wifi functionality
"writefile" Write text to a file
"zerofile" Zero the contents of an existing file
```
Как можно видеть, функционал отладочной программы немаленький. Предназначена она в первую очередь для тестирования оборудования – большинство команд отвечают за тестирование различных аппаратных подсистем устройства. Наиболее полезными для нас оказались команды **directory**, **memrw**, **memory** и **cat**.
Выполнив команду **directory**, можно ознакомиться с содержимым файловой системы:
```
[00011442:2885E526] :-) dir fs0:
--------- 2016-08-29 07:01 AppleInternal
--------- 2016-09-22 11:27 System
--------- 2016-09-22 11:29 private
--------- 2016-09-22 11:28 usr
```
Выполнив команду **cat -h**, можно прочитать любой файл:
**Результат чтения файла**
```
[00011442:2885E526] :-) cat -h
fs0:\AppleInternal\Diags\Logs\Smokey\Shared\ComponentLib\HallSensor\11A\HallSensor.lua
00000000: 2D 2D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D |--==============|
00000010: 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D |================|
00000020: 3D 3D 3D 3D 3D 3D 3D 3D 3D 0A 2D 2D 20 46 69 6C |=========.-- Fil|
00000030: 65 6E 61 6D 65 3A 20 20 48 61 6C 6C 53 65 6E 73 |ename: HallSens|
00000040: 6F 72 2E 6C 75 61 0A 2D 2D 20 44 65 73 63 72 69 |or.lua.-- Descri|
00000050: 70 74 69 6F 6E 3A 20 48 61 6C 6C 53 65 6E 73 6F |ption: HallSenso|
00000060: 72 20 74 65 73 74 20 66 69 6C 65 0A 2D 2D 3D 3D |r test file.--==|
00000070: 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D |================|
00000080: 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D |================|
00000090: 3D 3D 3D 3D 3D 0A 0A 72 65 71 75 69 72 65 20 22 |=====..require "|
000000A0: 43 6F 6D 70 6F 6E 65 6E 74 4C 69 62 2E 43 6F 6D |ComponentLib.Com|
000000B0: 6D 6F 6E 2E 31 31 41 22 0A 0A 6C 6F 63 61 6C 20 |mon.11A"..local |
000000C0: 43 4F 4D 50 4F 4E 45 4E 54 5F 4E 41 4D 45 20 3D |COMPONENT_NAME =|
000000D0: 20 22 48 61 6C 6C 53 65 6E 73 6F 72 22 0A 0A 2D | "HallSensor"..-|
000000E0: 2D 20 48 61 6C 6C 73 65 6E 73 6F 72 20 74 65 73 |- Hallsensor tes|
000000F0: 74 0A 66 75 6E 63 74 69 6F 6E 20 48 61 6C 6C 53 |t.function HallS|
00000100: 65 6E 73 6F 72 54 65 73 74 73 28 29 0A 09 53 51 |ensorTests()..SQ|
00000110: 41 5F 53 68 65 6C 6C 28 22 68 61 6C 6C 73 65 6E |A_Shell("hallsen|
00000120: 73 6F 72 20 2D 2D 6D 65 61 73 20 22 2E 2E 48 41 |sor --meas "..HA|
00000130: 4C 4C 5F 53 45 4E 53 4F 52 5F 4D 45 41 53 2E 2E |LL_SENSOR_MEAS..|
00000140: 22 20 2D 2D 64 65 6C 61 79 20 22 2E 2E 48 41 4C |" --delay "..HAL|
00000150: 4C 5F 53 45 4E 53 4F 52 5F 44 4C 59 29 0A 09 53 |L_SENSOR_DLY)..S|
00000160: 51 41 5F 53 68 65 6C 6C 28 22 68 61 6C 6C 73 65 |QA_Shell("hallse|
00000170: 6E 73 6F 72 20 2D 2D 69 72 71 69 6E 64 65 78 20 |nsor --irqindex |
00000180: 22 2E 2E 48 41 4C 4C 5F 53 45 4E 53 4F 52 5F 49 |"..HALL_SENSOR_I|
00000190: 52 51 5F 49 4E 44 45 58 29 0A 09 53 51 41 5F 53 |RQ_INDEX)..SQA_S|
000001A0: 68 65 6C 6C 28 22 68 61 6C 6C 73 65 6E 73 6F 72 |hell("hallsensor|
000001B0: 20 2D 2D 6F 66 66 20 20 22 29 0A 65 6E 64 0A 0A | --off ").end..|
```
Комбинируя эти две команды, мы считали все файлы с устройства (почти 150 МБ):
Среди файлов нашлась «пасхалка», рекомендующая не шутить с ~~Iphone7~~ огнем:
Выполнив команду **memory -dump**, можно читать диапазоны ОЗУ:
```
[00011442:2885E526] :-) memory --dump 0x800000000 0x100
0: 30 83 43 5B 39 16 04 49 4D 47 34 30 83 43 40 14 0.C[9..IMG40.C@
10: 16 04 49 4D 34 50 16 04 64 69 61 67 16 01 31 04 .C@..".X..@.?..
20: 83 43 40 00 80 22 00 58 01 04 40 F9 3F 00 00 F1 ..T?...@..T...
30: 20 05 00 54 3F 04 00 F1 40 00 00 54 FA 01 00 14 ....B...B...B.t
40: 02 00 80 D2 42 00 00 91 42 08 00 91 42 CC 74 D3 B...B.l.B.B.Bp.
50: 42 08 04 91 42 AC 6C D3 42 C0 42 91 42 70 00 91 _...!..R....c..
60: 5F 00 00 B9 21 00 80 52 03 00 80 D2 63 00 00 91 c...c.t.c...c.l
70: 63 08 00 91 63 CC 74 D3 63 08 04 91 63 AC 6C D3 c.B.cP..a......
80: 63 C0 42 91 63 50 00 91 61 00 00 B9 03 00 80 D2 c...c...c.t.c..
90: 63 00 00 91 63 08 00 91 63 CC 74 D3 63 08 04 91 c.l.c.B.c@.....
A0: 63 AC 6C D3 63 C0 42 91 63 40 00 91 7F 00 00 B9 ...RA..........
B0: 81 00 80 52 41 00 00 B9 7F 00 00 B9 00 00 00 14 @..............
C0: 40 03 00 00 00 00 00 00 B0 03 00 00 00 00 00 00 . ...O...?.....
D0: 1F 20 03 D5 DF 4F 03 D5 DF 3F 03 D5 1F 87 08 D5 .?.. .;.!.....!
E0: 9F 3F 03 D5 20 E2 3B D5 21 00 80 D2 00 00 21 8A .......a...<.@
F0: 20 E2 1B D5 9B F9 FF 10 61 06 00 10 3C 00 40 F9 z...Y.@........
```
Наконец, с помощью команды **memrw** можно перезаписывать ОЗУ:
```
[00011442:2885E526] :-) memrw 0x800000000 0x12345678abcdef
0x800000000: 0x12345678ABCDEF
OK
[00011442:2885E526] :-) memory --dump 0x800000000 0x10
0: EF CD AB 78 56 34 12 00 4D 47 34 30 83 43 40 14 ...xV4..MG40.C@
```
Несмотря на то, что чтение памяти это уже в меру полезный функционал, мы решили проверить: можно ли перезаписать области исполняемого кода и запустить что-то свое? Ведь iPhone девелоперский, а функционал пока что пользовательский – так не пойдет!
Стандартными способами сделать это не удалось, возникала ошибка с достаточно подробным трейс-логом:
**Лог возникшего исключения**
```
[00011442:2885E526] :-) memrw 0x87BF68AA0 0
panic: unhandled exception: 0
x0: 0x00000000 x1: 0x0000000A x2: 0x00000000 x3: 0x87BF68AA0
x4: 0x00000002 x5: 0x00000003 x6: 0x879D52218 x7: 0x00000003
x8: 0x87BF68E30 x9: 0x87BF6908C x10: 0x00000000 x11: 0x000000E0
x12: 0x000000E0 x13: 0x00000001 x14: 0x00000001 x15: 0x00000000
x16: 0x000000FF x17: 0x00000001 x18: 0x810000308 x19: 0x879D52228
x20: 0x00000008 x21: 0x00000000 x22: 0x87BF68AA0 x23: 0x00000007
x24: 0x00000001 x25: 0x87BF68AA0 x26: 0x00000000 x27: 0x00000002
x28: 0x87CA42332 fp: 0x87FBEFC20 lr: 0x87BF68D3C sp: 0x00000000
PC: 0x87BF68E30
SPSR: 0x80000005
ESR: 0x9600004F
FAR: 0x87BF68AA0
EC:0x25 - "Data Abort caused by current EL"
ISS:0x4F - "Permission Fault Level 3"
Memory Access Fault - write to read-only or unmapped address.
FAR contains target address.
0x87BF68AA0: /Users/build/archive/casaval_d10_202/src/shasta/BuildResults/D10diag/release/diag/TestDirectMemoryRW.macho + <0x4AA0> : text section
stack buffer at 0x87FBEEED0
printing callstack: 15 frames unrolled.
#0 0x87BF68E30
TestDirectMemoryRW.macho @ offset 0x4E30
#1 0x87BF68D38
TestDirectMemoryRW.macho @ offset 0x4D38
#2 0x87BF69620
TestDirectMemoryRW.macho @ offset 0x5620
#3 0x879B2C1D0
DiagShell.macho @ offset 0x41D0
#4 0x879B2C7F0
DiagShell.macho @ offset 0x47F0
#5 0x879B2D11C
DiagShell.macho @ offset 0x511C
#6 0x87FB75494
DxeMain.macho @ offset 0xD494
#7 0x87CAD8214
DiagBds.macho @ offset 0x4214
#8 0x87CAD8260
DiagBds.macho @ offset 0x4260
#9 0x87CAD82CC
DiagBds.macho @ offset 0x42CC
#10 0x87FB6C604
DxeMain.macho @ offset 0x4604
#11 0x87FB6C0F0
DxeMain.macho @ offset 0x40F0
#12 0x81034AA04
#13 0x81039C7E4
#14 0x81039C39C
Please report panic using panic.apple.com
hanging here...
```
В данном случае в трейс-логе сообщается, что при исполнении по адресу **0x87BF68E30** в модуле **TestDirectMemoryRW.macho** возникло исключение из-за записи в **read-only** адрес памяти. Но нет преград для технических исследователей под Новый год! Обратим внимание на самый последний вызов в стеке: **DxeMain.macho**. Присутствие аббревиатуры [DXE](https://ru.bmstu.wiki/EFI_(Extensible_Firmware_Interface)#.D0.A4.D0.B0.D0.B7.D0.B0_DXE) и строки *EDK Boot Loader commands* позволяет сделать вывод, что на устройстве запущена EFI-совместимая система. И действительно, образ системы diags.img4 корректно открывается с помощью [UEFITool](https://github.com/LongSoft/UEFITool):
Дизассемблирование программных модулей показало, что все исполняемые модули используют соглашения о вызовах EFI и стандартные структуры EDK:
Каждой команде терминала соответствует отдельный EFI-модуль, например, команде **memory** соответствует модуль **TestUtilities.macho**, который загружается в ОЗУ по адресу **0x87BE10000** (определено из трейс-лога).
Попробуем модифицировать программный код этого модуля, чтобы исполнить наш код.
По адресу **0x87BE1600D** располагается текстовая строка, выводимая по команде **memory –info**, модифицируем ее:
```
[00011442:2885E526] :-) memory --info
Total Memory: 0x80000000, free: 0x79B48000, fragmented: 0x10028000, frags: 5, in use: 0x64B8000
[00011442:2885E526] :-) memory --dump 0x87BE1600D 0x30
7BE1600D: 54 6F 74 61 6C 20 4D 65 6D 6F 72 79 3A 20 30 78 Total Memory: 0
7BE1601D: 25 78 2C 20 66 72 65 65 3A 20 30 78 25 6C 78 2C fragmented: 0x
7BE1602D: 20 66 72 61 67 6D 65 6E 74 65 64 3A 20 30 78 25 x, frags: %d, i
```
Чтобы модифицировать нужную нам область памяти, требуется изменить права доступа на страницу по адресу **0x87BE14000** с *read-only/execute* на *read/write/execute*. Согласно документации AArch64, за права доступа отвечает специальная таблица трансляции. Таблица должна располагаться в ОЗУ и состоять из записей по 8 байт следующего формата:
Таблица трансляции второго уровня была обнаружена по адресу **0x87FBF4000**, в диапазоне памяти, доступном для перезаписи. На этом уровне каждая запись соответствует 32 МБ (0x2000000) адресного пространства, поэтому нужная нам запись для диапазона 0x87A000000–0x87BFFFFFF находится по адресу 0x87FBF4000 + (0x87A000000 / 0x2000000) \* 8 = **0x87FBF61E8**:
```
[00011442:2885E526] :-) memory --dump 0x87FBF61E8 0x8
7FBF61E8: 03 C0 CE 7F 08 00 00 00
```
Запись имеет тип *table*, то есть указывает на таблицу трансляции третьего уровня по адресу **0x87FCEC000**. В этой таблице каждая запись соответствует одной 16 Кб (0x4000) странице адресного пространства и имеет тип *block*. Нужная нам запись для страницы **0x87BE14000** находится по адресу 0x87FCEC000 + (0x87BE14000 – 0x87A000000) / 0x4000 \* 8 = 0x87FCEFC28:
```
[00011442:2885E526] :-) memory --dump 0x87FCEFC28 8
7FCEFC28: AB 47 E1 7B 08 00 00 00 .G.{....+..{..`
```
Поскольку эта запись имеет тип *block*, она указывает на физическую страницу памяти и содержит атрибуты доступа. Нас интересует *Lower block attributes*, а именно поле Data Access Permissions bits:
Чтобы разрешить запись в страницу, устанавливаем значение этого поля в 0:
```
[00011442:2885E526] :-) memrw 0x87FCEFC28 --64 0x000000087BE1472B
0x87FCEFC28: 0x87BE1472B
OK
```
После этого у нас должен появиться доступ на запись для нужной области. После внесения требуемых изменений получаем желаемый результат:
```
[00011442:2885E526] :-) memrw 0x87BE16008 0x6C6548000A535341
0x87BE16008: 0x6C6548000A535341
OK
[00011442:2885E526] :-) memrw 0x87BE16010 0x0072626148206F6C
0x87BE16010: 0x72626148206F6C
OK
[00011442:2885E526] :-) memory --info
Hello Habr
```
*The moral:* с помощью описанного метода мы можем модифицировать любые системные приложения и исполнять произвольный код в среде UEFI на девелоперском iPhone.
Практической ценности для старых версий iPhone данное исследование не несет, но было весело разобраться в чем-то неизведанном и редком, особенно когда оно неожиданно появилось как подарок на Новый год.
P. S. А вот для исследования последних версий iPhone и получения SecureROM может пригодиться описанный метод: уязвимость checkm8 в них исправлена, а подобные «программаторы» на AliExpress на базе iPhone XR и iPhone 11 уже [продаются](http://aliexpress.com/item/4000325768447.html).
[](https://raccoonsecurity.ru/)
Raccoon Security – специальная команда экспертов НТЦ «Вулкан» в области практической информационной безопасности, криптографии, схемотехники, обратной разработки и создания низкоуровневого программного обеспечения. | https://habr.com/ru/post/482032/ | null | ru | null |
# Simple automation: фотоальбом
#### Зачем и почему
Эту статью меня побудил написать гневный отзыв одного хабрапользователя, заявившего, что, в переводе на русский, звучит примерно так: «хорош писать комментарии, пиши что-то полезное».
Послав его куда подальше и немного подумав, я решил, что он-таки прав, тем более что я вроде как не первый год пишу всякий код и наверняка есть, о чем рассказать — а вдруг кому пригодиться. Оглянувшись назад, вспомнилось, что как-то была задачка автоматизировать создание фотоальбома. Так почему бы не написать об этом?
#### Зачем и почему — 2
Я сам любитель фотографировать, и естественно, надо бы свои творения показывать человекам. Для этого интернет — самое подходящее место. Первое, что пришло на ум в свое время — это [Picasa](http://picasaweb.google.com). Но тут были моменты, которые мне сильно не нравились. Это
* ограниченный объем места;
* фотографии лежат не у меня, и мало ли что может с ними случиться, а трудов жалко.
Что нравилось — это то, что пикасофская софтинка позволяла массово грузить фотки и создавать альбом, а это важно, когда фоток много.
Все бы ничего, но случилось чудо — у меня появился свой веб-сервер. Соответственно захотелось держать все фотки у себя. К счастью, пикаса умела делать и локальные фотоальбомы — достаточно настроить нужные шаблоны — и в нужное время жать нужную кнопку. Пока меня все устраивало, но стало напрягать то, что большая красивая пикаса и линукссовый сервер вместе не смотрелись. Но какое-то время этот подход работал, ну и фиг бы с ним, но…
Тут я полностью перебрался под линуксы, соответственно запускать виндовую пикасу стало напряжно. Это был весомый аргумент к поиску нового решения. Таким решением стал скриптик, который позволял генерировать фотоальбом под линуксом, запускался из консоли и не требовал графического интерфейса.
#### Требования
Итак, что я хотел получить:
* скрипт, запускаемый из консоли, без каких либо тыканий мышой, по типу «запустил и забыл»;
* уменьшение фоток до нужного размера для просмотра;
* уменьшение до маленького размера, дабы показать в каталоге;
* поворот картинок если надо;
* декорирование картинок и вставка копирайта;
* генерирование html-страничек для показа всего этого добра;
* отсутствие привязки к БД.
#### Поехали
Раз нам надо запуск из консоли, то выбор сразу пал на Perl — просто, быстро и есть опыт написания скриптов на нем.
Все операции с картинками я возложил на [ImageMagick](http://www.imagemagick.org). Тут столкнулся с тем, что непонятно, картинка вертикальная или горизонтальная, по какой оси ужимать. Наверно тут есть несколько способов решения, недавно на хабре проскакивал рецепт. Я решил так: командочкой «identify» получаем параметры картинки и смотрим, что больше — первый размер или второй. И в зависимости от этого жмем картинку с нужным параметром.
**Детектим размерчик**
```
sub getSize
{
my $fname = shift;
my $cmd = escapeShell ("identify '$fname'");
my $info = `$cmd`;
my $fname_len = length($fname);
$info =~ s/^.{$fname_len}(.*)$/$1/;
my $type;
my $size;
($type, $size, undef) = split (' ', $info);
my ($width, $height) = split ('x', $size);
return ($width, $height);
}
```
Тут пришлось учесть один момент, то что имя файла может содержать пробелы и то, что в выводе от команды «identify» тоже пробелы используются как разделители. Немного танцев с бубном — и все работает.
**По размеру делаем ресайз**
```
sub resize
{
my $size = shift;
my $fname_in = shift;
my $fname_out = shift;
my ($w, $h) = getSize ($fname_in);
print "W: $w, H: $h\n";
my $cmd;
if ($w > $h) {
$cmd = "convert '$fname_in' -resize $size -auto-orient '$fname_out'";
} else {
$cmd = "convert '$fname_in' -resize x$size -auto-orient '$fname_out'";
}
print "CMD: $cmd\n";
$cmd = escapeShell($cmd);
`$cmd`;
}
```
Далее, я помнил, что пикаса приделывала тени к превью картинок. Порыв инет, оказалось, что это абсолютно не проблема и решается с помошью уже упомянутой ImageMagick. Рецепт взял [отсюда](http://www.imagemagick.org/Usage/blur/).
**Делаем тень**
```
sub shadow
{
my $fname_in = escapeShell(shift);
my $fname_out = escapeShell(shift);
my $cmd = "convert -page +3+3 '$fname_in' -matte "
. "\\( +clone -background black -shadow 70x2+2+2 \\) "
. " +swap -background '#9AB6D7' -mosaic '$fname_out'";
`$cmd`;
}
```
Пока разбирался с тенями, оказалось, что можно приделать к фоткам еще и watermark. А почему бы и нет? Рисуем свою картинку с подписью и накладываем на фотку с помощью того же ImageMagick. [Рецепт](http://www.imagemagick.org/Usage/annotating/#wmark_image).
**Вставляем картинку с копирайтом**
```
sub signImg
{
my $sign = shift;
my $fname_in = shift;
my $fname_out = shift;
my $cmd = "convert $sign -fill grey50 -colorize 40 miff:- | "
. " composite -dissolve 30 -gravity south - '$fname_in' "
. " '$fname_out'";
$cmd = escapeShell($cmd);
`$cmd`;
}
```
Вообще с картинками можно творить все, что угодно, там много [примеров](http://www.imagemagick.org/Usage/), каждый найдет себе то, что ему по душе.
Возникла проблема html-обвязки. Обычно на больших сайтах информация лежит в базе данных и в УРЛе передается ИД картинки и все хорошо и красиво. Но у меня на моем серверочке не было базы — она туда просто не помещалась, потому что сервер представлял собой допиленный роутер ASUS 
Передавать имя файла не хотелось из соображений секурности. Оставался выход — для каждого файла генерить свой html. Тоже не есть красиво.
На ум пришла идея, заимствованная из линуксов — одна и та же команда может иметь несколько симлинков, и в зависимости от имени симлинка она делает соответствующие дейстия. Итак, решение: пишем один темплейтик для показа картинки, создаем массивчик, в котором прописаны все имена файлов — это достаточно секурно, и создаем кучу симлинков, где имя симлинки совпадает с индексом массива картинок. Все — вот она база, собранная на коленке. А по имени файла лезем в массивчик и вытаскиваем имя файла картинки.
**Генерируем PHP-шки для сайта**
```
sub genPhpFiles
{
# Check if index exists already
my $new_index = undef;
if (-f "$dir_in/photo_index.inc") {
`cp $dir_in/photo_index.inc $dir_out_html/photo_index.inc`;
} else {
$new_index = 1;
open F, ">$dir_out_html/photo_index.inc";
print F ' $desc = array (';
print F "\n";
}
# Gen index and symlinks
opendir(my $dh, $dir_out_img) || die "Can't read dir `$dir_in': $!\n";
my $idx = 0;
my @files = readdir $dh;
@files = sort @files;
foreach (@files) {
next if ($_ =~ m/^\./ || $_ =~ m/\.inc$/);
if ($new_index) {
print F "array ('name' ='$_', 'desc' => '$_: '),\n";
}
`ln -s template.php $dir_out_html/$idx.php`;
$idx++;
}
closedir $dh;
if ($new_index) {
print F "\n); ?>";
close F;
}
}
```
**А так внутри PHP-шки определяем имя файла картинки по имени симлинка**
```
php
// Extract number from file name and use it as ID
$file = $_SERVER["SCRIPT_NAME"];
$id = preg_replace('/.*\/(\d+)\.php$/', '$1', $file);
?
```
Ну вот вроде и все — все требования выполнены.
Хм, получилось даже больше, чем я хотел изначально…
Пользуюсь этим скриптиком вот уже на протяжении нескольких месяцев, практически ничего не меняя, и остаюсь вполне доволен — он делает все, что было нужно — одним запуском командочки генерит и картинки, и html-ки, остается только положить на сервер.
Вот так выглядит сгенерированный результат в браузере:
**Индекс фотографий**
**Отдельная фотография**
#### Как пользоваться
Если кому нужно — то все скопом лежит в [архивчике](http://erzin.name/foto/photo_album.tar.gz).
Пользоваться элементарно:
* распаковать архивчик
* поправить стили и темплейты под ваш дизайн (photo.css, photo.inc, photo\_list.inc, template.php, index.php)
* в каталог «in» сложить исходные картинки
* запустить «make\_photo\_album» и получить в каталоге «out» картинки нужного размера и сгенерированные html-ки.
Канэц. Точка. | https://habr.com/ru/post/147964/ | null | ru | null |
# Ruby on Rails + legacy_migrations: односторонняя синхронизация данных между двумя проектами
Эта статья ставит целью описать решение одной нетривиальной задачи — автоматическая односторонняя синхронизация данных в базах двух проектов средствами Ruby on Rails, гема [legacy\_migrations](https://rubygems.org/gems/legacy_migrations) и относительно прямых рук.
#### Исходная ситуация
Имеется нагруженный проект, писавшийся на протяжении 3-х лет в несколько этапов без серьезного рефакторинга, отчего код разбух и используемые технологии ощутимо устарели. Было принято решение переписать проект с нуля на всем новом.
##### Старый проект:
* Rails 2.3.4 (позже обновлен до 2.3.12 + контроль зависимостей через bundler)
* MySQL 5
* Sphinx, Delayed Job, AR sendmailer, interlock + memcached для кеширования и остальное по мелочи
##### Новый проект:
* Rails 3.1.0.rc5 (на данный момент)
* Postgresql 8.4 (возможно 9 в последствии)
* О мелочах пока еще рано говорить, но предполагается Solr, Redis, [resque](https://rubygems.org/gems/resque)
Основная трудность — это синхронизация контента баз данных с возможностью отойти от старой архитектуры БД в новом проекте. Было рассмотрено множество вариантов, но выбранный в конечном итоге позволил создать автоматическую систему синхронизации контента, которая сохраняет id записей, сохраняет временные метки записей, добавляет новые и обновляет уже имеющиеся записи. И при всем при этом **не обязывает вас строго копировать схему существующей базы данных**.
#### Gem legacy\_migrations
В процессе поиска полуготового решения был найден (не без помощи группы ror2ru) удобный [gem](https://rubygems.org/gems/legacy_migrations), написанный еще во времена Rails 2.3.x, который позволяет переносить содержимое произвольных атрибутов одной модели в другую, с возможностью выполнить произвольные операции над ними. Это было хорошее начало, но в процессе тестирования обнаружились существенные недостатки:
* не сохранялись id записей (он укладывал объекты в базу подряд начиная с id=1)
* не сохранялись временные штампы записей (updated\_at, created\_at)
* при повторной прогонке rake задачи данные в таблице дублировались под новыми id
Хочу заострить внимание на том, зачем сохранять id элементов, есть следующий способ — создать атрибут наподобие old\_id и по нему сделать перепривязку на новые id. Но задача стоит не просто в создании нового проекта, а в замещении старого проекта новым, а из этого вытекает как минимум идентичность всех url'ов. Чтобы понять насколько это важно, достаточно поймать на улице специалиста по SEO и рассказать о том, что вы хотите поменять урлы на работающем проекте. Должна последовать однозначная реакция, которая может проявляться в разных формах — от обморока до психоза :)
Для устранения выявленных недостатков я сделал этот [форк](https://github.com/Antiarchitect/legacy_migrations). Чтобы лучше понять чего же такого я там понаписал можете проследовать [сюда](https://github.com/Antiarchitect/legacy_migrations/compare/5d043c7a7a5ab35a9d090ea270b6baf71ba5cf07...master).
Надо отметить, что способ переноса данных через AR модели имеет один существенный недостаток — низкая производительность, однако в моем случае база оказалась относительно небольшой (около 400 Мб в целом), а сервер достаточно мощным, чтобы не отказываться от этого подхода.
#### Процесс переноса
Для начала надо отметить, что мне повезло и при переносе старого проекта (и параллельном апгрейде версии Rails с 2.3.4 до 2.3.12) базы данных обоих проектов оказались на одном сервере — для периодической синхронизации нет ничего лучше.
##### Установка необходимых гемов
Для начала необходимо убедиться, что в Gemfile вписаны адаптеры для обеих СУБД:
```
gem 'mysql2'
gem 'pg'
```
Для установки legacy\_migrations есть два варианта — [форк](https://github.com/Antiarchitect/legacy_migrations) (в который уже внесены необходимые изменения) или оригинальный gem с возможностью собственноручного допиливания (привожу строки из Gemfile для обоих вариантов соответственно):
```
gem 'legacy_migrations', :git => 'git://github.com/Antiarchitect/legacy_migrations.git'
gem 'legacy_migrations', :path => 'vendor/gems/legacy_migrations-0.3.7'
```
после чего правки в код можно вносить самостоятельно, а чтобы gem оказался в path надо выполнить вот такую команду в корне вашего приложения:
```
gem unpack legacy_migrations --target vendor/gems
```
##### Принципы работы
Суть работы legacy\_migrations следующая: в проекте должны существовать модели **из** которых мы берем данные и модели **в** которые мы эти записи зеркалим. Таким образом config/database.yml нового проекта будет выглядеть примерно следующим образом:
```
production:
adapter: postgresql
encoding: utf8
database: newapp_production
username: postgres
password: somecomplicatedpassword
legacy:
adapter: mysql2
encoding: utf8
database: oldapp_production
username: root
password: anothercomplicatedpassword
```
Где legacy — это конфигурация для базы старого проекта (название можно выбрать произвольно).
Далее следует посмотреть на модели старого проекта и выбрать свободный префикс во избежание дальнейшей путаницы. В моем случае это был префикс «Old». После чего создаем директорию app/models/old и помещаем туда абстрактный класс, от которого будут наследоваться все остальные. Пример app/models/old/old\_base.rb:
```
class OldBase < ActiveRecord::Base
self.abstract_class = true
establish_connection 'legacy'
end
```
где аргумент 'legacy' должен соответствовать названию группы настроек для старой базы в config/database.yml. Таким образом все модели, наследуемые от класса OldBase (а не напрямую от ActiveRecord::Base) будут знать, к какой базе необходимо подключиться. Далее приведу пример одной такой модели:
```
class OldNewsDoc < OldBase
set_table_name 'news_docs'
end
```
так как наши классы теперь имеют префикс, который изначально не предполагался, необходимо напрямую указывать название таблицы.
Для того, чтобы классы из app/models/old автоматически подгружались необходимо прописать этот путь в config/application.rb вот так:
```
module NewApp
class Application < Rails::Application
...
config.autoload_paths += %W(#{config.root}/app/models/old)
...
end
end
```
А далее все довольно просто необходимо создать rake задачу, например вот такую (lib/tasks/legacy.rake):
```
require 'legacy_migrations'
namespace :legacy do
namespace :transfer do
desc 'Transfers News Docs from onru to onru2'
task :news_docs => :environment do
transfer_from OldNewsDoc, :to => NewsDoc do
from :id, :to => :id
from :updated_at, :to => :updated_at
from :created_at, :to => :created_at
from :news_rubric_id, :to => :news_rubric_id
from :title, :to => :title
from :annotation, :to => :annotation
from :text, :to => :text
end
end
end
end
```
Все — теперь запуск задачи возможен примерно так:
```
bundle exec rake legacy:transfer:news_docs RAILS_ENV=production
```
Подробнее про возможности legacy\_migrations стоит читать в этом авторском [посте](http://frontended.com/?p=89).
#### Автоматизация процесса
Тут возможны варианты, так как rake задача уже есть а уж как ее запускать — дело десятое, однако я хотел бы предложить вариант периодического запуска любых задач для проекта, который мне больше всего понравился.
##### Gem Whenever
Есть очень удобный gem — [whenever](https://rubygems.org/gems/whenever) — для целей автоматического запуска заданий для нужд приложения посредством cron, который с легкостью интегрируется в Capistrano и позволяет подстраивать запуск основных вещей (таких как rake задача, runner скрипт или консольная команда) под конкретную production среду и писать собственные типы исполняемых заданий.
Для этого необходимо установить whenever (строка из Gemfile):
```
gem 'whenever', :require => false
```
из корня приложения запустить команду
```
wheneverize .
```
и поместить во вновь созданный файл config/schedule.rb примерно следующее:
```
job_type :rake, "rvm use ree && cd :path && RAILS_ENV=:environment bundle exec rake :task :output"
if environment == 'production'
every :day, :at => '2am' do
rake "legacy:transfer:news_docs"
end
end
```
я переписал определение rake задачи под мою среду: я использую rvm пользовательской установки и ree в качестве интерпретатора ruby (как только Rails 3.1 станут стабильны переключусь на 1.9.2 — пока наблюдаются некоторые проблемы), также я использую bundler, поэтому любой бинарник или скрипт следует запускать через bundle exec.
В Capistrano wheneverize интегрируется так же легко и непринужденно (deploy.rb):
```
require 'whenever/capistrano'
...
set :whenever_command, "bundle exec whenever" # это обязательно, если используется bundler - иначе он не найдет команду whenever
```
После деплоя можно полюбоваться красивыми и опрятными строками в crontab:
```
crontab -l
```
P.S. Надеюсь, что статья будет полезной для людей столкнувшихся с аналогичной проблемой переноса данных из одного проекта в другой.
Андрей Воронков, [Evrone.com](http://evrone.com). | https://habr.com/ru/post/126001/ | null | ru | null |
# Передача треков Google Analytics сторонним доменам без javascript
#### О чем статья?
* О междоменном отслеживании
* О том, что если чего-то нет в [официальной документации](https://developers.google.com/analytics/devguides/collection/gajs/gaTrackingSite#cookies), то это не повод печалится, а повод добавить такую возможность.
#### Зачем передавать?
Чтобы не терять информацию о пользователе во время его перехода в платежную систему для совершения покупок, а также его походов по нашей экосистеме сайтов.
#### Почему без javascript?
* Если нужно выполнить редирект пользователя после обработки логики запроса на сервере.
* Google Analytics api и так хорошо документирован, а читать копипаст документации это не уровень хабра, [не](http://habrahabr.ru/company/Techart/blog/88039/) так [ли](http://habrahabr.ru/post/203622/)?
Суть метода проста. Берем все куки вида \_\_utm и передаем их, как параметры, в урле на другой домен. ~~Ничего не происходит. Расходимся.~~ Добавляем последним параметром \_\_utmk, который является особым хешем всех остальных кук гугл аналитики. Поздравляю мы сделали, то что делаем функция \_link в известном файле ga.js от Google Analytics.
И так если у вас переход на другие сайты обрабатывал контроллер, то вам **не надо** во все ссылки добавлять конструкцию вида:
```
onclick="_gaq.push(['_link', 'https://www.payment-system.com?contractId=example']); return false;"
```
Если нужны исходники формирования хеша для ключа utmk, прошу [в github](https://github.com/KyDeSniK/php-ga-cookie-tracking).
Далее история о процессе получения данного метода.
1. Задание получено:
«Прокинуть гугл аналитику для всех переходов с сайта на платежную систему»
Описание:
«Теряем информацию [откуда пришел, что искал, как дошел до кнопки buy] о самых важных пользователях, которые купили наш софт.
[Документация аналитики](https://developers.google.com/analytics/devguides/collection/gajs/gaTrackingSite#multipleDomains) советует воспользоваться конструкцией вида:
```
onclick="_gaq.push(['_link', 'http://another-domain.com']); return false;"
```
И поставить ей на все ссылки, которые ведут на другой домен.
Вот и проблема — у нас ссылок нет на платежную систему. Есть корзина с несколькими шагами. И контроллер, который определяет, какую платежную систему задействовать и с какими параметрами. После чего делает редирект пользователя на платежную систему.
В голову лезут „ленивые идеи“. Можно же сделать промежуточную страницу на которой пользователь будет нажимать кнопку подтверждения, с вызовом функции аналитики из доки. Или же javascript будет формировать ссылку/форму и перенаправлять пользователя. Но мы эти идеи откидываем сразу ~~как ущербные~~ и идем читать доку дальше.
> [A session from one domain can only be transferred to another domain via a properly configured click or form submission, or via \_getLinkerURL](https://developers.google.com/analytics/devguides/collection/gajs/gaTrackingSite#cookies).
И так. Нам доступны: клик пользователя, отправка формы, javascript метод. Only? Only! Realy?
Посмотрим, что же происходит когда пользователь нажимает на ссылку у которой установлен атрибут onclick.
поищем через поисковик наш сайт, переход по ссылке, имеем данные куки от аналитики:
```
__utma 31500988.382379344.1389384850.1389388916.1389389624.3
__utmb 31500988.1.10.1389389624
__utmc 31500988
__utmz 31500988.1389389624.3.2.utmcsr=yandex|utmccn=(organic)|utmcmd=organic|utmctr=наш_запрос
```
Подробнее о каждой из кук [тут](http://habrahabr.ru/post/100212/).
Перейдем на платежную систему через тестовую html ссылку, которая вызывает \_gaq.push('link'… описанный в документации.
Воспользовавшись консолью браузера (так удобнее) узнаем что в урл добавились параметры:
```
__utma 31500988.382379344.1389384850.1389388916.1389389624.3
__utmb 31500988.1.10.1389389624
__utmc 31500988
__utmz 31500988.1389389624.3.2.utmcsr=yandex|utmccn=(organic)|utmcmd=organic|utmctr=наш_запрос
__utmk 88022362
__utmv -
__utmx -
```
Так же установились куки (уже на другом домене) utma, utmb, utmc, и главное utmz, в которую перенеслось значение utmcsr=yandex|utmccn=(organic)|utmcmd=organic|utmctr=наш\_запрос
Далее зашел в тупик, попробовав передать без клиента 4 значения известных кук как параметры урла, но они упорно не хотели устанавливаться аналитикой как треки.
Анализ ga.js, ga\_debug.js, а точнее их минификация не дали результата, попытка сделать [beautifality](http://jsbeautifier.org/) ga.js тоже ни к чему не привела.
Внимательные уже заметили, что после javascript обработки появляются 3 новых параметра в запросе:
```
__utmk 88022362
__utmv -
__utmx -
```
Заметил это и я, но чуть позже. Немного покопав, наткнулся на данный [комментарий](http://habrahabr.ru/post/100212/#comment_3096428) к схожей по тематике статье на хабре.
Это оказались сорцы на Google Analytics Tracking For Adobe Flash.
Осталось дело за малым. Выяснить, что на основе всех кук формируется хеш и записывается в \_\_utmk и переписать **java функцию генерации хеша:**
```
/**
* Generate hash for input string. This is a global method, since it does not need
* to access any instance variables, and it is being used everywhere in the GATC module.
* @param input Input string to generate hash value on.
* @return Hash value of input string. If input string is undefined, or empty, return hash value of 1.
*/
public function generateHash( input:String ):int
{
var hash:int = 1; // hash buffer
var leftMost7:int = 0; // left-most 7 bits
var pos:int; // character position in string
var current:int; // current character in string
// if input is undef or empty, hash value is 1
if(input != null && input != "")
{
hash = 0;
// hash function
for( pos = input.length - 1 ; pos >= 0 ; pos-- )
{
current = input.charCodeAt(pos);
hash = ((hash << 6) & 0xfffffff) + current + (current << 14);
leftMost7 = hash & 0xfe00000;
if(leftMost7 != 0)
{
hash ^= leftMost7 >> 21;
}
}
}
return hash;
}
```
[на PHP](https://github.com/KyDeSniK/php-ga-cookie-tracking).
В завершении проверяем, что для одинаковых значений треков оба варианта ( javascript — ga.js — link() и php generateHash ) генерируют одинаковый ключ для \_\_utmk и на стороннем домене устанавливаются нужные треки.
#### Вывод:
У нас появился новый способ междоменного отслеживания. Он не лучше, не хуже, просто другой ( серверный ). | https://habr.com/ru/post/208706/ | null | ru | null |
# Пишем API для React компонентов, часть 1: не создавайте конфликтующие пропсы
> **Пишем API для React компонентов, часть 1: не создавайте конфликтующие пропсы**
>
>
>
> [Пишем API для React компонентов, часть 2: давайте названия поведению, а не способам взаимодействия](https://habr.com/ru/post/459378/)
>
>
>
> [Пишем API для React компонентов, часть 3: порядок пропсов важен](https://habr.com/ru/post/459380/)
>
>
>
> [Пишем API для React компонентов, часть 4: опасайтесь Апропакалипсиса!](https://habr.com/ru/post/459414/)
>
>
>
> [Пишем API для React компонентов, часть 5: просто используйте композицию](https://habr.com/ru/post/459416/)
>
>
>
> [Пишем API для React компонентов, часть 6: создаем связь между компонентами](https://habr.com/ru/post/459422/)
*Этот пост — перевод первой статьи из серии статей [Writing good component API](https://sid.st/component-api/), за авторством [@Sid](https://twitter.com/siddharthkp). При переводе, в любой непонятной ситуации, я буду руководствоваться [официальным переводом документации React JS на русский язык](https://ru.reactjs.org/)*
Когда речь идет о React компонентах, ваши пропсы — это ваш API.
Хороший API должен быть понятным, таким что бы разработчик мог сам догадаться как с ним работать. Это относиться не только к разработке библиотек компонентов, но и к разработке приложений. Важно что бы вам и вашей команде было удобно использовать компоненты и их API.
> Эта серия статей вдохновлена статьями и лекциями от [Sebastian Markbåge](https://twitter.com/sebmarkbage), [Brent Jackson](https://twitter.com/jxnblk), [Jenn Creighton](https://twitter.com/gurlcode) и [A. Jesse Jiryu Davis](https://twitter.com/jessejiryudavis).
После прочтения множества статей + лекций, и после более года проектирования дизайн системы [cosmos](https://github.com/auth0/cosmos), я пришел к этим принципам разработки.
Начнем с простого.
У нас есть кнопка:
```
Click me
```
Возможно, вам также понадобится основная кнопка, которая нужна для основного действия на странице. Раньше мне нравилось формировать API, как если бы я мог сказать — "Дайте мне основную кнопку":
```
Click me
Click me
```
Теперь, как это обычно и бывает с кнопками, вам понадобятся еще несколько вариантов. Вот как выглядит таблица нескольких пропсов для кнопок:
| имя | описание | тип | значение по умолчанию |
| --- | --- | --- | --- |
| `primary` | нужно для обозначения основного действия | `boolean` | false |
| `secondary` | для действий которые менее важны | `boolean` | false |
| `destructive` | Опасная кнопка, для действий с которыми пользователь должен быть осторожен, пример: удаление | `boolean` | false |
| `link` | нужно для отображения кнопки как ссылки | `boolean` | false |
Есть несколько пропсов, которые можно использовать для изменения внешнего вида кнопки. Что будет если кто-то использует их вместе?
```
Click me
```
Победит ли кто-нибудь из них? От чего это зависит? От порядка?
Зачем вообще кому-то это писать? Существует ли реальный случай когда вам нужно сказать "Дайте мне `primary` `destructive` кнопку"?
В большинстве случаев это ошибка. Но если разработчикам вообще приходится задавать такие вопросы (как выше приведенные), это, вероятно, не очень хороший API.
Для того кто решает каким будет API, важно:
1. минимизировать ошибки
2. минимизировать путаницу вокруг API
Итак, вот совет № 1: **не создавайте конфликтующие пропсы.**
Мы можем довольно легко исправить приведенный выше код, используя проп который позволит получить список вариантов. Назовем его `appearance` (внешний вид)
```
Click me
Click me
Click me
```
Мы можем добавить список поддерживаемых вариантов для `appearance` используя [prop-types](https://ru.reactjs.org/docs/typechecking-with-proptypes.html) (типы пропсов).
```
Button.PropTypes = {
appearance: PropTypes.oneOf(['default', 'primary', 'secondary', 'link', 'destructive'])
}
```
Теперь, даже если разработчик допустит ошибку, он получит предупреждение об этом в своем инструменте разработки.
```
Click me
```
```
Внимание: неправильный тип пропа:
Недействительный `prop` `appearance` в значении `danger` присвоен в `Button`,
возможно только одно из этих значений: `["default", "primary", "secondary", "link", "destructive"]`
```
Этот совет довольно прост в реализации, но он сделает ваш API намного проще в использовании (и поддержке).
*От переводчика — я будут обновлять список статей этой серии (в начале) по мере перевода и выхода новых статей.* | https://habr.com/ru/post/459272/ | null | ru | null |
# MLflow: управление многозадачным обучением с независимыми моделями
Введение
--------
Многозадачное обучение (Multi-task learning) - это машинное обучение, где модель обучается на нескольких задачах сразу. Это отличается от обычного обучения на одной задаче, где модель обучается только на одной задаче. Многозадачное обучение может предоставить большую эффективность и более хорошую обобщающую способность, поскольку модель изучает общую концепцию между задачами.
Однако, многозадачное обучение может представлять проблемы для управления моделями, такие как:
* Сложность обучения и тестирования модели на нескольких задачах
* Отсутствие общей метрики для оценки производительности модели на всех задачах
* Отсутствие способа отслеживать и сравнивать результаты различных экспериментов
* Сложность интерпретации и объяснения модели на нескольких задачах
MLflow предоставляет ряд инструментов для управления многозадачным обучением, включая:
* Отслеживание экспериментов: отслеживание и сравнение результатов различных экспериментов на каждой задаче
* Упаковка моделей и обслуживание их: упаковка многозадачной модели для легкого обмена и развертывания
* Интеграция с популярными фреймворками и облачными платформами для управления многозадачного обучения
Ввод MLflow как решения для этих проблем, позволяет более эффективно управлять многозадачным обучением, с возможностью отслеживания и сравнения экспериментов, упаковки моделей и интеграции с другими инструментами и платформами.
Многозадачное обучение с независимыми моделями
----------------------------------------------
В чем отличие многозадачное обучение с независимыми моделями от обычного? В обычном многозадачном обучении модель обучается на нескольких задачах сразу, используя одну и ту же модель для каждой задачи. Идея многозадачного обучения звучит очень круто, но на практике она не всегда хорошо работает. Иногда обучение отдельной модели для каждой задачи работает лучше из-за того, что обновления градиента для разных задач мешают или конфликтуют друг с другом, получится не эффективно. Это называется отрицательным трансфером.
Кроме того, с отдельно обученными моделями проще иметь дело. Это многозадачное обучение с независимыми моделями может быть полезным для отслеживания и сравнения результатов, упаковки и деплоя независимых моделей для каждой задачи индивидуально. Давайте сразу рассматривать на практике.
### Задание
Предлагаю сразу взять готовый пример задачи и решения [Multi-Task Learning for Classification with Keras](https://towardsdatascience.com/multi-task-learning-for-computer-vision-classification-with-keras-36c52e6243d2), изменить некоторый конвейер и код, чтобы переходило с одной модели на две независимых моделей для каждой задачи.
**Задача многоклассовой классификации:** модель должна классифицировать изображение в одну из нескольких категорий животных и транспортных средств (кошка, собака, лошадь, автомобиль, грузовик и другие).
**Задача бинарной классификации:** модель должна определять, является ли изображение только животным или транспортным средством.
### Загрузка набора данных
Сначала найти известный готовый набор данных, то код проще импортировать фреймворк TensorFlow, чтобы [получить и распределенных набор обучающих и тестовых данных](https://www.tensorflow.org/api_docs/python/tf/keras/datasets/cifar10/load_data):
```
import tensorflow as tf
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.cifar10.load_data()
```
[CIFAR-10](https://www.cs.toronto.edu/~kriz/cifar.html) содержит 60000 изображений `32x32x3` в 10 конкретных классах: 0 - самолет, 1 - автомобиль, 2 - птица, 3 - кошка, 4 - олень, 5 - собака, 6 - лягушка, 7 - лошадь, 8 - корабль, 9 - грузовик.
### Предобработка
Еще одна функция получения набор бинарного набор данных помогает преобразовать с одного выхода изображения на 2 выхода, получатся два набор данных бинарного(животные и транспорт) и многоклассовой (10 классов) классификации.
```
def generate_binary_labels(yy, animal_classes):
yy_2 = [0 if y in animal_classes else 1 for y in yy]
return yy_2
# 0 = animal, 1 = vehicle
y_train_2 = generate_binary_labels(y_train_1, [2, 3, 4, 5, 6, 7])
y_test_2 = generate_binary_labels(y_test_1, [2, 3, 4, 5, 6, 7])
```
Для многозадачного обучения важно, что метки обучения специфичны для каждой задачи. Поэтому, при n-задачном обучении, будут определены n массивов различных меток. В этом случае первая задача требует, чтобы метки были целыми числами от 0 до 9 (одно число для каждого класса, т.е. многоклассная классификации), а вторая задача требует метки 0 и 1 (так как это бинарная классификация). Данные были ранее предварительно обработаны, так что метки являются цифрами от 0 до 9, и, как и ожидалось, метки для бинарной классификации будут созданы на основе исходных меток 0-9, так что если экземпляр соответствует животному(3 - кошка, 4 - олень, 5 - собака, 6 - лягушка, 7 - лошадь), он будет иметь метку 0, а если соответствует транспортному средству(0 - самолет, 1 - автомобиль, 8 - корабль, 9 - грузовик) - метку 1.
```
from tensorflow.keras.utils import to_categorical
def preprocess_data_cifar10(x_train, y_train_1, x_test, y_test_1):
# 0 = animal, 1 = vehicle
y_train_2 = generate_binary_labels(y_train_1, [2, 3, 4, 5, 6, 7])
y_test_2 = generate_binary_labels(y_test_1, [2, 3, 4, 5, 6, 7])
n_class_1 = 10
n_class_2 = 2
y_train_1 = to_categorical(y_train_1, n_class_1)
y_test_1 = to_categorical(y_test_1, n_class_1)
y_train_2 = to_categorical(y_train_2, n_class_2)
y_test_2 = to_categorical(y_test_2, n_class_2)
return x_train, y_train_1, y_train_2, x_test, y_test_1, y_test_2
x_train, y_train_1, y_train_2, x_test, y_test_1, y_test_2 = preprocess_data_cifar10(x_train, y_train, x_test, y_test)
```
После получения бинарного набора данных выполняется `to_categorical` это функция из модуля `keras.utils` библиотеки `TensorFlow`, которая преобразует классы в категориальный формат, т.е. в матрицу из нулей и единиц, где каждая строка соответствует одному примеру и индекс с единицей соответствует классу этого примера. В данном случае используется функция для преобразования массива `y_train_1` и `y_test_1` в категориальный формат с `n_class_1` бинарными классами, а также `y_train_2` и `y_test_2` в категориальный формат с `n_class_2` классами. Это необходимо для использования в машинном обучении.
В итоге функция возвращает тренировочные и тестовые данные и два массива меток для двух задач классификации: многоклассовой классификации с метками от 0 до 9 и бинарной классификации с метками 0 и 1. Метки 0 и 1 соответствуют животным и транспортным средствам соответственно.
### Обучение первой и второй моделей
Создать отдельно две сверточных нейронные модели, см. архитектуру обычного многозадачного обучения из статьи [Multi-Task Learning for Classification with Keras](https://towardsdatascience.com/multi-task-learning-for-computer-vision-classification-with-keras-36c52e6243d2) , у которого один вход изображения и два выхода: 2 класса и 8 классов, а у меня 2 класса и 10 классов.
Функция создания модели сверточных нейронных сетей многоклассовой классификации `model1`
```
def create_task_learning_model(x_train_shape, y_train_shape):
inputs = tf.keras.layers.Input(shape=(x_train_shape[1], x_train_shape[2], x_train_shape[3]), name='input')
main_branch = tf.keras.layers.Conv2D(filters=32, kernel_size=(3, 3), strides=1)(inputs)
main_branch = tf.keras.layers.MaxPooling2D(pool_size=(2, 2), strides=2)(main_branch)
main_branch = tf.keras.layers.Conv2D(filters=64, kernel_size=(3, 3), strides=1)(main_branch)
main_branch = tf.keras.layers.MaxPooling2D(pool_size=(2, 2), strides=2)(main_branch)
main_branch = tf.keras.layers.Conv2D(filters=128, kernel_size=(3, 3), strides=1)(main_branch)
main_branch = tf.keras.layers.Flatten()(main_branch)
main_branch = tf.keras.layers.Dense(3512, activation='relu')(main_branch)
task_1_branch = tf.keras.layers.Dense(1024, activation='relu')(main_branch)
task_1_branch = tf.keras.layers.Dense(512, activation='relu')(task_1_branch)
task_1_branch = tf.keras.layers.Dense(256, activation='relu')(task_1_branch)
task_1_branch = tf.keras.layers.Dense(128, activation='relu')(task_1_branch)
task_1_branch = tf.keras.layers.Dense( y_train_shape[1], activation='softmax')(task_1_branch)
model = tf.keras.Model(inputs = inputs, outputs = [task_1_branch])
model.summary()
return model
```
После функция создания функция компиляции `model.compile`используется для конфигурирования модели для обучения.
```
model = create_task_learning_model(x_train.shape, y_train.shape)
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
```
В данном случае используется оптимизатор `Adam`, функция потерь categorical\_crossentropy для многоклассовой классификации и метрика accuracy для оценки качества модели.
Дальше `model.fit()` использует набор данных`x_train` и `y_train` для обучения в течение 50 эпох с `batch_size = 128`. В процессе обучения не выводится информация о прогрессе `verbose=0`.
```
model2_history = model.fit(x_train, y_train, epochs=50, batch_size=128, verbose=0)
```
Результаты обучения сохраняются в переменной `model2_history`.
После того, как функция создания модели сверточных нейронных сетей бинарной классификации model1 и как выше есть описание, но немного разные архитектура модели и параметры компиляции для задачи бинарной классификации следующие разницы:
* Убрать один слой с 1000 нейронами
* Бинарный выход модели сверточных сетей
* `binary_crossentropy` - функция потерь для бинарной классификации.
```
def create_task_learning_model(x_train_shape, y_train_shape):
inputs = tf.keras.layers.Input(shape=(x_train_shape[1], x_train_shape[2], x_train_shape[3]), name='input')
main_branch = tf.keras.layers.Conv2D(filters=32, kernel_size=(3, 3), strides=1)(inputs)
main_branch = tf.keras.layers.MaxPooling2D(pool_size=(2, 2), strides=2)(main_branch)
main_branch = tf.keras.layers.Conv2D(filters=64, kernel_size=(3, 3), strides=1)(main_branch)
main_branch = tf.keras.layers.MaxPooling2D(pool_size=(2, 2), strides=2)(main_branch)
main_branch = tf.keras.layers.Conv2D(filters=128, kernel_size=(3, 3), strides=1)(main_branch)
main_branch = tf.keras.layers.Flatten()(main_branch)
main_branch = tf.keras.layers.Dense(3512, activation='relu')(main_branch)
task_2_branch = tf.keras.layers.Dense(512, activation='relu')(main_branch)
task_2_branch = tf.keras.layers.Dense(256, activation='relu')(task_2_branch)
task_2_branch = tf.keras.layers.Dense(100, activation='relu')(task_2_branch)
task_2_branch = tf.keras.layers.Dense(y_train_shape[1], activation='sigmoid')(task_2_branch)
model = tf.keras.Model(inputs = inputs, outputs = [task_2_branch])
model.summary()
return model
model = create_task_learning_model(x_train.shape, y_train.shape)
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
model2_history = model.fit(x_train, y_train,
epochs=50, batch_size=128, verbose=0)
```
Если проблема с детерминизм для обучения, см. [stackoverflow](https://stackoverflow.com/questions/36288235/how-to-get-stable-results-with-tensorflow-setting-random-seed), которое решено на моей практике:
```
import tensorflow as tf
import random
import os
SEED = 0
def set_seeds(seed=SEED):
os.environ['PYTHONHASHSEED'] = str(seed)
random.seed(seed)
tf.random.set_seed(seed)
np.random.seed(seed)
def set_global_determinism(seed=SEED):
set_seeds(seed=seed)
os.environ['TF_DETERMINISTIC_OPS'] = '1'
os.environ['TF_CUDNN_DETERMINISTIC'] = '1'
tf.config.threading.set_inter_op_parallelism_threads(1)
tf.config.threading.set_intra_op_parallelism_threads(1)
# Call the above function with seed value
set_global_determinism(seed=SEED)
```
Это для чего? Это может быть полезно в случаях, когда вам нужно воспроизвести результаты эксперимента или дебажить модель, которая использует случайность. Без этого кода случайные числа будут генерироваться с разными начальными значениями каждый раз, когда код запускается, и результаты будут отличаться. Поэтому если вы хотите повторно получить тот же самый результат в вашем коде, необходимо явно установить seed чтобы генератор использовал одинаковое начальное значение. Это может быть полезно для отладки, и позволит вам воспроизвести результаты.
### Сохранение обученных моделей
```
model.save(PATH_MODEL)
new_model = tf.keras.models.load_model(PATH_MODEL)
new_model.summary()
```
Этот код сохраняет первую обученную модель в указанный файл. Затем загружает ее и выводит ее описание для проверки. Это позволяет использовать обученную модель в дальнейшем без необходимости повторного обучения, так же как и для второй обученной модели
### Общая оценка
```
import tensorflow as tf
model1 = tf.keras.models.load_model(PATH_MODEL_1)
model1.summary()
model2 = tf.keras.models.load_model(PATH_MODEL_2)
model2.summary()
e1 = model1.evaluate(x_test, y_test_1)
print('Task1 evaluate: ', e1)
e2 = model2.evaluate(x_test, y_test_2)
print('Task2 evaluate: ', e2)
sum_loss = e1[0] + e2[0]
print('Multi task evaluate sum loss: ', sum_loss)
ave_acc = (e1[1] + e2[1])/2
print('Multi task evaluate average accurate: ', ave_acc)
```
В коде используется загрузка обученных моделей с ранее сохраненных путей `PATH_MODEL_1` и `PATH_MODEL_2`, затем выводится информация о моделях с помощью `summary()`. Далее происходит оценка качества моделей на тестовых данных `x_test` и `y_test_1` и `y_test_2` с использованием evaluate() с расчетом итоговой суммы потери и средней точности. MLflow покажет их. Для более быстрого обучения модели рекомендуется включить GPU (при его наличии), установив переменную среды окружения `export CUDA_VISIBLE_DEVICES='0'`.
Направленный ациклический граф конвейера()
------------------------------------------
Направленный ациклический граф конвейера( сокращение pipeline DAG) получился с нуля загрузки набора данных до общей оценки с помощью фреймворка [DVC](https://dvc.org/) для оркестрации и платформы [DagsHub](https://dagshub.com) для визуального графа
Видные красные стрелки к файлам этапа (`Stage File`) будут рассмотрены в MLflow далее.
MLflow: отслеживание экспериментов с независимыми моделями
----------------------------------------------------------
MLflow может использоваться для управления многозадачным обучением с независимыми моделями, так же как и для обычного многозадачного обучения. Хотя есть множество статей о MLflow на хабре, не буду писать подробное руководство по нему. В данном случае я покажу просто различные параметры и результаты экспериментов, но не буду рассматривать настройку моделей обучения.
### API-код
Для отслеживания экспериментов нужно добавить несколько строк кода:
Библиотека MLflow используется для отслеживания экспериментов `mlflow.set_experiment("model1")` устанавливает имя эксперимента в MLflow. `mlflow.start_run()` начинает новую сессию запуска, которая используется для отслеживания метрик и параметров модели. Интересно `mlflow.tensorflow.autolog()` автоматически отслеживает метрики и параметры модели в ходе выполнения кода обучения, но не обязательно. `mlflow.log_metric("test_loss", e[0])` и `mlflow.log_metric("test_acc", e[1])` записывает метрики тестовой потери и точности в сессию запуска.
Для второй модели `model2` нужно добавить такой же код для отслеживания ее экспериментов в MLflow. Но для каждой модели нужно задавать свой эксперимент, поэтому нужно будет изменить`model1` на `model2` или любое другое название, чтобы отделять эксперименты для разных моделей.
Для общей оценки многозадачного обучения добавить немного по другому:
В последнем коде cначала создается эксперимент с именем `main_evaluate`, затем запускается run с помощью контекстного менеджера. Далее загружаются модели `model1` и `model2` с путями PATH\_MODEL\_1 и `PATH_MODEL_2` соответственно. Затем модели оцениваются на тестовых данных с помощью `model1.evaluate` и `model2.evaluate`. После этого считается суммарная потеря и средняя точность и записывается в логи с помощью `mlflow.log_metric("sum_loss", sum_loss)` и `mlflow.log_metric("ave_acc", ave_acc)` соответственно.
### Интерфейс отслеживания экспериментов
Чтобы проверить MLflow UI, необходимо запустить команду "mlflow ui" в терминале или консоли. Это запустит веб-сервер на локальной машине на порту 5000. После этого вы можете открыть браузер и перейти по адресу<http://localhost:5000>, чтобы просмотреть интерфейс MLflow. В интерфейсе можно увидеть все эксперименты, которые были запущены с помощью MLflow, в том числе три эксперимента для каждой модели и общей оценки обучения, это будет показано как три строки в каждом интерфейсе, смотрите первую модель:
Смотрите вторую модель:
И смотрите общую оценку обучения:
В интерфейсах MLflow для двух моделей и общей оценки обучения отображаются четыре эксперимента. В каждом интерфейсе в последних двух строках показаны одинаковые результаты и параметры. Это связано с решением проблемы детерминизма, как было рассказано выше. Изменение параметра `epochs` в двух моделях приведет к изменению результатов в первых двух строках в каждом интерфейсе.
Мне кажется, что вы теперь знаете, как использовать инструмент MLflow для многозадачного обучения и можете перейти к более подробному руководству. Далее мы рассмотрим обслуживание моделей.
MLflow: Обслуживание моделей
----------------------------
Обслуживание моделей(Model serving) - это процесс обслуживания модели, который делает доступным для использования и внедрения модели в реальном мире. Может включать в себя предоставление API-интерфейса для запросов, обработку входных данных, использование вычислительной мощности и ресурсов, мониторинг модели в процессе использования.
MLflow может использоваться для запуска сервера, который поддерживает независимые модели. Это позволяет легко обновлять и управлять моделями, а также иметь возможность обслуживать несколько моделей одновременно. Он также предоставляет инструменты для мониторинга и отслеживания использования модели в реальном времени, что помогает обеспечить качество и надежность модели.
### Управление использованием GPU и CPU
Чтобы улучшить производительность и избежать проблемы с двумя моделями на
одной видеокарте, рекомендуется использовать команду `export
CUDA_VISIBLE_DEVICES=''` для выключения GPU во время обслуживания.
Однако, не забывайте включить GPU при обучении, как указано в подразделе
"Общая оценка" выше. Для переключения между GPU для обучения и CPU для
обслуживания, можно использовать различные методы автоматического переключения между GPU для обучения и CPU для обслуживания, например, с помощью `argparser`
для передачи аргументов внутрь кода, которые можно преобразовать в переменные ниже.
```
import os
if control_GPU==1:
os.system("export CUDA_VISIBLE_DEVICES='0'")
else:
os.system("export CUDA_VISIBLE_DEVICES=''")
```
### Запуск сервера
Поэтому необходимо выключить GPU. Затем необходимо перейти в интерфейс MLflow, копировать путь(`file:////mlruns/run\_id/uuid/artifacts/model`) к лучшей модели из столбца "Run Name" и использовать его для запуска сервера с помощью команды `mlflow models serve --no-conda -m file:////mlruns/run\_id/uuid/artifacts/model -h 0.0.0.0 -p 8001`. Для второй модели нужно запустить команду mlflow models serve с теми же аргументами, но на другом порте, например: `mlflow models serve --no-conda -m file:////mlruns/run\_id/uuid/artifacts/model -h 0.0.0.0 -p 8002`. Это позволит запустить вторую модель на другом порте, не конфликтуя с первой моделью.
Вот пример команды запуска для первой модели:
```
mlflow models serve --no-conda -m file:///home/yayay/yayay/git/github/mlflow_MTL/src/mlruns/404852075031124987/3e3d293adfcd4c509ce51a445089c417/artifacts/model -h 0.0.0.0 -p 8001
```
Для второй модели используйте другой путь на другом порте:
```
mlflow models serve --no-conda -m file:///home/yayay/yayay/git/github/mlflow_MTL/src/mlruns/909331581180947176/db0f2cbb10a64aeeb768d5408fcb9cca/artifacts/model -h 0.0.0.0 -p 8002
```
К сожалению, MLflow не позволяет использовать разные роутеры для каждой модели на одном порте, например, `0.0.0.0/model1`, `0.0.0.0/model2` и т.д. Как показано на [Stackoverflow](https://stackoverflow.com/questions/70620074/serving-multiple-ml-models-using-mlflow-in-a-single-vm). В качестве альтернативы, можно использовать другие инструменты для развертывания моделей, такие как Selder, FastAPI и другие.
### Проверка запросов и ответов
Проверка запроса и ответа с моделями может быть выполнена с использованием библиотеки requests. Эта библиотека предоставляет инструменты для отправки HTTP-запросов и обработки ответов сервера.
Например, можно отправить POST-запрос на адрес сервера, на котором развернута модель, используя код:
```
import requests
r2 = requests.post('http://0.0.0.0:8002/invocations', json=j)
print(r2.status_code)
dict_r2 = r2.json()
print(
"predicted binary labels:",
dict_binary_label[np.argmax(dict_r2["predictions"][0])]
)
r1 = requests.post('http://0.0.0.0:8001/invocations', json=j)
print(r1.status_code)
dict_r1 = r1.json()
print(
"predicted multiclass labels:",
dict_multiclass_label[np.argmax(dict_r1["predictions"][0])],
)
```
Вывод кода статуса 200(работает http) и ответа для животных и лошади:
Командная строкаВсе задание и решение завершены, и можно просмотреть [полный код](https://github.com/YAYAYru/mlflow_MTL), чтобы убедиться, что он работает корректно.
### Дополнительные материалы
* [CS 330: Deep Multi-Task and Meta Learning, Fall 2022](https://cs330.stanford.edu/)
* [Multi-Task Learning for Classification with Keras](https://towardsdatascience.com/multi-task-learning-for-computer-vision-classification-with-keras-36c52e6243d2)
* [MLflow](https://mlflow.org/) | https://habr.com/ru/post/712904/ | null | ru | null |
# PHP 7 получит в два раза более эффективный Hashtable
Начатый процесс переписывания ядра PHP идет семимильными шагами. Эта статья вольный пересказ [поста](http://nikic.github.io/2014/12/22/PHPs-new-hashtable-implementation.html) одного из авторов кода ядра PHP о достигнутых значительных успехах в оптимизации такой структуры данных, как hashtable. Больше технических подробностей под катом.
Простой скрипт, который создает массив из 100000 целых чисел, демонстрирует следующие результаты:
| | 32 bit | 64 bit |
| --- | --- | --- |
| PHP 5.6 | 7.37 MiB | 13.97 MiB |
| PHP 7.0 | 3.00 MiB | 4.00 MiB |
**Код теста**
```
$startMemory = memory_get_usage();
$array = range(1, 100000);
echo memory_get_usage() - $startMemory, " bytes\n";
```
PHP 7, как можно видеть, потребляет в 2.5 меньше памяти в 32-х разрядной версии и в 3.5 раза в 64-х разрядной, что согласитесь впечатляет.
### Лирическое отступление
В сущности в PHP все массивы это упорядоченные словари (т.е они представляют собой упорядоченный список пар вида ключ-значение), где ассоциирование ключа значению реализовано на основе hashtable. Сделано это для того, чтобы ключами массива могли выступать не только целочисленные типы, а и сложные типы вроде строк. Сам процесс происходит следующим образом — от ключа массива берется хэш, который представлен целым числом. Это целое число используется как индекс в массиве.
Проблема возникает, когда хэширующая функция возвращает одинаковые хэши для разных ключей, то есть возникает коллизия (то, что это действительно происходит легко убедится – количество возможных ключей бесконечно велико, в то время как количество хэшей ограничено размером типа integer).
Существуют два способа борьбы с коллизиями. Первый – открытая адресация, когда элемент сохраняется с другим индексом, если текущий уже занят, второй – хранить элементы с одинаковым индексом в связном списке. PHP использует второй способ.
Обычно элементы hashtable никак не упорядочены. Но в PHP делая итерацию по массиву, мы получаем элементы именно в том порядке, в котором мы их туда записывали. Это означает, что hashtable должна поддерживать механизм хранения порядка элементов.
### Старый механизм работы hashtable
Эта схема наглядно демонстрирует принцип работы hashtable в PHP 5:
Элементы разрешения коллизий на схеме обозначены как buckets (корзина). Для каждой такой «корзины» выделяется память. На картинке не показаны значения, которые хранятся в «корзинах», так как они помещаются в отдельные zval-структуры размером 16 или 24 байта. Также на картинке опущен связный список, который хранит порядок элементов массива. Для массива, который содержит ключи «a», «b», «c» он будет выглядеть так:
Итак, почему старая структура неэффективна в плане производительности и потребляемой памяти?
* «Корзины» требуют выделения места. Этот процесс довольно медленный и дополнительно требует 8 или 16 байт оверхеда в адресном заголовке. Это не позволяет эффективно использовать память и кэш.
* Структуры zval для данных также требует выделения места. Проблемы с памятью и оверхом заголовка все те же, что и у «корзины», плюс использование zval обязывает нас хранить указатель на него в каждой «корзине»
* Два связных списка требуют в сумме 4 указателя на корзину (т.к. списки двунаправленные). Это отнимает у нас еще от 16 до 32 байт. Кроме того, перемещение по связному списку это операция, которая плохо поддается кешированию.
Новая реализация hashtable призвана решить эти недостатки. Структура zval была переписана таким образом, чтобы ее можно было напрямую включать в сложные объекты (например, в вышеупомянутую «корзину»), а сама «корзина» стала выглядеть так:
```
typedef struct _Bucket {
zend_ulong h;
zend_string *key;
zval val;
} Bucket;
```
То есть «корзина» стала включать в себя хеш h, ключ key и значение val. Целочисленные ключи сохраняются в переменной h (в таком случае хеш и ключ идентичны).
Давайте взглянем на всю структуру целиком:
```
typedef struct _HashTable {
uint32_t nTableSize;
uint32_t nTableMask;
uint32_t nNumUsed;
uint32_t nNumOfElements;
zend_long nNextFreeElement;
Bucket *arData;
uint32_t *arHash;
dtor_func_t pDestructor;
uint32_t nInternalPointer;
union {
struct {
ZEND_ENDIAN_LOHI_3(
zend_uchar flags,
zend_uchar nApplyCount,
uint16_t reserve)
} v;
uint32_t flags;
} u;
} HashTable;
```
«Корзины» хранятся в массиве arData. Этот массив кратен степени двойки и его текущий размер хранится в переменной nTableSize (минимальный размер 8). Реальный размер массива хранится в nNumOfElements. Заметьте, что массив теперь включает в себя все «корзины», вместо того чтобы хранить указатели на них.
### Порядок элементов
Массив arData теперь хранит элементы в порядке их вставки. При удалении из массива элемент помечается меткой IS\_UNDEF и не учитывается в дальнейшем. То есть при удалении элемент физически остается в массиве пока счетчик занятых ячеек не достигнет размера nTableSize. При достижении этого лимита PHP попытается перестроить массив.
Такой подход позволяет сэкономить 8/16 байт на указателях, по сравнению с PHP 5. Приятным бонусом также будет то, что теперь итерация по массиву будет означать линейное сканирование памяти, что гораздо более эффективно для кеширования, чем обход связного списка.
Единственным недостатком остается неуменьшающийся размер arData, что потенциально может привести к значительному потреблению памяти на массивах в миллионы элементов.
### Обход Hashtable
Хэшем заведует функция DJBX33A, которая возвращает 32-х или 64-х битное беззнаковое целое, что слишком много для использования в качестве индекса. Для этого выполняем операцию «И» с хэшем и размером таблицы уменьшенным на единицу и результат записываем в переменную ht->nTableMask. Индекс получаем в результате операции
```
idx = ht->arHash[hash & ht->nTableMask]
```
Полученный индекс будет соответствовать первому элементу в массиве коллизий. То есть ht->arData[idx] это первый элемент, который нам нужно проверить. Если хранимый там ключ соответствует требуемому, то заканчиваем поиск. В противном случае следуем к следующему элементу до тех пор пока не найдем искомый или не получим INVALID\_IDX, что будет означать что данный ключ не существует.
Прелесть такого подхода заключается в том, что в отличии от PHP 5, нам больше не требуется двусвязный список.
### Сжатые и пустые hashtable
PHP использует hashtable для всех массивов. Но в определенных случаях, например, когда ключи массива целые, это не совсем рационально. В PHP 7 для этого применяется сжатие hashtable. Массив arHash в таком случае равен NULL и поиск идет по индексам arData. К сожалению, такая оптимизация применима, только если ключи идут по возрастанию, т.е. для массива [1 => 2, 0 => 1] сжатие применено не будет.
Пустые hashtable это особый случай в PHP 5 и PHP 7. Практика показывает, что пустой массив имеет неплохие шансы таковым и остаться. В этом случае массивы arData/arHash будет проинициализированы только когда первый элмент будет вставлен в hashtable. Для того чтобы избежать костылей и проверок используется следующий прием: пока меньше или равно своему значению по-умолчанию, nTableMask устанавливается в ноль. Это означает, что выражение hash & ht->nTableMask всегда будет равно нулю. В этом случае массив arHash содержит всего один элемент с нулевым индексом, который содержит значение INVALID\_IDX. При итерации по массиву мы всегда ищем до первого встреченного значения INVALID\_IDX, что в нашем случае будет означать массив нулевого размера, что и требуется от пустого hashtable.
### Итог
Все вышеперечисленные оптимизации позволили сократить занимаемый элементом размер с 144 байт в PHP 5 до 36 (32 в случае сжатия) байт в PHP 7. Небольшой недостаток новой реализации – слегка избыточное выделение памяти и отсутствие ускорения, если все значения массива одинаковы. Напомню, что в PHP 5 в этом случае используется всего один zval, так что уменьшение потребление памяти значительное:
**Код теста**
```
$startMemory = memory_get_usage();
$array = array_fill(0, 100000, 42);
echo memory_get_usage() - $startMemory, " bytes\n";
```
| | 32 bit | 64 bit |
| --- | --- | --- |
| PHP 5.6 | 4.70 MiB | 9.39 MiB |
| PHP 7.0 | 3.00 MiB | 4.00 MiB |
Несмотря на это, PHP 7 все равно показывает лучшую эффективность. | https://habr.com/ru/post/247145/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.